diff --git a/docs/developer/index.asciidoc b/docs/developer/index.asciidoc index 9e349a38557f..86d1d32e75e3 100644 --- a/docs/developer/index.asciidoc +++ b/docs/developer/index.asciidoc @@ -12,6 +12,7 @@ running in no time. If you have any problems, file an issue in the https://githu * <> * <> * <> +* <> -- @@ -29,3 +30,5 @@ include::advanced/index.asciidoc[] include::plugin-list.asciidoc[] +include::telemetry.asciidoc[] + diff --git a/docs/developer/telemetry.asciidoc b/docs/developer/telemetry.asciidoc new file mode 100644 index 000000000000..75f42a860624 --- /dev/null +++ b/docs/developer/telemetry.asciidoc @@ -0,0 +1,18 @@ +[[development-telemetry]] +== Development Telemetry + +To help us provide a good developer experience, we track some straightforward metrics when running certain tasks locally and ship them to a service that we run. To disable this functionality, specify `CI_STATS_DISABLED=true` in your environment. + +The operations we current report timing data for: + +* Total execution time of `yarn kbn bootstrap` + +Along with the execution time of each execution, we ship the following information about your machine to the service: + +* The `branch` property from the package.json file +* The value of the `data/uuid` file +* https://nodejs.org/docs/latest/api/os.html#os_os_platform[Operating system platform] +* https://nodejs.org/docs/latest/api/os.html#os_os_release[Operating system release] +* https://nodejs.org/docs/latest/api/os.html#os_os_cpus[Count, model, and speed of the CPUs] +* https://nodejs.org/docs/latest/api/os.html#os_os_arch[CPU architecture] +* https://nodejs.org/docs/latest/api/os.html#os_os_totalmem[Total memory] and https://nodejs.org/docs/latest/api/os.html#os_os_freemem[Free memory] \ No newline at end of file diff --git a/packages/kbn-dev-utils/ci_stats_reporter/package.json b/packages/kbn-dev-utils/ci_stats_reporter/package.json new file mode 100644 index 000000000000..a4f86a9239e3 --- /dev/null +++ b/packages/kbn-dev-utils/ci_stats_reporter/package.json @@ -0,0 +1,3 @@ +{ + "main": "../target/ci_stats_reporter/ci_stats_reporter" +} \ No newline at end of file diff --git a/packages/kbn-dev-utils/src/ci_stats_reporter/ci_stats_config.ts b/packages/kbn-dev-utils/src/ci_stats_reporter/ci_stats_config.ts new file mode 100644 index 000000000000..9af52ae8d2df --- /dev/null +++ b/packages/kbn-dev-utils/src/ci_stats_reporter/ci_stats_config.ts @@ -0,0 +1,52 @@ +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0 and the Server Side Public License, v 1; you may not use this file except + * in compliance with, at your election, the Elastic License 2.0 or the Server + * Side Public License, v 1. + */ + +import type { ToolingLog } from '../tooling_log'; + +export interface Config { + apiToken: string; + buildId: string; +} + +function validateConfig(log: ToolingLog, config: { [k in keyof Config]: unknown }) { + const validApiToken = typeof config.apiToken === 'string' && config.apiToken.length !== 0; + if (!validApiToken) { + log.warning('KIBANA_CI_STATS_CONFIG is missing a valid api token, stats will not be reported'); + return; + } + + const validId = typeof config.buildId === 'string' && config.buildId.length !== 0; + if (!validId) { + log.warning('KIBANA_CI_STATS_CONFIG is missing a valid build id, stats will not be reported'); + return; + } + + return config as Config; +} + +export function parseConfig(log: ToolingLog) { + const configJson = process.env.KIBANA_CI_STATS_CONFIG; + if (!configJson) { + log.debug('KIBANA_CI_STATS_CONFIG environment variable not found, disabling CiStatsReporter'); + return; + } + + let config: unknown; + try { + config = JSON.parse(configJson); + } catch (_) { + // handled below + } + + if (typeof config === 'object' && config !== null) { + return validateConfig(log, config as { [k in keyof Config]: unknown }); + } + + log.warning('KIBANA_CI_STATS_CONFIG is invalid, stats will not be reported'); + return; +} diff --git a/packages/kbn-dev-utils/src/ci_stats_reporter/ci_stats_reporter.ts b/packages/kbn-dev-utils/src/ci_stats_reporter/ci_stats_reporter.ts index 93826cf3add8..7847cad0fd5e 100644 --- a/packages/kbn-dev-utils/src/ci_stats_reporter/ci_stats_reporter.ts +++ b/packages/kbn-dev-utils/src/ci_stats_reporter/ci_stats_reporter.ts @@ -7,69 +7,50 @@ */ import { inspect } from 'util'; +import Os from 'os'; +import Fs from 'fs'; +import Path from 'path'; import Axios from 'axios'; import { ToolingLog } from '../tooling_log'; +import { parseConfig, Config } from './ci_stats_config'; -interface Config { - apiUrl: string; - apiToken: string; - buildId: string; -} +const BASE_URL = 'https://ci-stats.kibana.dev'; -export type CiStatsMetrics = Array<{ +export interface CiStatsMetric { group: string; id: string; value: number; limit?: number; limitConfigPath?: string; -}>; - -function parseConfig(log: ToolingLog) { - const configJson = process.env.KIBANA_CI_STATS_CONFIG; - if (!configJson) { - log.debug('KIBANA_CI_STATS_CONFIG environment variable not found, disabling CiStatsReporter'); - return; - } - - let config: unknown; - try { - config = JSON.parse(configJson); - } catch (_) { - // handled below - } - - if (typeof config === 'object' && config !== null) { - return validateConfig(log, config as { [k in keyof Config]: unknown }); - } - - log.warning('KIBANA_CI_STATS_CONFIG is invalid, stats will not be reported'); - return; } -function validateConfig(log: ToolingLog, config: { [k in keyof Config]: unknown }) { - const validApiUrl = typeof config.apiUrl === 'string' && config.apiUrl.length !== 0; - if (!validApiUrl) { - log.warning('KIBANA_CI_STATS_CONFIG is missing a valid api url, stats will not be reported'); - return; - } - - const validApiToken = typeof config.apiToken === 'string' && config.apiToken.length !== 0; - if (!validApiToken) { - log.warning('KIBANA_CI_STATS_CONFIG is missing a valid api token, stats will not be reported'); - return; - } - - const validId = typeof config.buildId === 'string' && config.buildId.length !== 0; - if (!validId) { - log.warning('KIBANA_CI_STATS_CONFIG is missing a valid build id, stats will not be reported'); - return; - } - - return config as Config; +export interface CiStatsTimingMetadata { + [key: string]: string | string[] | number | boolean | undefined; +} +export interface CiStatsTiming { + group: string; + id: string; + ms: number; + meta?: CiStatsTimingMetadata; } +export interface ReqOptions { + auth: boolean; + path: string; + body: any; + bodyDesc: string; +} + +export interface TimingsOptions { + /** list of timings to record */ + timings: CiStatsTiming[]; + /** master, 7.x, etc, automatically detected from package.json if not specified */ + upstreamBranch?: string; + /** value of data/uuid, automatically loaded if not specified */ + kibanaUuid?: string | null; +} export class CiStatsReporter { static fromEnv(log: ToolingLog) { return new CiStatsReporter(parseConfig(log), log); @@ -78,19 +59,126 @@ export class CiStatsReporter { constructor(private config: Config | undefined, private log: ToolingLog) {} isEnabled() { - return !!this.config; + return process.env.CI_STATS_DISABLED !== 'true'; } - async metrics(metrics: CiStatsMetrics) { - if (!this.config) { + hasBuildConfig() { + return this.isEnabled() && !!this.config?.apiToken && !!this.config?.buildId; + } + + /** + * Report timings data to the ci-stats service. If running in CI then the reporter + * will include the buildId in the report with the access token, otherwise the timings + * data will be recorded as anonymous timing data. + */ + async timings(options: TimingsOptions) { + if (!this.isEnabled()) { return; } + const buildId = this.config?.buildId; + const timings = options.timings; + const upstreamBranch = options.upstreamBranch ?? this.getUpstreamBranch(); + const kibanaUuid = options.kibanaUuid === undefined ? this.getKibanaUuid() : options.kibanaUuid; + const defaultMetadata = { + osPlatform: Os.platform(), + osRelease: Os.release(), + osArch: Os.arch(), + cpuCount: Os.cpus()?.length, + cpuModel: Os.cpus()[0]?.model, + cpuSpeed: Os.cpus()[0]?.speed, + freeMem: Os.freemem(), + totalMem: Os.totalmem(), + kibanaUuid, + }; + + return await this.req({ + auth: !!buildId, + path: '/v1/timings', + body: { + buildId, + upstreamBranch, + timings, + defaultMetadata, + }, + bodyDesc: timings.length === 1 ? `${timings.length} timing` : `${timings.length} timings`, + }); + } + + /** + * Report metrics data to the ci-stats service. If running outside of CI this method + * does nothing as metrics can only be reported when associated with a specific CI build. + */ + async metrics(metrics: CiStatsMetric[]) { + if (!this.hasBuildConfig()) { + return; + } + + const buildId = this.config?.buildId; + + if (!buildId) { + throw new Error(`CiStatsReporter can't be authorized without a buildId`); + } + + return await this.req({ + auth: true, + path: '/v1/metrics', + body: { + buildId, + metrics, + }, + bodyDesc: `metrics: ${metrics + .map(({ group, id, value }) => `[${group}/${id}=${value}]`) + .join(' ')}`, + }); + } + + /** + * In order to allow this code to run before @kbn/utils is built, @kbn/pm will pass + * in the upstreamBranch when calling the timings() method. Outside of @kbn/pm + * we rely on @kbn/utils to find the package.json file. + */ + private getUpstreamBranch() { + // specify the module id in a way that will keep webpack from bundling extra code into @kbn/pm + const hideFromWebpack = ['@', 'kbn/utils']; + // eslint-disable-next-line @typescript-eslint/no-var-requires + const { kibanaPackageJson } = require(hideFromWebpack.join('')); + return kibanaPackageJson.branch; + } + + /** + * In order to allow this code to run before @kbn/utils is built, @kbn/pm will pass + * in the kibanaUuid when calling the timings() method. Outside of @kbn/pm + * we rely on @kbn/utils to find the repo root. + */ + private getKibanaUuid() { + // specify the module id in a way that will keep webpack from bundling extra code into @kbn/pm + const hideFromWebpack = ['@', 'kbn/utils']; + // eslint-disable-next-line @typescript-eslint/no-var-requires + const { REPO_ROOT } = require(hideFromWebpack.join('')); + try { + return Fs.readFileSync(Path.resolve(REPO_ROOT, 'data/uuid'), 'utf-8').trim(); + } catch (error) { + if (error.code === 'ENOENT') { + return undefined; + } + + throw error; + } + } + + private async req({ auth, body, bodyDesc, path }: ReqOptions) { let attempt = 0; const maxAttempts = 5; - const bodySummary = metrics - .map(({ group, id, value }) => `[${group}/${id}=${value}]`) - .join(' '); + + let headers; + if (auth && this.config) { + headers = { + Authorization: `token ${this.config.apiToken}`, + }; + } else if (auth) { + throw new Error('this.req() shouldnt be called with auth=true if this.config is defined'); + } while (true) { attempt += 1; @@ -98,15 +186,10 @@ export class CiStatsReporter { try { await Axios.request({ method: 'POST', - url: '/v1/metrics', - baseURL: this.config.apiUrl, - headers: { - Authorization: `token ${this.config.apiToken}`, - }, - data: { - buildId: this.config.buildId, - metrics, - }, + url: path, + baseURL: BASE_URL, + headers, + data: body, }); return true; @@ -116,19 +199,19 @@ export class CiStatsReporter { throw error; } - if (error?.response && error.response.status !== 502) { + if (error?.response && error.response.status < 502) { // error response from service was received so warn the user and move on this.log.warning( - `error recording metric [status=${error.response.status}] [resp=${inspect( + `error reporting ${bodyDesc} [status=${error.response.status}] [resp=${inspect( error.response.data - )}] ${bodySummary}` + )}]` ); return; } if (attempt === maxAttempts) { this.log.warning( - `failed to reach kibana-ci-stats service too many times, unable to record metric ${bodySummary}` + `unable to report ${bodyDesc}, failed to reach ci-stats service too many times` ); return; } @@ -139,7 +222,7 @@ export class CiStatsReporter { : 'no response'; this.log.warning( - `failed to reach kibana-ci-stats service [reason=${reason}], retrying in ${attempt} seconds` + `failed to reach ci-stats service [reason=${reason}], retrying in ${attempt} seconds` ); await new Promise((resolve) => setTimeout(resolve, attempt * 1000)); diff --git a/packages/kbn-optimizer/src/limits.ts b/packages/kbn-optimizer/src/limits.ts index 077fe38ddc7f..4479e0acc097 100644 --- a/packages/kbn-optimizer/src/limits.ts +++ b/packages/kbn-optimizer/src/limits.ts @@ -11,7 +11,7 @@ import Path from 'path'; import dedent from 'dedent'; import Yaml from 'js-yaml'; -import { createFailError, ToolingLog, CiStatsMetrics } from '@kbn/dev-utils'; +import { createFailError, ToolingLog, CiStatsMetric } from '@kbn/dev-utils'; import { OptimizerConfig, Limits } from './optimizer'; @@ -86,7 +86,7 @@ export function updateBundleLimits({ limitsPath, }: UpdateBundleLimitsOptions) { const limits = readLimits(limitsPath); - const metrics: CiStatsMetrics = config.bundles + const metrics: CiStatsMetric[] = config.bundles .map((bundle) => JSON.parse(Fs.readFileSync(Path.resolve(bundle.outputDir, 'metrics.json'), 'utf-8')) ) diff --git a/packages/kbn-optimizer/src/worker/bundle_metrics_plugin.ts b/packages/kbn-optimizer/src/worker/bundle_metrics_plugin.ts index 909a97a3e11c..92875d3f69e4 100644 --- a/packages/kbn-optimizer/src/worker/bundle_metrics_plugin.ts +++ b/packages/kbn-optimizer/src/worker/bundle_metrics_plugin.ts @@ -10,7 +10,7 @@ import Path from 'path'; import webpack from 'webpack'; import { RawSource } from 'webpack-sources'; -import { CiStatsMetrics } from '@kbn/dev-utils'; +import { CiStatsMetric } from '@kbn/dev-utils'; import { Bundle } from '../common'; @@ -68,7 +68,7 @@ export class BundleMetricsPlugin { throw new Error(`moduleCount wasn't populated by PopulateBundleCachePlugin`); } - const bundleMetrics: CiStatsMetrics = [ + const bundleMetrics: CiStatsMetric[] = [ { group: `@kbn/optimizer bundle module count`, id: bundle.id, diff --git a/packages/kbn-pm/dist/index.js b/packages/kbn-pm/dist/index.js index 6c032a4e855c..206c5c62d247 100644 --- a/packages/kbn-pm/dist/index.js +++ b/packages/kbn-pm/dist/index.js @@ -94,7 +94,7 @@ __webpack_require__.r(__webpack_exports__); /* harmony import */ var _cli__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1); /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "run", function() { return _cli__WEBPACK_IMPORTED_MODULE_0__["run"]; }); -/* harmony import */ var _production__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(520); +/* harmony import */ var _production__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(563); /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "buildBazelProductionProjects", function() { return _production__WEBPACK_IMPORTED_MODULE_1__["buildBazelProductionProjects"]; }); /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "buildNonBazelProductionProjects", function() { return _production__WEBPACK_IMPORTED_MODULE_1__["buildNonBazelProductionProjects"]; }); @@ -108,7 +108,7 @@ __webpack_require__.r(__webpack_exports__); /* harmony import */ var _utils_package_json__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(251); /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "transformDependencies", function() { return _utils_package_json__WEBPACK_IMPORTED_MODULE_4__["transformDependencies"]; }); -/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(519); +/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(562); /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "getProjectPaths", function() { return _config__WEBPACK_IMPORTED_MODULE_5__["getProjectPaths"]; }); /* @@ -8895,6 +8895,10 @@ __webpack_require__.r(__webpack_exports__); const BootstrapCommand = { description: 'Install dependencies and crosslink projects', name: 'bootstrap', + reportTiming: { + group: 'bootstrap', + id: 'overall time' + }, async run(projects, projectGraph, { options, @@ -59490,11 +59494,13 @@ function waitUntilWatchIsReady(stream, opts = {}) { "use strict"; __webpack_require__.r(__webpack_exports__); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "runCommand", function() { return runCommand; }); -/* harmony import */ var _utils_errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(249); -/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(246); -/* harmony import */ var _utils_projects__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(248); -/* harmony import */ var _utils_projects_tree__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(371); -/* harmony import */ var _utils_kibana__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(515); +/* harmony import */ var _kbn_dev_utils_ci_stats_reporter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(515); +/* harmony import */ var _kbn_dev_utils_ci_stats_reporter__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_kbn_dev_utils_ci_stats_reporter__WEBPACK_IMPORTED_MODULE_0__); +/* harmony import */ var _utils_errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(249); +/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(246); +/* harmony import */ var _utils_projects__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(248); +/* harmony import */ var _utils_projects_tree__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(371); +/* harmony import */ var _utils_kibana__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(558); function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } @@ -59513,10 +59519,14 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope + async function runCommand(command, config) { + const runStartTime = Date.now(); + let kbn; + try { - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].debug(`Running [${command.name}] command from [${config.rootPath}]`); - const kbn = await _utils_kibana__WEBPACK_IMPORTED_MODULE_4__["Kibana"].loadFrom(config.rootPath); + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].debug(`Running [${command.name}] command from [${config.rootPath}]`); + kbn = await _utils_kibana__WEBPACK_IMPORTED_MODULE_5__["Kibana"].loadFrom(config.rootPath); const projects = kbn.getFilteredProjects({ skipKibanaPlugins: Boolean(config.options['skip-kibana-plugins']), ossOnly: Boolean(config.options.oss), @@ -59525,31 +59535,66 @@ async function runCommand(command, config) { }); if (projects.size === 0) { - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].error(`There are no projects found. Double check project name(s) in '-i/--include' and '-e/--exclude' filters.`); + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].error(`There are no projects found. Double check project name(s) in '-i/--include' and '-e/--exclude' filters.`); return process.exit(1); } - const projectGraph = Object(_utils_projects__WEBPACK_IMPORTED_MODULE_2__["buildProjectGraph"])(projects); - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].debug(`Found ${projects.size.toString()} projects`); - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].debug(Object(_utils_projects_tree__WEBPACK_IMPORTED_MODULE_3__["renderProjectsTree"])(config.rootPath, projects)); + const projectGraph = Object(_utils_projects__WEBPACK_IMPORTED_MODULE_3__["buildProjectGraph"])(projects); + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].debug(`Found ${projects.size.toString()} projects`); + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].debug(Object(_utils_projects_tree__WEBPACK_IMPORTED_MODULE_4__["renderProjectsTree"])(config.rootPath, projects)); await command.run(projects, projectGraph, _objectSpread(_objectSpread({}, config), {}, { kbn })); - } catch (error) { - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].error(`[${command.name}] failed:`); - if (error instanceof _utils_errors__WEBPACK_IMPORTED_MODULE_0__["CliError"]) { - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].error(error.message); + if (command.reportTiming) { + const reporter = _kbn_dev_utils_ci_stats_reporter__WEBPACK_IMPORTED_MODULE_0__["CiStatsReporter"].fromEnv(_utils_log__WEBPACK_IMPORTED_MODULE_2__["log"]); + await reporter.timings({ + upstreamBranch: kbn.kibanaProject.json.branch, + // prevent loading @kbn/utils by passing null + kibanaUuid: kbn.getUuid() || null, + timings: [{ + group: command.reportTiming.group, + id: command.reportTiming.id, + ms: Date.now() - runStartTime, + meta: { + success: true + } + }] + }); + } + } catch (error) { + if (command.reportTiming) { + // if we don't have a kbn object then things are too broken to report on + if (kbn) { + const reporter = _kbn_dev_utils_ci_stats_reporter__WEBPACK_IMPORTED_MODULE_0__["CiStatsReporter"].fromEnv(_utils_log__WEBPACK_IMPORTED_MODULE_2__["log"]); + await reporter.timings({ + upstreamBranch: kbn.kibanaProject.json.branch, + timings: [{ + group: command.reportTiming.group, + id: command.reportTiming.id, + ms: Date.now() - runStartTime, + meta: { + success: false + } + }] + }); + } + } + + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].error(`[${command.name}] failed:`); + + if (error instanceof _utils_errors__WEBPACK_IMPORTED_MODULE_1__["CliError"]) { + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].error(error.message); const metaOutput = Object.entries(error.meta).map(([key, value]) => `${key}: ${value}`).join('\n'); if (metaOutput) { - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].info('Additional debugging info:\n'); - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].indent(2); - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].info(metaOutput); - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].indent(-2); + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].info('Additional debugging info:\n'); + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].indent(2); + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].info(metaOutput); + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].indent(-2); } } else { - _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].error(error); + _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].error(error); } process.exit(1); @@ -59566,6 +59611,3663 @@ function toArray(value) { /***/ }), /* 515 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0 and the Server Side Public License, v 1; you may not use this file except + * in compliance with, at your election, the Elastic License 2.0 or the Server + * Side Public License, v 1. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.CiStatsReporter = void 0; +const tslib_1 = __webpack_require__(7); +const util_1 = __webpack_require__(112); +const os_1 = tslib_1.__importDefault(__webpack_require__(121)); +const fs_1 = tslib_1.__importDefault(__webpack_require__(134)); +const path_1 = tslib_1.__importDefault(__webpack_require__(4)); +const axios_1 = tslib_1.__importDefault(__webpack_require__(516)); +const ci_stats_config_1 = __webpack_require__(556); +const BASE_URL = 'https://ci-stats.kibana.dev'; +class CiStatsReporter { + constructor(config, log) { + this.config = config; + this.log = log; + } + static fromEnv(log) { + return new CiStatsReporter(ci_stats_config_1.parseConfig(log), log); + } + isEnabled() { + return process.env.CI_STATS_DISABLED !== 'true'; + } + hasBuildConfig() { + var _a, _b; + return this.isEnabled() && !!((_a = this.config) === null || _a === void 0 ? void 0 : _a.apiToken) && !!((_b = this.config) === null || _b === void 0 ? void 0 : _b.buildId); + } + /** + * Report timings data to the ci-stats service. If running in CI then the reporter + * will include the buildId in the report with the access token, otherwise the timings + * data will be recorded as anonymous timing data. + */ + async timings(options) { + var _a, _b, _c, _d, _e; + if (!this.isEnabled()) { + return; + } + const buildId = (_a = this.config) === null || _a === void 0 ? void 0 : _a.buildId; + const timings = options.timings; + const upstreamBranch = (_b = options.upstreamBranch) !== null && _b !== void 0 ? _b : this.getUpstreamBranch(); + const kibanaUuid = options.kibanaUuid === undefined ? this.getKibanaUuid() : options.kibanaUuid; + const defaultMetadata = { + osPlatform: os_1.default.platform(), + osRelease: os_1.default.release(), + osArch: os_1.default.arch(), + cpuCount: (_c = os_1.default.cpus()) === null || _c === void 0 ? void 0 : _c.length, + cpuModel: (_d = os_1.default.cpus()[0]) === null || _d === void 0 ? void 0 : _d.model, + cpuSpeed: (_e = os_1.default.cpus()[0]) === null || _e === void 0 ? void 0 : _e.speed, + freeMem: os_1.default.freemem(), + totalMem: os_1.default.totalmem(), + kibanaUuid, + }; + return await this.req({ + auth: !!buildId, + path: '/v1/timings', + body: { + buildId, + upstreamBranch, + timings, + defaultMetadata, + }, + bodyDesc: timings.length === 1 ? `${timings.length} timing` : `${timings.length} timings`, + }); + } + /** + * Report metrics data to the ci-stats service. If running outside of CI this method + * does nothing as metrics can only be reported when associated with a specific CI build. + */ + async metrics(metrics) { + var _a; + if (!this.hasBuildConfig()) { + return; + } + const buildId = (_a = this.config) === null || _a === void 0 ? void 0 : _a.buildId; + if (!buildId) { + throw new Error(`CiStatsReporter can't be authorized without a buildId`); + } + return await this.req({ + auth: true, + path: '/v1/metrics', + body: { + buildId, + metrics, + }, + bodyDesc: `metrics: ${metrics + .map(({ group, id, value }) => `[${group}/${id}=${value}]`) + .join(' ')}`, + }); + } + /** + * In order to allow this code to run before @kbn/utils is built, @kbn/pm will pass + * in the upstreamBranch when calling the timings() method. Outside of @kbn/pm + * we rely on @kbn/utils to find the package.json file. + */ + getUpstreamBranch() { + // specify the module id in a way that will keep webpack from bundling extra code into @kbn/pm + const hideFromWebpack = ['@', 'kbn/utils']; + // eslint-disable-next-line @typescript-eslint/no-var-requires + const { kibanaPackageJson } = __webpack_require__(557)(hideFromWebpack.join('')); + return kibanaPackageJson.branch; + } + /** + * In order to allow this code to run before @kbn/utils is built, @kbn/pm will pass + * in the kibanaUuid when calling the timings() method. Outside of @kbn/pm + * we rely on @kbn/utils to find the repo root. + */ + getKibanaUuid() { + // specify the module id in a way that will keep webpack from bundling extra code into @kbn/pm + const hideFromWebpack = ['@', 'kbn/utils']; + // eslint-disable-next-line @typescript-eslint/no-var-requires + const { REPO_ROOT } = __webpack_require__(557)(hideFromWebpack.join('')); + try { + return fs_1.default.readFileSync(path_1.default.resolve(REPO_ROOT, 'data/uuid'), 'utf-8').trim(); + } + catch (error) { + if (error.code === 'ENOENT') { + return undefined; + } + throw error; + } + } + async req({ auth, body, bodyDesc, path }) { + var _a; + let attempt = 0; + const maxAttempts = 5; + let headers; + if (auth && this.config) { + headers = { + Authorization: `token ${this.config.apiToken}`, + }; + } + else if (auth) { + throw new Error('this.req() shouldnt be called with auth=true if this.config is defined'); + } + while (true) { + attempt += 1; + try { + await axios_1.default.request({ + method: 'POST', + url: path, + baseURL: BASE_URL, + headers, + data: body, + }); + return true; + } + catch (error) { + if (!(error === null || error === void 0 ? void 0 : error.request)) { + // not an axios error, must be a usage error that we should notify user about + throw error; + } + if ((error === null || error === void 0 ? void 0 : error.response) && error.response.status < 502) { + // error response from service was received so warn the user and move on + this.log.warning(`error reporting ${bodyDesc} [status=${error.response.status}] [resp=${util_1.inspect(error.response.data)}]`); + return; + } + if (attempt === maxAttempts) { + this.log.warning(`unable to report ${bodyDesc}, failed to reach ci-stats service too many times`); + return; + } + // we failed to reach the backend and we have remaining attempts, lets retry after a short delay + const reason = ((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status) ? `${error.response.status} response` + : 'no response'; + this.log.warning(`failed to reach ci-stats service [reason=${reason}], retrying in ${attempt} seconds`); + await new Promise((resolve) => setTimeout(resolve, attempt * 1000)); + } + } + } +} +exports.CiStatsReporter = CiStatsReporter; + + +/***/ }), +/* 516 */ +/***/ (function(module, exports, __webpack_require__) { + +module.exports = __webpack_require__(517); + +/***/ }), +/* 517 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); +var bind = __webpack_require__(519); +var Axios = __webpack_require__(520); +var mergeConfig = __webpack_require__(551); +var defaults = __webpack_require__(526); + +/** + * Create an instance of Axios + * + * @param {Object} defaultConfig The default config for the instance + * @return {Axios} A new instance of Axios + */ +function createInstance(defaultConfig) { + var context = new Axios(defaultConfig); + var instance = bind(Axios.prototype.request, context); + + // Copy axios.prototype to instance + utils.extend(instance, Axios.prototype, context); + + // Copy context to instance + utils.extend(instance, context); + + return instance; +} + +// Create the default instance to be exported +var axios = createInstance(defaults); + +// Expose Axios class to allow class inheritance +axios.Axios = Axios; + +// Factory for creating new instances +axios.create = function create(instanceConfig) { + return createInstance(mergeConfig(axios.defaults, instanceConfig)); +}; + +// Expose Cancel & CancelToken +axios.Cancel = __webpack_require__(552); +axios.CancelToken = __webpack_require__(553); +axios.isCancel = __webpack_require__(525); + +// Expose all/spread +axios.all = function all(promises) { + return Promise.all(promises); +}; +axios.spread = __webpack_require__(554); + +// Expose isAxiosError +axios.isAxiosError = __webpack_require__(555); + +module.exports = axios; + +// Allow use of default import syntax in TypeScript +module.exports.default = axios; + + +/***/ }), +/* 518 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var bind = __webpack_require__(519); + +/*global toString:true*/ + +// utils is a library of generic helper functions non-specific to axios + +var toString = Object.prototype.toString; + +/** + * Determine if a value is an Array + * + * @param {Object} val The value to test + * @returns {boolean} True if value is an Array, otherwise false + */ +function isArray(val) { + return toString.call(val) === '[object Array]'; +} + +/** + * Determine if a value is undefined + * + * @param {Object} val The value to test + * @returns {boolean} True if the value is undefined, otherwise false + */ +function isUndefined(val) { + return typeof val === 'undefined'; +} + +/** + * Determine if a value is a Buffer + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Buffer, otherwise false + */ +function isBuffer(val) { + return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) + && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val); +} + +/** + * Determine if a value is an ArrayBuffer + * + * @param {Object} val The value to test + * @returns {boolean} True if value is an ArrayBuffer, otherwise false + */ +function isArrayBuffer(val) { + return toString.call(val) === '[object ArrayBuffer]'; +} + +/** + * Determine if a value is a FormData + * + * @param {Object} val The value to test + * @returns {boolean} True if value is an FormData, otherwise false + */ +function isFormData(val) { + return (typeof FormData !== 'undefined') && (val instanceof FormData); +} + +/** + * Determine if a value is a view on an ArrayBuffer + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false + */ +function isArrayBufferView(val) { + var result; + if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) { + result = ArrayBuffer.isView(val); + } else { + result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer); + } + return result; +} + +/** + * Determine if a value is a String + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a String, otherwise false + */ +function isString(val) { + return typeof val === 'string'; +} + +/** + * Determine if a value is a Number + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Number, otherwise false + */ +function isNumber(val) { + return typeof val === 'number'; +} + +/** + * Determine if a value is an Object + * + * @param {Object} val The value to test + * @returns {boolean} True if value is an Object, otherwise false + */ +function isObject(val) { + return val !== null && typeof val === 'object'; +} + +/** + * Determine if a value is a plain Object + * + * @param {Object} val The value to test + * @return {boolean} True if value is a plain Object, otherwise false + */ +function isPlainObject(val) { + if (toString.call(val) !== '[object Object]') { + return false; + } + + var prototype = Object.getPrototypeOf(val); + return prototype === null || prototype === Object.prototype; +} + +/** + * Determine if a value is a Date + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Date, otherwise false + */ +function isDate(val) { + return toString.call(val) === '[object Date]'; +} + +/** + * Determine if a value is a File + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a File, otherwise false + */ +function isFile(val) { + return toString.call(val) === '[object File]'; +} + +/** + * Determine if a value is a Blob + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Blob, otherwise false + */ +function isBlob(val) { + return toString.call(val) === '[object Blob]'; +} + +/** + * Determine if a value is a Function + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Function, otherwise false + */ +function isFunction(val) { + return toString.call(val) === '[object Function]'; +} + +/** + * Determine if a value is a Stream + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a Stream, otherwise false + */ +function isStream(val) { + return isObject(val) && isFunction(val.pipe); +} + +/** + * Determine if a value is a URLSearchParams object + * + * @param {Object} val The value to test + * @returns {boolean} True if value is a URLSearchParams object, otherwise false + */ +function isURLSearchParams(val) { + return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams; +} + +/** + * Trim excess whitespace off the beginning and end of a string + * + * @param {String} str The String to trim + * @returns {String} The String freed of excess whitespace + */ +function trim(str) { + return str.replace(/^\s*/, '').replace(/\s*$/, ''); +} + +/** + * Determine if we're running in a standard browser environment + * + * This allows axios to run in a web worker, and react-native. + * Both environments support XMLHttpRequest, but not fully standard globals. + * + * web workers: + * typeof window -> undefined + * typeof document -> undefined + * + * react-native: + * navigator.product -> 'ReactNative' + * nativescript + * navigator.product -> 'NativeScript' or 'NS' + */ +function isStandardBrowserEnv() { + if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' || + navigator.product === 'NativeScript' || + navigator.product === 'NS')) { + return false; + } + return ( + typeof window !== 'undefined' && + typeof document !== 'undefined' + ); +} + +/** + * Iterate over an Array or an Object invoking a function for each item. + * + * If `obj` is an Array callback will be called passing + * the value, index, and complete array for each item. + * + * If 'obj' is an Object callback will be called passing + * the value, key, and complete object for each property. + * + * @param {Object|Array} obj The object to iterate + * @param {Function} fn The callback to invoke for each item + */ +function forEach(obj, fn) { + // Don't bother if no value provided + if (obj === null || typeof obj === 'undefined') { + return; + } + + // Force an array if not already something iterable + if (typeof obj !== 'object') { + /*eslint no-param-reassign:0*/ + obj = [obj]; + } + + if (isArray(obj)) { + // Iterate over array values + for (var i = 0, l = obj.length; i < l; i++) { + fn.call(null, obj[i], i, obj); + } + } else { + // Iterate over object keys + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + fn.call(null, obj[key], key, obj); + } + } + } +} + +/** + * Accepts varargs expecting each argument to be an object, then + * immutably merges the properties of each object and returns result. + * + * When multiple objects contain the same key the later object in + * the arguments list will take precedence. + * + * Example: + * + * ```js + * var result = merge({foo: 123}, {foo: 456}); + * console.log(result.foo); // outputs 456 + * ``` + * + * @param {Object} obj1 Object to merge + * @returns {Object} Result of all merge properties + */ +function merge(/* obj1, obj2, obj3, ... */) { + var result = {}; + function assignValue(val, key) { + if (isPlainObject(result[key]) && isPlainObject(val)) { + result[key] = merge(result[key], val); + } else if (isPlainObject(val)) { + result[key] = merge({}, val); + } else if (isArray(val)) { + result[key] = val.slice(); + } else { + result[key] = val; + } + } + + for (var i = 0, l = arguments.length; i < l; i++) { + forEach(arguments[i], assignValue); + } + return result; +} + +/** + * Extends object a by mutably adding to it the properties of object b. + * + * @param {Object} a The object to be extended + * @param {Object} b The object to copy properties from + * @param {Object} thisArg The object to bind function to + * @return {Object} The resulting value of object a + */ +function extend(a, b, thisArg) { + forEach(b, function assignValue(val, key) { + if (thisArg && typeof val === 'function') { + a[key] = bind(val, thisArg); + } else { + a[key] = val; + } + }); + return a; +} + +/** + * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM) + * + * @param {string} content with BOM + * @return {string} content value without BOM + */ +function stripBOM(content) { + if (content.charCodeAt(0) === 0xFEFF) { + content = content.slice(1); + } + return content; +} + +module.exports = { + isArray: isArray, + isArrayBuffer: isArrayBuffer, + isBuffer: isBuffer, + isFormData: isFormData, + isArrayBufferView: isArrayBufferView, + isString: isString, + isNumber: isNumber, + isObject: isObject, + isPlainObject: isPlainObject, + isUndefined: isUndefined, + isDate: isDate, + isFile: isFile, + isBlob: isBlob, + isFunction: isFunction, + isStream: isStream, + isURLSearchParams: isURLSearchParams, + isStandardBrowserEnv: isStandardBrowserEnv, + forEach: forEach, + merge: merge, + extend: extend, + trim: trim, + stripBOM: stripBOM +}; + + +/***/ }), +/* 519 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = function bind(fn, thisArg) { + return function wrap() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + return fn.apply(thisArg, args); + }; +}; + + +/***/ }), +/* 520 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); +var buildURL = __webpack_require__(521); +var InterceptorManager = __webpack_require__(522); +var dispatchRequest = __webpack_require__(523); +var mergeConfig = __webpack_require__(551); + +/** + * Create a new instance of Axios + * + * @param {Object} instanceConfig The default config for the instance + */ +function Axios(instanceConfig) { + this.defaults = instanceConfig; + this.interceptors = { + request: new InterceptorManager(), + response: new InterceptorManager() + }; +} + +/** + * Dispatch a request + * + * @param {Object} config The config specific for this request (merged with this.defaults) + */ +Axios.prototype.request = function request(config) { + /*eslint no-param-reassign:0*/ + // Allow for axios('example/url'[, config]) a la fetch API + if (typeof config === 'string') { + config = arguments[1] || {}; + config.url = arguments[0]; + } else { + config = config || {}; + } + + config = mergeConfig(this.defaults, config); + + // Set config.method + if (config.method) { + config.method = config.method.toLowerCase(); + } else if (this.defaults.method) { + config.method = this.defaults.method.toLowerCase(); + } else { + config.method = 'get'; + } + + // Hook up interceptors middleware + var chain = [dispatchRequest, undefined]; + var promise = Promise.resolve(config); + + this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { + chain.unshift(interceptor.fulfilled, interceptor.rejected); + }); + + this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { + chain.push(interceptor.fulfilled, interceptor.rejected); + }); + + while (chain.length) { + promise = promise.then(chain.shift(), chain.shift()); + } + + return promise; +}; + +Axios.prototype.getUri = function getUri(config) { + config = mergeConfig(this.defaults, config); + return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, ''); +}; + +// Provide aliases for supported request methods +utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) { + /*eslint func-names:0*/ + Axios.prototype[method] = function(url, config) { + return this.request(mergeConfig(config || {}, { + method: method, + url: url, + data: (config || {}).data + })); + }; +}); + +utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { + /*eslint func-names:0*/ + Axios.prototype[method] = function(url, data, config) { + return this.request(mergeConfig(config || {}, { + method: method, + url: url, + data: data + })); + }; +}); + +module.exports = Axios; + + +/***/ }), +/* 521 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); + +function encode(val) { + return encodeURIComponent(val). + replace(/%3A/gi, ':'). + replace(/%24/g, '$'). + replace(/%2C/gi, ','). + replace(/%20/g, '+'). + replace(/%5B/gi, '['). + replace(/%5D/gi, ']'); +} + +/** + * Build a URL by appending params to the end + * + * @param {string} url The base of the url (e.g., http://www.google.com) + * @param {object} [params] The params to be appended + * @returns {string} The formatted url + */ +module.exports = function buildURL(url, params, paramsSerializer) { + /*eslint no-param-reassign:0*/ + if (!params) { + return url; + } + + var serializedParams; + if (paramsSerializer) { + serializedParams = paramsSerializer(params); + } else if (utils.isURLSearchParams(params)) { + serializedParams = params.toString(); + } else { + var parts = []; + + utils.forEach(params, function serialize(val, key) { + if (val === null || typeof val === 'undefined') { + return; + } + + if (utils.isArray(val)) { + key = key + '[]'; + } else { + val = [val]; + } + + utils.forEach(val, function parseValue(v) { + if (utils.isDate(v)) { + v = v.toISOString(); + } else if (utils.isObject(v)) { + v = JSON.stringify(v); + } + parts.push(encode(key) + '=' + encode(v)); + }); + }); + + serializedParams = parts.join('&'); + } + + if (serializedParams) { + var hashmarkIndex = url.indexOf('#'); + if (hashmarkIndex !== -1) { + url = url.slice(0, hashmarkIndex); + } + + url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams; + } + + return url; +}; + + +/***/ }), +/* 522 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); + +function InterceptorManager() { + this.handlers = []; +} + +/** + * Add a new interceptor to the stack + * + * @param {Function} fulfilled The function to handle `then` for a `Promise` + * @param {Function} rejected The function to handle `reject` for a `Promise` + * + * @return {Number} An ID used to remove interceptor later + */ +InterceptorManager.prototype.use = function use(fulfilled, rejected) { + this.handlers.push({ + fulfilled: fulfilled, + rejected: rejected + }); + return this.handlers.length - 1; +}; + +/** + * Remove an interceptor from the stack + * + * @param {Number} id The ID that was returned by `use` + */ +InterceptorManager.prototype.eject = function eject(id) { + if (this.handlers[id]) { + this.handlers[id] = null; + } +}; + +/** + * Iterate over all the registered interceptors + * + * This method is particularly useful for skipping over any + * interceptors that may have become `null` calling `eject`. + * + * @param {Function} fn The function to call for each interceptor + */ +InterceptorManager.prototype.forEach = function forEach(fn) { + utils.forEach(this.handlers, function forEachHandler(h) { + if (h !== null) { + fn(h); + } + }); +}; + +module.exports = InterceptorManager; + + +/***/ }), +/* 523 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); +var transformData = __webpack_require__(524); +var isCancel = __webpack_require__(525); +var defaults = __webpack_require__(526); + +/** + * Throws a `Cancel` if cancellation has been requested. + */ +function throwIfCancellationRequested(config) { + if (config.cancelToken) { + config.cancelToken.throwIfRequested(); + } +} + +/** + * Dispatch a request to the server using the configured adapter. + * + * @param {object} config The config that is to be used for the request + * @returns {Promise} The Promise to be fulfilled + */ +module.exports = function dispatchRequest(config) { + throwIfCancellationRequested(config); + + // Ensure headers exist + config.headers = config.headers || {}; + + // Transform request data + config.data = transformData( + config.data, + config.headers, + config.transformRequest + ); + + // Flatten headers + config.headers = utils.merge( + config.headers.common || {}, + config.headers[config.method] || {}, + config.headers + ); + + utils.forEach( + ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'], + function cleanHeaderConfig(method) { + delete config.headers[method]; + } + ); + + var adapter = config.adapter || defaults.adapter; + + return adapter(config).then(function onAdapterResolution(response) { + throwIfCancellationRequested(config); + + // Transform response data + response.data = transformData( + response.data, + response.headers, + config.transformResponse + ); + + return response; + }, function onAdapterRejection(reason) { + if (!isCancel(reason)) { + throwIfCancellationRequested(config); + + // Transform response data + if (reason && reason.response) { + reason.response.data = transformData( + reason.response.data, + reason.response.headers, + config.transformResponse + ); + } + } + + return Promise.reject(reason); + }); +}; + + +/***/ }), +/* 524 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); + +/** + * Transform the data for a request or a response + * + * @param {Object|String} data The data to be transformed + * @param {Array} headers The headers for the request or response + * @param {Array|Function} fns A single function or Array of functions + * @returns {*} The resulting transformed data + */ +module.exports = function transformData(data, headers, fns) { + /*eslint no-param-reassign:0*/ + utils.forEach(fns, function transform(fn) { + data = fn(data, headers); + }); + + return data; +}; + + +/***/ }), +/* 525 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = function isCancel(value) { + return !!(value && value.__CANCEL__); +}; + + +/***/ }), +/* 526 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); +var normalizeHeaderName = __webpack_require__(527); + +var DEFAULT_CONTENT_TYPE = { + 'Content-Type': 'application/x-www-form-urlencoded' +}; + +function setContentTypeIfUnset(headers, value) { + if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) { + headers['Content-Type'] = value; + } +} + +function getDefaultAdapter() { + var adapter; + if (typeof XMLHttpRequest !== 'undefined') { + // For browsers use XHR adapter + adapter = __webpack_require__(528); + } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') { + // For node use HTTP adapter + adapter = __webpack_require__(538); + } + return adapter; +} + +var defaults = { + adapter: getDefaultAdapter(), + + transformRequest: [function transformRequest(data, headers) { + normalizeHeaderName(headers, 'Accept'); + normalizeHeaderName(headers, 'Content-Type'); + if (utils.isFormData(data) || + utils.isArrayBuffer(data) || + utils.isBuffer(data) || + utils.isStream(data) || + utils.isFile(data) || + utils.isBlob(data) + ) { + return data; + } + if (utils.isArrayBufferView(data)) { + return data.buffer; + } + if (utils.isURLSearchParams(data)) { + setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8'); + return data.toString(); + } + if (utils.isObject(data)) { + setContentTypeIfUnset(headers, 'application/json;charset=utf-8'); + return JSON.stringify(data); + } + return data; + }], + + transformResponse: [function transformResponse(data) { + /*eslint no-param-reassign:0*/ + if (typeof data === 'string') { + try { + data = JSON.parse(data); + } catch (e) { /* Ignore */ } + } + return data; + }], + + /** + * A timeout in milliseconds to abort a request. If set to 0 (default) a + * timeout is not created. + */ + timeout: 0, + + xsrfCookieName: 'XSRF-TOKEN', + xsrfHeaderName: 'X-XSRF-TOKEN', + + maxContentLength: -1, + maxBodyLength: -1, + + validateStatus: function validateStatus(status) { + return status >= 200 && status < 300; + } +}; + +defaults.headers = { + common: { + 'Accept': 'application/json, text/plain, */*' + } +}; + +utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) { + defaults.headers[method] = {}; +}); + +utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) { + defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE); +}); + +module.exports = defaults; + + +/***/ }), +/* 527 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); + +module.exports = function normalizeHeaderName(headers, normalizedName) { + utils.forEach(headers, function processHeader(value, name) { + if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) { + headers[normalizedName] = value; + delete headers[name]; + } + }); +}; + + +/***/ }), +/* 528 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); +var settle = __webpack_require__(529); +var cookies = __webpack_require__(532); +var buildURL = __webpack_require__(521); +var buildFullPath = __webpack_require__(533); +var parseHeaders = __webpack_require__(536); +var isURLSameOrigin = __webpack_require__(537); +var createError = __webpack_require__(530); + +module.exports = function xhrAdapter(config) { + return new Promise(function dispatchXhrRequest(resolve, reject) { + var requestData = config.data; + var requestHeaders = config.headers; + + if (utils.isFormData(requestData)) { + delete requestHeaders['Content-Type']; // Let the browser set it + } + + var request = new XMLHttpRequest(); + + // HTTP basic authentication + if (config.auth) { + var username = config.auth.username || ''; + var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : ''; + requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password); + } + + var fullPath = buildFullPath(config.baseURL, config.url); + request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true); + + // Set the request timeout in MS + request.timeout = config.timeout; + + // Listen for ready state + request.onreadystatechange = function handleLoad() { + if (!request || request.readyState !== 4) { + return; + } + + // The request errored out and we didn't get a response, this will be + // handled by onerror instead + // With one exception: request that using file: protocol, most browsers + // will return status as 0 even though it's a successful request + if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) { + return; + } + + // Prepare the response + var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null; + var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response; + var response = { + data: responseData, + status: request.status, + statusText: request.statusText, + headers: responseHeaders, + config: config, + request: request + }; + + settle(resolve, reject, response); + + // Clean up request + request = null; + }; + + // Handle browser request cancellation (as opposed to a manual cancellation) + request.onabort = function handleAbort() { + if (!request) { + return; + } + + reject(createError('Request aborted', config, 'ECONNABORTED', request)); + + // Clean up request + request = null; + }; + + // Handle low level network errors + request.onerror = function handleError() { + // Real errors are hidden from us by the browser + // onerror should only fire if it's a network error + reject(createError('Network Error', config, null, request)); + + // Clean up request + request = null; + }; + + // Handle timeout + request.ontimeout = function handleTimeout() { + var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded'; + if (config.timeoutErrorMessage) { + timeoutErrorMessage = config.timeoutErrorMessage; + } + reject(createError(timeoutErrorMessage, config, 'ECONNABORTED', + request)); + + // Clean up request + request = null; + }; + + // Add xsrf header + // This is only done if running in a standard browser environment. + // Specifically not if we're in a web worker, or react-native. + if (utils.isStandardBrowserEnv()) { + // Add xsrf header + var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? + cookies.read(config.xsrfCookieName) : + undefined; + + if (xsrfValue) { + requestHeaders[config.xsrfHeaderName] = xsrfValue; + } + } + + // Add headers to the request + if ('setRequestHeader' in request) { + utils.forEach(requestHeaders, function setRequestHeader(val, key) { + if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') { + // Remove Content-Type if data is undefined + delete requestHeaders[key]; + } else { + // Otherwise add header to the request + request.setRequestHeader(key, val); + } + }); + } + + // Add withCredentials to request if needed + if (!utils.isUndefined(config.withCredentials)) { + request.withCredentials = !!config.withCredentials; + } + + // Add responseType to request if needed + if (config.responseType) { + try { + request.responseType = config.responseType; + } catch (e) { + // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2. + // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function. + if (config.responseType !== 'json') { + throw e; + } + } + } + + // Handle progress if needed + if (typeof config.onDownloadProgress === 'function') { + request.addEventListener('progress', config.onDownloadProgress); + } + + // Not all browsers support upload events + if (typeof config.onUploadProgress === 'function' && request.upload) { + request.upload.addEventListener('progress', config.onUploadProgress); + } + + if (config.cancelToken) { + // Handle cancellation + config.cancelToken.promise.then(function onCanceled(cancel) { + if (!request) { + return; + } + + request.abort(); + reject(cancel); + // Clean up request + request = null; + }); + } + + if (!requestData) { + requestData = null; + } + + // Send the request + request.send(requestData); + }); +}; + + +/***/ }), +/* 529 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var createError = __webpack_require__(530); + +/** + * Resolve or reject a Promise based on response status. + * + * @param {Function} resolve A function that resolves the promise. + * @param {Function} reject A function that rejects the promise. + * @param {object} response The response. + */ +module.exports = function settle(resolve, reject, response) { + var validateStatus = response.config.validateStatus; + if (!response.status || !validateStatus || validateStatus(response.status)) { + resolve(response); + } else { + reject(createError( + 'Request failed with status code ' + response.status, + response.config, + null, + response.request, + response + )); + } +}; + + +/***/ }), +/* 530 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var enhanceError = __webpack_require__(531); + +/** + * Create an Error with the specified message, config, error code, request and response. + * + * @param {string} message The error message. + * @param {Object} config The config. + * @param {string} [code] The error code (for example, 'ECONNABORTED'). + * @param {Object} [request] The request. + * @param {Object} [response] The response. + * @returns {Error} The created error. + */ +module.exports = function createError(message, config, code, request, response) { + var error = new Error(message); + return enhanceError(error, config, code, request, response); +}; + + +/***/ }), +/* 531 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Update an Error with the specified config, error code, and response. + * + * @param {Error} error The error to update. + * @param {Object} config The config. + * @param {string} [code] The error code (for example, 'ECONNABORTED'). + * @param {Object} [request] The request. + * @param {Object} [response] The response. + * @returns {Error} The error. + */ +module.exports = function enhanceError(error, config, code, request, response) { + error.config = config; + if (code) { + error.code = code; + } + + error.request = request; + error.response = response; + error.isAxiosError = true; + + error.toJSON = function toJSON() { + return { + // Standard + message: this.message, + name: this.name, + // Microsoft + description: this.description, + number: this.number, + // Mozilla + fileName: this.fileName, + lineNumber: this.lineNumber, + columnNumber: this.columnNumber, + stack: this.stack, + // Axios + config: this.config, + code: this.code + }; + }; + return error; +}; + + +/***/ }), +/* 532 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); + +module.exports = ( + utils.isStandardBrowserEnv() ? + + // Standard browser envs support document.cookie + (function standardBrowserEnv() { + return { + write: function write(name, value, expires, path, domain, secure) { + var cookie = []; + cookie.push(name + '=' + encodeURIComponent(value)); + + if (utils.isNumber(expires)) { + cookie.push('expires=' + new Date(expires).toGMTString()); + } + + if (utils.isString(path)) { + cookie.push('path=' + path); + } + + if (utils.isString(domain)) { + cookie.push('domain=' + domain); + } + + if (secure === true) { + cookie.push('secure'); + } + + document.cookie = cookie.join('; '); + }, + + read: function read(name) { + var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)')); + return (match ? decodeURIComponent(match[3]) : null); + }, + + remove: function remove(name) { + this.write(name, '', Date.now() - 86400000); + } + }; + })() : + + // Non standard browser env (web workers, react-native) lack needed support. + (function nonStandardBrowserEnv() { + return { + write: function write() {}, + read: function read() { return null; }, + remove: function remove() {} + }; + })() +); + + +/***/ }), +/* 533 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var isAbsoluteURL = __webpack_require__(534); +var combineURLs = __webpack_require__(535); + +/** + * Creates a new URL by combining the baseURL with the requestedURL, + * only when the requestedURL is not already an absolute URL. + * If the requestURL is absolute, this function returns the requestedURL untouched. + * + * @param {string} baseURL The base URL + * @param {string} requestedURL Absolute or relative URL to combine + * @returns {string} The combined full path + */ +module.exports = function buildFullPath(baseURL, requestedURL) { + if (baseURL && !isAbsoluteURL(requestedURL)) { + return combineURLs(baseURL, requestedURL); + } + return requestedURL; +}; + + +/***/ }), +/* 534 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Determines whether the specified URL is absolute + * + * @param {string} url The URL to test + * @returns {boolean} True if the specified URL is absolute, otherwise false + */ +module.exports = function isAbsoluteURL(url) { + // A URL is considered absolute if it begins with "://" or "//" (protocol-relative URL). + // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed + // by any combination of letters, digits, plus, period, or hyphen. + return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url); +}; + + +/***/ }), +/* 535 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Creates a new URL by combining the specified URLs + * + * @param {string} baseURL The base URL + * @param {string} relativeURL The relative URL + * @returns {string} The combined URL + */ +module.exports = function combineURLs(baseURL, relativeURL) { + return relativeURL + ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '') + : baseURL; +}; + + +/***/ }), +/* 536 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); + +// Headers whose duplicates are ignored by node +// c.f. https://nodejs.org/api/http.html#http_message_headers +var ignoreDuplicateOf = [ + 'age', 'authorization', 'content-length', 'content-type', 'etag', + 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since', + 'last-modified', 'location', 'max-forwards', 'proxy-authorization', + 'referer', 'retry-after', 'user-agent' +]; + +/** + * Parse headers into an object + * + * ``` + * Date: Wed, 27 Aug 2014 08:58:49 GMT + * Content-Type: application/json + * Connection: keep-alive + * Transfer-Encoding: chunked + * ``` + * + * @param {String} headers Headers needing to be parsed + * @returns {Object} Headers parsed into an object + */ +module.exports = function parseHeaders(headers) { + var parsed = {}; + var key; + var val; + var i; + + if (!headers) { return parsed; } + + utils.forEach(headers.split('\n'), function parser(line) { + i = line.indexOf(':'); + key = utils.trim(line.substr(0, i)).toLowerCase(); + val = utils.trim(line.substr(i + 1)); + + if (key) { + if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) { + return; + } + if (key === 'set-cookie') { + parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]); + } else { + parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val; + } + } + }); + + return parsed; +}; + + +/***/ }), +/* 537 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); + +module.exports = ( + utils.isStandardBrowserEnv() ? + + // Standard browser envs have full support of the APIs needed to test + // whether the request URL is of the same origin as current location. + (function standardBrowserEnv() { + var msie = /(msie|trident)/i.test(navigator.userAgent); + var urlParsingNode = document.createElement('a'); + var originURL; + + /** + * Parse a URL to discover it's components + * + * @param {String} url The URL to be parsed + * @returns {Object} + */ + function resolveURL(url) { + var href = url; + + if (msie) { + // IE needs attribute set twice to normalize properties + urlParsingNode.setAttribute('href', href); + href = urlParsingNode.href; + } + + urlParsingNode.setAttribute('href', href); + + // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils + return { + href: urlParsingNode.href, + protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '', + host: urlParsingNode.host, + search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '', + hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '', + hostname: urlParsingNode.hostname, + port: urlParsingNode.port, + pathname: (urlParsingNode.pathname.charAt(0) === '/') ? + urlParsingNode.pathname : + '/' + urlParsingNode.pathname + }; + } + + originURL = resolveURL(window.location.href); + + /** + * Determine if a URL shares the same origin as the current location + * + * @param {String} requestURL The URL to test + * @returns {boolean} True if URL shares the same origin, otherwise false + */ + return function isURLSameOrigin(requestURL) { + var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL; + return (parsed.protocol === originURL.protocol && + parsed.host === originURL.host); + }; + })() : + + // Non standard browser envs (web workers, react-native) lack needed support. + (function nonStandardBrowserEnv() { + return function isURLSameOrigin() { + return true; + }; + })() +); + + +/***/ }), +/* 538 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); +var settle = __webpack_require__(529); +var buildFullPath = __webpack_require__(533); +var buildURL = __webpack_require__(521); +var http = __webpack_require__(539); +var https = __webpack_require__(540); +var httpFollow = __webpack_require__(541).http; +var httpsFollow = __webpack_require__(541).https; +var url = __webpack_require__(283); +var zlib = __webpack_require__(549); +var pkg = __webpack_require__(550); +var createError = __webpack_require__(530); +var enhanceError = __webpack_require__(531); + +var isHttps = /https:?/; + +/** + * + * @param {http.ClientRequestArgs} options + * @param {AxiosProxyConfig} proxy + * @param {string} location + */ +function setProxy(options, proxy, location) { + options.hostname = proxy.host; + options.host = proxy.host; + options.port = proxy.port; + options.path = location; + + // Basic proxy authorization + if (proxy.auth) { + var base64 = Buffer.from(proxy.auth.username + ':' + proxy.auth.password, 'utf8').toString('base64'); + options.headers['Proxy-Authorization'] = 'Basic ' + base64; + } + + // If a proxy is used, any redirects must also pass through the proxy + options.beforeRedirect = function beforeRedirect(redirection) { + redirection.headers.host = redirection.host; + setProxy(redirection, proxy, redirection.href); + }; +} + +/*eslint consistent-return:0*/ +module.exports = function httpAdapter(config) { + return new Promise(function dispatchHttpRequest(resolvePromise, rejectPromise) { + var resolve = function resolve(value) { + resolvePromise(value); + }; + var reject = function reject(value) { + rejectPromise(value); + }; + var data = config.data; + var headers = config.headers; + + // Set User-Agent (required by some servers) + // Only set header if it hasn't been set in config + // See https://github.com/axios/axios/issues/69 + if (!headers['User-Agent'] && !headers['user-agent']) { + headers['User-Agent'] = 'axios/' + pkg.version; + } + + if (data && !utils.isStream(data)) { + if (Buffer.isBuffer(data)) { + // Nothing to do... + } else if (utils.isArrayBuffer(data)) { + data = Buffer.from(new Uint8Array(data)); + } else if (utils.isString(data)) { + data = Buffer.from(data, 'utf-8'); + } else { + return reject(createError( + 'Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream', + config + )); + } + + // Add Content-Length header if data exists + headers['Content-Length'] = data.length; + } + + // HTTP basic authentication + var auth = undefined; + if (config.auth) { + var username = config.auth.username || ''; + var password = config.auth.password || ''; + auth = username + ':' + password; + } + + // Parse url + var fullPath = buildFullPath(config.baseURL, config.url); + var parsed = url.parse(fullPath); + var protocol = parsed.protocol || 'http:'; + + if (!auth && parsed.auth) { + var urlAuth = parsed.auth.split(':'); + var urlUsername = urlAuth[0] || ''; + var urlPassword = urlAuth[1] || ''; + auth = urlUsername + ':' + urlPassword; + } + + if (auth) { + delete headers.Authorization; + } + + var isHttpsRequest = isHttps.test(protocol); + var agent = isHttpsRequest ? config.httpsAgent : config.httpAgent; + + var options = { + path: buildURL(parsed.path, config.params, config.paramsSerializer).replace(/^\?/, ''), + method: config.method.toUpperCase(), + headers: headers, + agent: agent, + agents: { http: config.httpAgent, https: config.httpsAgent }, + auth: auth + }; + + if (config.socketPath) { + options.socketPath = config.socketPath; + } else { + options.hostname = parsed.hostname; + options.port = parsed.port; + } + + var proxy = config.proxy; + if (!proxy && proxy !== false) { + var proxyEnv = protocol.slice(0, -1) + '_proxy'; + var proxyUrl = process.env[proxyEnv] || process.env[proxyEnv.toUpperCase()]; + if (proxyUrl) { + var parsedProxyUrl = url.parse(proxyUrl); + var noProxyEnv = process.env.no_proxy || process.env.NO_PROXY; + var shouldProxy = true; + + if (noProxyEnv) { + var noProxy = noProxyEnv.split(',').map(function trim(s) { + return s.trim(); + }); + + shouldProxy = !noProxy.some(function proxyMatch(proxyElement) { + if (!proxyElement) { + return false; + } + if (proxyElement === '*') { + return true; + } + if (proxyElement[0] === '.' && + parsed.hostname.substr(parsed.hostname.length - proxyElement.length) === proxyElement) { + return true; + } + + return parsed.hostname === proxyElement; + }); + } + + if (shouldProxy) { + proxy = { + host: parsedProxyUrl.hostname, + port: parsedProxyUrl.port, + protocol: parsedProxyUrl.protocol + }; + + if (parsedProxyUrl.auth) { + var proxyUrlAuth = parsedProxyUrl.auth.split(':'); + proxy.auth = { + username: proxyUrlAuth[0], + password: proxyUrlAuth[1] + }; + } + } + } + } + + if (proxy) { + options.headers.host = parsed.hostname + (parsed.port ? ':' + parsed.port : ''); + setProxy(options, proxy, protocol + '//' + parsed.hostname + (parsed.port ? ':' + parsed.port : '') + options.path); + } + + var transport; + var isHttpsProxy = isHttpsRequest && (proxy ? isHttps.test(proxy.protocol) : true); + if (config.transport) { + transport = config.transport; + } else if (config.maxRedirects === 0) { + transport = isHttpsProxy ? https : http; + } else { + if (config.maxRedirects) { + options.maxRedirects = config.maxRedirects; + } + transport = isHttpsProxy ? httpsFollow : httpFollow; + } + + if (config.maxBodyLength > -1) { + options.maxBodyLength = config.maxBodyLength; + } + + // Create the request + var req = transport.request(options, function handleResponse(res) { + if (req.aborted) return; + + // uncompress the response body transparently if required + var stream = res; + + // return the last request in case of redirects + var lastRequest = res.req || req; + + + // if no content, is HEAD request or decompress disabled we should not decompress + if (res.statusCode !== 204 && lastRequest.method !== 'HEAD' && config.decompress !== false) { + switch (res.headers['content-encoding']) { + /*eslint default-case:0*/ + case 'gzip': + case 'compress': + case 'deflate': + // add the unzipper to the body stream processing pipeline + stream = stream.pipe(zlib.createUnzip()); + + // remove the content-encoding in order to not confuse downstream operations + delete res.headers['content-encoding']; + break; + } + } + + var response = { + status: res.statusCode, + statusText: res.statusMessage, + headers: res.headers, + config: config, + request: lastRequest + }; + + if (config.responseType === 'stream') { + response.data = stream; + settle(resolve, reject, response); + } else { + var responseBuffer = []; + stream.on('data', function handleStreamData(chunk) { + responseBuffer.push(chunk); + + // make sure the content length is not over the maxContentLength if specified + if (config.maxContentLength > -1 && Buffer.concat(responseBuffer).length > config.maxContentLength) { + stream.destroy(); + reject(createError('maxContentLength size of ' + config.maxContentLength + ' exceeded', + config, null, lastRequest)); + } + }); + + stream.on('error', function handleStreamError(err) { + if (req.aborted) return; + reject(enhanceError(err, config, null, lastRequest)); + }); + + stream.on('end', function handleStreamEnd() { + var responseData = Buffer.concat(responseBuffer); + if (config.responseType !== 'arraybuffer') { + responseData = responseData.toString(config.responseEncoding); + if (!config.responseEncoding || config.responseEncoding === 'utf8') { + responseData = utils.stripBOM(responseData); + } + } + + response.data = responseData; + settle(resolve, reject, response); + }); + } + }); + + // Handle errors + req.on('error', function handleRequestError(err) { + if (req.aborted && err.code !== 'ERR_FR_TOO_MANY_REDIRECTS') return; + reject(enhanceError(err, config, null, req)); + }); + + // Handle request timeout + if (config.timeout) { + // Sometime, the response will be very slow, and does not respond, the connect event will be block by event loop system. + // And timer callback will be fired, and abort() will be invoked before connection, then get "socket hang up" and code ECONNRESET. + // At this time, if we have a large number of request, nodejs will hang up some socket on background. and the number will up and up. + // And then these socket which be hang up will devoring CPU little by little. + // ClientRequest.setTimeout will be fired on the specify milliseconds, and can make sure that abort() will be fired after connect. + req.setTimeout(config.timeout, function handleRequestTimeout() { + req.abort(); + reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED', req)); + }); + } + + if (config.cancelToken) { + // Handle cancellation + config.cancelToken.promise.then(function onCanceled(cancel) { + if (req.aborted) return; + + req.abort(); + reject(cancel); + }); + } + + // Send the request + if (utils.isStream(data)) { + data.on('error', function handleStreamError(err) { + reject(enhanceError(err, config, null, req)); + }).pipe(req); + } else { + req.end(data); + } + }); +}; + + +/***/ }), +/* 539 */ +/***/ (function(module, exports) { + +module.exports = require("http"); + +/***/ }), +/* 540 */ +/***/ (function(module, exports) { + +module.exports = require("https"); + +/***/ }), +/* 541 */ +/***/ (function(module, exports, __webpack_require__) { + +var url = __webpack_require__(283); +var URL = url.URL; +var http = __webpack_require__(539); +var https = __webpack_require__(540); +var Writable = __webpack_require__(138).Writable; +var assert = __webpack_require__(140); +var debug = __webpack_require__(542); + +// Create handlers that pass events from native requests +var eventHandlers = Object.create(null); +["abort", "aborted", "connect", "error", "socket", "timeout"].forEach(function (event) { + eventHandlers[event] = function (arg1, arg2, arg3) { + this._redirectable.emit(event, arg1, arg2, arg3); + }; +}); + +// Error types with codes +var RedirectionError = createErrorType( + "ERR_FR_REDIRECTION_FAILURE", + "" +); +var TooManyRedirectsError = createErrorType( + "ERR_FR_TOO_MANY_REDIRECTS", + "Maximum number of redirects exceeded" +); +var MaxBodyLengthExceededError = createErrorType( + "ERR_FR_MAX_BODY_LENGTH_EXCEEDED", + "Request body larger than maxBodyLength limit" +); +var WriteAfterEndError = createErrorType( + "ERR_STREAM_WRITE_AFTER_END", + "write after end" +); + +// An HTTP(S) request that can be redirected +function RedirectableRequest(options, responseCallback) { + // Initialize the request + Writable.call(this); + this._sanitizeOptions(options); + this._options = options; + this._ended = false; + this._ending = false; + this._redirectCount = 0; + this._redirects = []; + this._requestBodyLength = 0; + this._requestBodyBuffers = []; + + // Attach a callback if passed + if (responseCallback) { + this.on("response", responseCallback); + } + + // React to responses of native requests + var self = this; + this._onNativeResponse = function (response) { + self._processResponse(response); + }; + + // Perform the first request + this._performRequest(); +} +RedirectableRequest.prototype = Object.create(Writable.prototype); + +// Writes buffered data to the current native request +RedirectableRequest.prototype.write = function (data, encoding, callback) { + // Writing is not allowed if end has been called + if (this._ending) { + throw new WriteAfterEndError(); + } + + // Validate input and shift parameters if necessary + if (!(typeof data === "string" || typeof data === "object" && ("length" in data))) { + throw new TypeError("data should be a string, Buffer or Uint8Array"); + } + if (typeof encoding === "function") { + callback = encoding; + encoding = null; + } + + // Ignore empty buffers, since writing them doesn't invoke the callback + // https://github.com/nodejs/node/issues/22066 + if (data.length === 0) { + if (callback) { + callback(); + } + return; + } + // Only write when we don't exceed the maximum body length + if (this._requestBodyLength + data.length <= this._options.maxBodyLength) { + this._requestBodyLength += data.length; + this._requestBodyBuffers.push({ data: data, encoding: encoding }); + this._currentRequest.write(data, encoding, callback); + } + // Error when we exceed the maximum body length + else { + this.emit("error", new MaxBodyLengthExceededError()); + this.abort(); + } +}; + +// Ends the current native request +RedirectableRequest.prototype.end = function (data, encoding, callback) { + // Shift parameters if necessary + if (typeof data === "function") { + callback = data; + data = encoding = null; + } + else if (typeof encoding === "function") { + callback = encoding; + encoding = null; + } + + // Write data if needed and end + if (!data) { + this._ended = this._ending = true; + this._currentRequest.end(null, null, callback); + } + else { + var self = this; + var currentRequest = this._currentRequest; + this.write(data, encoding, function () { + self._ended = true; + currentRequest.end(null, null, callback); + }); + this._ending = true; + } +}; + +// Sets a header value on the current native request +RedirectableRequest.prototype.setHeader = function (name, value) { + this._options.headers[name] = value; + this._currentRequest.setHeader(name, value); +}; + +// Clears a header value on the current native request +RedirectableRequest.prototype.removeHeader = function (name) { + delete this._options.headers[name]; + this._currentRequest.removeHeader(name); +}; + +// Global timeout for all underlying requests +RedirectableRequest.prototype.setTimeout = function (msecs, callback) { + if (callback) { + this.once("timeout", callback); + } + + if (this.socket) { + startTimer(this, msecs); + } + else { + var self = this; + this._currentRequest.once("socket", function () { + startTimer(self, msecs); + }); + } + + this.once("response", clearTimer); + this.once("error", clearTimer); + + return this; +}; + +function startTimer(request, msecs) { + clearTimeout(request._timeout); + request._timeout = setTimeout(function () { + request.emit("timeout"); + }, msecs); +} + +function clearTimer() { + clearTimeout(this._timeout); +} + +// Proxy all other public ClientRequest methods +[ + "abort", "flushHeaders", "getHeader", + "setNoDelay", "setSocketKeepAlive", +].forEach(function (method) { + RedirectableRequest.prototype[method] = function (a, b) { + return this._currentRequest[method](a, b); + }; +}); + +// Proxy all public ClientRequest properties +["aborted", "connection", "socket"].forEach(function (property) { + Object.defineProperty(RedirectableRequest.prototype, property, { + get: function () { return this._currentRequest[property]; }, + }); +}); + +RedirectableRequest.prototype._sanitizeOptions = function (options) { + // Ensure headers are always present + if (!options.headers) { + options.headers = {}; + } + + // Since http.request treats host as an alias of hostname, + // but the url module interprets host as hostname plus port, + // eliminate the host property to avoid confusion. + if (options.host) { + // Use hostname if set, because it has precedence + if (!options.hostname) { + options.hostname = options.host; + } + delete options.host; + } + + // Complete the URL object when necessary + if (!options.pathname && options.path) { + var searchPos = options.path.indexOf("?"); + if (searchPos < 0) { + options.pathname = options.path; + } + else { + options.pathname = options.path.substring(0, searchPos); + options.search = options.path.substring(searchPos); + } + } +}; + + +// Executes the next native request (initial or redirect) +RedirectableRequest.prototype._performRequest = function () { + // Load the native protocol + var protocol = this._options.protocol; + var nativeProtocol = this._options.nativeProtocols[protocol]; + if (!nativeProtocol) { + this.emit("error", new TypeError("Unsupported protocol " + protocol)); + return; + } + + // If specified, use the agent corresponding to the protocol + // (HTTP and HTTPS use different types of agents) + if (this._options.agents) { + var scheme = protocol.substr(0, protocol.length - 1); + this._options.agent = this._options.agents[scheme]; + } + + // Create the native request + var request = this._currentRequest = + nativeProtocol.request(this._options, this._onNativeResponse); + this._currentUrl = url.format(this._options); + + // Set up event handlers + request._redirectable = this; + for (var event in eventHandlers) { + /* istanbul ignore else */ + if (event) { + request.on(event, eventHandlers[event]); + } + } + + // End a redirected request + // (The first request must be ended explicitly with RedirectableRequest#end) + if (this._isRedirect) { + // Write the request entity and end. + var i = 0; + var self = this; + var buffers = this._requestBodyBuffers; + (function writeNext(error) { + // Only write if this request has not been redirected yet + /* istanbul ignore else */ + if (request === self._currentRequest) { + // Report any write errors + /* istanbul ignore if */ + if (error) { + self.emit("error", error); + } + // Write the next buffer if there are still left + else if (i < buffers.length) { + var buffer = buffers[i++]; + /* istanbul ignore else */ + if (!request.finished) { + request.write(buffer.data, buffer.encoding, writeNext); + } + } + // End the request if `end` has been called on us + else if (self._ended) { + request.end(); + } + } + }()); + } +}; + +// Processes a response from the current native request +RedirectableRequest.prototype._processResponse = function (response) { + // Store the redirected response + var statusCode = response.statusCode; + if (this._options.trackRedirects) { + this._redirects.push({ + url: this._currentUrl, + headers: response.headers, + statusCode: statusCode, + }); + } + + // RFC7231§6.4: The 3xx (Redirection) class of status code indicates + // that further action needs to be taken by the user agent in order to + // fulfill the request. If a Location header field is provided, + // the user agent MAY automatically redirect its request to the URI + // referenced by the Location field value, + // even if the specific status code is not understood. + var location = response.headers.location; + if (location && this._options.followRedirects !== false && + statusCode >= 300 && statusCode < 400) { + // Abort the current request + this._currentRequest.removeAllListeners(); + this._currentRequest.on("error", noop); + this._currentRequest.abort(); + // Discard the remainder of the response to avoid waiting for data + response.destroy(); + + // RFC7231§6.4: A client SHOULD detect and intervene + // in cyclical redirections (i.e., "infinite" redirection loops). + if (++this._redirectCount > this._options.maxRedirects) { + this.emit("error", new TooManyRedirectsError()); + return; + } + + // RFC7231§6.4: Automatic redirection needs to done with + // care for methods not known to be safe, […] + // RFC7231§6.4.2–3: For historical reasons, a user agent MAY change + // the request method from POST to GET for the subsequent request. + if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" || + // RFC7231§6.4.4: The 303 (See Other) status code indicates that + // the server is redirecting the user agent to a different resource […] + // A user agent can perform a retrieval request targeting that URI + // (a GET or HEAD request if using HTTP) […] + (statusCode === 303) && !/^(?:GET|HEAD)$/.test(this._options.method)) { + this._options.method = "GET"; + // Drop a possible entity and headers related to it + this._requestBodyBuffers = []; + removeMatchingHeaders(/^content-/i, this._options.headers); + } + + // Drop the Host header, as the redirect might lead to a different host + var previousHostName = removeMatchingHeaders(/^host$/i, this._options.headers) || + url.parse(this._currentUrl).hostname; + + // Create the redirected request + var redirectUrl = url.resolve(this._currentUrl, location); + debug("redirecting to", redirectUrl); + this._isRedirect = true; + var redirectUrlParts = url.parse(redirectUrl); + Object.assign(this._options, redirectUrlParts); + + // Drop the Authorization header if redirecting to another host + if (redirectUrlParts.hostname !== previousHostName) { + removeMatchingHeaders(/^authorization$/i, this._options.headers); + } + + // Evaluate the beforeRedirect callback + if (typeof this._options.beforeRedirect === "function") { + var responseDetails = { headers: response.headers }; + try { + this._options.beforeRedirect.call(null, this._options, responseDetails); + } + catch (err) { + this.emit("error", err); + return; + } + this._sanitizeOptions(this._options); + } + + // Perform the redirected request + try { + this._performRequest(); + } + catch (cause) { + var error = new RedirectionError("Redirected request failed: " + cause.message); + error.cause = cause; + this.emit("error", error); + } + } + else { + // The response is not a redirect; return it as-is + response.responseUrl = this._currentUrl; + response.redirects = this._redirects; + this.emit("response", response); + + // Clean up + this._requestBodyBuffers = []; + } +}; + +// Wraps the key/value object of protocols with redirect functionality +function wrap(protocols) { + // Default settings + var exports = { + maxRedirects: 21, + maxBodyLength: 10 * 1024 * 1024, + }; + + // Wrap each protocol + var nativeProtocols = {}; + Object.keys(protocols).forEach(function (scheme) { + var protocol = scheme + ":"; + var nativeProtocol = nativeProtocols[protocol] = protocols[scheme]; + var wrappedProtocol = exports[scheme] = Object.create(nativeProtocol); + + // Executes a request, following redirects + wrappedProtocol.request = function (input, options, callback) { + // Parse parameters + if (typeof input === "string") { + var urlStr = input; + try { + input = urlToOptions(new URL(urlStr)); + } + catch (err) { + /* istanbul ignore next */ + input = url.parse(urlStr); + } + } + else if (URL && (input instanceof URL)) { + input = urlToOptions(input); + } + else { + callback = options; + options = input; + input = { protocol: protocol }; + } + if (typeof options === "function") { + callback = options; + options = null; + } + + // Set defaults + options = Object.assign({ + maxRedirects: exports.maxRedirects, + maxBodyLength: exports.maxBodyLength, + }, input, options); + options.nativeProtocols = nativeProtocols; + + assert.equal(options.protocol, protocol, "protocol mismatch"); + debug("options", options); + return new RedirectableRequest(options, callback); + }; + + // Executes a GET request, following redirects + wrappedProtocol.get = function (input, options, callback) { + var request = wrappedProtocol.request(input, options, callback); + request.end(); + return request; + }; + }); + return exports; +} + +/* istanbul ignore next */ +function noop() { /* empty */ } + +// from https://github.com/nodejs/node/blob/master/lib/internal/url.js +function urlToOptions(urlObject) { + var options = { + protocol: urlObject.protocol, + hostname: urlObject.hostname.startsWith("[") ? + /* istanbul ignore next */ + urlObject.hostname.slice(1, -1) : + urlObject.hostname, + hash: urlObject.hash, + search: urlObject.search, + pathname: urlObject.pathname, + path: urlObject.pathname + urlObject.search, + href: urlObject.href, + }; + if (urlObject.port !== "") { + options.port = Number(urlObject.port); + } + return options; +} + +function removeMatchingHeaders(regex, headers) { + var lastValue; + for (var header in headers) { + if (regex.test(header)) { + lastValue = headers[header]; + delete headers[header]; + } + } + return lastValue; +} + +function createErrorType(code, defaultMessage) { + function CustomError(message) { + Error.captureStackTrace(this, this.constructor); + this.message = message || defaultMessage; + } + CustomError.prototype = new Error(); + CustomError.prototype.constructor = CustomError; + CustomError.prototype.name = "Error [" + code + "]"; + CustomError.prototype.code = code; + return CustomError; +} + +// Exports +module.exports = wrap({ http: http, https: https }); +module.exports.wrap = wrap; + + +/***/ }), +/* 542 */ +/***/ (function(module, exports, __webpack_require__) { + +var debug; +try { + /* eslint global-require: off */ + debug = __webpack_require__(543)("follow-redirects"); +} +catch (error) { + debug = function () { /* */ }; +} +module.exports = debug; + + +/***/ }), +/* 543 */ +/***/ (function(module, exports, __webpack_require__) { + +/** + * Detect Electron renderer process, which is node, but we should + * treat as a browser. + */ + +if (typeof process !== 'undefined' && process.type === 'renderer') { + module.exports = __webpack_require__(544); +} else { + module.exports = __webpack_require__(547); +} + + +/***/ }), +/* 544 */ +/***/ (function(module, exports, __webpack_require__) { + +/** + * This is the web browser implementation of `debug()`. + * + * Expose `debug()` as the module. + */ + +exports = module.exports = __webpack_require__(545); +exports.log = log; +exports.formatArgs = formatArgs; +exports.save = save; +exports.load = load; +exports.useColors = useColors; +exports.storage = 'undefined' != typeof chrome + && 'undefined' != typeof chrome.storage + ? chrome.storage.local + : localstorage(); + +/** + * Colors. + */ + +exports.colors = [ + 'lightseagreen', + 'forestgreen', + 'goldenrod', + 'dodgerblue', + 'darkorchid', + 'crimson' +]; + +/** + * Currently only WebKit-based Web Inspectors, Firefox >= v31, + * and the Firebug extension (any Firefox version) are known + * to support "%c" CSS customizations. + * + * TODO: add a `localStorage` variable to explicitly enable/disable colors + */ + +function useColors() { + // NB: In an Electron preload script, document will be defined but not fully + // initialized. Since we know we're in Chrome, we'll just detect this case + // explicitly + if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') { + return true; + } + + // is webkit? http://stackoverflow.com/a/16459606/376773 + // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632 + return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) || + // is firebug? http://stackoverflow.com/a/398120/376773 + (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) || + // is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) || + // double check webkit in userAgent just in case we are in a worker + (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)); +} + +/** + * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. + */ + +exports.formatters.j = function(v) { + try { + return JSON.stringify(v); + } catch (err) { + return '[UnexpectedJSONParseError]: ' + err.message; + } +}; + + +/** + * Colorize log arguments if enabled. + * + * @api public + */ + +function formatArgs(args) { + var useColors = this.useColors; + + args[0] = (useColors ? '%c' : '') + + this.namespace + + (useColors ? ' %c' : ' ') + + args[0] + + (useColors ? '%c ' : ' ') + + '+' + exports.humanize(this.diff); + + if (!useColors) return; + + var c = 'color: ' + this.color; + args.splice(1, 0, c, 'color: inherit') + + // the final "%c" is somewhat tricky, because there could be other + // arguments passed either before or after the %c, so we need to + // figure out the correct index to insert the CSS into + var index = 0; + var lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, function(match) { + if ('%%' === match) return; + index++; + if ('%c' === match) { + // we only are interested in the *last* %c + // (the user may have provided their own) + lastC = index; + } + }); + + args.splice(lastC, 0, c); +} + +/** + * Invokes `console.log()` when available. + * No-op when `console.log` is not a "function". + * + * @api public + */ + +function log() { + // this hackery is required for IE8/9, where + // the `console.log` function doesn't have 'apply' + return 'object' === typeof console + && console.log + && Function.prototype.apply.call(console.log, console, arguments); +} + +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ + +function save(namespaces) { + try { + if (null == namespaces) { + exports.storage.removeItem('debug'); + } else { + exports.storage.debug = namespaces; + } + } catch(e) {} +} + +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ + +function load() { + var r; + try { + r = exports.storage.debug; + } catch(e) {} + + // If debug isn't set in LS, and we're in Electron, try to load $DEBUG + if (!r && typeof process !== 'undefined' && 'env' in process) { + r = process.env.DEBUG; + } + + return r; +} + +/** + * Enable namespaces listed in `localStorage.debug` initially. + */ + +exports.enable(load()); + +/** + * Localstorage attempts to return the localstorage. + * + * This is necessary because safari throws + * when a user disables cookies/localstorage + * and you attempt to access it. + * + * @return {LocalStorage} + * @api private + */ + +function localstorage() { + try { + return window.localStorage; + } catch (e) {} +} + + +/***/ }), +/* 545 */ +/***/ (function(module, exports, __webpack_require__) { + + +/** + * This is the common logic for both the Node.js and web browser + * implementations of `debug()`. + * + * Expose `debug()` as the module. + */ + +exports = module.exports = createDebug.debug = createDebug['default'] = createDebug; +exports.coerce = coerce; +exports.disable = disable; +exports.enable = enable; +exports.enabled = enabled; +exports.humanize = __webpack_require__(546); + +/** + * The currently active debug mode names, and names to skip. + */ + +exports.names = []; +exports.skips = []; + +/** + * Map of special "%n" handling functions, for the debug "format" argument. + * + * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". + */ + +exports.formatters = {}; + +/** + * Previous log timestamp. + */ + +var prevTime; + +/** + * Select a color. + * @param {String} namespace + * @return {Number} + * @api private + */ + +function selectColor(namespace) { + var hash = 0, i; + + for (i in namespace) { + hash = ((hash << 5) - hash) + namespace.charCodeAt(i); + hash |= 0; // Convert to 32bit integer + } + + return exports.colors[Math.abs(hash) % exports.colors.length]; +} + +/** + * Create a debugger with the given `namespace`. + * + * @param {String} namespace + * @return {Function} + * @api public + */ + +function createDebug(namespace) { + + function debug() { + // disabled? + if (!debug.enabled) return; + + var self = debug; + + // set `diff` timestamp + var curr = +new Date(); + var ms = curr - (prevTime || curr); + self.diff = ms; + self.prev = prevTime; + self.curr = curr; + prevTime = curr; + + // turn the `arguments` into a proper Array + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + + args[0] = exports.coerce(args[0]); + + if ('string' !== typeof args[0]) { + // anything else let's inspect with %O + args.unshift('%O'); + } + + // apply any `formatters` transformations + var index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) { + // if we encounter an escaped % then don't increase the array index + if (match === '%%') return match; + index++; + var formatter = exports.formatters[format]; + if ('function' === typeof formatter) { + var val = args[index]; + match = formatter.call(self, val); + + // now we need to remove `args[index]` since it's inlined in the `format` + args.splice(index, 1); + index--; + } + return match; + }); + + // apply env-specific formatting (colors, etc.) + exports.formatArgs.call(self, args); + + var logFn = debug.log || exports.log || console.log.bind(console); + logFn.apply(self, args); + } + + debug.namespace = namespace; + debug.enabled = exports.enabled(namespace); + debug.useColors = exports.useColors(); + debug.color = selectColor(namespace); + + // env-specific initialization logic for debug instances + if ('function' === typeof exports.init) { + exports.init(debug); + } + + return debug; +} + +/** + * Enables a debug mode by namespaces. This can include modes + * separated by a colon and wildcards. + * + * @param {String} namespaces + * @api public + */ + +function enable(namespaces) { + exports.save(namespaces); + + exports.names = []; + exports.skips = []; + + var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/); + var len = split.length; + + for (var i = 0; i < len; i++) { + if (!split[i]) continue; // ignore empty strings + namespaces = split[i].replace(/\*/g, '.*?'); + if (namespaces[0] === '-') { + exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); + } else { + exports.names.push(new RegExp('^' + namespaces + '$')); + } + } +} + +/** + * Disable debug output. + * + * @api public + */ + +function disable() { + exports.enable(''); +} + +/** + * Returns true if the given mode name is enabled, false otherwise. + * + * @param {String} name + * @return {Boolean} + * @api public + */ + +function enabled(name) { + var i, len; + for (i = 0, len = exports.skips.length; i < len; i++) { + if (exports.skips[i].test(name)) { + return false; + } + } + for (i = 0, len = exports.names.length; i < len; i++) { + if (exports.names[i].test(name)) { + return true; + } + } + return false; +} + +/** + * Coerce `val`. + * + * @param {Mixed} val + * @return {Mixed} + * @api private + */ + +function coerce(val) { + if (val instanceof Error) return val.stack || val.message; + return val; +} + + +/***/ }), +/* 546 */ +/***/ (function(module, exports) { + +/** + * Helpers. + */ + +var s = 1000; +var m = s * 60; +var h = m * 60; +var d = h * 24; +var y = d * 365.25; + +/** + * Parse or format the given `val`. + * + * Options: + * + * - `long` verbose formatting [false] + * + * @param {String|Number} val + * @param {Object} [options] + * @throws {Error} throw an error if val is not a non-empty string or a number + * @return {String|Number} + * @api public + */ + +module.exports = function(val, options) { + options = options || {}; + var type = typeof val; + if (type === 'string' && val.length > 0) { + return parse(val); + } else if (type === 'number' && isNaN(val) === false) { + return options.long ? fmtLong(val) : fmtShort(val); + } + throw new Error( + 'val is not a non-empty string or a valid number. val=' + + JSON.stringify(val) + ); +}; + +/** + * Parse the given `str` and return milliseconds. + * + * @param {String} str + * @return {Number} + * @api private + */ + +function parse(str) { + str = String(str); + if (str.length > 100) { + return; + } + var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec( + str + ); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type = (match[2] || 'ms').toLowerCase(); + switch (type) { + case 'years': + case 'year': + case 'yrs': + case 'yr': + case 'y': + return n * y; + case 'days': + case 'day': + case 'd': + return n * d; + case 'hours': + case 'hour': + case 'hrs': + case 'hr': + case 'h': + return n * h; + case 'minutes': + case 'minute': + case 'mins': + case 'min': + case 'm': + return n * m; + case 'seconds': + case 'second': + case 'secs': + case 'sec': + case 's': + return n * s; + case 'milliseconds': + case 'millisecond': + case 'msecs': + case 'msec': + case 'ms': + return n; + default: + return undefined; + } +} + +/** + * Short format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function fmtShort(ms) { + if (ms >= d) { + return Math.round(ms / d) + 'd'; + } + if (ms >= h) { + return Math.round(ms / h) + 'h'; + } + if (ms >= m) { + return Math.round(ms / m) + 'm'; + } + if (ms >= s) { + return Math.round(ms / s) + 's'; + } + return ms + 'ms'; +} + +/** + * Long format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function fmtLong(ms) { + return plural(ms, d, 'day') || + plural(ms, h, 'hour') || + plural(ms, m, 'minute') || + plural(ms, s, 'second') || + ms + ' ms'; +} + +/** + * Pluralization helper. + */ + +function plural(ms, n, name) { + if (ms < n) { + return; + } + if (ms < n * 1.5) { + return Math.floor(ms / n) + ' ' + name; + } + return Math.ceil(ms / n) + ' ' + name + 's'; +} + + +/***/ }), +/* 547 */ +/***/ (function(module, exports, __webpack_require__) { + +/** + * Module dependencies. + */ + +var tty = __webpack_require__(122); +var util = __webpack_require__(112); + +/** + * This is the Node.js implementation of `debug()`. + * + * Expose `debug()` as the module. + */ + +exports = module.exports = __webpack_require__(545); +exports.init = init; +exports.log = log; +exports.formatArgs = formatArgs; +exports.save = save; +exports.load = load; +exports.useColors = useColors; + +/** + * Colors. + */ + +exports.colors = [6, 2, 3, 4, 5, 1]; + +/** + * Build up the default `inspectOpts` object from the environment variables. + * + * $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js + */ + +exports.inspectOpts = Object.keys(process.env).filter(function (key) { + return /^debug_/i.test(key); +}).reduce(function (obj, key) { + // camel-case + var prop = key + .substring(6) + .toLowerCase() + .replace(/_([a-z])/g, function (_, k) { return k.toUpperCase() }); + + // coerce string value into JS value + var val = process.env[key]; + if (/^(yes|on|true|enabled)$/i.test(val)) val = true; + else if (/^(no|off|false|disabled)$/i.test(val)) val = false; + else if (val === 'null') val = null; + else val = Number(val); + + obj[prop] = val; + return obj; +}, {}); + +/** + * The file descriptor to write the `debug()` calls to. + * Set the `DEBUG_FD` env variable to override with another value. i.e.: + * + * $ DEBUG_FD=3 node script.js 3>debug.log + */ + +var fd = parseInt(process.env.DEBUG_FD, 10) || 2; + +if (1 !== fd && 2 !== fd) { + util.deprecate(function(){}, 'except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)')() +} + +var stream = 1 === fd ? process.stdout : + 2 === fd ? process.stderr : + createWritableStdioStream(fd); + +/** + * Is stdout a TTY? Colored output is enabled when `true`. + */ + +function useColors() { + return 'colors' in exports.inspectOpts + ? Boolean(exports.inspectOpts.colors) + : tty.isatty(fd); +} + +/** + * Map %o to `util.inspect()`, all on a single line. + */ + +exports.formatters.o = function(v) { + this.inspectOpts.colors = this.useColors; + return util.inspect(v, this.inspectOpts) + .split('\n').map(function(str) { + return str.trim() + }).join(' '); +}; + +/** + * Map %o to `util.inspect()`, allowing multiple lines if needed. + */ + +exports.formatters.O = function(v) { + this.inspectOpts.colors = this.useColors; + return util.inspect(v, this.inspectOpts); +}; + +/** + * Adds ANSI color escape codes if enabled. + * + * @api public + */ + +function formatArgs(args) { + var name = this.namespace; + var useColors = this.useColors; + + if (useColors) { + var c = this.color; + var prefix = ' \u001b[3' + c + ';1m' + name + ' ' + '\u001b[0m'; + + args[0] = prefix + args[0].split('\n').join('\n' + prefix); + args.push('\u001b[3' + c + 'm+' + exports.humanize(this.diff) + '\u001b[0m'); + } else { + args[0] = new Date().toUTCString() + + ' ' + name + ' ' + args[0]; + } +} + +/** + * Invokes `util.format()` with the specified arguments and writes to `stream`. + */ + +function log() { + return stream.write(util.format.apply(util, arguments) + '\n'); +} + +/** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ + +function save(namespaces) { + if (null == namespaces) { + // If you set a process.env field to null or undefined, it gets cast to the + // string 'null' or 'undefined'. Just delete instead. + delete process.env.DEBUG; + } else { + process.env.DEBUG = namespaces; + } +} + +/** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ + +function load() { + return process.env.DEBUG; +} + +/** + * Copied from `node/src/node.js`. + * + * XXX: It's lame that node doesn't expose this API out-of-the-box. It also + * relies on the undocumented `tty_wrap.guessHandleType()` which is also lame. + */ + +function createWritableStdioStream (fd) { + var stream; + var tty_wrap = process.binding('tty_wrap'); + + // Note stream._type is used for test-module-load-list.js + + switch (tty_wrap.guessHandleType(fd)) { + case 'TTY': + stream = new tty.WriteStream(fd); + stream._type = 'tty'; + + // Hack to have stream not keep the event loop alive. + // See https://github.com/joyent/node/issues/1726 + if (stream._handle && stream._handle.unref) { + stream._handle.unref(); + } + break; + + case 'FILE': + var fs = __webpack_require__(134); + stream = new fs.SyncWriteStream(fd, { autoClose: false }); + stream._type = 'fs'; + break; + + case 'PIPE': + case 'TCP': + var net = __webpack_require__(548); + stream = new net.Socket({ + fd: fd, + readable: false, + writable: true + }); + + // FIXME Should probably have an option in net.Socket to create a + // stream from an existing fd which is writable only. But for now + // we'll just add this hack and set the `readable` member to false. + // Test: ./node test/fixtures/echo.js < /etc/passwd + stream.readable = false; + stream.read = null; + stream._type = 'pipe'; + + // FIXME Hack to have stream not keep the event loop alive. + // See https://github.com/joyent/node/issues/1726 + if (stream._handle && stream._handle.unref) { + stream._handle.unref(); + } + break; + + default: + // Probably an error on in uv_guess_handle() + throw new Error('Implement me. Unknown stream file type!'); + } + + // For supporting legacy API we put the FD here. + stream.fd = fd; + + stream._isStdio = true; + + return stream; +} + +/** + * Init logic for `debug` instances. + * + * Create a new `inspectOpts` object in case `useColors` is set + * differently for a particular `debug` instance. + */ + +function init (debug) { + debug.inspectOpts = {}; + + var keys = Object.keys(exports.inspectOpts); + for (var i = 0; i < keys.length; i++) { + debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]]; + } +} + +/** + * Enable namespaces listed in `process.env.DEBUG` initially. + */ + +exports.enable(load()); + + +/***/ }), +/* 548 */ +/***/ (function(module, exports) { + +module.exports = require("net"); + +/***/ }), +/* 549 */ +/***/ (function(module, exports) { + +module.exports = require("zlib"); + +/***/ }), +/* 550 */ +/***/ (function(module) { + +module.exports = JSON.parse("{\"name\":\"axios\",\"version\":\"0.21.1\",\"description\":\"Promise based HTTP client for the browser and node.js\",\"main\":\"index.js\",\"scripts\":{\"test\":\"grunt test && bundlesize\",\"start\":\"node ./sandbox/server.js\",\"build\":\"NODE_ENV=production grunt build\",\"preversion\":\"npm test\",\"version\":\"npm run build && grunt version && git add -A dist && git add CHANGELOG.md bower.json package.json\",\"postversion\":\"git push && git push --tags\",\"examples\":\"node ./examples/server.js\",\"coveralls\":\"cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js\",\"fix\":\"eslint --fix lib/**/*.js\"},\"repository\":{\"type\":\"git\",\"url\":\"https://github.com/axios/axios.git\"},\"keywords\":[\"xhr\",\"http\",\"ajax\",\"promise\",\"node\"],\"author\":\"Matt Zabriskie\",\"license\":\"MIT\",\"bugs\":{\"url\":\"https://github.com/axios/axios/issues\"},\"homepage\":\"https://github.com/axios/axios\",\"devDependencies\":{\"bundlesize\":\"^0.17.0\",\"coveralls\":\"^3.0.0\",\"es6-promise\":\"^4.2.4\",\"grunt\":\"^1.0.2\",\"grunt-banner\":\"^0.6.0\",\"grunt-cli\":\"^1.2.0\",\"grunt-contrib-clean\":\"^1.1.0\",\"grunt-contrib-watch\":\"^1.0.0\",\"grunt-eslint\":\"^20.1.0\",\"grunt-karma\":\"^2.0.0\",\"grunt-mocha-test\":\"^0.13.3\",\"grunt-ts\":\"^6.0.0-beta.19\",\"grunt-webpack\":\"^1.0.18\",\"istanbul-instrumenter-loader\":\"^1.0.0\",\"jasmine-core\":\"^2.4.1\",\"karma\":\"^1.3.0\",\"karma-chrome-launcher\":\"^2.2.0\",\"karma-coverage\":\"^1.1.1\",\"karma-firefox-launcher\":\"^1.1.0\",\"karma-jasmine\":\"^1.1.1\",\"karma-jasmine-ajax\":\"^0.1.13\",\"karma-opera-launcher\":\"^1.0.0\",\"karma-safari-launcher\":\"^1.0.0\",\"karma-sauce-launcher\":\"^1.2.0\",\"karma-sinon\":\"^1.0.5\",\"karma-sourcemap-loader\":\"^0.3.7\",\"karma-webpack\":\"^1.7.0\",\"load-grunt-tasks\":\"^3.5.2\",\"minimist\":\"^1.2.0\",\"mocha\":\"^5.2.0\",\"sinon\":\"^4.5.0\",\"typescript\":\"^2.8.1\",\"url-search-params\":\"^0.10.0\",\"webpack\":\"^1.13.1\",\"webpack-dev-server\":\"^1.14.1\"},\"browser\":{\"./lib/adapters/http.js\":\"./lib/adapters/xhr.js\"},\"jsdelivr\":\"dist/axios.min.js\",\"unpkg\":\"dist/axios.min.js\",\"typings\":\"./index.d.ts\",\"dependencies\":{\"follow-redirects\":\"^1.10.0\"},\"bundlesize\":[{\"path\":\"./dist/axios.min.js\",\"threshold\":\"5kB\"}]}"); + +/***/ }), +/* 551 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var utils = __webpack_require__(518); + +/** + * Config-specific merge-function which creates a new config-object + * by merging two configuration objects together. + * + * @param {Object} config1 + * @param {Object} config2 + * @returns {Object} New object resulting from merging config2 to config1 + */ +module.exports = function mergeConfig(config1, config2) { + // eslint-disable-next-line no-param-reassign + config2 = config2 || {}; + var config = {}; + + var valueFromConfig2Keys = ['url', 'method', 'data']; + var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy', 'params']; + var defaultToConfig2Keys = [ + 'baseURL', 'transformRequest', 'transformResponse', 'paramsSerializer', + 'timeout', 'timeoutMessage', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName', + 'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress', 'decompress', + 'maxContentLength', 'maxBodyLength', 'maxRedirects', 'transport', 'httpAgent', + 'httpsAgent', 'cancelToken', 'socketPath', 'responseEncoding' + ]; + var directMergeKeys = ['validateStatus']; + + function getMergedValue(target, source) { + if (utils.isPlainObject(target) && utils.isPlainObject(source)) { + return utils.merge(target, source); + } else if (utils.isPlainObject(source)) { + return utils.merge({}, source); + } else if (utils.isArray(source)) { + return source.slice(); + } + return source; + } + + function mergeDeepProperties(prop) { + if (!utils.isUndefined(config2[prop])) { + config[prop] = getMergedValue(config1[prop], config2[prop]); + } else if (!utils.isUndefined(config1[prop])) { + config[prop] = getMergedValue(undefined, config1[prop]); + } + } + + utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) { + if (!utils.isUndefined(config2[prop])) { + config[prop] = getMergedValue(undefined, config2[prop]); + } + }); + + utils.forEach(mergeDeepPropertiesKeys, mergeDeepProperties); + + utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) { + if (!utils.isUndefined(config2[prop])) { + config[prop] = getMergedValue(undefined, config2[prop]); + } else if (!utils.isUndefined(config1[prop])) { + config[prop] = getMergedValue(undefined, config1[prop]); + } + }); + + utils.forEach(directMergeKeys, function merge(prop) { + if (prop in config2) { + config[prop] = getMergedValue(config1[prop], config2[prop]); + } else if (prop in config1) { + config[prop] = getMergedValue(undefined, config1[prop]); + } + }); + + var axiosKeys = valueFromConfig2Keys + .concat(mergeDeepPropertiesKeys) + .concat(defaultToConfig2Keys) + .concat(directMergeKeys); + + var otherKeys = Object + .keys(config1) + .concat(Object.keys(config2)) + .filter(function filterAxiosKeys(key) { + return axiosKeys.indexOf(key) === -1; + }); + + utils.forEach(otherKeys, mergeDeepProperties); + + return config; +}; + + +/***/ }), +/* 552 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * A `Cancel` is an object that is thrown when an operation is canceled. + * + * @class + * @param {string=} message The message. + */ +function Cancel(message) { + this.message = message; +} + +Cancel.prototype.toString = function toString() { + return 'Cancel' + (this.message ? ': ' + this.message : ''); +}; + +Cancel.prototype.__CANCEL__ = true; + +module.exports = Cancel; + + +/***/ }), +/* 553 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var Cancel = __webpack_require__(552); + +/** + * A `CancelToken` is an object that can be used to request cancellation of an operation. + * + * @class + * @param {Function} executor The executor function. + */ +function CancelToken(executor) { + if (typeof executor !== 'function') { + throw new TypeError('executor must be a function.'); + } + + var resolvePromise; + this.promise = new Promise(function promiseExecutor(resolve) { + resolvePromise = resolve; + }); + + var token = this; + executor(function cancel(message) { + if (token.reason) { + // Cancellation has already been requested + return; + } + + token.reason = new Cancel(message); + resolvePromise(token.reason); + }); +} + +/** + * Throws a `Cancel` if cancellation has been requested. + */ +CancelToken.prototype.throwIfRequested = function throwIfRequested() { + if (this.reason) { + throw this.reason; + } +}; + +/** + * Returns an object that contains a new `CancelToken` and a function that, when called, + * cancels the `CancelToken`. + */ +CancelToken.source = function source() { + var cancel; + var token = new CancelToken(function executor(c) { + cancel = c; + }); + return { + token: token, + cancel: cancel + }; +}; + +module.exports = CancelToken; + + +/***/ }), +/* 554 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Syntactic sugar for invoking a function and expanding an array for arguments. + * + * Common use case would be to use `Function.prototype.apply`. + * + * ```js + * function f(x, y, z) {} + * var args = [1, 2, 3]; + * f.apply(null, args); + * ``` + * + * With `spread` this example can be re-written. + * + * ```js + * spread(function(x, y, z) {})([1, 2, 3]); + * ``` + * + * @param {Function} callback + * @returns {Function} + */ +module.exports = function spread(callback) { + return function wrap(arr) { + return callback.apply(null, arr); + }; +}; + + +/***/ }), +/* 555 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Determines whether the payload is an error thrown by Axios + * + * @param {*} payload The value to test + * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false + */ +module.exports = function isAxiosError(payload) { + return (typeof payload === 'object') && (payload.isAxiosError === true); +}; + + +/***/ }), +/* 556 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +/* + * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one + * or more contributor license agreements. Licensed under the Elastic License + * 2.0 and the Server Side Public License, v 1; you may not use this file except + * in compliance with, at your election, the Elastic License 2.0 or the Server + * Side Public License, v 1. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.parseConfig = void 0; +function validateConfig(log, config) { + const validApiToken = typeof config.apiToken === 'string' && config.apiToken.length !== 0; + if (!validApiToken) { + log.warning('KIBANA_CI_STATS_CONFIG is missing a valid api token, stats will not be reported'); + return; + } + const validId = typeof config.buildId === 'string' && config.buildId.length !== 0; + if (!validId) { + log.warning('KIBANA_CI_STATS_CONFIG is missing a valid build id, stats will not be reported'); + return; + } + return config; +} +function parseConfig(log) { + const configJson = process.env.KIBANA_CI_STATS_CONFIG; + if (!configJson) { + log.debug('KIBANA_CI_STATS_CONFIG environment variable not found, disabling CiStatsReporter'); + return; + } + let config; + try { + config = JSON.parse(configJson); + } + catch (_) { + // handled below + } + if (typeof config === 'object' && config !== null) { + return validateConfig(log, config); + } + log.warning('KIBANA_CI_STATS_CONFIG is invalid, stats will not be reported'); + return; +} +exports.parseConfig = parseConfig; + + +/***/ }), +/* 557 */ +/***/ (function(module, exports) { + +function webpackEmptyContext(req) { + var e = new Error("Cannot find module '" + req + "'"); + e.code = 'MODULE_NOT_FOUND'; + throw e; +} +webpackEmptyContext.keys = function() { return []; }; +webpackEmptyContext.resolve = webpackEmptyContext; +module.exports = webpackEmptyContext; +webpackEmptyContext.id = 557; + +/***/ }), +/* 558 */ /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; @@ -59573,13 +63275,15 @@ __webpack_require__.r(__webpack_exports__); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Kibana", function() { return Kibana; }); /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4); /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_0__); -/* harmony import */ var multimatch__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(516); -/* harmony import */ var multimatch__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(multimatch__WEBPACK_IMPORTED_MODULE_1__); -/* harmony import */ var is_path_inside__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(239); -/* harmony import */ var is_path_inside__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(is_path_inside__WEBPACK_IMPORTED_MODULE_2__); -/* harmony import */ var _yarn_lock__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(366); -/* harmony import */ var _projects__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(248); -/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(519); +/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(134); +/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_1__); +/* harmony import */ var multimatch__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(559); +/* harmony import */ var multimatch__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(multimatch__WEBPACK_IMPORTED_MODULE_2__); +/* harmony import */ var is_path_inside__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(239); +/* harmony import */ var is_path_inside__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(is_path_inside__WEBPACK_IMPORTED_MODULE_3__); +/* harmony import */ var _yarn_lock__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(366); +/* harmony import */ var _projects__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(248); +/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(562); function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } @@ -59599,6 +63303,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope + /** * Helper class for dealing with a set of projects as children of * the Kibana project. The kbn/pm is currently implemented to be @@ -59613,7 +63318,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope class Kibana { static async loadFrom(rootPath) { - return new Kibana(await Object(_projects__WEBPACK_IMPORTED_MODULE_4__["getProjects"])(rootPath, Object(_config__WEBPACK_IMPORTED_MODULE_5__["getProjectPaths"])({ + return new Kibana(await Object(_projects__WEBPACK_IMPORTED_MODULE_5__["getProjects"])(rootPath, Object(_config__WEBPACK_IMPORTED_MODULE_6__["getProjectPaths"])({ rootPath }))); } @@ -59672,7 +63377,7 @@ class Kibana { getProjectAndDeps(name) { const project = this.getProject(name); - return Object(_projects__WEBPACK_IMPORTED_MODULE_4__["includeTransitiveProjects"])([project], this.allWorkspaceProjects); + return Object(_projects__WEBPACK_IMPORTED_MODULE_5__["includeTransitiveProjects"])([project], this.allWorkspaceProjects); } /** filter the projects to just those matching certain paths/include/exclude tags */ @@ -59681,10 +63386,10 @@ class Kibana { const allProjects = this.getAllProjects(); const filteredProjects = new Map(); const pkgJsonPaths = Array.from(allProjects.values()).map(p => p.packageJsonLocation); - const filteredPkgJsonGlobs = Object(_config__WEBPACK_IMPORTED_MODULE_5__["getProjectPaths"])(_objectSpread(_objectSpread({}, options), {}, { + const filteredPkgJsonGlobs = Object(_config__WEBPACK_IMPORTED_MODULE_6__["getProjectPaths"])(_objectSpread(_objectSpread({}, options), {}, { rootPath: this.kibanaProject.path })).map(g => path__WEBPACK_IMPORTED_MODULE_0___default.a.resolve(g, 'package.json')); - const matchingPkgJsonPaths = multimatch__WEBPACK_IMPORTED_MODULE_1___default()(pkgJsonPaths, filteredPkgJsonGlobs); + const matchingPkgJsonPaths = multimatch__WEBPACK_IMPORTED_MODULE_2___default()(pkgJsonPaths, filteredPkgJsonGlobs); for (const project of allProjects.values()) { const pathMatches = matchingPkgJsonPaths.includes(project.packageJsonLocation); @@ -59700,7 +63405,7 @@ class Kibana { } isPartOfRepo(project) { - return project.path === this.kibanaProject.path || is_path_inside__WEBPACK_IMPORTED_MODULE_2___default()(project.path, this.kibanaProject.path); + return project.path === this.kibanaProject.path || is_path_inside__WEBPACK_IMPORTED_MODULE_3___default()(project.path, this.kibanaProject.path); } isOutsideRepo(project) { @@ -59708,7 +63413,7 @@ class Kibana { } resolveAllProductionDependencies(yarnLock, log) { - const kibanaDeps = Object(_yarn_lock__WEBPACK_IMPORTED_MODULE_3__["resolveDepsForProject"])({ + const kibanaDeps = Object(_yarn_lock__WEBPACK_IMPORTED_MODULE_4__["resolveDepsForProject"])({ project: this.kibanaProject, yarnLock, kbn: this, @@ -59716,7 +63421,7 @@ class Kibana { productionDepsOnly: true, log }); - const xpackDeps = Object(_yarn_lock__WEBPACK_IMPORTED_MODULE_3__["resolveDepsForProject"])({ + const xpackDeps = Object(_yarn_lock__WEBPACK_IMPORTED_MODULE_4__["resolveDepsForProject"])({ project: this.getProject('x-pack'), yarnLock, kbn: this, @@ -59727,18 +63432,30 @@ class Kibana { return new Map([...kibanaDeps.entries(), ...xpackDeps.entries()]); } + getUuid() { + try { + return fs__WEBPACK_IMPORTED_MODULE_1___default.a.readFileSync(this.getAbsolute('data/uuid'), 'utf-8').trim(); + } catch (error) { + if (error.code === 'ENOENT') { + return undefined; + } + + throw error; + } + } + } /***/ }), -/* 516 */ +/* 559 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const minimatch = __webpack_require__(150); const arrayUnion = __webpack_require__(145); -const arrayDiffer = __webpack_require__(517); -const arrify = __webpack_require__(518); +const arrayDiffer = __webpack_require__(560); +const arrify = __webpack_require__(561); module.exports = (list, patterns, options = {}) => { list = arrify(list); @@ -59762,7 +63479,7 @@ module.exports = (list, patterns, options = {}) => { /***/ }), -/* 517 */ +/* 560 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -59777,7 +63494,7 @@ module.exports = arrayDiffer; /***/ }), -/* 518 */ +/* 561 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -59807,7 +63524,7 @@ module.exports = arrify; /***/ }), -/* 519 */ +/* 562 */ /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; @@ -59866,15 +63583,15 @@ function getProjectPaths({ } /***/ }), -/* 520 */ +/* 563 */ /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; __webpack_require__.r(__webpack_exports__); -/* harmony import */ var _build_bazel_production_projects__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(521); +/* harmony import */ var _build_bazel_production_projects__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(564); /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "buildBazelProductionProjects", function() { return _build_bazel_production_projects__WEBPACK_IMPORTED_MODULE_0__["buildBazelProductionProjects"]; }); -/* harmony import */ var _build_non_bazel_production_projects__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(746); +/* harmony import */ var _build_non_bazel_production_projects__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(783); /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "buildNonBazelProductionProjects", function() { return _build_non_bazel_production_projects__WEBPACK_IMPORTED_MODULE_1__["buildNonBazelProductionProjects"]; }); /* @@ -59888,19 +63605,19 @@ __webpack_require__.r(__webpack_exports__); /***/ }), -/* 521 */ +/* 564 */ /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; __webpack_require__.r(__webpack_exports__); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "buildBazelProductionProjects", function() { return buildBazelProductionProjects; }); -/* harmony import */ var cpy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(522); +/* harmony import */ var cpy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(565); /* harmony import */ var cpy__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(cpy__WEBPACK_IMPORTED_MODULE_0__); -/* harmony import */ var globby__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(737); +/* harmony import */ var globby__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(774); /* harmony import */ var globby__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(globby__WEBPACK_IMPORTED_MODULE_1__); /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4); /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_2__); -/* harmony import */ var _build_non_bazel_production_projects__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(746); +/* harmony import */ var _build_non_bazel_production_projects__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(783); /* harmony import */ var _utils_bazel__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(372); /* harmony import */ var _utils_fs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(131); /* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(246); @@ -59995,7 +63712,7 @@ async function applyCorrectPermissions(project, kibanaRoot, buildRoot) { } /***/ }), -/* 522 */ +/* 565 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -60003,14 +63720,14 @@ async function applyCorrectPermissions(project, kibanaRoot, buildRoot) { const EventEmitter = __webpack_require__(156); const path = __webpack_require__(4); const os = __webpack_require__(121); -const pMap = __webpack_require__(523); -const arrify = __webpack_require__(518); -const globby = __webpack_require__(526); -const hasGlob = __webpack_require__(721); -const cpFile = __webpack_require__(723); -const junk = __webpack_require__(733); -const pFilter = __webpack_require__(734); -const CpyError = __webpack_require__(736); +const pMap = __webpack_require__(566); +const arrify = __webpack_require__(561); +const globby = __webpack_require__(569); +const hasGlob = __webpack_require__(758); +const cpFile = __webpack_require__(760); +const junk = __webpack_require__(770); +const pFilter = __webpack_require__(771); +const CpyError = __webpack_require__(773); const defaultOptions = { ignoreJunk: true @@ -60161,12 +63878,12 @@ module.exports = (source, destination, { /***/ }), -/* 523 */ +/* 566 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -const AggregateError = __webpack_require__(524); +const AggregateError = __webpack_require__(567); module.exports = async ( iterable, @@ -60249,12 +63966,12 @@ module.exports = async ( /***/ }), -/* 524 */ +/* 567 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -const indentString = __webpack_require__(525); +const indentString = __webpack_require__(568); const cleanStack = __webpack_require__(244); const cleanInternalStack = stack => stack.replace(/\s+at .*aggregate-error\/index.js:\d+:\d+\)?/g, ''); @@ -60303,7 +64020,7 @@ module.exports = AggregateError; /***/ }), -/* 525 */ +/* 568 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -60345,17 +64062,17 @@ module.exports = (string, count = 1, options) => { /***/ }), -/* 526 */ +/* 569 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const fs = __webpack_require__(134); -const arrayUnion = __webpack_require__(527); +const arrayUnion = __webpack_require__(570); const glob = __webpack_require__(147); -const fastGlob = __webpack_require__(529); -const dirGlob = __webpack_require__(714); -const gitignore = __webpack_require__(717); +const fastGlob = __webpack_require__(572); +const dirGlob = __webpack_require__(751); +const gitignore = __webpack_require__(754); const DEFAULT_FILTER = () => false; @@ -60500,12 +64217,12 @@ module.exports.gitignore = gitignore; /***/ }), -/* 527 */ +/* 570 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var arrayUniq = __webpack_require__(528); +var arrayUniq = __webpack_require__(571); module.exports = function () { return arrayUniq([].concat.apply([], arguments)); @@ -60513,7 +64230,7 @@ module.exports = function () { /***/ }), -/* 528 */ +/* 571 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -60582,10 +64299,10 @@ if ('Set' in global) { /***/ }), -/* 529 */ +/* 572 */ /***/ (function(module, exports, __webpack_require__) { -const pkg = __webpack_require__(530); +const pkg = __webpack_require__(573); module.exports = pkg.async; module.exports.default = pkg.async; @@ -60598,19 +64315,19 @@ module.exports.generateTasks = pkg.generateTasks; /***/ }), -/* 530 */ +/* 573 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -var optionsManager = __webpack_require__(531); -var taskManager = __webpack_require__(532); -var reader_async_1 = __webpack_require__(685); -var reader_stream_1 = __webpack_require__(709); -var reader_sync_1 = __webpack_require__(710); -var arrayUtils = __webpack_require__(712); -var streamUtils = __webpack_require__(713); +var optionsManager = __webpack_require__(574); +var taskManager = __webpack_require__(575); +var reader_async_1 = __webpack_require__(722); +var reader_stream_1 = __webpack_require__(746); +var reader_sync_1 = __webpack_require__(747); +var arrayUtils = __webpack_require__(749); +var streamUtils = __webpack_require__(750); /** * Synchronous API. */ @@ -60676,7 +64393,7 @@ function isString(source) { /***/ }), -/* 531 */ +/* 574 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -60714,13 +64431,13 @@ exports.prepare = prepare; /***/ }), -/* 532 */ +/* 575 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -var patternUtils = __webpack_require__(533); +var patternUtils = __webpack_require__(576); /** * Generate tasks based on parent directory of each pattern. */ @@ -60811,16 +64528,16 @@ exports.convertPatternGroupToTask = convertPatternGroupToTask; /***/ }), -/* 533 */ +/* 576 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var path = __webpack_require__(4); -var globParent = __webpack_require__(534); +var globParent = __webpack_require__(577); var isGlob = __webpack_require__(172); -var micromatch = __webpack_require__(537); +var micromatch = __webpack_require__(580); var GLOBSTAR = '**'; /** * Return true for static pattern. @@ -60966,15 +64683,15 @@ exports.matchAny = matchAny; /***/ }), -/* 534 */ +/* 577 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var path = __webpack_require__(4); -var isglob = __webpack_require__(535); -var pathDirname = __webpack_require__(536); +var isglob = __webpack_require__(578); +var pathDirname = __webpack_require__(579); var isWin32 = __webpack_require__(121).platform() === 'win32'; module.exports = function globParent(str) { @@ -60997,7 +64714,7 @@ module.exports = function globParent(str) { /***/ }), -/* 535 */ +/* 578 */ /***/ (function(module, exports, __webpack_require__) { /*! @@ -61028,7 +64745,7 @@ module.exports = function isGlob(str) { /***/ }), -/* 536 */ +/* 579 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -61178,7 +64895,7 @@ module.exports.win32 = win32; /***/ }), -/* 537 */ +/* 580 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -61189,18 +64906,18 @@ module.exports.win32 = win32; */ var util = __webpack_require__(112); -var braces = __webpack_require__(538); -var toRegex = __webpack_require__(539); -var extend = __webpack_require__(653); +var braces = __webpack_require__(581); +var toRegex = __webpack_require__(582); +var extend = __webpack_require__(690); /** * Local dependencies */ -var compilers = __webpack_require__(655); -var parsers = __webpack_require__(681); -var cache = __webpack_require__(682); -var utils = __webpack_require__(683); +var compilers = __webpack_require__(692); +var parsers = __webpack_require__(718); +var cache = __webpack_require__(719); +var utils = __webpack_require__(720); var MAX_LENGTH = 1024 * 64; /** @@ -62062,7 +65779,7 @@ module.exports = micromatch; /***/ }), -/* 538 */ +/* 581 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -62072,18 +65789,18 @@ module.exports = micromatch; * Module dependencies */ -var toRegex = __webpack_require__(539); -var unique = __webpack_require__(559); -var extend = __webpack_require__(560); +var toRegex = __webpack_require__(582); +var unique = __webpack_require__(602); +var extend = __webpack_require__(603); /** * Local dependencies */ -var compilers = __webpack_require__(562); -var parsers = __webpack_require__(575); -var Braces = __webpack_require__(580); -var utils = __webpack_require__(563); +var compilers = __webpack_require__(605); +var parsers = __webpack_require__(618); +var Braces = __webpack_require__(623); +var utils = __webpack_require__(606); var MAX_LENGTH = 1024 * 64; var cache = {}; @@ -62387,16 +66104,16 @@ module.exports = braces; /***/ }), -/* 539 */ +/* 582 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var safe = __webpack_require__(540); -var define = __webpack_require__(546); -var extend = __webpack_require__(552); -var not = __webpack_require__(556); +var safe = __webpack_require__(583); +var define = __webpack_require__(589); +var extend = __webpack_require__(595); +var not = __webpack_require__(599); var MAX_LENGTH = 1024 * 64; /** @@ -62549,10 +66266,10 @@ module.exports.makeRe = makeRe; /***/ }), -/* 540 */ +/* 583 */ /***/ (function(module, exports, __webpack_require__) { -var parse = __webpack_require__(541); +var parse = __webpack_require__(584); var types = parse.types; module.exports = function (re, opts) { @@ -62598,13 +66315,13 @@ function isRegExp (x) { /***/ }), -/* 541 */ +/* 584 */ /***/ (function(module, exports, __webpack_require__) { -var util = __webpack_require__(542); -var types = __webpack_require__(543); -var sets = __webpack_require__(544); -var positions = __webpack_require__(545); +var util = __webpack_require__(585); +var types = __webpack_require__(586); +var sets = __webpack_require__(587); +var positions = __webpack_require__(588); module.exports = function(regexpStr) { @@ -62886,11 +66603,11 @@ module.exports.types = types; /***/ }), -/* 542 */ +/* 585 */ /***/ (function(module, exports, __webpack_require__) { -var types = __webpack_require__(543); -var sets = __webpack_require__(544); +var types = __webpack_require__(586); +var sets = __webpack_require__(587); // All of these are private and only used by randexp. @@ -63003,7 +66720,7 @@ exports.error = function(regexp, msg) { /***/ }), -/* 543 */ +/* 586 */ /***/ (function(module, exports) { module.exports = { @@ -63019,10 +66736,10 @@ module.exports = { /***/ }), -/* 544 */ +/* 587 */ /***/ (function(module, exports, __webpack_require__) { -var types = __webpack_require__(543); +var types = __webpack_require__(586); var INTS = function() { return [{ type: types.RANGE , from: 48, to: 57 }]; @@ -63107,10 +66824,10 @@ exports.anyChar = function() { /***/ }), -/* 545 */ +/* 588 */ /***/ (function(module, exports, __webpack_require__) { -var types = __webpack_require__(543); +var types = __webpack_require__(586); exports.wordBoundary = function() { return { type: types.POSITION, value: 'b' }; @@ -63130,7 +66847,7 @@ exports.end = function() { /***/ }), -/* 546 */ +/* 589 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63143,8 +66860,8 @@ exports.end = function() { -var isobject = __webpack_require__(547); -var isDescriptor = __webpack_require__(548); +var isobject = __webpack_require__(590); +var isDescriptor = __webpack_require__(591); var define = (typeof Reflect !== 'undefined' && Reflect.defineProperty) ? Reflect.defineProperty : Object.defineProperty; @@ -63175,7 +66892,7 @@ module.exports = function defineProperty(obj, key, val) { /***/ }), -/* 547 */ +/* 590 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63194,7 +66911,7 @@ module.exports = function isObject(val) { /***/ }), -/* 548 */ +/* 591 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63207,9 +66924,9 @@ module.exports = function isObject(val) { -var typeOf = __webpack_require__(549); -var isAccessor = __webpack_require__(550); -var isData = __webpack_require__(551); +var typeOf = __webpack_require__(592); +var isAccessor = __webpack_require__(593); +var isData = __webpack_require__(594); module.exports = function isDescriptor(obj, key) { if (typeOf(obj) !== 'object') { @@ -63223,7 +66940,7 @@ module.exports = function isDescriptor(obj, key) { /***/ }), -/* 549 */ +/* 592 */ /***/ (function(module, exports) { var toString = Object.prototype.toString; @@ -63358,7 +67075,7 @@ function isBuffer(val) { /***/ }), -/* 550 */ +/* 593 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63371,7 +67088,7 @@ function isBuffer(val) { -var typeOf = __webpack_require__(549); +var typeOf = __webpack_require__(592); // accessor descriptor properties var accessor = { @@ -63434,7 +67151,7 @@ module.exports = isAccessorDescriptor; /***/ }), -/* 551 */ +/* 594 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63447,7 +67164,7 @@ module.exports = isAccessorDescriptor; -var typeOf = __webpack_require__(549); +var typeOf = __webpack_require__(592); module.exports = function isDataDescriptor(obj, prop) { // data descriptor properties @@ -63490,14 +67207,14 @@ module.exports = function isDataDescriptor(obj, prop) { /***/ }), -/* 552 */ +/* 595 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var isExtendable = __webpack_require__(553); -var assignSymbols = __webpack_require__(555); +var isExtendable = __webpack_require__(596); +var assignSymbols = __webpack_require__(598); module.exports = Object.assign || function(obj/*, objects*/) { if (obj === null || typeof obj === 'undefined') { @@ -63557,7 +67274,7 @@ function isEnum(obj, key) { /***/ }), -/* 553 */ +/* 596 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63570,7 +67287,7 @@ function isEnum(obj, key) { -var isPlainObject = __webpack_require__(554); +var isPlainObject = __webpack_require__(597); module.exports = function isExtendable(val) { return isPlainObject(val) || typeof val === 'function' || Array.isArray(val); @@ -63578,7 +67295,7 @@ module.exports = function isExtendable(val) { /***/ }), -/* 554 */ +/* 597 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63591,7 +67308,7 @@ module.exports = function isExtendable(val) { -var isObject = __webpack_require__(547); +var isObject = __webpack_require__(590); function isObjectObject(o) { return isObject(o) === true @@ -63622,7 +67339,7 @@ module.exports = function isPlainObject(o) { /***/ }), -/* 555 */ +/* 598 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63669,14 +67386,14 @@ module.exports = function(receiver, objects) { /***/ }), -/* 556 */ +/* 599 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var extend = __webpack_require__(557); -var safe = __webpack_require__(540); +var extend = __webpack_require__(600); +var safe = __webpack_require__(583); /** * The main export is a function that takes a `pattern` string and an `options` object. @@ -63748,14 +67465,14 @@ module.exports = toRegex; /***/ }), -/* 557 */ +/* 600 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var isExtendable = __webpack_require__(558); -var assignSymbols = __webpack_require__(555); +var isExtendable = __webpack_require__(601); +var assignSymbols = __webpack_require__(598); module.exports = Object.assign || function(obj/*, objects*/) { if (obj === null || typeof obj === 'undefined') { @@ -63815,7 +67532,7 @@ function isEnum(obj, key) { /***/ }), -/* 558 */ +/* 601 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63828,7 +67545,7 @@ function isEnum(obj, key) { -var isPlainObject = __webpack_require__(554); +var isPlainObject = __webpack_require__(597); module.exports = function isExtendable(val) { return isPlainObject(val) || typeof val === 'function' || Array.isArray(val); @@ -63836,7 +67553,7 @@ module.exports = function isExtendable(val) { /***/ }), -/* 559 */ +/* 602 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63886,13 +67603,13 @@ module.exports.immutable = function uniqueImmutable(arr) { /***/ }), -/* 560 */ +/* 603 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var isObject = __webpack_require__(561); +var isObject = __webpack_require__(604); module.exports = function extend(o/*, objects*/) { if (!isObject(o)) { o = {}; } @@ -63926,7 +67643,7 @@ function hasOwn(obj, key) { /***/ }), -/* 561 */ +/* 604 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -63946,13 +67663,13 @@ module.exports = function isExtendable(val) { /***/ }), -/* 562 */ +/* 605 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var utils = __webpack_require__(563); +var utils = __webpack_require__(606); module.exports = function(braces, options) { braces.compiler @@ -64235,25 +67952,25 @@ function hasQueue(node) { /***/ }), -/* 563 */ +/* 606 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var splitString = __webpack_require__(564); +var splitString = __webpack_require__(607); var utils = module.exports; /** * Module dependencies */ -utils.extend = __webpack_require__(560); -utils.flatten = __webpack_require__(567); -utils.isObject = __webpack_require__(547); -utils.fillRange = __webpack_require__(568); -utils.repeat = __webpack_require__(574); -utils.unique = __webpack_require__(559); +utils.extend = __webpack_require__(603); +utils.flatten = __webpack_require__(610); +utils.isObject = __webpack_require__(590); +utils.fillRange = __webpack_require__(611); +utils.repeat = __webpack_require__(617); +utils.unique = __webpack_require__(602); utils.define = function(obj, key, val) { Object.defineProperty(obj, key, { @@ -64585,7 +68302,7 @@ utils.escapeRegex = function(str) { /***/ }), -/* 564 */ +/* 607 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -64598,7 +68315,7 @@ utils.escapeRegex = function(str) { -var extend = __webpack_require__(565); +var extend = __webpack_require__(608); module.exports = function(str, options, fn) { if (typeof str !== 'string') { @@ -64763,14 +68480,14 @@ function keepEscaping(opts, str, idx) { /***/ }), -/* 565 */ +/* 608 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var isExtendable = __webpack_require__(566); -var assignSymbols = __webpack_require__(555); +var isExtendable = __webpack_require__(609); +var assignSymbols = __webpack_require__(598); module.exports = Object.assign || function(obj/*, objects*/) { if (obj === null || typeof obj === 'undefined') { @@ -64830,7 +68547,7 @@ function isEnum(obj, key) { /***/ }), -/* 566 */ +/* 609 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -64843,7 +68560,7 @@ function isEnum(obj, key) { -var isPlainObject = __webpack_require__(554); +var isPlainObject = __webpack_require__(597); module.exports = function isExtendable(val) { return isPlainObject(val) || typeof val === 'function' || Array.isArray(val); @@ -64851,7 +68568,7 @@ module.exports = function isExtendable(val) { /***/ }), -/* 567 */ +/* 610 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -64880,7 +68597,7 @@ function flat(arr, res) { /***/ }), -/* 568 */ +/* 611 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -64894,10 +68611,10 @@ function flat(arr, res) { var util = __webpack_require__(112); -var isNumber = __webpack_require__(569); -var extend = __webpack_require__(560); -var repeat = __webpack_require__(572); -var toRegex = __webpack_require__(573); +var isNumber = __webpack_require__(612); +var extend = __webpack_require__(603); +var repeat = __webpack_require__(615); +var toRegex = __webpack_require__(616); /** * Return a range of numbers or letters. @@ -65095,7 +68812,7 @@ module.exports = fillRange; /***/ }), -/* 569 */ +/* 612 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -65108,7 +68825,7 @@ module.exports = fillRange; -var typeOf = __webpack_require__(570); +var typeOf = __webpack_require__(613); module.exports = function isNumber(num) { var type = typeOf(num); @@ -65124,10 +68841,10 @@ module.exports = function isNumber(num) { /***/ }), -/* 570 */ +/* 613 */ /***/ (function(module, exports, __webpack_require__) { -var isBuffer = __webpack_require__(571); +var isBuffer = __webpack_require__(614); var toString = Object.prototype.toString; /** @@ -65246,7 +68963,7 @@ module.exports = function kindOf(val) { /***/ }), -/* 571 */ +/* 614 */ /***/ (function(module, exports) { /*! @@ -65273,7 +68990,7 @@ function isSlowBuffer (obj) { /***/ }), -/* 572 */ +/* 615 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -65350,7 +69067,7 @@ function repeat(str, num) { /***/ }), -/* 573 */ +/* 616 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -65363,8 +69080,8 @@ function repeat(str, num) { -var repeat = __webpack_require__(572); -var isNumber = __webpack_require__(569); +var repeat = __webpack_require__(615); +var isNumber = __webpack_require__(612); var cache = {}; function toRegexRange(min, max, options) { @@ -65651,7 +69368,7 @@ module.exports = toRegexRange; /***/ }), -/* 574 */ +/* 617 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -65676,14 +69393,14 @@ module.exports = function repeat(ele, num) { /***/ }), -/* 575 */ +/* 618 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var Node = __webpack_require__(576); -var utils = __webpack_require__(563); +var Node = __webpack_require__(619); +var utils = __webpack_require__(606); /** * Braces parsers @@ -66043,15 +69760,15 @@ function concatNodes(pos, node, parent, options) { /***/ }), -/* 576 */ +/* 619 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var isObject = __webpack_require__(547); -var define = __webpack_require__(577); -var utils = __webpack_require__(578); +var isObject = __webpack_require__(590); +var define = __webpack_require__(620); +var utils = __webpack_require__(621); var ownNames; /** @@ -66542,7 +70259,7 @@ exports = module.exports = Node; /***/ }), -/* 577 */ +/* 620 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -66555,7 +70272,7 @@ exports = module.exports = Node; -var isDescriptor = __webpack_require__(548); +var isDescriptor = __webpack_require__(591); module.exports = function defineProperty(obj, prop, val) { if (typeof obj !== 'object' && typeof obj !== 'function') { @@ -66580,13 +70297,13 @@ module.exports = function defineProperty(obj, prop, val) { /***/ }), -/* 578 */ +/* 621 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var typeOf = __webpack_require__(579); +var typeOf = __webpack_require__(622); var utils = module.exports; /** @@ -67606,10 +71323,10 @@ function assert(val, message) { /***/ }), -/* 579 */ +/* 622 */ /***/ (function(module, exports, __webpack_require__) { -var isBuffer = __webpack_require__(571); +var isBuffer = __webpack_require__(614); var toString = Object.prototype.toString; /** @@ -67728,17 +71445,17 @@ module.exports = function kindOf(val) { /***/ }), -/* 580 */ +/* 623 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var extend = __webpack_require__(560); -var Snapdragon = __webpack_require__(581); -var compilers = __webpack_require__(562); -var parsers = __webpack_require__(575); -var utils = __webpack_require__(563); +var extend = __webpack_require__(603); +var Snapdragon = __webpack_require__(624); +var compilers = __webpack_require__(605); +var parsers = __webpack_require__(618); +var utils = __webpack_require__(606); /** * Customize Snapdragon parser and renderer @@ -67839,17 +71556,17 @@ module.exports = Braces; /***/ }), -/* 581 */ +/* 624 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var Base = __webpack_require__(582); -var define = __webpack_require__(610); -var Compiler = __webpack_require__(621); -var Parser = __webpack_require__(650); -var utils = __webpack_require__(630); +var Base = __webpack_require__(625); +var define = __webpack_require__(653); +var Compiler = __webpack_require__(664); +var Parser = __webpack_require__(687); +var utils = __webpack_require__(667); var regexCache = {}; var cache = {}; @@ -68020,20 +71737,20 @@ module.exports.Parser = Parser; /***/ }), -/* 582 */ +/* 625 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var util = __webpack_require__(112); -var define = __webpack_require__(583); -var CacheBase = __webpack_require__(584); -var Emitter = __webpack_require__(585); -var isObject = __webpack_require__(547); -var merge = __webpack_require__(604); -var pascal = __webpack_require__(607); -var cu = __webpack_require__(608); +var define = __webpack_require__(626); +var CacheBase = __webpack_require__(627); +var Emitter = __webpack_require__(628); +var isObject = __webpack_require__(590); +var merge = __webpack_require__(647); +var pascal = __webpack_require__(650); +var cu = __webpack_require__(651); /** * Optionally define a custom `cache` namespace to use. @@ -68462,7 +72179,7 @@ module.exports.namespace = namespace; /***/ }), -/* 583 */ +/* 626 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -68475,7 +72192,7 @@ module.exports.namespace = namespace; -var isDescriptor = __webpack_require__(548); +var isDescriptor = __webpack_require__(591); module.exports = function defineProperty(obj, prop, val) { if (typeof obj !== 'object' && typeof obj !== 'function') { @@ -68500,21 +72217,21 @@ module.exports = function defineProperty(obj, prop, val) { /***/ }), -/* 584 */ +/* 627 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var isObject = __webpack_require__(547); -var Emitter = __webpack_require__(585); -var visit = __webpack_require__(586); -var toPath = __webpack_require__(589); -var union = __webpack_require__(591); -var del = __webpack_require__(595); -var get = __webpack_require__(593); -var has = __webpack_require__(600); -var set = __webpack_require__(603); +var isObject = __webpack_require__(590); +var Emitter = __webpack_require__(628); +var visit = __webpack_require__(629); +var toPath = __webpack_require__(632); +var union = __webpack_require__(634); +var del = __webpack_require__(638); +var get = __webpack_require__(636); +var has = __webpack_require__(643); +var set = __webpack_require__(646); /** * Create a `Cache` constructor that when instantiated will @@ -68768,7 +72485,7 @@ module.exports.namespace = namespace; /***/ }), -/* 585 */ +/* 628 */ /***/ (function(module, exports, __webpack_require__) { @@ -68937,7 +72654,7 @@ Emitter.prototype.hasListeners = function(event){ /***/ }), -/* 586 */ +/* 629 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -68950,8 +72667,8 @@ Emitter.prototype.hasListeners = function(event){ -var visit = __webpack_require__(587); -var mapVisit = __webpack_require__(588); +var visit = __webpack_require__(630); +var mapVisit = __webpack_require__(631); module.exports = function(collection, method, val) { var result; @@ -68974,7 +72691,7 @@ module.exports = function(collection, method, val) { /***/ }), -/* 587 */ +/* 630 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -68987,7 +72704,7 @@ module.exports = function(collection, method, val) { -var isObject = __webpack_require__(547); +var isObject = __webpack_require__(590); module.exports = function visit(thisArg, method, target, val) { if (!isObject(thisArg) && typeof thisArg !== 'function') { @@ -69014,14 +72731,14 @@ module.exports = function visit(thisArg, method, target, val) { /***/ }), -/* 588 */ +/* 631 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var util = __webpack_require__(112); -var visit = __webpack_require__(587); +var visit = __webpack_require__(630); /** * Map `visit` over an array of objects. @@ -69058,7 +72775,7 @@ function isObject(val) { /***/ }), -/* 589 */ +/* 632 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69071,7 +72788,7 @@ function isObject(val) { -var typeOf = __webpack_require__(590); +var typeOf = __webpack_require__(633); module.exports = function toPath(args) { if (typeOf(args) !== 'arguments') { @@ -69098,10 +72815,10 @@ function filter(arr) { /***/ }), -/* 590 */ +/* 633 */ /***/ (function(module, exports, __webpack_require__) { -var isBuffer = __webpack_require__(571); +var isBuffer = __webpack_require__(614); var toString = Object.prototype.toString; /** @@ -69220,16 +72937,16 @@ module.exports = function kindOf(val) { /***/ }), -/* 591 */ +/* 634 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var isObject = __webpack_require__(561); -var union = __webpack_require__(592); -var get = __webpack_require__(593); -var set = __webpack_require__(594); +var isObject = __webpack_require__(604); +var union = __webpack_require__(635); +var get = __webpack_require__(636); +var set = __webpack_require__(637); module.exports = function unionValue(obj, prop, value) { if (!isObject(obj)) { @@ -69257,7 +72974,7 @@ function arrayify(val) { /***/ }), -/* 592 */ +/* 635 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69293,7 +73010,7 @@ module.exports = function union(init) { /***/ }), -/* 593 */ +/* 636 */ /***/ (function(module, exports) { /*! @@ -69349,7 +73066,7 @@ function toString(val) { /***/ }), -/* 594 */ +/* 637 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69362,10 +73079,10 @@ function toString(val) { -var split = __webpack_require__(564); -var extend = __webpack_require__(560); -var isPlainObject = __webpack_require__(554); -var isObject = __webpack_require__(561); +var split = __webpack_require__(607); +var extend = __webpack_require__(603); +var isPlainObject = __webpack_require__(597); +var isObject = __webpack_require__(604); module.exports = function(obj, prop, val) { if (!isObject(obj)) { @@ -69411,7 +73128,7 @@ function isValidKey(key) { /***/ }), -/* 595 */ +/* 638 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69424,8 +73141,8 @@ function isValidKey(key) { -var isObject = __webpack_require__(547); -var has = __webpack_require__(596); +var isObject = __webpack_require__(590); +var has = __webpack_require__(639); module.exports = function unset(obj, prop) { if (!isObject(obj)) { @@ -69450,7 +73167,7 @@ module.exports = function unset(obj, prop) { /***/ }), -/* 596 */ +/* 639 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69463,9 +73180,9 @@ module.exports = function unset(obj, prop) { -var isObject = __webpack_require__(597); -var hasValues = __webpack_require__(599); -var get = __webpack_require__(593); +var isObject = __webpack_require__(640); +var hasValues = __webpack_require__(642); +var get = __webpack_require__(636); module.exports = function(obj, prop, noZero) { if (isObject(obj)) { @@ -69476,7 +73193,7 @@ module.exports = function(obj, prop, noZero) { /***/ }), -/* 597 */ +/* 640 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69489,7 +73206,7 @@ module.exports = function(obj, prop, noZero) { -var isArray = __webpack_require__(598); +var isArray = __webpack_require__(641); module.exports = function isObject(val) { return val != null && typeof val === 'object' && isArray(val) === false; @@ -69497,7 +73214,7 @@ module.exports = function isObject(val) { /***/ }), -/* 598 */ +/* 641 */ /***/ (function(module, exports) { var toString = {}.toString; @@ -69508,7 +73225,7 @@ module.exports = Array.isArray || function (arr) { /***/ }), -/* 599 */ +/* 642 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69551,7 +73268,7 @@ module.exports = function hasValue(o, noZero) { /***/ }), -/* 600 */ +/* 643 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69564,9 +73281,9 @@ module.exports = function hasValue(o, noZero) { -var isObject = __webpack_require__(547); -var hasValues = __webpack_require__(601); -var get = __webpack_require__(593); +var isObject = __webpack_require__(590); +var hasValues = __webpack_require__(644); +var get = __webpack_require__(636); module.exports = function(val, prop) { return hasValues(isObject(val) && prop ? get(val, prop) : val); @@ -69574,7 +73291,7 @@ module.exports = function(val, prop) { /***/ }), -/* 601 */ +/* 644 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69587,8 +73304,8 @@ module.exports = function(val, prop) { -var typeOf = __webpack_require__(602); -var isNumber = __webpack_require__(569); +var typeOf = __webpack_require__(645); +var isNumber = __webpack_require__(612); module.exports = function hasValue(val) { // is-number checks for NaN and other edge cases @@ -69641,10 +73358,10 @@ module.exports = function hasValue(val) { /***/ }), -/* 602 */ +/* 645 */ /***/ (function(module, exports, __webpack_require__) { -var isBuffer = __webpack_require__(571); +var isBuffer = __webpack_require__(614); var toString = Object.prototype.toString; /** @@ -69766,7 +73483,7 @@ module.exports = function kindOf(val) { /***/ }), -/* 603 */ +/* 646 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69779,10 +73496,10 @@ module.exports = function kindOf(val) { -var split = __webpack_require__(564); -var extend = __webpack_require__(560); -var isPlainObject = __webpack_require__(554); -var isObject = __webpack_require__(561); +var split = __webpack_require__(607); +var extend = __webpack_require__(603); +var isPlainObject = __webpack_require__(597); +var isObject = __webpack_require__(604); module.exports = function(obj, prop, val) { if (!isObject(obj)) { @@ -69828,14 +73545,14 @@ function isValidKey(key) { /***/ }), -/* 604 */ +/* 647 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var isExtendable = __webpack_require__(605); -var forIn = __webpack_require__(606); +var isExtendable = __webpack_require__(648); +var forIn = __webpack_require__(649); function mixinDeep(target, objects) { var len = arguments.length, i = 0; @@ -69899,7 +73616,7 @@ module.exports = mixinDeep; /***/ }), -/* 605 */ +/* 648 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69912,7 +73629,7 @@ module.exports = mixinDeep; -var isPlainObject = __webpack_require__(554); +var isPlainObject = __webpack_require__(597); module.exports = function isExtendable(val) { return isPlainObject(val) || typeof val === 'function' || Array.isArray(val); @@ -69920,7 +73637,7 @@ module.exports = function isExtendable(val) { /***/ }), -/* 606 */ +/* 649 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -69943,7 +73660,7 @@ module.exports = function forIn(obj, fn, thisArg) { /***/ }), -/* 607 */ +/* 650 */ /***/ (function(module, exports) { /*! @@ -69970,14 +73687,14 @@ module.exports = pascalcase; /***/ }), -/* 608 */ +/* 651 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; var util = __webpack_require__(112); -var utils = __webpack_require__(609); +var utils = __webpack_require__(652); /** * Expose class utils @@ -70342,7 +74059,7 @@ cu.bubble = function(Parent, events) { /***/ }), -/* 609 */ +/* 652 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -70356,10 +74073,10 @@ var utils = {}; * Lazily required module dependencies */ -utils.union = __webpack_require__(592); -utils.define = __webpack_require__(610); -utils.isObj = __webpack_require__(547); -utils.staticExtend = __webpack_require__(617); +utils.union = __webpack_require__(635); +utils.define = __webpack_require__(653); +utils.isObj = __webpack_require__(590); +utils.staticExtend = __webpack_require__(660); /** @@ -70370,7 +74087,7 @@ module.exports = utils; /***/ }), -/* 610 */ +/* 653 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -70383,7 +74100,7 @@ module.exports = utils; -var isDescriptor = __webpack_require__(611); +var isDescriptor = __webpack_require__(654); module.exports = function defineProperty(obj, prop, val) { if (typeof obj !== 'object' && typeof obj !== 'function') { @@ -70408,7 +74125,7 @@ module.exports = function defineProperty(obj, prop, val) { /***/ }), -/* 611 */ +/* 654 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -70421,9 +74138,9 @@ module.exports = function defineProperty(obj, prop, val) { -var typeOf = __webpack_require__(612); -var isAccessor = __webpack_require__(613); -var isData = __webpack_require__(615); +var typeOf = __webpack_require__(655); +var isAccessor = __webpack_require__(656); +var isData = __webpack_require__(658); module.exports = function isDescriptor(obj, key) { if (typeOf(obj) !== 'object') { @@ -70437,7 +74154,7 @@ module.exports = function isDescriptor(obj, key) { /***/ }), -/* 612 */ +/* 655 */ /***/ (function(module, exports) { var toString = Object.prototype.toString; @@ -70590,7 +74307,7 @@ function isBuffer(val) { /***/ }), -/* 613 */ +/* 656 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -70603,7 +74320,7 @@ function isBuffer(val) { -var typeOf = __webpack_require__(614); +var typeOf = __webpack_require__(657); // accessor descriptor properties var accessor = { @@ -70666,10 +74383,10 @@ module.exports = isAccessorDescriptor; /***/ }), -/* 614 */ +/* 657 */ /***/ (function(module, exports, __webpack_require__) { -var isBuffer = __webpack_require__(571); +var isBuffer = __webpack_require__(614); var toString = Object.prototype.toString; /** @@ -70788,7 +74505,7 @@ module.exports = function kindOf(val) { /***/ }), -/* 615 */ +/* 658 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -70801,7 +74518,7 @@ module.exports = function kindOf(val) { -var typeOf = __webpack_require__(616); +var typeOf = __webpack_require__(659); // data descriptor properties var data = { @@ -70850,10 +74567,10 @@ module.exports = isDataDescriptor; /***/ }), -/* 616 */ +/* 659 */ /***/ (function(module, exports, __webpack_require__) { -var isBuffer = __webpack_require__(571); +var isBuffer = __webpack_require__(614); var toString = Object.prototype.toString; /** @@ -70972,7 +74689,7 @@ module.exports = function kindOf(val) { /***/ }), -/* 617 */ +/* 660 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -70985,8 +74702,8 @@ module.exports = function kindOf(val) { -var copy = __webpack_require__(618); -var define = __webpack_require__(610); +var copy = __webpack_require__(661); +var define = __webpack_require__(653); var util = __webpack_require__(112); /** @@ -71069,15 +74786,15 @@ module.exports = extend; /***/ }), -/* 618 */ +/* 661 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var typeOf = __webpack_require__(619); -var copyDescriptor = __webpack_require__(620); -var define = __webpack_require__(610); +var typeOf = __webpack_require__(662); +var copyDescriptor = __webpack_require__(663); +var define = __webpack_require__(653); /** * Copy static properties, prototype properties, and descriptors from one object to another. @@ -71250,10 +74967,10 @@ module.exports.has = has; /***/ }), -/* 619 */ +/* 662 */ /***/ (function(module, exports, __webpack_require__) { -var isBuffer = __webpack_require__(571); +var isBuffer = __webpack_require__(614); var toString = Object.prototype.toString; /** @@ -71372,7 +75089,7 @@ module.exports = function kindOf(val) { /***/ }), -/* 620 */ +/* 663 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -71460,16 +75177,16 @@ function isObject(val) { /***/ }), -/* 621 */ +/* 664 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var use = __webpack_require__(622); -var define = __webpack_require__(610); -var debug = __webpack_require__(624)('snapdragon:compiler'); -var utils = __webpack_require__(630); +var use = __webpack_require__(665); +var define = __webpack_require__(653); +var debug = __webpack_require__(543)('snapdragon:compiler'); +var utils = __webpack_require__(667); /** * Create a new `Compiler` with the given `options`. @@ -71623,7 +75340,7 @@ Compiler.prototype = { // source map support if (opts.sourcemap) { - var sourcemaps = __webpack_require__(649); + var sourcemaps = __webpack_require__(686); sourcemaps(this); this.mapVisit(this.ast.nodes); this.applySourceMaps(); @@ -71644,7 +75361,7 @@ module.exports = Compiler; /***/ }), -/* 622 */ +/* 665 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -71657,7 +75374,7 @@ module.exports = Compiler; -var utils = __webpack_require__(623); +var utils = __webpack_require__(666); module.exports = function base(app, opts) { if (!utils.isObject(app) && typeof app !== 'function') { @@ -71772,7 +75489,7 @@ module.exports = function base(app, opts) { /***/ }), -/* 623 */ +/* 666 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -71786,8 +75503,8 @@ var utils = {}; * Lazily required module dependencies */ -utils.define = __webpack_require__(610); -utils.isObject = __webpack_require__(547); +utils.define = __webpack_require__(653); +utils.isObject = __webpack_require__(590); utils.isString = function(val) { @@ -71802,840 +75519,7 @@ module.exports = utils; /***/ }), -/* 624 */ -/***/ (function(module, exports, __webpack_require__) { - -/** - * Detect Electron renderer process, which is node, but we should - * treat as a browser. - */ - -if (typeof process !== 'undefined' && process.type === 'renderer') { - module.exports = __webpack_require__(625); -} else { - module.exports = __webpack_require__(628); -} - - -/***/ }), -/* 625 */ -/***/ (function(module, exports, __webpack_require__) { - -/** - * This is the web browser implementation of `debug()`. - * - * Expose `debug()` as the module. - */ - -exports = module.exports = __webpack_require__(626); -exports.log = log; -exports.formatArgs = formatArgs; -exports.save = save; -exports.load = load; -exports.useColors = useColors; -exports.storage = 'undefined' != typeof chrome - && 'undefined' != typeof chrome.storage - ? chrome.storage.local - : localstorage(); - -/** - * Colors. - */ - -exports.colors = [ - 'lightseagreen', - 'forestgreen', - 'goldenrod', - 'dodgerblue', - 'darkorchid', - 'crimson' -]; - -/** - * Currently only WebKit-based Web Inspectors, Firefox >= v31, - * and the Firebug extension (any Firefox version) are known - * to support "%c" CSS customizations. - * - * TODO: add a `localStorage` variable to explicitly enable/disable colors - */ - -function useColors() { - // NB: In an Electron preload script, document will be defined but not fully - // initialized. Since we know we're in Chrome, we'll just detect this case - // explicitly - if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') { - return true; - } - - // is webkit? http://stackoverflow.com/a/16459606/376773 - // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632 - return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) || - // is firebug? http://stackoverflow.com/a/398120/376773 - (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) || - // is firefox >= v31? - // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages - (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) || - // double check webkit in userAgent just in case we are in a worker - (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)); -} - -/** - * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. - */ - -exports.formatters.j = function(v) { - try { - return JSON.stringify(v); - } catch (err) { - return '[UnexpectedJSONParseError]: ' + err.message; - } -}; - - -/** - * Colorize log arguments if enabled. - * - * @api public - */ - -function formatArgs(args) { - var useColors = this.useColors; - - args[0] = (useColors ? '%c' : '') - + this.namespace - + (useColors ? ' %c' : ' ') - + args[0] - + (useColors ? '%c ' : ' ') - + '+' + exports.humanize(this.diff); - - if (!useColors) return; - - var c = 'color: ' + this.color; - args.splice(1, 0, c, 'color: inherit') - - // the final "%c" is somewhat tricky, because there could be other - // arguments passed either before or after the %c, so we need to - // figure out the correct index to insert the CSS into - var index = 0; - var lastC = 0; - args[0].replace(/%[a-zA-Z%]/g, function(match) { - if ('%%' === match) return; - index++; - if ('%c' === match) { - // we only are interested in the *last* %c - // (the user may have provided their own) - lastC = index; - } - }); - - args.splice(lastC, 0, c); -} - -/** - * Invokes `console.log()` when available. - * No-op when `console.log` is not a "function". - * - * @api public - */ - -function log() { - // this hackery is required for IE8/9, where - // the `console.log` function doesn't have 'apply' - return 'object' === typeof console - && console.log - && Function.prototype.apply.call(console.log, console, arguments); -} - -/** - * Save `namespaces`. - * - * @param {String} namespaces - * @api private - */ - -function save(namespaces) { - try { - if (null == namespaces) { - exports.storage.removeItem('debug'); - } else { - exports.storage.debug = namespaces; - } - } catch(e) {} -} - -/** - * Load `namespaces`. - * - * @return {String} returns the previously persisted debug modes - * @api private - */ - -function load() { - var r; - try { - r = exports.storage.debug; - } catch(e) {} - - // If debug isn't set in LS, and we're in Electron, try to load $DEBUG - if (!r && typeof process !== 'undefined' && 'env' in process) { - r = process.env.DEBUG; - } - - return r; -} - -/** - * Enable namespaces listed in `localStorage.debug` initially. - */ - -exports.enable(load()); - -/** - * Localstorage attempts to return the localstorage. - * - * This is necessary because safari throws - * when a user disables cookies/localstorage - * and you attempt to access it. - * - * @return {LocalStorage} - * @api private - */ - -function localstorage() { - try { - return window.localStorage; - } catch (e) {} -} - - -/***/ }), -/* 626 */ -/***/ (function(module, exports, __webpack_require__) { - - -/** - * This is the common logic for both the Node.js and web browser - * implementations of `debug()`. - * - * Expose `debug()` as the module. - */ - -exports = module.exports = createDebug.debug = createDebug['default'] = createDebug; -exports.coerce = coerce; -exports.disable = disable; -exports.enable = enable; -exports.enabled = enabled; -exports.humanize = __webpack_require__(627); - -/** - * The currently active debug mode names, and names to skip. - */ - -exports.names = []; -exports.skips = []; - -/** - * Map of special "%n" handling functions, for the debug "format" argument. - * - * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". - */ - -exports.formatters = {}; - -/** - * Previous log timestamp. - */ - -var prevTime; - -/** - * Select a color. - * @param {String} namespace - * @return {Number} - * @api private - */ - -function selectColor(namespace) { - var hash = 0, i; - - for (i in namespace) { - hash = ((hash << 5) - hash) + namespace.charCodeAt(i); - hash |= 0; // Convert to 32bit integer - } - - return exports.colors[Math.abs(hash) % exports.colors.length]; -} - -/** - * Create a debugger with the given `namespace`. - * - * @param {String} namespace - * @return {Function} - * @api public - */ - -function createDebug(namespace) { - - function debug() { - // disabled? - if (!debug.enabled) return; - - var self = debug; - - // set `diff` timestamp - var curr = +new Date(); - var ms = curr - (prevTime || curr); - self.diff = ms; - self.prev = prevTime; - self.curr = curr; - prevTime = curr; - - // turn the `arguments` into a proper Array - var args = new Array(arguments.length); - for (var i = 0; i < args.length; i++) { - args[i] = arguments[i]; - } - - args[0] = exports.coerce(args[0]); - - if ('string' !== typeof args[0]) { - // anything else let's inspect with %O - args.unshift('%O'); - } - - // apply any `formatters` transformations - var index = 0; - args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) { - // if we encounter an escaped % then don't increase the array index - if (match === '%%') return match; - index++; - var formatter = exports.formatters[format]; - if ('function' === typeof formatter) { - var val = args[index]; - match = formatter.call(self, val); - - // now we need to remove `args[index]` since it's inlined in the `format` - args.splice(index, 1); - index--; - } - return match; - }); - - // apply env-specific formatting (colors, etc.) - exports.formatArgs.call(self, args); - - var logFn = debug.log || exports.log || console.log.bind(console); - logFn.apply(self, args); - } - - debug.namespace = namespace; - debug.enabled = exports.enabled(namespace); - debug.useColors = exports.useColors(); - debug.color = selectColor(namespace); - - // env-specific initialization logic for debug instances - if ('function' === typeof exports.init) { - exports.init(debug); - } - - return debug; -} - -/** - * Enables a debug mode by namespaces. This can include modes - * separated by a colon and wildcards. - * - * @param {String} namespaces - * @api public - */ - -function enable(namespaces) { - exports.save(namespaces); - - exports.names = []; - exports.skips = []; - - var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/); - var len = split.length; - - for (var i = 0; i < len; i++) { - if (!split[i]) continue; // ignore empty strings - namespaces = split[i].replace(/\*/g, '.*?'); - if (namespaces[0] === '-') { - exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); - } else { - exports.names.push(new RegExp('^' + namespaces + '$')); - } - } -} - -/** - * Disable debug output. - * - * @api public - */ - -function disable() { - exports.enable(''); -} - -/** - * Returns true if the given mode name is enabled, false otherwise. - * - * @param {String} name - * @return {Boolean} - * @api public - */ - -function enabled(name) { - var i, len; - for (i = 0, len = exports.skips.length; i < len; i++) { - if (exports.skips[i].test(name)) { - return false; - } - } - for (i = 0, len = exports.names.length; i < len; i++) { - if (exports.names[i].test(name)) { - return true; - } - } - return false; -} - -/** - * Coerce `val`. - * - * @param {Mixed} val - * @return {Mixed} - * @api private - */ - -function coerce(val) { - if (val instanceof Error) return val.stack || val.message; - return val; -} - - -/***/ }), -/* 627 */ -/***/ (function(module, exports) { - -/** - * Helpers. - */ - -var s = 1000; -var m = s * 60; -var h = m * 60; -var d = h * 24; -var y = d * 365.25; - -/** - * Parse or format the given `val`. - * - * Options: - * - * - `long` verbose formatting [false] - * - * @param {String|Number} val - * @param {Object} [options] - * @throws {Error} throw an error if val is not a non-empty string or a number - * @return {String|Number} - * @api public - */ - -module.exports = function(val, options) { - options = options || {}; - var type = typeof val; - if (type === 'string' && val.length > 0) { - return parse(val); - } else if (type === 'number' && isNaN(val) === false) { - return options.long ? fmtLong(val) : fmtShort(val); - } - throw new Error( - 'val is not a non-empty string or a valid number. val=' + - JSON.stringify(val) - ); -}; - -/** - * Parse the given `str` and return milliseconds. - * - * @param {String} str - * @return {Number} - * @api private - */ - -function parse(str) { - str = String(str); - if (str.length > 100) { - return; - } - var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec( - str - ); - if (!match) { - return; - } - var n = parseFloat(match[1]); - var type = (match[2] || 'ms').toLowerCase(); - switch (type) { - case 'years': - case 'year': - case 'yrs': - case 'yr': - case 'y': - return n * y; - case 'days': - case 'day': - case 'd': - return n * d; - case 'hours': - case 'hour': - case 'hrs': - case 'hr': - case 'h': - return n * h; - case 'minutes': - case 'minute': - case 'mins': - case 'min': - case 'm': - return n * m; - case 'seconds': - case 'second': - case 'secs': - case 'sec': - case 's': - return n * s; - case 'milliseconds': - case 'millisecond': - case 'msecs': - case 'msec': - case 'ms': - return n; - default: - return undefined; - } -} - -/** - * Short format for `ms`. - * - * @param {Number} ms - * @return {String} - * @api private - */ - -function fmtShort(ms) { - if (ms >= d) { - return Math.round(ms / d) + 'd'; - } - if (ms >= h) { - return Math.round(ms / h) + 'h'; - } - if (ms >= m) { - return Math.round(ms / m) + 'm'; - } - if (ms >= s) { - return Math.round(ms / s) + 's'; - } - return ms + 'ms'; -} - -/** - * Long format for `ms`. - * - * @param {Number} ms - * @return {String} - * @api private - */ - -function fmtLong(ms) { - return plural(ms, d, 'day') || - plural(ms, h, 'hour') || - plural(ms, m, 'minute') || - plural(ms, s, 'second') || - ms + ' ms'; -} - -/** - * Pluralization helper. - */ - -function plural(ms, n, name) { - if (ms < n) { - return; - } - if (ms < n * 1.5) { - return Math.floor(ms / n) + ' ' + name; - } - return Math.ceil(ms / n) + ' ' + name + 's'; -} - - -/***/ }), -/* 628 */ -/***/ (function(module, exports, __webpack_require__) { - -/** - * Module dependencies. - */ - -var tty = __webpack_require__(122); -var util = __webpack_require__(112); - -/** - * This is the Node.js implementation of `debug()`. - * - * Expose `debug()` as the module. - */ - -exports = module.exports = __webpack_require__(626); -exports.init = init; -exports.log = log; -exports.formatArgs = formatArgs; -exports.save = save; -exports.load = load; -exports.useColors = useColors; - -/** - * Colors. - */ - -exports.colors = [6, 2, 3, 4, 5, 1]; - -/** - * Build up the default `inspectOpts` object from the environment variables. - * - * $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js - */ - -exports.inspectOpts = Object.keys(process.env).filter(function (key) { - return /^debug_/i.test(key); -}).reduce(function (obj, key) { - // camel-case - var prop = key - .substring(6) - .toLowerCase() - .replace(/_([a-z])/g, function (_, k) { return k.toUpperCase() }); - - // coerce string value into JS value - var val = process.env[key]; - if (/^(yes|on|true|enabled)$/i.test(val)) val = true; - else if (/^(no|off|false|disabled)$/i.test(val)) val = false; - else if (val === 'null') val = null; - else val = Number(val); - - obj[prop] = val; - return obj; -}, {}); - -/** - * The file descriptor to write the `debug()` calls to. - * Set the `DEBUG_FD` env variable to override with another value. i.e.: - * - * $ DEBUG_FD=3 node script.js 3>debug.log - */ - -var fd = parseInt(process.env.DEBUG_FD, 10) || 2; - -if (1 !== fd && 2 !== fd) { - util.deprecate(function(){}, 'except for stderr(2) and stdout(1), any other usage of DEBUG_FD is deprecated. Override debug.log if you want to use a different log function (https://git.io/debug_fd)')() -} - -var stream = 1 === fd ? process.stdout : - 2 === fd ? process.stderr : - createWritableStdioStream(fd); - -/** - * Is stdout a TTY? Colored output is enabled when `true`. - */ - -function useColors() { - return 'colors' in exports.inspectOpts - ? Boolean(exports.inspectOpts.colors) - : tty.isatty(fd); -} - -/** - * Map %o to `util.inspect()`, all on a single line. - */ - -exports.formatters.o = function(v) { - this.inspectOpts.colors = this.useColors; - return util.inspect(v, this.inspectOpts) - .split('\n').map(function(str) { - return str.trim() - }).join(' '); -}; - -/** - * Map %o to `util.inspect()`, allowing multiple lines if needed. - */ - -exports.formatters.O = function(v) { - this.inspectOpts.colors = this.useColors; - return util.inspect(v, this.inspectOpts); -}; - -/** - * Adds ANSI color escape codes if enabled. - * - * @api public - */ - -function formatArgs(args) { - var name = this.namespace; - var useColors = this.useColors; - - if (useColors) { - var c = this.color; - var prefix = ' \u001b[3' + c + ';1m' + name + ' ' + '\u001b[0m'; - - args[0] = prefix + args[0].split('\n').join('\n' + prefix); - args.push('\u001b[3' + c + 'm+' + exports.humanize(this.diff) + '\u001b[0m'); - } else { - args[0] = new Date().toUTCString() - + ' ' + name + ' ' + args[0]; - } -} - -/** - * Invokes `util.format()` with the specified arguments and writes to `stream`. - */ - -function log() { - return stream.write(util.format.apply(util, arguments) + '\n'); -} - -/** - * Save `namespaces`. - * - * @param {String} namespaces - * @api private - */ - -function save(namespaces) { - if (null == namespaces) { - // If you set a process.env field to null or undefined, it gets cast to the - // string 'null' or 'undefined'. Just delete instead. - delete process.env.DEBUG; - } else { - process.env.DEBUG = namespaces; - } -} - -/** - * Load `namespaces`. - * - * @return {String} returns the previously persisted debug modes - * @api private - */ - -function load() { - return process.env.DEBUG; -} - -/** - * Copied from `node/src/node.js`. - * - * XXX: It's lame that node doesn't expose this API out-of-the-box. It also - * relies on the undocumented `tty_wrap.guessHandleType()` which is also lame. - */ - -function createWritableStdioStream (fd) { - var stream; - var tty_wrap = process.binding('tty_wrap'); - - // Note stream._type is used for test-module-load-list.js - - switch (tty_wrap.guessHandleType(fd)) { - case 'TTY': - stream = new tty.WriteStream(fd); - stream._type = 'tty'; - - // Hack to have stream not keep the event loop alive. - // See https://github.com/joyent/node/issues/1726 - if (stream._handle && stream._handle.unref) { - stream._handle.unref(); - } - break; - - case 'FILE': - var fs = __webpack_require__(134); - stream = new fs.SyncWriteStream(fd, { autoClose: false }); - stream._type = 'fs'; - break; - - case 'PIPE': - case 'TCP': - var net = __webpack_require__(629); - stream = new net.Socket({ - fd: fd, - readable: false, - writable: true - }); - - // FIXME Should probably have an option in net.Socket to create a - // stream from an existing fd which is writable only. But for now - // we'll just add this hack and set the `readable` member to false. - // Test: ./node test/fixtures/echo.js < /etc/passwd - stream.readable = false; - stream.read = null; - stream._type = 'pipe'; - - // FIXME Hack to have stream not keep the event loop alive. - // See https://github.com/joyent/node/issues/1726 - if (stream._handle && stream._handle.unref) { - stream._handle.unref(); - } - break; - - default: - // Probably an error on in uv_guess_handle() - throw new Error('Implement me. Unknown stream file type!'); - } - - // For supporting legacy API we put the FD here. - stream.fd = fd; - - stream._isStdio = true; - - return stream; -} - -/** - * Init logic for `debug` instances. - * - * Create a new `inspectOpts` object in case `useColors` is set - * differently for a particular `debug` instance. - */ - -function init (debug) { - debug.inspectOpts = {}; - - var keys = Object.keys(exports.inspectOpts); - for (var i = 0; i < keys.length; i++) { - debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]]; - } -} - -/** - * Enable namespaces listed in `process.env.DEBUG` initially. - */ - -exports.enable(load()); - - -/***/ }), -/* 629 */ -/***/ (function(module, exports) { - -module.exports = require("net"); - -/***/ }), -/* 630 */ +/* 667 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -72645,9 +75529,9 @@ module.exports = require("net"); * Module dependencies */ -exports.extend = __webpack_require__(560); -exports.SourceMap = __webpack_require__(631); -exports.sourceMapResolve = __webpack_require__(642); +exports.extend = __webpack_require__(603); +exports.SourceMap = __webpack_require__(668); +exports.sourceMapResolve = __webpack_require__(679); /** * Convert backslash in the given string to forward slashes @@ -72690,7 +75574,7 @@ exports.last = function(arr, n) { /***/ }), -/* 631 */ +/* 668 */ /***/ (function(module, exports, __webpack_require__) { /* @@ -72698,13 +75582,13 @@ exports.last = function(arr, n) { * Licensed under the New BSD license. See LICENSE.txt or: * http://opensource.org/licenses/BSD-3-Clause */ -exports.SourceMapGenerator = __webpack_require__(632).SourceMapGenerator; -exports.SourceMapConsumer = __webpack_require__(638).SourceMapConsumer; -exports.SourceNode = __webpack_require__(641).SourceNode; +exports.SourceMapGenerator = __webpack_require__(669).SourceMapGenerator; +exports.SourceMapConsumer = __webpack_require__(675).SourceMapConsumer; +exports.SourceNode = __webpack_require__(678).SourceNode; /***/ }), -/* 632 */ +/* 669 */ /***/ (function(module, exports, __webpack_require__) { /* -*- Mode: js; js-indent-level: 2; -*- */ @@ -72714,10 +75598,10 @@ exports.SourceNode = __webpack_require__(641).SourceNode; * http://opensource.org/licenses/BSD-3-Clause */ -var base64VLQ = __webpack_require__(633); -var util = __webpack_require__(635); -var ArraySet = __webpack_require__(636).ArraySet; -var MappingList = __webpack_require__(637).MappingList; +var base64VLQ = __webpack_require__(670); +var util = __webpack_require__(672); +var ArraySet = __webpack_require__(673).ArraySet; +var MappingList = __webpack_require__(674).MappingList; /** * An instance of the SourceMapGenerator represents a source map which is @@ -73126,7 +76010,7 @@ exports.SourceMapGenerator = SourceMapGenerator; /***/ }), -/* 633 */ +/* 670 */ /***/ (function(module, exports, __webpack_require__) { /* -*- Mode: js; js-indent-level: 2; -*- */ @@ -73166,7 +76050,7 @@ exports.SourceMapGenerator = SourceMapGenerator; * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -var base64 = __webpack_require__(634); +var base64 = __webpack_require__(671); // A single base 64 digit can contain 6 bits of data. For the base 64 variable // length quantities we use in the source map spec, the first bit is the sign, @@ -73272,7 +76156,7 @@ exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) { /***/ }), -/* 634 */ +/* 671 */ /***/ (function(module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ @@ -73345,7 +76229,7 @@ exports.decode = function (charCode) { /***/ }), -/* 635 */ +/* 672 */ /***/ (function(module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ @@ -73768,7 +76652,7 @@ exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflate /***/ }), -/* 636 */ +/* 673 */ /***/ (function(module, exports, __webpack_require__) { /* -*- Mode: js; js-indent-level: 2; -*- */ @@ -73778,7 +76662,7 @@ exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflate * http://opensource.org/licenses/BSD-3-Clause */ -var util = __webpack_require__(635); +var util = __webpack_require__(672); var has = Object.prototype.hasOwnProperty; var hasNativeMap = typeof Map !== "undefined"; @@ -73895,7 +76779,7 @@ exports.ArraySet = ArraySet; /***/ }), -/* 637 */ +/* 674 */ /***/ (function(module, exports, __webpack_require__) { /* -*- Mode: js; js-indent-level: 2; -*- */ @@ -73905,7 +76789,7 @@ exports.ArraySet = ArraySet; * http://opensource.org/licenses/BSD-3-Clause */ -var util = __webpack_require__(635); +var util = __webpack_require__(672); /** * Determine whether mappingB is after mappingA with respect to generated @@ -73980,7 +76864,7 @@ exports.MappingList = MappingList; /***/ }), -/* 638 */ +/* 675 */ /***/ (function(module, exports, __webpack_require__) { /* -*- Mode: js; js-indent-level: 2; -*- */ @@ -73990,11 +76874,11 @@ exports.MappingList = MappingList; * http://opensource.org/licenses/BSD-3-Clause */ -var util = __webpack_require__(635); -var binarySearch = __webpack_require__(639); -var ArraySet = __webpack_require__(636).ArraySet; -var base64VLQ = __webpack_require__(633); -var quickSort = __webpack_require__(640).quickSort; +var util = __webpack_require__(672); +var binarySearch = __webpack_require__(676); +var ArraySet = __webpack_require__(673).ArraySet; +var base64VLQ = __webpack_require__(670); +var quickSort = __webpack_require__(677).quickSort; function SourceMapConsumer(aSourceMap) { var sourceMap = aSourceMap; @@ -75068,7 +77952,7 @@ exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer; /***/ }), -/* 639 */ +/* 676 */ /***/ (function(module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ @@ -75185,7 +78069,7 @@ exports.search = function search(aNeedle, aHaystack, aCompare, aBias) { /***/ }), -/* 640 */ +/* 677 */ /***/ (function(module, exports) { /* -*- Mode: js; js-indent-level: 2; -*- */ @@ -75305,7 +78189,7 @@ exports.quickSort = function (ary, comparator) { /***/ }), -/* 641 */ +/* 678 */ /***/ (function(module, exports, __webpack_require__) { /* -*- Mode: js; js-indent-level: 2; -*- */ @@ -75315,8 +78199,8 @@ exports.quickSort = function (ary, comparator) { * http://opensource.org/licenses/BSD-3-Clause */ -var SourceMapGenerator = __webpack_require__(632).SourceMapGenerator; -var util = __webpack_require__(635); +var SourceMapGenerator = __webpack_require__(669).SourceMapGenerator; +var util = __webpack_require__(672); // Matches a Windows-style `\r\n` newline or a `\n` newline used by all other // operating systems these days (capturing the result). @@ -75724,17 +78608,17 @@ exports.SourceNode = SourceNode; /***/ }), -/* 642 */ +/* 679 */ /***/ (function(module, exports, __webpack_require__) { // Copyright 2014, 2015, 2016, 2017 Simon Lydell // X11 (“MIT”) Licensed. (See LICENSE.) -var sourceMappingURL = __webpack_require__(643) -var resolveUrl = __webpack_require__(644) -var decodeUriComponent = __webpack_require__(645) -var urix = __webpack_require__(647) -var atob = __webpack_require__(648) +var sourceMappingURL = __webpack_require__(680) +var resolveUrl = __webpack_require__(681) +var decodeUriComponent = __webpack_require__(682) +var urix = __webpack_require__(684) +var atob = __webpack_require__(685) @@ -76032,7 +78916,7 @@ module.exports = { /***/ }), -/* 643 */ +/* 680 */ /***/ (function(module, exports, __webpack_require__) { var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;// Copyright 2014 Simon Lydell @@ -76095,7 +78979,7 @@ void (function(root, factory) { /***/ }), -/* 644 */ +/* 681 */ /***/ (function(module, exports, __webpack_require__) { // Copyright 2014 Simon Lydell @@ -76113,13 +78997,13 @@ module.exports = resolveUrl /***/ }), -/* 645 */ +/* 682 */ /***/ (function(module, exports, __webpack_require__) { // Copyright 2017 Simon Lydell // X11 (“MIT”) Licensed. (See LICENSE.) -var decodeUriComponent = __webpack_require__(646) +var decodeUriComponent = __webpack_require__(683) function customDecodeUriComponent(string) { // `decodeUriComponent` turns `+` into ` `, but that's not wanted. @@ -76130,7 +79014,7 @@ module.exports = customDecodeUriComponent /***/ }), -/* 646 */ +/* 683 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -76231,7 +79115,7 @@ module.exports = function (encodedURI) { /***/ }), -/* 647 */ +/* 684 */ /***/ (function(module, exports, __webpack_require__) { // Copyright 2014 Simon Lydell @@ -76254,7 +79138,7 @@ module.exports = urix /***/ }), -/* 648 */ +/* 685 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -76268,7 +79152,7 @@ module.exports = atob.atob = atob; /***/ }), -/* 649 */ +/* 686 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -76276,8 +79160,8 @@ module.exports = atob.atob = atob; var fs = __webpack_require__(134); var path = __webpack_require__(4); -var define = __webpack_require__(610); -var utils = __webpack_require__(630); +var define = __webpack_require__(653); +var utils = __webpack_require__(667); /** * Expose `mixin()`. @@ -76420,19 +79304,19 @@ exports.comment = function(node) { /***/ }), -/* 650 */ +/* 687 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var use = __webpack_require__(622); +var use = __webpack_require__(665); var util = __webpack_require__(112); -var Cache = __webpack_require__(651); -var define = __webpack_require__(610); -var debug = __webpack_require__(624)('snapdragon:parser'); -var Position = __webpack_require__(652); -var utils = __webpack_require__(630); +var Cache = __webpack_require__(688); +var define = __webpack_require__(653); +var debug = __webpack_require__(543)('snapdragon:parser'); +var Position = __webpack_require__(689); +var utils = __webpack_require__(667); /** * Create a new `Parser` with the given `input` and `options`. @@ -76960,7 +79844,7 @@ module.exports = Parser; /***/ }), -/* 651 */ +/* 688 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -77067,13 +79951,13 @@ MapCache.prototype.del = function mapDelete(key) { /***/ }), -/* 652 */ +/* 689 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var define = __webpack_require__(610); +var define = __webpack_require__(653); /** * Store position for a node @@ -77088,14 +79972,14 @@ module.exports = function Position(start, parser) { /***/ }), -/* 653 */ +/* 690 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var isExtendable = __webpack_require__(654); -var assignSymbols = __webpack_require__(555); +var isExtendable = __webpack_require__(691); +var assignSymbols = __webpack_require__(598); module.exports = Object.assign || function(obj/*, objects*/) { if (obj === null || typeof obj === 'undefined') { @@ -77155,7 +80039,7 @@ function isEnum(obj, key) { /***/ }), -/* 654 */ +/* 691 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -77168,7 +80052,7 @@ function isEnum(obj, key) { -var isPlainObject = __webpack_require__(554); +var isPlainObject = __webpack_require__(597); module.exports = function isExtendable(val) { return isPlainObject(val) || typeof val === 'function' || Array.isArray(val); @@ -77176,14 +80060,14 @@ module.exports = function isExtendable(val) { /***/ }), -/* 655 */ +/* 692 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var nanomatch = __webpack_require__(656); -var extglob = __webpack_require__(670); +var nanomatch = __webpack_require__(693); +var extglob = __webpack_require__(707); module.exports = function(snapdragon) { var compilers = snapdragon.compiler.compilers; @@ -77260,7 +80144,7 @@ function escapeExtglobs(compiler) { /***/ }), -/* 656 */ +/* 693 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -77271,17 +80155,17 @@ function escapeExtglobs(compiler) { */ var util = __webpack_require__(112); -var toRegex = __webpack_require__(539); -var extend = __webpack_require__(657); +var toRegex = __webpack_require__(582); +var extend = __webpack_require__(694); /** * Local dependencies */ -var compilers = __webpack_require__(659); -var parsers = __webpack_require__(660); -var cache = __webpack_require__(663); -var utils = __webpack_require__(665); +var compilers = __webpack_require__(696); +var parsers = __webpack_require__(697); +var cache = __webpack_require__(700); +var utils = __webpack_require__(702); var MAX_LENGTH = 1024 * 64; /** @@ -78105,14 +80989,14 @@ module.exports = nanomatch; /***/ }), -/* 657 */ +/* 694 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var isExtendable = __webpack_require__(658); -var assignSymbols = __webpack_require__(555); +var isExtendable = __webpack_require__(695); +var assignSymbols = __webpack_require__(598); module.exports = Object.assign || function(obj/*, objects*/) { if (obj === null || typeof obj === 'undefined') { @@ -78172,7 +81056,7 @@ function isEnum(obj, key) { /***/ }), -/* 658 */ +/* 695 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -78185,7 +81069,7 @@ function isEnum(obj, key) { -var isPlainObject = __webpack_require__(554); +var isPlainObject = __webpack_require__(597); module.exports = function isExtendable(val) { return isPlainObject(val) || typeof val === 'function' || Array.isArray(val); @@ -78193,7 +81077,7 @@ module.exports = function isExtendable(val) { /***/ }), -/* 659 */ +/* 696 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -78539,15 +81423,15 @@ module.exports = function(nanomatch, options) { /***/ }), -/* 660 */ +/* 697 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var regexNot = __webpack_require__(556); -var toRegex = __webpack_require__(539); -var isOdd = __webpack_require__(661); +var regexNot = __webpack_require__(599); +var toRegex = __webpack_require__(582); +var isOdd = __webpack_require__(698); /** * Characters to use in negation regex (we want to "not" match @@ -78933,7 +81817,7 @@ module.exports.not = NOT_REGEX; /***/ }), -/* 661 */ +/* 698 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -78946,7 +81830,7 @@ module.exports.not = NOT_REGEX; -var isNumber = __webpack_require__(662); +var isNumber = __webpack_require__(699); module.exports = function isOdd(i) { if (!isNumber(i)) { @@ -78960,7 +81844,7 @@ module.exports = function isOdd(i) { /***/ }), -/* 662 */ +/* 699 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -78988,14 +81872,14 @@ module.exports = function isNumber(num) { /***/ }), -/* 663 */ +/* 700 */ /***/ (function(module, exports, __webpack_require__) { -module.exports = new (__webpack_require__(664))(); +module.exports = new (__webpack_require__(701))(); /***/ }), -/* 664 */ +/* 701 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -79008,7 +81892,7 @@ module.exports = new (__webpack_require__(664))(); -var MapCache = __webpack_require__(651); +var MapCache = __webpack_require__(688); /** * Create a new `FragmentCache` with an optional object to use for `caches`. @@ -79130,7 +82014,7 @@ exports = module.exports = FragmentCache; /***/ }), -/* 665 */ +/* 702 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -79143,14 +82027,14 @@ var path = __webpack_require__(4); * Module dependencies */ -var isWindows = __webpack_require__(666)(); -var Snapdragon = __webpack_require__(581); -utils.define = __webpack_require__(667); -utils.diff = __webpack_require__(668); -utils.extend = __webpack_require__(657); -utils.pick = __webpack_require__(669); -utils.typeOf = __webpack_require__(549); -utils.unique = __webpack_require__(559); +var isWindows = __webpack_require__(703)(); +var Snapdragon = __webpack_require__(624); +utils.define = __webpack_require__(704); +utils.diff = __webpack_require__(705); +utils.extend = __webpack_require__(694); +utils.pick = __webpack_require__(706); +utils.typeOf = __webpack_require__(592); +utils.unique = __webpack_require__(602); /** * Returns true if the given value is effectively an empty string @@ -79516,7 +82400,7 @@ utils.unixify = function(options) { /***/ }), -/* 666 */ +/* 703 */ /***/ (function(module, exports, __webpack_require__) { var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! @@ -79544,7 +82428,7 @@ var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_ /***/ }), -/* 667 */ +/* 704 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -79557,8 +82441,8 @@ var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_ -var isobject = __webpack_require__(547); -var isDescriptor = __webpack_require__(548); +var isobject = __webpack_require__(590); +var isDescriptor = __webpack_require__(591); var define = (typeof Reflect !== 'undefined' && Reflect.defineProperty) ? Reflect.defineProperty : Object.defineProperty; @@ -79589,7 +82473,7 @@ module.exports = function defineProperty(obj, key, val) { /***/ }), -/* 668 */ +/* 705 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -79643,7 +82527,7 @@ function diffArray(one, two) { /***/ }), -/* 669 */ +/* 706 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -79656,7 +82540,7 @@ function diffArray(one, two) { -var isObject = __webpack_require__(547); +var isObject = __webpack_require__(590); module.exports = function pick(obj, keys) { if (!isObject(obj) && typeof obj !== 'function') { @@ -79685,7 +82569,7 @@ module.exports = function pick(obj, keys) { /***/ }), -/* 670 */ +/* 707 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -79695,18 +82579,18 @@ module.exports = function pick(obj, keys) { * Module dependencies */ -var extend = __webpack_require__(560); -var unique = __webpack_require__(559); -var toRegex = __webpack_require__(539); +var extend = __webpack_require__(603); +var unique = __webpack_require__(602); +var toRegex = __webpack_require__(582); /** * Local dependencies */ -var compilers = __webpack_require__(671); -var parsers = __webpack_require__(677); -var Extglob = __webpack_require__(680); -var utils = __webpack_require__(679); +var compilers = __webpack_require__(708); +var parsers = __webpack_require__(714); +var Extglob = __webpack_require__(717); +var utils = __webpack_require__(716); var MAX_LENGTH = 1024 * 64; /** @@ -80023,13 +82907,13 @@ module.exports = extglob; /***/ }), -/* 671 */ +/* 708 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var brackets = __webpack_require__(672); +var brackets = __webpack_require__(709); /** * Extglob compilers @@ -80199,7 +83083,7 @@ module.exports = function(extglob) { /***/ }), -/* 672 */ +/* 709 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -80209,17 +83093,17 @@ module.exports = function(extglob) { * Local dependencies */ -var compilers = __webpack_require__(673); -var parsers = __webpack_require__(675); +var compilers = __webpack_require__(710); +var parsers = __webpack_require__(712); /** * Module dependencies */ -var debug = __webpack_require__(624)('expand-brackets'); -var extend = __webpack_require__(560); -var Snapdragon = __webpack_require__(581); -var toRegex = __webpack_require__(539); +var debug = __webpack_require__(543)('expand-brackets'); +var extend = __webpack_require__(603); +var Snapdragon = __webpack_require__(624); +var toRegex = __webpack_require__(582); /** * Parses the given POSIX character class `pattern` and returns a @@ -80417,13 +83301,13 @@ module.exports = brackets; /***/ }), -/* 673 */ +/* 710 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var posix = __webpack_require__(674); +var posix = __webpack_require__(711); module.exports = function(brackets) { brackets.compiler @@ -80511,7 +83395,7 @@ module.exports = function(brackets) { /***/ }), -/* 674 */ +/* 711 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -80540,14 +83424,14 @@ module.exports = { /***/ }), -/* 675 */ +/* 712 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var utils = __webpack_require__(676); -var define = __webpack_require__(610); +var utils = __webpack_require__(713); +var define = __webpack_require__(653); /** * Text regex @@ -80766,14 +83650,14 @@ module.exports.TEXT_REGEX = TEXT_REGEX; /***/ }), -/* 676 */ +/* 713 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var toRegex = __webpack_require__(539); -var regexNot = __webpack_require__(556); +var toRegex = __webpack_require__(582); +var regexNot = __webpack_require__(599); var cached; /** @@ -80807,15 +83691,15 @@ exports.createRegex = function(pattern, include) { /***/ }), -/* 677 */ +/* 714 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var brackets = __webpack_require__(672); -var define = __webpack_require__(678); -var utils = __webpack_require__(679); +var brackets = __webpack_require__(709); +var define = __webpack_require__(715); +var utils = __webpack_require__(716); /** * Characters to use in text regex (we want to "not" match @@ -80970,7 +83854,7 @@ module.exports = parsers; /***/ }), -/* 678 */ +/* 715 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -80983,7 +83867,7 @@ module.exports = parsers; -var isDescriptor = __webpack_require__(548); +var isDescriptor = __webpack_require__(591); module.exports = function defineProperty(obj, prop, val) { if (typeof obj !== 'object' && typeof obj !== 'function') { @@ -81008,14 +83892,14 @@ module.exports = function defineProperty(obj, prop, val) { /***/ }), -/* 679 */ +/* 716 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var regex = __webpack_require__(556); -var Cache = __webpack_require__(664); +var regex = __webpack_require__(599); +var Cache = __webpack_require__(701); /** * Utils @@ -81084,7 +83968,7 @@ utils.createRegex = function(str) { /***/ }), -/* 680 */ +/* 717 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -81094,16 +83978,16 @@ utils.createRegex = function(str) { * Module dependencies */ -var Snapdragon = __webpack_require__(581); -var define = __webpack_require__(678); -var extend = __webpack_require__(560); +var Snapdragon = __webpack_require__(624); +var define = __webpack_require__(715); +var extend = __webpack_require__(603); /** * Local dependencies */ -var compilers = __webpack_require__(671); -var parsers = __webpack_require__(677); +var compilers = __webpack_require__(708); +var parsers = __webpack_require__(714); /** * Customize Snapdragon parser and renderer @@ -81169,16 +84053,16 @@ module.exports = Extglob; /***/ }), -/* 681 */ +/* 718 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var extglob = __webpack_require__(670); -var nanomatch = __webpack_require__(656); -var regexNot = __webpack_require__(556); -var toRegex = __webpack_require__(539); +var extglob = __webpack_require__(707); +var nanomatch = __webpack_require__(693); +var regexNot = __webpack_require__(599); +var toRegex = __webpack_require__(582); var not; /** @@ -81259,14 +84143,14 @@ function textRegex(pattern) { /***/ }), -/* 682 */ +/* 719 */ /***/ (function(module, exports, __webpack_require__) { -module.exports = new (__webpack_require__(664))(); +module.exports = new (__webpack_require__(701))(); /***/ }), -/* 683 */ +/* 720 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -81279,13 +84163,13 @@ var path = __webpack_require__(4); * Module dependencies */ -var Snapdragon = __webpack_require__(581); -utils.define = __webpack_require__(684); -utils.diff = __webpack_require__(668); -utils.extend = __webpack_require__(653); -utils.pick = __webpack_require__(669); -utils.typeOf = __webpack_require__(549); -utils.unique = __webpack_require__(559); +var Snapdragon = __webpack_require__(624); +utils.define = __webpack_require__(721); +utils.diff = __webpack_require__(705); +utils.extend = __webpack_require__(690); +utils.pick = __webpack_require__(706); +utils.typeOf = __webpack_require__(592); +utils.unique = __webpack_require__(602); /** * Returns true if the platform is windows, or `path.sep` is `\\`. @@ -81582,7 +84466,7 @@ utils.unixify = function(options) { /***/ }), -/* 684 */ +/* 721 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -81595,8 +84479,8 @@ utils.unixify = function(options) { -var isobject = __webpack_require__(547); -var isDescriptor = __webpack_require__(548); +var isobject = __webpack_require__(590); +var isDescriptor = __webpack_require__(591); var define = (typeof Reflect !== 'undefined' && Reflect.defineProperty) ? Reflect.defineProperty : Object.defineProperty; @@ -81627,7 +84511,7 @@ module.exports = function defineProperty(obj, key, val) { /***/ }), -/* 685 */ +/* 722 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -81646,9 +84530,9 @@ var __extends = (this && this.__extends) || (function () { }; })(); Object.defineProperty(exports, "__esModule", { value: true }); -var readdir = __webpack_require__(686); -var reader_1 = __webpack_require__(699); -var fs_stream_1 = __webpack_require__(703); +var readdir = __webpack_require__(723); +var reader_1 = __webpack_require__(736); +var fs_stream_1 = __webpack_require__(740); var ReaderAsync = /** @class */ (function (_super) { __extends(ReaderAsync, _super); function ReaderAsync() { @@ -81709,15 +84593,15 @@ exports.default = ReaderAsync; /***/ }), -/* 686 */ +/* 723 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -const readdirSync = __webpack_require__(687); -const readdirAsync = __webpack_require__(695); -const readdirStream = __webpack_require__(698); +const readdirSync = __webpack_require__(724); +const readdirAsync = __webpack_require__(732); +const readdirStream = __webpack_require__(735); module.exports = exports = readdirAsyncPath; exports.readdir = exports.readdirAsync = exports.async = readdirAsyncPath; @@ -81801,7 +84685,7 @@ function readdirStreamStat (dir, options) { /***/ }), -/* 687 */ +/* 724 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -81809,11 +84693,11 @@ function readdirStreamStat (dir, options) { module.exports = readdirSync; -const DirectoryReader = __webpack_require__(688); +const DirectoryReader = __webpack_require__(725); let syncFacade = { - fs: __webpack_require__(693), - forEach: __webpack_require__(694), + fs: __webpack_require__(730), + forEach: __webpack_require__(731), sync: true }; @@ -81842,7 +84726,7 @@ function readdirSync (dir, options, internalOptions) { /***/ }), -/* 688 */ +/* 725 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -81851,9 +84735,9 @@ function readdirSync (dir, options, internalOptions) { const Readable = __webpack_require__(138).Readable; const EventEmitter = __webpack_require__(156).EventEmitter; const path = __webpack_require__(4); -const normalizeOptions = __webpack_require__(689); -const stat = __webpack_require__(691); -const call = __webpack_require__(692); +const normalizeOptions = __webpack_require__(726); +const stat = __webpack_require__(728); +const call = __webpack_require__(729); /** * Asynchronously reads the contents of a directory and streams the results @@ -82229,14 +85113,14 @@ module.exports = DirectoryReader; /***/ }), -/* 689 */ +/* 726 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const path = __webpack_require__(4); -const globToRegExp = __webpack_require__(690); +const globToRegExp = __webpack_require__(727); module.exports = normalizeOptions; @@ -82413,7 +85297,7 @@ function normalizeOptions (options, internalOptions) { /***/ }), -/* 690 */ +/* 727 */ /***/ (function(module, exports) { module.exports = function (glob, opts) { @@ -82550,13 +85434,13 @@ module.exports = function (glob, opts) { /***/ }), -/* 691 */ +/* 728 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -const call = __webpack_require__(692); +const call = __webpack_require__(729); module.exports = stat; @@ -82631,7 +85515,7 @@ function symlinkStat (fs, path, lstats, callback) { /***/ }), -/* 692 */ +/* 729 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -82692,14 +85576,14 @@ function callOnce (fn) { /***/ }), -/* 693 */ +/* 730 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const fs = __webpack_require__(134); -const call = __webpack_require__(692); +const call = __webpack_require__(729); /** * A facade around {@link fs.readdirSync} that allows it to be called @@ -82763,7 +85647,7 @@ exports.lstat = function (path, callback) { /***/ }), -/* 694 */ +/* 731 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -82792,7 +85676,7 @@ function syncForEach (array, iterator, done) { /***/ }), -/* 695 */ +/* 732 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -82800,12 +85684,12 @@ function syncForEach (array, iterator, done) { module.exports = readdirAsync; -const maybe = __webpack_require__(696); -const DirectoryReader = __webpack_require__(688); +const maybe = __webpack_require__(733); +const DirectoryReader = __webpack_require__(725); let asyncFacade = { fs: __webpack_require__(134), - forEach: __webpack_require__(697), + forEach: __webpack_require__(734), async: true }; @@ -82847,7 +85731,7 @@ function readdirAsync (dir, options, callback, internalOptions) { /***/ }), -/* 696 */ +/* 733 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -82874,7 +85758,7 @@ module.exports = function maybe (cb, promise) { /***/ }), -/* 697 */ +/* 734 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -82910,7 +85794,7 @@ function asyncForEach (array, iterator, done) { /***/ }), -/* 698 */ +/* 735 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -82918,11 +85802,11 @@ function asyncForEach (array, iterator, done) { module.exports = readdirStream; -const DirectoryReader = __webpack_require__(688); +const DirectoryReader = __webpack_require__(725); let streamFacade = { fs: __webpack_require__(134), - forEach: __webpack_require__(697), + forEach: __webpack_require__(734), async: true }; @@ -82942,16 +85826,16 @@ function readdirStream (dir, options, internalOptions) { /***/ }), -/* 699 */ +/* 736 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); var path = __webpack_require__(4); -var deep_1 = __webpack_require__(700); -var entry_1 = __webpack_require__(702); -var pathUtil = __webpack_require__(701); +var deep_1 = __webpack_require__(737); +var entry_1 = __webpack_require__(739); +var pathUtil = __webpack_require__(738); var Reader = /** @class */ (function () { function Reader(options) { this.options = options; @@ -83017,14 +85901,14 @@ exports.default = Reader; /***/ }), -/* 700 */ +/* 737 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -var pathUtils = __webpack_require__(701); -var patternUtils = __webpack_require__(533); +var pathUtils = __webpack_require__(738); +var patternUtils = __webpack_require__(576); var DeepFilter = /** @class */ (function () { function DeepFilter(options, micromatchOptions) { this.options = options; @@ -83107,7 +85991,7 @@ exports.default = DeepFilter; /***/ }), -/* 701 */ +/* 738 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83138,14 +86022,14 @@ exports.makeAbsolute = makeAbsolute; /***/ }), -/* 702 */ +/* 739 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -var pathUtils = __webpack_require__(701); -var patternUtils = __webpack_require__(533); +var pathUtils = __webpack_require__(738); +var patternUtils = __webpack_require__(576); var EntryFilter = /** @class */ (function () { function EntryFilter(options, micromatchOptions) { this.options = options; @@ -83230,7 +86114,7 @@ exports.default = EntryFilter; /***/ }), -/* 703 */ +/* 740 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83250,8 +86134,8 @@ var __extends = (this && this.__extends) || (function () { })(); Object.defineProperty(exports, "__esModule", { value: true }); var stream = __webpack_require__(138); -var fsStat = __webpack_require__(704); -var fs_1 = __webpack_require__(708); +var fsStat = __webpack_require__(741); +var fs_1 = __webpack_require__(745); var FileSystemStream = /** @class */ (function (_super) { __extends(FileSystemStream, _super); function FileSystemStream() { @@ -83301,14 +86185,14 @@ exports.default = FileSystemStream; /***/ }), -/* 704 */ +/* 741 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const optionsManager = __webpack_require__(705); -const statProvider = __webpack_require__(707); +const optionsManager = __webpack_require__(742); +const statProvider = __webpack_require__(744); /** * Asynchronous API. */ @@ -83339,13 +86223,13 @@ exports.statSync = statSync; /***/ }), -/* 705 */ +/* 742 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); -const fsAdapter = __webpack_require__(706); +const fsAdapter = __webpack_require__(743); function prepare(opts) { const options = Object.assign({ fs: fsAdapter.getFileSystemAdapter(opts ? opts.fs : undefined), @@ -83358,7 +86242,7 @@ exports.prepare = prepare; /***/ }), -/* 706 */ +/* 743 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83381,7 +86265,7 @@ exports.getFileSystemAdapter = getFileSystemAdapter; /***/ }), -/* 707 */ +/* 744 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83433,7 +86317,7 @@ exports.isFollowedSymlink = isFollowedSymlink; /***/ }), -/* 708 */ +/* 745 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83464,7 +86348,7 @@ exports.default = FileSystem; /***/ }), -/* 709 */ +/* 746 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83484,9 +86368,9 @@ var __extends = (this && this.__extends) || (function () { })(); Object.defineProperty(exports, "__esModule", { value: true }); var stream = __webpack_require__(138); -var readdir = __webpack_require__(686); -var reader_1 = __webpack_require__(699); -var fs_stream_1 = __webpack_require__(703); +var readdir = __webpack_require__(723); +var reader_1 = __webpack_require__(736); +var fs_stream_1 = __webpack_require__(740); var TransformStream = /** @class */ (function (_super) { __extends(TransformStream, _super); function TransformStream(reader) { @@ -83554,7 +86438,7 @@ exports.default = ReaderStream; /***/ }), -/* 710 */ +/* 747 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83573,9 +86457,9 @@ var __extends = (this && this.__extends) || (function () { }; })(); Object.defineProperty(exports, "__esModule", { value: true }); -var readdir = __webpack_require__(686); -var reader_1 = __webpack_require__(699); -var fs_sync_1 = __webpack_require__(711); +var readdir = __webpack_require__(723); +var reader_1 = __webpack_require__(736); +var fs_sync_1 = __webpack_require__(748); var ReaderSync = /** @class */ (function (_super) { __extends(ReaderSync, _super); function ReaderSync() { @@ -83635,7 +86519,7 @@ exports.default = ReaderSync; /***/ }), -/* 711 */ +/* 748 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83654,8 +86538,8 @@ var __extends = (this && this.__extends) || (function () { }; })(); Object.defineProperty(exports, "__esModule", { value: true }); -var fsStat = __webpack_require__(704); -var fs_1 = __webpack_require__(708); +var fsStat = __webpack_require__(741); +var fs_1 = __webpack_require__(745); var FileSystemSync = /** @class */ (function (_super) { __extends(FileSystemSync, _super); function FileSystemSync() { @@ -83701,7 +86585,7 @@ exports.default = FileSystemSync; /***/ }), -/* 712 */ +/* 749 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83717,7 +86601,7 @@ exports.flatten = flatten; /***/ }), -/* 713 */ +/* 750 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83738,13 +86622,13 @@ exports.merge = merge; /***/ }), -/* 714 */ +/* 751 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const path = __webpack_require__(4); -const pathType = __webpack_require__(715); +const pathType = __webpack_require__(752); const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0]; @@ -83810,13 +86694,13 @@ module.exports.sync = (input, opts) => { /***/ }), -/* 715 */ +/* 752 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const fs = __webpack_require__(134); -const pify = __webpack_require__(716); +const pify = __webpack_require__(753); function type(fn, fn2, fp) { if (typeof fp !== 'string') { @@ -83859,7 +86743,7 @@ exports.symlinkSync = typeSync.bind(null, 'lstatSync', 'isSymbolicLink'); /***/ }), -/* 716 */ +/* 753 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -83950,17 +86834,17 @@ module.exports = (obj, opts) => { /***/ }), -/* 717 */ +/* 754 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const fs = __webpack_require__(134); const path = __webpack_require__(4); -const fastGlob = __webpack_require__(529); -const gitIgnore = __webpack_require__(718); -const pify = __webpack_require__(719); -const slash = __webpack_require__(720); +const fastGlob = __webpack_require__(572); +const gitIgnore = __webpack_require__(755); +const pify = __webpack_require__(756); +const slash = __webpack_require__(757); const DEFAULT_IGNORE = [ '**/node_modules/**', @@ -84058,7 +86942,7 @@ module.exports.sync = options => { /***/ }), -/* 718 */ +/* 755 */ /***/ (function(module, exports) { // A simple implementation of make-array @@ -84527,7 +87411,7 @@ module.exports = options => new IgnoreBase(options) /***/ }), -/* 719 */ +/* 756 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -84602,7 +87486,7 @@ module.exports = (input, options) => { /***/ }), -/* 720 */ +/* 757 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -84620,7 +87504,7 @@ module.exports = input => { /***/ }), -/* 721 */ +/* 758 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -84633,7 +87517,7 @@ module.exports = input => { -var isGlob = __webpack_require__(722); +var isGlob = __webpack_require__(759); module.exports = function hasGlob(val) { if (val == null) return false; @@ -84653,7 +87537,7 @@ module.exports = function hasGlob(val) { /***/ }), -/* 722 */ +/* 759 */ /***/ (function(module, exports, __webpack_require__) { /*! @@ -84684,17 +87568,17 @@ module.exports = function isGlob(str) { /***/ }), -/* 723 */ +/* 760 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const path = __webpack_require__(4); const {constants: fsConstants} = __webpack_require__(134); -const pEvent = __webpack_require__(724); -const CpFileError = __webpack_require__(727); -const fs = __webpack_require__(729); -const ProgressEmitter = __webpack_require__(732); +const pEvent = __webpack_require__(761); +const CpFileError = __webpack_require__(764); +const fs = __webpack_require__(766); +const ProgressEmitter = __webpack_require__(769); const cpFileAsync = async (source, destination, options, progressEmitter) => { let readError; @@ -84808,12 +87692,12 @@ module.exports.sync = (source, destination, options) => { /***/ }), -/* 724 */ +/* 761 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -const pTimeout = __webpack_require__(725); +const pTimeout = __webpack_require__(762); const symbolAsyncIterator = Symbol.asyncIterator || '@@asyncIterator'; @@ -85104,12 +87988,12 @@ module.exports.iterator = (emitter, event, options) => { /***/ }), -/* 725 */ +/* 762 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -const pFinally = __webpack_require__(726); +const pFinally = __webpack_require__(763); class TimeoutError extends Error { constructor(message) { @@ -85155,7 +88039,7 @@ module.exports.TimeoutError = TimeoutError; /***/ }), -/* 726 */ +/* 763 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -85177,12 +88061,12 @@ module.exports = (promise, onFinally) => { /***/ }), -/* 727 */ +/* 764 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -const NestedError = __webpack_require__(728); +const NestedError = __webpack_require__(765); class CpFileError extends NestedError { constructor(message, nested) { @@ -85196,7 +88080,7 @@ module.exports = CpFileError; /***/ }), -/* 728 */ +/* 765 */ /***/ (function(module, exports, __webpack_require__) { var inherits = __webpack_require__(112).inherits; @@ -85252,16 +88136,16 @@ module.exports = NestedError; /***/ }), -/* 729 */ +/* 766 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const {promisify} = __webpack_require__(112); const fs = __webpack_require__(133); -const makeDir = __webpack_require__(730); -const pEvent = __webpack_require__(724); -const CpFileError = __webpack_require__(727); +const makeDir = __webpack_require__(767); +const pEvent = __webpack_require__(761); +const CpFileError = __webpack_require__(764); const stat = promisify(fs.stat); const lstat = promisify(fs.lstat); @@ -85358,7 +88242,7 @@ exports.copyFileSync = (source, destination, flags) => { /***/ }), -/* 730 */ +/* 767 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -85366,7 +88250,7 @@ exports.copyFileSync = (source, destination, flags) => { const fs = __webpack_require__(134); const path = __webpack_require__(4); const {promisify} = __webpack_require__(112); -const semver = __webpack_require__(731); +const semver = __webpack_require__(768); const useNativeRecursiveOption = semver.satisfies(process.version, '>=10.12.0'); @@ -85521,7 +88405,7 @@ module.exports.sync = (input, options) => { /***/ }), -/* 731 */ +/* 768 */ /***/ (function(module, exports) { exports = module.exports = SemVer @@ -87123,7 +90007,7 @@ function coerce (version, options) { /***/ }), -/* 732 */ +/* 769 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -87164,7 +90048,7 @@ module.exports = ProgressEmitter; /***/ }), -/* 733 */ +/* 770 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -87210,12 +90094,12 @@ exports.default = module.exports; /***/ }), -/* 734 */ +/* 771 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -const pMap = __webpack_require__(735); +const pMap = __webpack_require__(772); const pFilter = async (iterable, filterer, options) => { const values = await pMap( @@ -87232,7 +90116,7 @@ module.exports.default = pFilter; /***/ }), -/* 735 */ +/* 772 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -87311,12 +90195,12 @@ module.exports.default = pMap; /***/ }), -/* 736 */ +/* 773 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -const NestedError = __webpack_require__(728); +const NestedError = __webpack_require__(765); class CpyError extends NestedError { constructor(message, nested) { @@ -87330,16 +90214,16 @@ module.exports = CpyError; /***/ }), -/* 737 */ +/* 774 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -const arrayUnion = __webpack_require__(738); +const arrayUnion = __webpack_require__(775); const glob = __webpack_require__(147); -const fastGlob = __webpack_require__(529); -const dirGlob = __webpack_require__(739); -const gitignore = __webpack_require__(743); +const fastGlob = __webpack_require__(572); +const dirGlob = __webpack_require__(776); +const gitignore = __webpack_require__(780); const DEFAULT_FILTER = () => false; @@ -87465,12 +90349,12 @@ module.exports.gitignore = gitignore; /***/ }), -/* 738 */ +/* 775 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; -var arrayUniq = __webpack_require__(528); +var arrayUniq = __webpack_require__(571); module.exports = function () { return arrayUniq([].concat.apply([], arguments)); @@ -87478,14 +90362,14 @@ module.exports = function () { /***/ }), -/* 739 */ +/* 776 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const path = __webpack_require__(4); -const arrify = __webpack_require__(740); -const pathType = __webpack_require__(741); +const arrify = __webpack_require__(777); +const pathType = __webpack_require__(778); const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0]; const getPath = filepath => filepath[0] === '!' ? filepath.slice(1) : filepath; @@ -87533,7 +90417,7 @@ module.exports.sync = (input, opts) => { /***/ }), -/* 740 */ +/* 777 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -87548,13 +90432,13 @@ module.exports = function (val) { /***/ }), -/* 741 */ +/* 778 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const fs = __webpack_require__(134); -const pify = __webpack_require__(742); +const pify = __webpack_require__(779); function type(fn, fn2, fp) { if (typeof fp !== 'string') { @@ -87597,7 +90481,7 @@ exports.symlinkSync = typeSync.bind(null, 'lstatSync', 'isSymbolicLink'); /***/ }), -/* 742 */ +/* 779 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -87688,17 +90572,17 @@ module.exports = (obj, opts) => { /***/ }), -/* 743 */ +/* 780 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; const fs = __webpack_require__(134); const path = __webpack_require__(4); -const fastGlob = __webpack_require__(529); -const gitIgnore = __webpack_require__(744); -const pify = __webpack_require__(742); -const slash = __webpack_require__(745); +const fastGlob = __webpack_require__(572); +const gitIgnore = __webpack_require__(781); +const pify = __webpack_require__(779); +const slash = __webpack_require__(782); const DEFAULT_IGNORE = [ '**/node_modules/**', @@ -87790,7 +90674,7 @@ module.exports.sync = o => { /***/ }), -/* 744 */ +/* 781 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -88222,7 +91106,7 @@ typeof process !== 'undefined' && (process.env && process.env.IGNORE_TEST_WIN32 /***/ }), -/* 745 */ +/* 782 */ /***/ (function(module, exports, __webpack_require__) { "use strict"; @@ -88240,7 +91124,7 @@ module.exports = function (str) { /***/ }), -/* 746 */ +/* 783 */ /***/ (function(module, __webpack_exports__, __webpack_require__) { "use strict"; @@ -88248,13 +91132,13 @@ __webpack_require__.r(__webpack_exports__); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "buildNonBazelProductionProjects", function() { return buildNonBazelProductionProjects; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getProductionProjects", function() { return getProductionProjects; }); /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "buildProject", function() { return buildProject; }); -/* harmony import */ var cpy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(522); +/* harmony import */ var cpy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(565); /* harmony import */ var cpy__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(cpy__WEBPACK_IMPORTED_MODULE_0__); /* harmony import */ var del__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(143); /* harmony import */ var del__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(del__WEBPACK_IMPORTED_MODULE_1__); /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4); /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_2__); -/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(519); +/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(562); /* harmony import */ var _utils_fs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(131); /* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(246); /* harmony import */ var _utils_package_json__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(251); diff --git a/packages/kbn-pm/src/commands/bootstrap.ts b/packages/kbn-pm/src/commands/bootstrap.ts index 544bfd5587e0..4a6a43ff2d91 100644 --- a/packages/kbn-pm/src/commands/bootstrap.ts +++ b/packages/kbn-pm/src/commands/bootstrap.ts @@ -23,6 +23,11 @@ export const BootstrapCommand: ICommand = { description: 'Install dependencies and crosslink projects', name: 'bootstrap', + reportTiming: { + group: 'bootstrap', + id: 'overall time', + }, + async run(projects, projectGraph, { options, kbn, rootPath }) { const nonBazelProjectsOnly = await getNonBazelProjectsOnly(projects); const batchedNonBazelProjects = topologicallyBatchProjects(nonBazelProjectsOnly, projectGraph); diff --git a/packages/kbn-pm/src/commands/index.ts b/packages/kbn-pm/src/commands/index.ts index 9f02a6bf7038..0ab6bc9c7808 100644 --- a/packages/kbn-pm/src/commands/index.ts +++ b/packages/kbn-pm/src/commands/index.ts @@ -18,6 +18,10 @@ export interface ICommandConfig { export interface ICommand { name: string; description: string; + reportTiming?: { + group: string; + id: string; + }; run: (projects: ProjectMap, projectGraph: ProjectGraph, config: ICommandConfig) => Promise; } diff --git a/packages/kbn-pm/src/run.ts b/packages/kbn-pm/src/run.ts index 5ffe2beeeb77..e5d74cee65ba 100644 --- a/packages/kbn-pm/src/run.ts +++ b/packages/kbn-pm/src/run.ts @@ -6,6 +6,8 @@ * Side Public License, v 1. */ +import { CiStatsReporter } from '@kbn/dev-utils/ci_stats_reporter'; + import { ICommand, ICommandConfig } from './commands'; import { CliError } from './utils/errors'; import { log } from './utils/log'; @@ -14,10 +16,13 @@ import { renderProjectsTree } from './utils/projects_tree'; import { Kibana } from './utils/kibana'; export async function runCommand(command: ICommand, config: Omit) { + const runStartTime = Date.now(); + let kbn; + try { log.debug(`Running [${command.name}] command from [${config.rootPath}]`); - const kbn = await Kibana.loadFrom(config.rootPath); + kbn = await Kibana.loadFrom(config.rootPath); const projects = kbn.getFilteredProjects({ skipKibanaPlugins: Boolean(config.options['skip-kibana-plugins']), ossOnly: Boolean(config.options.oss), @@ -41,7 +46,46 @@ export async function runCommand(command: ICommand, config: Omit