> = RT['type'];
type OptionalProperties = Readonly<
{ [K in keyof RequiredProperties
]: TypeOf }
>;
+type DefinedProperties = Omit &
+ { [K in keyof DefinedProperties]: NP[K] };
+
+type ExtendedObjectType = ObjectType<
+ ExtendedProps
+>;
+
+type ExtendedObjectTypeOptions = ObjectTypeOptions<
+ ExtendedProps
+>;
+
interface UnknownOptions {
/**
* Options for dealing with unknown keys:
@@ -61,10 +81,13 @@ export type ObjectTypeOptions = TypeOptions extends Type> {
- private props: Record;
+ private props: P;
+ private options: ObjectTypeOptions;
+ private propSchemas: Record;
- constructor(props: P, { unknowns = 'forbid', ...typeOptions }: ObjectTypeOptions = {}) {
+ constructor(props: P, options: ObjectTypeOptions
= {}) {
const schemaKeys = {} as Record;
+ const { unknowns = 'forbid', ...typeOptions } = options;
for (const [key, value] of Object.entries(props)) {
schemaKeys[key] = value.getSchema();
}
@@ -77,7 +100,93 @@ export class ObjectType extends Type>
.options({ stripUnknown: { objects: unknowns === 'ignore' } });
super(schema, typeOptions);
- this.props = schemaKeys;
+ this.props = props;
+ this.propSchemas = schemaKeys;
+ this.options = options;
+ }
+
+ /**
+ * Return a new `ObjectType` instance extended with given `newProps` properties.
+ * Original properties can be deleted from the copy by passing a `null` or `undefined` value for the key.
+ *
+ * @example
+ * How to add a new key to an object schema
+ * ```ts
+ * const origin = schema.object({
+ * initial: schema.string(),
+ * });
+ *
+ * const extended = origin.extends({
+ * added: schema.number(),
+ * });
+ * ```
+ *
+ * How to remove an existing key from an object schema
+ * ```ts
+ * const origin = schema.object({
+ * initial: schema.string(),
+ * toRemove: schema.number(),
+ * });
+ *
+ * const extended = origin.extends({
+ * toRemove: undefined,
+ * });
+ * ```
+ *
+ * How to override the schema's options
+ * ```ts
+ * const origin = schema.object({
+ * initial: schema.string(),
+ * }, { defaultValue: { initial: 'foo' }});
+ *
+ * const extended = origin.extends({
+ * added: schema.number(),
+ * }, { defaultValue: { initial: 'foo', added: 'bar' }});
+ *
+ * @remarks
+ * `extends` only support extending first-level properties. It's currently not possible to perform deep/nested extensions.
+ *
+ * ```ts
+ * const origin = schema.object({
+ * foo: schema.string(),
+ * nested: schema.object({
+ * a: schema.string(),
+ * b: schema.string(),
+ * }),
+ * });
+ *
+ * const extended = origin.extends({
+ * nested: schema.object({
+ * c: schema.string(),
+ * }),
+ * });
+ *
+ * // TypeOf is `{ foo: string; nested: { c: string } }`
+ * ```
+ */
+ public extends(
+ newProps: NP,
+ newOptions?: ExtendedObjectTypeOptions
+ ): ExtendedObjectType {
+ const extendedProps = Object.entries({
+ ...this.props,
+ ...newProps,
+ }).reduce((memo, [key, value]) => {
+ if (value !== null && value !== undefined) {
+ return {
+ ...memo,
+ [key]: value,
+ };
+ }
+ return memo;
+ }, {} as ExtendedProps);
+
+ const extendedOptions = {
+ ...this.options,
+ ...newOptions,
+ } as ExtendedObjectTypeOptions;
+
+ return new ObjectType(extendedProps, extendedOptions);
}
protected handleError(type: string, { reason, value }: Record) {
@@ -95,10 +204,10 @@ export class ObjectType extends Type>
}
validateKey(key: string, value: any) {
- if (!this.props[key]) {
+ if (!this.propSchemas[key]) {
throw new Error(`${key} is not a valid part of this schema`);
}
- const { value: validatedValue, error } = this.props[key].validate(value);
+ const { value: validatedValue, error } = this.propSchemas[key].validate(value);
if (error) {
throw new ValidationError(error as any, key);
}
diff --git a/packages/kbn-dev-utils/package.json b/packages/kbn-dev-utils/package.json
index 08b2e5b226967..5000d8b7490be 100644
--- a/packages/kbn-dev-utils/package.json
+++ b/packages/kbn-dev-utils/package.json
@@ -13,7 +13,7 @@
"axios": "^0.19.0",
"chalk": "^2.4.2",
"dedent": "^0.7.0",
- "execa": "^4.0.0",
+ "execa": "^4.0.2",
"exit-hook": "^2.2.0",
"getopts": "^2.2.5",
"load-json-file": "^6.2.0",
diff --git a/packages/kbn-dev-utils/src/tooling_log/index.ts b/packages/kbn-dev-utils/src/tooling_log/index.ts
index f8009a255f010..acf944f23a816 100644
--- a/packages/kbn-dev-utils/src/tooling_log/index.ts
+++ b/packages/kbn-dev-utils/src/tooling_log/index.ts
@@ -19,5 +19,5 @@
export { ToolingLog } from './tooling_log';
export { ToolingLogTextWriter, ToolingLogTextWriterConfig } from './tooling_log_text_writer';
-export { pickLevelFromFlags, parseLogLevel, LogLevel } from './log_levels';
+export { pickLevelFromFlags, parseLogLevel, LogLevel, ParsedLogLevel } from './log_levels';
export { ToolingLogCollectingWriter } from './tooling_log_collecting_writer';
diff --git a/packages/kbn-dev-utils/src/tooling_log/tooling_log_collecting_writer.ts b/packages/kbn-dev-utils/src/tooling_log/tooling_log_collecting_writer.ts
index 7e79077032156..fd59ebe5c46dc 100644
--- a/packages/kbn-dev-utils/src/tooling_log/tooling_log_collecting_writer.ts
+++ b/packages/kbn-dev-utils/src/tooling_log/tooling_log_collecting_writer.ts
@@ -18,13 +18,14 @@
*/
import { ToolingLogTextWriter } from './tooling_log_text_writer';
+import { LogLevel } from './log_levels';
export class ToolingLogCollectingWriter extends ToolingLogTextWriter {
messages: string[] = [];
- constructor() {
+ constructor(level: LogLevel = 'verbose') {
super({
- level: 'verbose',
+ level,
writeTo: {
write: (msg) => {
// trim trailing new line
diff --git a/packages/kbn-dev-utils/src/tooling_log/tooling_log_text_writer.ts b/packages/kbn-dev-utils/src/tooling_log/tooling_log_text_writer.ts
index b8c12433a0ebb..28ccc60428ae3 100644
--- a/packages/kbn-dev-utils/src/tooling_log/tooling_log_text_writer.ts
+++ b/packages/kbn-dev-utils/src/tooling_log/tooling_log_text_writer.ts
@@ -47,7 +47,7 @@ export interface ToolingLogTextWriterConfig {
function shouldWriteType(level: ParsedLogLevel, type: MessageTypes) {
if (type === 'write') {
- return true;
+ return level.name !== 'silent';
}
return Boolean(level.flags[type === 'success' ? 'info' : type]);
diff --git a/packages/kbn-es/package.json b/packages/kbn-es/package.json
index 8b964d8399904..271b4a3dc661b 100644
--- a/packages/kbn-es/package.json
+++ b/packages/kbn-es/package.json
@@ -11,7 +11,7 @@
"chalk": "^2.4.2",
"dedent": "^0.7.0",
"del": "^5.1.0",
- "execa": "^4.0.0",
+ "execa": "^4.0.2",
"getopts": "^2.2.4",
"glob": "^7.1.2",
"node-fetch": "^2.6.0",
diff --git a/packages/kbn-monaco/README.md b/packages/kbn-monaco/README.md
new file mode 100644
index 0000000000000..c5d7dd7dbfed5
--- /dev/null
+++ b/packages/kbn-monaco/README.md
@@ -0,0 +1,5 @@
+# @kbn/monaco
+
+A customized version of monaco that is automatically configured the way we want it to be when imported as `@kbn/monaco`. Additionally, imports to this package are automatically shared with all plugins using `@kbn/ui-shared-deps`.
+
+Includes custom xjson language support. The `es_ui_shared` plugin has an example of how to use it, in the future we will likely expose helpers from this package to make using it everywhere a little more seamless.
\ No newline at end of file
diff --git a/packages/kbn-monaco/package.json b/packages/kbn-monaco/package.json
new file mode 100644
index 0000000000000..170c014e6e326
--- /dev/null
+++ b/packages/kbn-monaco/package.json
@@ -0,0 +1,27 @@
+{
+ "name": "@kbn/monaco",
+ "version": "1.0.0",
+ "private": true,
+ "main": "./target/index.js",
+ "license": "Apache-2.0",
+ "scripts": {
+ "build": "node ./scripts/build.js",
+ "kbn:bootstrap": "yarn build --dev"
+ },
+ "dependencies": {
+ "regenerator-runtime": "^0.13.3",
+ "monaco-editor": "~0.17.0"
+ },
+ "devDependencies": {
+ "@kbn/babel-preset": "1.0.0",
+ "@kbn/dev-utils": "1.0.0",
+ "babel-loader": "^8.0.6",
+ "css-loader": "^3.4.2",
+ "del": "^5.1.0",
+ "raw-loader": "3.1.0",
+ "supports-color": "^7.0.0",
+ "typescript": "3.7.2",
+ "webpack": "^4.41.5",
+ "webpack-cli": "^3.3.10"
+ }
+}
diff --git a/packages/kbn-monaco/scripts/build.js b/packages/kbn-monaco/scripts/build.js
new file mode 100644
index 0000000000000..c5540e3c956c8
--- /dev/null
+++ b/packages/kbn-monaco/scripts/build.js
@@ -0,0 +1,64 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const path = require('path');
+const del = require('del');
+const supportsColor = require('supports-color');
+const { run } = require('@kbn/dev-utils');
+
+const TARGET_BUILD_DIR = path.resolve(__dirname, '../target');
+const ROOT_DIR = path.resolve(__dirname, '../');
+const WEBPACK_CONFIG_PATH = path.resolve(ROOT_DIR, 'webpack.config.js');
+
+run(
+ async ({ procRunner, log, flags }) => {
+ log.info('Deleting old output');
+
+ await del(TARGET_BUILD_DIR);
+
+ const cwd = ROOT_DIR;
+ const env = { ...process.env };
+ if (supportsColor.stdout) {
+ env.FORCE_COLOR = 'true';
+ }
+
+ await procRunner.run('worker', {
+ cmd: 'webpack',
+ args: ['--config', WEBPACK_CONFIG_PATH, flags.dev ? '--env.dev' : '--env.prod'],
+ wait: true,
+ env,
+ cwd,
+ });
+
+ await procRunner.run('tsc ', {
+ cmd: 'tsc',
+ args: [],
+ wait: true,
+ env,
+ cwd,
+ });
+
+ log.success('Complete');
+ },
+ {
+ flags: {
+ boolean: ['dev'],
+ },
+ }
+);
diff --git a/packages/kbn-monaco/src/index.ts b/packages/kbn-monaco/src/index.ts
new file mode 100644
index 0000000000000..9213a1bfe1327
--- /dev/null
+++ b/packages/kbn-monaco/src/index.ts
@@ -0,0 +1,25 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export { monaco } from './monaco';
+export { XJsonLang } from './xjson';
+
+/* eslint-disable-next-line @kbn/eslint/module_migration */
+import * as BarePluginApi from 'monaco-editor/esm/vs/editor/editor.api';
+export { BarePluginApi };
diff --git a/packages/kbn-ui-shared-deps/monaco.ts b/packages/kbn-monaco/src/monaco.ts
similarity index 96%
rename from packages/kbn-ui-shared-deps/monaco.ts
rename to packages/kbn-monaco/src/monaco.ts
index 42801c69a3e2c..a40b2212ef0e2 100644
--- a/packages/kbn-ui-shared-deps/monaco.ts
+++ b/packages/kbn-monaco/src/monaco.ts
@@ -17,6 +17,8 @@
* under the License.
*/
+/* eslint-disable @kbn/eslint/module_migration */
+
import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
import 'monaco-editor/esm/vs/base/common/worker/simpleWorker';
diff --git a/packages/kbn-monaco/src/xjson/README.md b/packages/kbn-monaco/src/xjson/README.md
new file mode 100644
index 0000000000000..8652d0bd776d2
--- /dev/null
+++ b/packages/kbn-monaco/src/xjson/README.md
@@ -0,0 +1,28 @@
+# README
+
+This folder contains the language definitions for XJSON used by the Monaco editor.
+
+## Summary of contents
+
+Note: All source code.
+
+### ./worker
+
+The worker proxy and worker instantiation code used in both the main thread and the worker thread.
+
+### ./lexer_rules
+
+Contains the Monarch-specific language tokenization rules for XJSON. Each set of rules registers itself against monaco.
+
+### ./constants.ts
+
+Contains the unique language ID.
+
+### ./language
+
+Takes care of global setup steps for the language (like registering it against Monaco) and exports a way to load up
+the grammar parser.
+
+### ./worker_proxy_service
+
+A stateful mechanism for holding a reference to the Monaco-provided proxy getter.
diff --git a/packages/kbn-monaco/src/xjson/constants.ts b/packages/kbn-monaco/src/xjson/constants.ts
new file mode 100644
index 0000000000000..dc107abff4ffe
--- /dev/null
+++ b/packages/kbn-monaco/src/xjson/constants.ts
@@ -0,0 +1,20 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export const ID = 'xjson';
diff --git a/packages/kbn-monaco/src/xjson/grammar.ts b/packages/kbn-monaco/src/xjson/grammar.ts
new file mode 100644
index 0000000000000..e95059f9ece2d
--- /dev/null
+++ b/packages/kbn-monaco/src/xjson/grammar.ts
@@ -0,0 +1,213 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export enum AnnoTypes {
+ error = 'error',
+ warning = 'warning',
+}
+
+/* eslint-disable */
+
+export const createParser = () => {
+ 'use strict';
+ let at: any,
+ annos: any[], // annotations
+ ch: any,
+ text: any,
+ value: any,
+ escapee: any = {
+ '"': '"',
+ '\\': '\\',
+ '/': '/',
+ b: '\b',
+ f: '\f',
+ n: '\n',
+ r: '\r',
+ t: ' ',
+ },
+ error = function (m: string) {
+ throw {
+ at: at,
+ text: m,
+ message: m,
+ };
+ },
+ warning = function (m: string, idx: number) {
+ annos.push({
+ type: AnnoTypes.warning,
+ at: idx,
+ text: m,
+ });
+ },
+ reset = function (newAt: number) {
+ ch = text.charAt(newAt);
+ at = newAt + 1;
+ },
+ next = function (c?: string) {
+ return (
+ c && c !== ch && error("Expected '" + c + "' instead of '" + ch + "'"),
+ (ch = text.charAt(at)),
+ (at += 1),
+ ch
+ );
+ },
+ nextUpTo = function (upTo: any, errorMessage: string) {
+ let currentAt = at,
+ i = text.indexOf(upTo, currentAt);
+ if (i < 0) {
+ error(errorMessage || "Expected '" + upTo + "'");
+ }
+ reset(i + upTo.length);
+ return text.substring(currentAt, i);
+ },
+ peek = function (c: string) {
+ return text.substr(at, c.length) === c; // nocommit - double check
+ },
+ number = function () {
+ var number,
+ string = '';
+ for ('-' === ch && ((string = '-'), next('-')); ch >= '0' && '9' >= ch; )
+ (string += ch), next();
+ if ('.' === ch) for (string += '.'; next() && ch >= '0' && '9' >= ch; ) string += ch;
+ if ('e' === ch || 'E' === ch)
+ for (
+ string += ch, next(), ('-' === ch || '+' === ch) && ((string += ch), next());
+ ch >= '0' && '9' >= ch;
+
+ )
+ (string += ch), next();
+ return (number = +string), isNaN(number) ? (error('Bad number'), void 0) : number;
+ },
+ string = function () {
+ let hex: any,
+ i: any,
+ uffff: any,
+ string = '';
+ if ('"' === ch) {
+ if (peek('""')) {
+ // literal
+ next('"');
+ next('"');
+ return nextUpTo('"""', 'failed to find closing \'"""\'');
+ } else {
+ for (; next(); ) {
+ if ('"' === ch) return next(), string;
+ if ('\\' === ch)
+ if ((next(), 'u' === ch)) {
+ for (
+ uffff = 0, i = 0;
+ 4 > i && ((hex = parseInt(next(), 16)), isFinite(hex));
+ i += 1
+ )
+ uffff = 16 * uffff + hex;
+ string += String.fromCharCode(uffff);
+ } else {
+ if ('string' != typeof escapee[ch]) break;
+ string += escapee[ch];
+ }
+ else string += ch;
+ }
+ }
+ }
+ error('Bad string');
+ },
+ white = function () {
+ for (; ch && ' ' >= ch; ) next();
+ },
+ word = function () {
+ switch (ch) {
+ case 't':
+ return next('t'), next('r'), next('u'), next('e'), !0;
+ case 'f':
+ return next('f'), next('a'), next('l'), next('s'), next('e'), !1;
+ case 'n':
+ return next('n'), next('u'), next('l'), next('l'), null;
+ }
+ error("Unexpected '" + ch + "'");
+ },
+ array = function () {
+ var array: any[] = [];
+ if ('[' === ch) {
+ if ((next('['), white(), ']' === ch)) return next(']'), array;
+ for (; ch; ) {
+ if ((array.push(value()), white(), ']' === ch)) return next(']'), array;
+ next(','), white();
+ }
+ }
+ error('Bad array');
+ },
+ object = function () {
+ var key,
+ object: any = {};
+ if ('{' === ch) {
+ if ((next('{'), white(), '}' === ch)) return next('}'), object;
+ for (; ch; ) {
+ let latchKeyStart = at;
+ if (
+ ((key = string()),
+ white(),
+ next(':'),
+ Object.hasOwnProperty.call(object, key) &&
+ warning('Duplicate key "' + key + '"', latchKeyStart),
+ (object[key] = value()),
+ white(),
+ '}' === ch)
+ )
+ return next('}'), object;
+ next(','), white();
+ }
+ }
+ error('Bad object');
+ };
+ return (
+ (value = function () {
+ switch ((white(), ch)) {
+ case '{':
+ return object();
+ case '[':
+ return array();
+ case '"':
+ return string();
+ case '-':
+ return number();
+ default:
+ return ch >= '0' && '9' >= ch ? number() : word();
+ }
+ }),
+ function (source: string) {
+ annos = [];
+ let errored = false;
+ text = source;
+ at = 0;
+ ch = ' ';
+ white();
+
+ try {
+ value();
+ } catch (e) {
+ errored = true;
+ annos.push({ type: AnnoTypes.error, at: e.at - 1, text: e.message });
+ }
+ if (!errored && ch) {
+ error('Syntax error');
+ }
+ return { annotations: annos };
+ }
+ );
+};
diff --git a/packages/kbn-monaco/src/xjson/index.ts b/packages/kbn-monaco/src/xjson/index.ts
new file mode 100644
index 0000000000000..35fd35887bc56
--- /dev/null
+++ b/packages/kbn-monaco/src/xjson/index.ts
@@ -0,0 +1,24 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { registerGrammarChecker } from './language';
+
+import { ID } from './constants';
+
+export const XJsonLang = { registerGrammarChecker, ID };
diff --git a/packages/kbn-monaco/src/xjson/language.ts b/packages/kbn-monaco/src/xjson/language.ts
new file mode 100644
index 0000000000000..fe505818d3c9a
--- /dev/null
+++ b/packages/kbn-monaco/src/xjson/language.ts
@@ -0,0 +1,89 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// This file contains a lot of single setup logic for registering a language globally
+
+import { monaco } from '../monaco';
+import { WorkerProxyService } from './worker_proxy_service';
+import { registerLexerRules } from './lexer_rules';
+import { ID } from './constants';
+// @ts-ignore
+import workerSrc from '!!raw-loader!../../target/public/xjson.editor.worker.js';
+
+const wps = new WorkerProxyService();
+
+// Register rules against shared monaco instance.
+registerLexerRules(monaco);
+
+// In future we will need to make this map languages to workers using "id" and/or "label" values
+// that get passed in.
+// @ts-ignore
+window.MonacoEnvironment = {
+ getWorker: (id: any, label: any) => {
+ // In kibana we will probably build this once and then load with raw-loader
+ const blob = new Blob([workerSrc], { type: 'application/javascript' });
+ return new Worker(URL.createObjectURL(blob));
+ },
+};
+
+monaco.languages.onLanguage(ID, async () => {
+ return wps.setup();
+});
+
+const OWNER = 'XJSON_GRAMMAR_CHECKER';
+export const registerGrammarChecker = (editor: monaco.editor.IEditor) => {
+ const allDisposables: monaco.IDisposable[] = [];
+
+ const updateAnnos = async () => {
+ const { annotations } = await wps.getAnnos();
+ const model = editor.getModel() as monaco.editor.ITextModel;
+ monaco.editor.setModelMarkers(
+ model,
+ OWNER,
+ annotations.map(({ at, text, type }) => {
+ const { column, lineNumber } = model.getPositionAt(at);
+ return {
+ startLineNumber: lineNumber,
+ startColumn: column,
+ endLineNumber: lineNumber,
+ endColumn: column,
+ message: text,
+ severity: type === 'error' ? monaco.MarkerSeverity.Error : monaco.MarkerSeverity.Warning,
+ };
+ })
+ );
+ };
+
+ const onModelAdd = (model: monaco.editor.IModel) => {
+ allDisposables.push(
+ model.onDidChangeContent(async () => {
+ updateAnnos();
+ })
+ );
+
+ updateAnnos();
+ };
+
+ allDisposables.push(monaco.editor.onDidCreateModel(onModelAdd));
+ monaco.editor.getModels().forEach(onModelAdd);
+ return () => {
+ wps.stop();
+ allDisposables.forEach((d) => d.dispose());
+ };
+};
diff --git a/packages/kbn-monaco/src/xjson/lexer_rules/esql.ts b/packages/kbn-monaco/src/xjson/lexer_rules/esql.ts
new file mode 100644
index 0000000000000..e75b1013d3727
--- /dev/null
+++ b/packages/kbn-monaco/src/xjson/lexer_rules/esql.ts
@@ -0,0 +1,270 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { monaco } from '../../monaco';
+
+export const ID = 'esql';
+
+const brackets = [
+ { open: '[', close: ']', token: 'delimiter.square' },
+ { open: '(', close: ')', token: 'delimiter.parenthesis' },
+];
+
+const keywords = [
+ 'describe',
+ 'between',
+ 'in',
+ 'like',
+ 'not',
+ 'and',
+ 'or',
+ 'desc',
+ 'select',
+ 'from',
+ 'where',
+ 'having',
+ 'group',
+ 'by',
+ 'order',
+ 'asc',
+ 'desc',
+ 'pivot',
+ 'for',
+ 'in',
+ 'as',
+ 'show',
+ 'columns',
+ 'include',
+ 'frozen',
+ 'tables',
+ 'escape',
+ 'limit',
+ 'rlike',
+ 'all',
+ 'distinct',
+ 'is',
+];
+const builtinFunctions = [
+ 'avg',
+ 'count',
+ 'first',
+ 'first_value',
+ 'last',
+ 'last_value',
+ 'max',
+ 'min',
+ 'sum',
+ 'kurtosis',
+ 'mad',
+ 'percentile',
+ 'percentile_rank',
+ 'skewness',
+ 'stddev_pop',
+ 'sum_of_squares',
+ 'var_pop',
+ 'histogram',
+ 'case',
+ 'coalesce',
+ 'greatest',
+ 'ifnull',
+ 'iif',
+ 'isnull',
+ 'least',
+ 'nullif',
+ 'nvl',
+ 'curdate',
+ 'current_date',
+ 'current_time',
+ 'current_timestamp',
+ 'curtime',
+ 'dateadd',
+ 'datediff',
+ 'datepart',
+ 'datetrunc',
+ 'date_add',
+ 'date_diff',
+ 'date_part',
+ 'date_trunc',
+ 'day',
+ 'dayname',
+ 'dayofmonth',
+ 'dayofweek',
+ 'dayofyear',
+ 'day_name',
+ 'day_of_month',
+ 'day_of_week',
+ 'day_of_year',
+ 'dom',
+ 'dow',
+ 'doy',
+ 'hour',
+ 'hour_of_day',
+ 'idow',
+ 'isodayofweek',
+ 'isodow',
+ 'isoweek',
+ 'isoweekofyear',
+ 'iso_day_of_week',
+ 'iso_week_of_year',
+ 'iw',
+ 'iwoy',
+ 'minute',
+ 'minute_of_day',
+ 'minute_of_hour',
+ 'month',
+ 'monthname',
+ 'month_name',
+ 'month_of_year',
+ 'now',
+ 'quarter',
+ 'second',
+ 'second_of_minute',
+ 'timestampadd',
+ 'timestampdiff',
+ 'timestamp_add',
+ 'timestamp_diff',
+ 'today',
+ 'week',
+ 'week_of_year',
+ 'year',
+ 'abs',
+ 'acos',
+ 'asin',
+ 'atan',
+ 'atan2',
+ 'cbrt',
+ 'ceil',
+ 'ceiling',
+ 'cos',
+ 'cosh',
+ 'cot',
+ 'degrees',
+ 'e',
+ 'exp',
+ 'expm1',
+ 'floor',
+ 'log',
+ 'log10',
+ 'mod',
+ 'pi',
+ 'power',
+ 'radians',
+ 'rand',
+ 'random',
+ 'round',
+ 'sign',
+ 'signum|sin',
+ 'sinh',
+ 'sqrt',
+ 'tan',
+ 'truncate',
+ 'ascii',
+ 'bit_length',
+ 'char',
+ 'character_length',
+ 'char_length',
+ 'concat',
+ 'insert',
+ 'lcase',
+ 'left',
+ 'length',
+ 'locate',
+ 'ltrim',
+ 'octet_length',
+ 'position',
+ 'repeat',
+ 'replace',
+ 'right',
+ 'rtrim',
+ 'space',
+ 'substring',
+ 'ucase',
+ 'cast',
+ 'convert',
+ 'database',
+ 'user',
+ 'st_astext',
+ 'st_aswkt',
+ 'st_distance',
+ 'st_geometrytype',
+ 'st_geomfromtext',
+ 'st_wkttosql',
+ 'st_x',
+ 'st_y',
+ 'st_z',
+ 'score',
+];
+
+export const lexerRules = {
+ defaultToken: 'invalid',
+ ignoreCase: true,
+ tokenPostfix: '',
+ keywords,
+ builtinFunctions,
+ brackets,
+ tokenizer: {
+ root: [
+ [
+ /[a-zA-Z_$][a-zA-Z0-9_$]*\b/,
+ {
+ cases: {
+ '@keywords': 'keyword',
+ '@builtinFunctions': 'identifier',
+ '@default': 'identifier',
+ },
+ },
+ ],
+ [/[()]/, '@brackets'],
+ [/--.*$/, 'comment'],
+ [/\/\*/, 'comment', '@comment'],
+ [/\/.*$/, 'comment'],
+
+ [/".*?"/, 'string'],
+
+ [/'.*?'/, 'constant'],
+ [/`.*?`/, 'string'],
+ // whitespace
+ [/[ \t\r\n]+/, { token: '@whitespace' }],
+ [/[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?\\b/, 'entity.name.function'],
+ [/⇐|<⇒|\*|\.|\:\:|\+|\-|\/|\/\/|%|&|\^|~|<|>|<=|=>|==|!=|<>|=/, 'keyword.operator'],
+ [/[\(]/, 'paren.lparen'],
+ [/[\)]/, 'paren.rparen'],
+ [/\s+/, 'text'],
+ ],
+ numbers: [
+ [/0[xX][0-9a-fA-F]*/, 'number'],
+ [/[$][+-]*\d*(\.\d*)?/, 'number'],
+ [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number'],
+ ],
+ strings: [
+ [/N'/, { token: 'string', next: '@string' }],
+ [/'/, { token: 'string', next: '@string' }],
+ ],
+ string: [
+ [/[^']+/, 'string'],
+ [/''/, 'string'],
+ [/'/, { token: 'string', next: '@pop' }],
+ ],
+ comment: [
+ [/[^\/*]+/, 'comment'],
+ [/\*\//, 'comment', '@pop'],
+ [/[\/*]/, 'comment'],
+ ],
+ },
+} as monaco.languages.IMonarchLanguage;
diff --git a/packages/kbn-monaco/src/xjson/lexer_rules/index.ts b/packages/kbn-monaco/src/xjson/lexer_rules/index.ts
new file mode 100644
index 0000000000000..515de09510a61
--- /dev/null
+++ b/packages/kbn-monaco/src/xjson/lexer_rules/index.ts
@@ -0,0 +1,33 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/* eslint-disable-next-line @kbn/eslint/module_migration */
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import * as xJson from './xjson';
+import * as esql from './esql';
+import * as painless from './painless';
+
+export const registerLexerRules = (m: typeof monaco) => {
+ m.languages.register({ id: xJson.ID });
+ m.languages.setMonarchTokensProvider(xJson.ID, xJson.lexerRules);
+ m.languages.register({ id: painless.ID });
+ m.languages.setMonarchTokensProvider(painless.ID, painless.lexerRules);
+ m.languages.register({ id: esql.ID });
+ m.languages.setMonarchTokensProvider(esql.ID, esql.lexerRules);
+};
diff --git a/packages/kbn-monaco/src/xjson/lexer_rules/painless.ts b/packages/kbn-monaco/src/xjson/lexer_rules/painless.ts
new file mode 100644
index 0000000000000..676eb3134026a
--- /dev/null
+++ b/packages/kbn-monaco/src/xjson/lexer_rules/painless.ts
@@ -0,0 +1,194 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { monaco } from '../../monaco';
+
+export const ID = 'painless';
+
+/**
+ * Extends the default type for a Monarch language so we can use
+ * attribute references (like @keywords to reference the keywords list)
+ * in the defined tokenizer
+ */
+interface Language extends monaco.languages.IMonarchLanguage {
+ default: string;
+ brackets: any;
+ keywords: string[];
+ symbols: RegExp;
+ escapes: RegExp;
+ digits: RegExp;
+ primitives: string[];
+ octaldigits: RegExp;
+ binarydigits: RegExp;
+ constants: string[];
+ operators: string[];
+}
+
+export const lexerRules = {
+ default: 'invalid',
+ tokenPostfix: '',
+ // painless does not use < >, so we define our own
+ brackets: [
+ ['{', '}', 'delimiter.curly'],
+ ['[', ']', 'delimiter.square'],
+ ['(', ')', 'delimiter.parenthesis'],
+ ],
+ keywords: [
+ 'if',
+ 'in',
+ 'else',
+ 'while',
+ 'do',
+ 'for',
+ 'continue',
+ 'break',
+ 'return',
+ 'new',
+ 'try',
+ 'catch',
+ 'throw',
+ 'this',
+ 'instanceof',
+ ],
+ primitives: ['void', 'boolean', 'byte', 'short', 'char', 'int', 'long', 'float', 'double', 'def'],
+ constants: ['true', 'false'],
+ operators: [
+ '=',
+ '>',
+ '<',
+ '!',
+ '~',
+ '?',
+ '?:',
+ '?.',
+ ':',
+ '==',
+ '===',
+ '<=',
+ '>=',
+ '!=',
+ '!==',
+ '&&',
+ '||',
+ '++',
+ '--',
+ '+',
+ '-',
+ '*',
+ '/',
+ '&',
+ '|',
+ '^',
+ '%',
+ '<<',
+ '>>',
+ '>>>',
+ '+=',
+ '-=',
+ '*=',
+ '/=',
+ '&=',
+ '|=',
+ '^=',
+ '%=',
+ '<<=',
+ '>>=',
+ '>>>=',
+ '->',
+ '::',
+ '=~',
+ '==~',
+ ],
+ symbols: /[=> {
+ worker.initialize((ctx: any, createData: any) => {
+ return new XJsonWorker(ctx);
+ });
+};
diff --git a/packages/kbn-monaco/src/xjson/worker/xjson_worker.ts b/packages/kbn-monaco/src/xjson/worker/xjson_worker.ts
new file mode 100644
index 0000000000000..501adcacb6990
--- /dev/null
+++ b/packages/kbn-monaco/src/xjson/worker/xjson_worker.ts
@@ -0,0 +1,35 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/* eslint-disable-next-line @kbn/eslint/module_migration */
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import { createParser } from '../grammar';
+
+export class XJsonWorker {
+ constructor(private ctx: monaco.worker.IWorkerContext) {}
+ private parser: any;
+
+ async parse() {
+ if (!this.parser) {
+ this.parser = createParser();
+ }
+ const [model] = this.ctx.getMirrorModels();
+ return this.parser(model.getValue());
+ }
+}
diff --git a/packages/kbn-monaco/src/xjson/worker_proxy_service.ts b/packages/kbn-monaco/src/xjson/worker_proxy_service.ts
new file mode 100644
index 0000000000000..17d6d56e51e59
--- /dev/null
+++ b/packages/kbn-monaco/src/xjson/worker_proxy_service.ts
@@ -0,0 +1,55 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { AnnoTypes } from './grammar';
+import { monaco } from '../monaco';
+import { XJsonWorker } from './worker';
+import { ID } from './constants';
+
+export interface Annotation {
+ name?: string;
+ type: AnnoTypes;
+ text: string;
+ at: number;
+}
+
+export interface AnnotationsResponse {
+ annotations: Annotation[];
+}
+
+export class WorkerProxyService {
+ private worker: monaco.editor.MonacoWebWorker | undefined;
+
+ public async getAnnos(): Promise {
+ if (!this.worker) {
+ throw new Error('Worker Proxy Service has not been setup!');
+ }
+ await this.worker.withSyncedResources(monaco.editor.getModels().map(({ uri }) => uri));
+ const proxy = await this.worker.getProxy();
+ return proxy.parse();
+ }
+
+ public setup() {
+ this.worker = monaco.editor.createWebWorker({ label: ID, moduleId: '' });
+ }
+
+ public stop() {
+ if (this.worker) this.worker.dispose();
+ }
+}
diff --git a/packages/kbn-monaco/tsconfig.json b/packages/kbn-monaco/tsconfig.json
new file mode 100644
index 0000000000000..95acfd32b24dd
--- /dev/null
+++ b/packages/kbn-monaco/tsconfig.json
@@ -0,0 +1,15 @@
+{
+ "extends": "../../tsconfig.json",
+ "compilerOptions": {
+ "outDir": "./target",
+ "declaration": true,
+ "sourceMap": true,
+ "types": [
+ "jest",
+ "node"
+ ]
+ },
+ "include": [
+ "src/**/*"
+ ]
+}
diff --git a/packages/kbn-monaco/webpack.config.js b/packages/kbn-monaco/webpack.config.js
new file mode 100644
index 0000000000000..1a7d8c031670c
--- /dev/null
+++ b/packages/kbn-monaco/webpack.config.js
@@ -0,0 +1,51 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const path = require('path');
+
+const createLangWorkerConfig = (lang) => ({
+ mode: 'production',
+ entry: path.resolve(__dirname, 'src', lang, 'worker', `${lang}.worker.ts`),
+ output: {
+ path: path.resolve(__dirname, 'target/public'),
+ filename: `${lang}.editor.worker.js`,
+ },
+ resolve: {
+ modules: ['node_modules'],
+ extensions: ['.js', '.ts', '.tsx'],
+ },
+ stats: 'errors-only',
+ module: {
+ rules: [
+ {
+ test: /\.(js|ts)$/,
+ exclude: /node_modules/,
+ use: {
+ loader: 'babel-loader',
+ options: {
+ babelrc: false,
+ presets: [require.resolve('@kbn/babel-preset/webpack_preset')],
+ },
+ },
+ },
+ ],
+ },
+});
+
+module.exports = [createLangWorkerConfig('xjson')];
diff --git a/packages/kbn-monaco/yarn.lock b/packages/kbn-monaco/yarn.lock
new file mode 120000
index 0000000000000..3f82ebc9cdbae
--- /dev/null
+++ b/packages/kbn-monaco/yarn.lock
@@ -0,0 +1 @@
+../../yarn.lock
\ No newline at end of file
diff --git a/packages/kbn-plugin-generator/package.json b/packages/kbn-plugin-generator/package.json
index b3b1eff41e4b5..b9df67b32e5d3 100644
--- a/packages/kbn-plugin-generator/package.json
+++ b/packages/kbn-plugin-generator/package.json
@@ -6,7 +6,7 @@
"dependencies": {
"chalk": "^2.4.2",
"dedent": "^0.7.0",
- "execa": "^4.0.0",
+ "execa": "^4.0.2",
"getopts": "^2.2.4",
"lodash.camelcase": "^4.3.0",
"lodash.kebabcase": "^4.1.1",
diff --git a/packages/kbn-plugin-helpers/package.json b/packages/kbn-plugin-helpers/package.json
index 040b779a69951..362e8302c3bec 100644
--- a/packages/kbn-plugin-helpers/package.json
+++ b/packages/kbn-plugin-helpers/package.json
@@ -16,7 +16,7 @@
"argv-split": "^2.0.1",
"commander": "^3.0.0",
"del": "^5.1.0",
- "execa": "^4.0.0",
+ "execa": "^4.0.2",
"globby": "^8.0.1",
"gulp-babel": "^8.0.0",
"gulp-rename": "1.4.0",
diff --git a/packages/kbn-pm/dist/index.js b/packages/kbn-pm/dist/index.js
index 21fff4d85ece6..93152ef1b71dc 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__(705);
+/* harmony import */ var _production__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(697);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "buildProductionProjects", function() { return _production__WEBPACK_IMPORTED_MODULE_1__["buildProductionProjects"]; });
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "prepareExternalProjectDependencies", function() { return _production__WEBPACK_IMPORTED_MODULE_1__["prepareExternalProjectDependencies"]; });
@@ -105,10 +105,10 @@ __webpack_require__.r(__webpack_exports__);
/* harmony import */ var _utils_project__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(517);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "Project", function() { return _utils_project__WEBPACK_IMPORTED_MODULE_3__["Project"]; });
-/* harmony import */ var _utils_workspaces__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(578);
+/* harmony import */ var _utils_workspaces__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(573);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "copyWorkspacePackages", function() { return _utils_workspaces__WEBPACK_IMPORTED_MODULE_4__["copyWorkspacePackages"]; });
-/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(579);
+/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(574);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "getProjectPaths", function() { return _config__WEBPACK_IMPORTED_MODULE_5__["getProjectPaths"]; });
/*
@@ -143,17 +143,17 @@ __webpack_require__.r(__webpack_exports__);
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "run", function() { return run; });
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var dedent__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(14);
-/* harmony import */ var dedent__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(dedent__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var getopts__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(15);
-/* harmony import */ var getopts__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(getopts__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(16);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var _commands__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(17);
+/* harmony import */ var dedent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
+/* harmony import */ var dedent__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(dedent__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var getopts__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3);
+/* harmony import */ var getopts__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(getopts__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 _kbn_dev_utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5);
+/* harmony import */ var _kbn_dev_utils__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_kbn_dev_utils__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _commands__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(488);
/* harmony import */ var _run__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(689);
-/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(34);
+/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(500);
/*
* Licensed to Elasticsearch B.V. under one or more contributor
* license agreements. See the NOTICE file distributed with
@@ -181,37 +181,43 @@ __webpack_require__.r(__webpack_exports__);
function help() {
- const availableCommands = Object.keys(_commands__WEBPACK_IMPORTED_MODULE_4__["commands"]).map(commandName => _commands__WEBPACK_IMPORTED_MODULE_4__["commands"][commandName]).map(command => `${command.name} - ${command.description}`);
- _utils_log__WEBPACK_IMPORTED_MODULE_6__["log"].write(dedent__WEBPACK_IMPORTED_MODULE_1___default.a`
- usage: kbn []
+ _utils_log__WEBPACK_IMPORTED_MODULE_6__["log"].info(dedent__WEBPACK_IMPORTED_MODULE_0___default.a`
+ usage: kbn []
- By default commands are run for Kibana itself, all packages in the 'packages/'
- folder and for all plugins in './plugins' and '../kibana-extra'.
+ By default commands are run for Kibana itself, all packages in the 'packages/'
+ folder and for all plugins in './plugins' and '../kibana-extra'.
- Available commands:
+ Available commands:
- ${availableCommands.join('\n ')}
+ ${Object.values(_commands__WEBPACK_IMPORTED_MODULE_4__["commands"]).map(command => `${command.name} - ${command.description}`).join('\n ')}
- Global options:
+ Global options:
- -e, --exclude Exclude specified project. Can be specified multiple times to exclude multiple projects, e.g. '-e kibana -e @kbn/pm'.
- -i, --include Include only specified projects. If left unspecified, it defaults to including all projects.
- --oss Do not include the x-pack when running command.
- --skip-kibana-plugins Filter all plugins in ./plugins and ../kibana-extra when running command.
- --no-cache Disable the bootstrap cache
- `);
+ -e, --exclude Exclude specified project. Can be specified multiple times to exclude multiple projects, e.g. '-e kibana -e @kbn/pm'.
+ -i, --include Include only specified projects. If left unspecified, it defaults to including all projects.
+ --oss Do not include the x-pack when running command.
+ --skip-kibana-plugins Filter all plugins in ./plugins and ../kibana-extra when running command.
+ --no-cache Disable the bootstrap cache
+ --verbose Set log level to verbose
+ --debug Set log level to debug
+ --quiet Set log level to error
+ --silent Disable log output
+ ` + '\n');
}
async function run(argv) {
- // We can simplify this setup (and remove this extra handling) once Yarn
+ _utils_log__WEBPACK_IMPORTED_MODULE_6__["log"].setLogLevel(Object(_kbn_dev_utils__WEBPACK_IMPORTED_MODULE_3__["pickLevelFromFlags"])(getopts__WEBPACK_IMPORTED_MODULE_1___default()(argv, {
+ boolean: ['verbose', 'debug', 'quiet', 'silent']
+ }))); // We can simplify this setup (and remove this extra handling) once Yarn
// starts forwarding the `--` directly to this script, see
// https://github.com/yarnpkg/yarn/blob/b2d3e1a8fe45ef376b716d597cc79b38702a9320/src/cli/index.js#L174-L182
+
if (argv.includes('--')) {
- _utils_log__WEBPACK_IMPORTED_MODULE_6__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.red(`Using "--" is not allowed, as it doesn't work with 'yarn kbn'.`));
+ _utils_log__WEBPACK_IMPORTED_MODULE_6__["log"].error(`Using "--" is not allowed, as it doesn't work with 'yarn kbn'.`);
process.exit(1);
}
- const options = getopts__WEBPACK_IMPORTED_MODULE_2___default()(argv, {
+ const options = getopts__WEBPACK_IMPORTED_MODULE_1___default()(argv, {
alias: {
e: 'exclude',
h: 'help',
@@ -231,7 +237,7 @@ async function run(argv) {
// built version of this tool.
- const rootPath = Object(path__WEBPACK_IMPORTED_MODULE_3__["resolve"])(__dirname, '../../../');
+ const rootPath = Object(path__WEBPACK_IMPORTED_MODULE_2__["resolve"])(__dirname, '../../../');
const commandName = args[0];
const extraArgs = args.slice(1);
const commandOptions = {
@@ -242,7 +248,7 @@ async function run(argv) {
const command = _commands__WEBPACK_IMPORTED_MODULE_4__["commands"][commandName];
if (command === undefined) {
- _utils_log__WEBPACK_IMPORTED_MODULE_6__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.red(`[${commandName}] is not a valid command, see 'kbn --help'`));
+ _utils_log__WEBPACK_IMPORTED_MODULE_6__["log"].error(`[${commandName}] is not a valid command, see 'kbn --help'`);
process.exit(1);
}
@@ -255,9872 +261,11181 @@ async function run(argv) {
"use strict";
-const escapeStringRegexp = __webpack_require__(3);
-const ansiStyles = __webpack_require__(4);
-const stdoutColor = __webpack_require__(10).stdout;
-
-const template = __webpack_require__(13);
-
-const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
-
-// `supportsColor.level` → `ansiStyles.color[name]` mapping
-const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
-
-// `color-convert` models to exclude from the Chalk API due to conflicts and such
-const skipModels = new Set(['gray']);
-const styles = Object.create(null);
+function dedent(strings) {
-function applyOptions(obj, options) {
- options = options || {};
+ var raw = void 0;
+ if (typeof strings === "string") {
+ // dedent can be used as a plain function
+ raw = [strings];
+ } else {
+ raw = strings.raw;
+ }
- // Detect level if not set manually
- const scLevel = stdoutColor ? stdoutColor.level : 0;
- obj.level = options.level === undefined ? scLevel : options.level;
- obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
-}
+ // first, perform interpolation
+ var result = "";
+ for (var i = 0; i < raw.length; i++) {
+ result += raw[i].
+ // join lines when there is a suppressed newline
+ replace(/\\\n[ \t]*/g, "").
-function Chalk(options) {
- // We check for this.template here since calling `chalk.constructor()`
- // by itself will have a `this` of a previously constructed chalk object
- if (!this || !(this instanceof Chalk) || this.template) {
- const chalk = {};
- applyOptions(chalk, options);
+ // handle escaped backticks
+ replace(/\\`/g, "`");
- chalk.template = function () {
- const args = [].slice.call(arguments);
- return chalkTag.apply(null, [chalk.template].concat(args));
- };
+ if (i < (arguments.length <= 1 ? 0 : arguments.length - 1)) {
+ result += arguments.length <= i + 1 ? undefined : arguments[i + 1];
+ }
+ }
- Object.setPrototypeOf(chalk, Chalk.prototype);
- Object.setPrototypeOf(chalk.template, chalk);
+ // now strip indentation
+ var lines = result.split("\n");
+ var mindent = null;
+ lines.forEach(function (l) {
+ var m = l.match(/^(\s+)\S+/);
+ if (m) {
+ var indent = m[1].length;
+ if (!mindent) {
+ // this is the first indented line
+ mindent = indent;
+ } else {
+ mindent = Math.min(mindent, indent);
+ }
+ }
+ });
- chalk.template.constructor = Chalk;
+ if (mindent !== null) {
+ result = lines.map(function (l) {
+ return l[0] === " " ? l.slice(mindent) : l;
+ }).join("\n");
+ }
- return chalk.template;
- }
+ // dedent eats leading and trailing whitespace too
+ result = result.trim();
- applyOptions(this, options);
+ // handle escaped newlines at the end to ensure they don't get stripped too
+ return result.replace(/\\n/g, "\n");
}
-// Use bright blue on Windows as the normal blue color is illegible
-if (isSimpleWindowsTerm) {
- ansiStyles.blue.open = '\u001B[94m';
+if (true) {
+ module.exports = dedent;
}
-for (const key of Object.keys(ansiStyles)) {
- ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
-
- styles[key] = {
- get() {
- const codes = ansiStyles[key];
- return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
- }
- };
-}
-styles.visible = {
- get() {
- return build.call(this, this._styles || [], true, 'visible');
- }
-};
+/***/ }),
+/* 3 */
+/***/ (function(module, exports, __webpack_require__) {
-ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
-for (const model of Object.keys(ansiStyles.color.ansi)) {
- if (skipModels.has(model)) {
- continue;
- }
+"use strict";
- styles[model] = {
- get() {
- const level = this.level;
- return function () {
- const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
- const codes = {
- open,
- close: ansiStyles.color.close,
- closeRe: ansiStyles.color.closeRe
- };
- return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
- };
- }
- };
-}
-ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
-for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
- if (skipModels.has(model)) {
- continue;
- }
+const EMPTYARR = []
+const SHORTSPLIT = /$|[!-@[-`{-~][\s\S]*/g
+const isArray = Array.isArray
- const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
- styles[bgModel] = {
- get() {
- const level = this.level;
- return function () {
- const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
- const codes = {
- open,
- close: ansiStyles.bgColor.close,
- closeRe: ansiStyles.bgColor.closeRe
- };
- return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
- };
- }
- };
+const parseValue = function(any) {
+ if (any === "") return ""
+ if (any === "false") return false
+ const maybe = Number(any)
+ return maybe * 0 === 0 ? maybe : any
}
-const proto = Object.defineProperties(() => {}, styles);
-
-function build(_styles, _empty, key) {
- const builder = function () {
- return applyStyle.apply(builder, arguments);
- };
-
- builder._styles = _styles;
- builder._empty = _empty;
-
- const self = this;
-
- Object.defineProperty(builder, 'level', {
- enumerable: true,
- get() {
- return self.level;
- },
- set(level) {
- self.level = level;
- }
- });
+const parseAlias = function(aliases) {
+ let out = {},
+ key,
+ alias,
+ prev,
+ len,
+ any,
+ i,
+ k
- Object.defineProperty(builder, 'enabled', {
- enumerable: true,
- get() {
- return self.enabled;
- },
- set(enabled) {
- self.enabled = enabled;
- }
- });
+ for (key in aliases) {
+ any = aliases[key]
+ alias = out[key] = isArray(any) ? any : [any]
- // See below for fix regarding invisible grey/dim combination on Windows
- builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
+ for (i = 0, len = alias.length; i < len; i++) {
+ prev = out[alias[i]] = [key]
- // `__proto__` is used because we must return a function, but there is
- // no way to create a function with a different prototype
- builder.__proto__ = proto; // eslint-disable-line no-proto
+ for (k = 0; k < len; k++) {
+ if (i !== k) prev.push(alias[k])
+ }
+ }
+ }
- return builder;
+ return out
}
-function applyStyle() {
- // Support varags, but simply cast to string in case there's only one arg
- const args = arguments;
- const argsLen = args.length;
- let str = String(arguments[0]);
+const parseDefault = function(aliases, defaults) {
+ let out = {},
+ key,
+ alias,
+ value,
+ len,
+ i
- if (argsLen === 0) {
- return '';
- }
+ for (key in defaults) {
+ value = defaults[key]
+ alias = aliases[key]
- if (argsLen > 1) {
- // Don't slice `arguments`, it prevents V8 optimizations
- for (let a = 1; a < argsLen; a++) {
- str += ' ' + args[a];
- }
- }
+ out[key] = value
- if (!this.enabled || this.level <= 0 || !str) {
- return this._empty ? '' : str;
- }
+ if (alias === undefined) {
+ aliases[key] = EMPTYARR
+ } else {
+ for (i = 0, len = alias.length; i < len; i++) {
+ out[alias[i]] = value
+ }
+ }
+ }
- // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
- // see https://github.com/chalk/chalk/issues/58
- // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
- const originalDim = ansiStyles.dim.open;
- if (isSimpleWindowsTerm && this.hasGrey) {
- ansiStyles.dim.open = '';
- }
+ return out
+}
- for (const code of this._styles.slice().reverse()) {
- // Replace any instances already present with a re-opening code
- // otherwise only the part of the string until said closing code
- // will be colored, and the rest will simply be 'plain'.
- str = code.open + str.replace(code.closeRe, code.open) + code.close;
+const parseOptions = function(aliases, options, value) {
+ let out = {},
+ key,
+ alias,
+ len,
+ end,
+ i,
+ k
- // Close the styling before a linebreak and reopen
- // after next line to fix a bleed issue on macOS
- // https://github.com/chalk/chalk/pull/92
- str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
- }
+ if (options !== undefined) {
+ for (i = 0, len = options.length; i < len; i++) {
+ key = options[i]
+ alias = aliases[key]
- // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
- ansiStyles.dim.open = originalDim;
+ out[key] = value
- return str;
+ if (alias === undefined) {
+ aliases[key] = EMPTYARR
+ } else {
+ for (k = 0, end = alias.length; k < end; k++) {
+ out[alias[k]] = value
+ }
+ }
+ }
+ }
+
+ return out
}
-function chalkTag(chalk, strings) {
- if (!Array.isArray(strings)) {
- // If chalk() was called by itself or with a string,
- // return the string itself as a string.
- return [].slice.call(arguments, 1).join(' ');
- }
+const write = function(out, key, value, aliases, unknown) {
+ let i,
+ prev,
+ alias = aliases[key],
+ len = alias === undefined ? -1 : alias.length
- const args = [].slice.call(arguments, 2);
- const parts = [strings.raw[0]];
+ if (len >= 0 || unknown === undefined || unknown(key)) {
+ prev = out[key]
- for (let i = 1; i < strings.length; i++) {
- parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
- parts.push(String(strings.raw[i]));
- }
+ if (prev === undefined) {
+ out[key] = value
+ } else {
+ if (isArray(prev)) {
+ prev.push(value)
+ } else {
+ out[key] = [prev, value]
+ }
+ }
- return template(chalk, parts.join(''));
+ for (i = 0; i < len; i++) {
+ out[alias[i]] = out[key]
+ }
+ }
}
-Object.defineProperties(Chalk.prototype, styles);
+const getopts = function(argv, opts) {
+ let unknown = (opts = opts || {}).unknown,
+ aliases = parseAlias(opts.alias),
+ strings = parseOptions(aliases, opts.string, ""),
+ values = parseDefault(aliases, opts.default),
+ bools = parseOptions(aliases, opts.boolean, false),
+ stopEarly = opts.stopEarly,
+ _ = [],
+ out = { _ },
+ i = 0,
+ k = 0,
+ len = argv.length,
+ key,
+ arg,
+ end,
+ match,
+ value
-module.exports = Chalk(); // eslint-disable-line new-cap
-module.exports.supportsColor = stdoutColor;
-module.exports.default = module.exports; // For TypeScript
+ for (; i < len; i++) {
+ arg = argv[i]
+ if (arg[0] !== "-" || arg === "-") {
+ if (stopEarly) while (i < len) _.push(argv[i++])
+ else _.push(arg)
+ } else if (arg === "--") {
+ while (++i < len) _.push(argv[i])
+ } else if (arg[1] === "-") {
+ end = arg.indexOf("=", 2)
+ if (arg[2] === "n" && arg[3] === "o" && arg[4] === "-") {
+ key = arg.slice(5, end >= 0 ? end : undefined)
+ value = false
+ } else if (end >= 0) {
+ key = arg.slice(2, end)
+ value =
+ bools[key] !== undefined ||
+ (strings[key] === undefined
+ ? parseValue(arg.slice(end + 1))
+ : arg.slice(end + 1))
+ } else {
+ key = arg.slice(2)
+ value =
+ bools[key] !== undefined ||
+ (len === i + 1 || argv[i + 1][0] === "-"
+ ? strings[key] === undefined
+ ? true
+ : ""
+ : strings[key] === undefined
+ ? parseValue(argv[++i])
+ : argv[++i])
+ }
+ write(out, key, value, aliases, unknown)
+ } else {
+ SHORTSPLIT.lastIndex = 2
+ match = SHORTSPLIT.exec(arg)
+ end = match.index
+ value = match[0]
-/***/ }),
-/* 3 */
-/***/ (function(module, exports, __webpack_require__) {
+ for (k = 1; k < end; k++) {
+ write(
+ out,
+ (key = arg[k]),
+ k + 1 < end
+ ? strings[key] === undefined ||
+ arg.substring(k + 1, (k = end)) + value
+ : value === ""
+ ? len === i + 1 || argv[i + 1][0] === "-"
+ ? strings[key] === undefined || ""
+ : bools[key] !== undefined ||
+ (strings[key] === undefined ? parseValue(argv[++i]) : argv[++i])
+ : bools[key] !== undefined ||
+ (strings[key] === undefined ? parseValue(value) : value),
+ aliases,
+ unknown
+ )
+ }
+ }
+ }
-"use strict";
+ for (key in values) if (out[key] === undefined) out[key] = values[key]
+ for (key in bools) if (out[key] === undefined) out[key] = false
+ for (key in strings) if (out[key] === undefined) out[key] = ""
+ return out
+}
-var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+module.exports = getopts
-module.exports = function (str) {
- if (typeof str !== 'string') {
- throw new TypeError('Expected a string');
- }
- return str.replace(matchOperatorsRe, '\\$&');
-};
+/***/ }),
+/* 4 */
+/***/ (function(module, exports) {
+module.exports = require("path");
/***/ }),
-/* 4 */
+/* 5 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-/* WEBPACK VAR INJECTION */(function(module) {
-const colorConvert = __webpack_require__(6);
-
-const wrapAnsi16 = (fn, offset) => function () {
- const code = fn.apply(colorConvert, arguments);
- return `\u001B[${code + offset}m`;
-};
-const wrapAnsi256 = (fn, offset) => function () {
- const code = fn.apply(colorConvert, arguments);
- return `\u001B[${38 + offset};5;${code}m`;
-};
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+var proc_runner_1 = __webpack_require__(7);
+exports.withProcRunner = proc_runner_1.withProcRunner;
+exports.ProcRunner = proc_runner_1.ProcRunner;
+tslib_1.__exportStar(__webpack_require__(400), exports);
+var serializers_1 = __webpack_require__(405);
+exports.createAbsolutePathSerializer = serializers_1.createAbsolutePathSerializer;
+var certs_1 = __webpack_require__(430);
+exports.CA_CERT_PATH = certs_1.CA_CERT_PATH;
+exports.ES_KEY_PATH = certs_1.ES_KEY_PATH;
+exports.ES_CERT_PATH = certs_1.ES_CERT_PATH;
+exports.ES_P12_PATH = certs_1.ES_P12_PATH;
+exports.ES_P12_PASSWORD = certs_1.ES_P12_PASSWORD;
+exports.ES_EMPTYPASSWORD_P12_PATH = certs_1.ES_EMPTYPASSWORD_P12_PATH;
+exports.ES_NOPASSWORD_P12_PATH = certs_1.ES_NOPASSWORD_P12_PATH;
+exports.KBN_KEY_PATH = certs_1.KBN_KEY_PATH;
+exports.KBN_CERT_PATH = certs_1.KBN_CERT_PATH;
+exports.KBN_P12_PATH = certs_1.KBN_P12_PATH;
+exports.KBN_P12_PASSWORD = certs_1.KBN_P12_PASSWORD;
+var run_1 = __webpack_require__(431);
+exports.run = run_1.run;
+exports.createFailError = run_1.createFailError;
+exports.createFlagError = run_1.createFlagError;
+exports.combineErrors = run_1.combineErrors;
+exports.isFailError = run_1.isFailError;
+var repo_root_1 = __webpack_require__(407);
+exports.REPO_ROOT = repo_root_1.REPO_ROOT;
+var kbn_client_1 = __webpack_require__(436);
+exports.KbnClient = kbn_client_1.KbnClient;
+tslib_1.__exportStar(__webpack_require__(479), exports);
+tslib_1.__exportStar(__webpack_require__(486), exports);
-const wrapAnsi16m = (fn, offset) => function () {
- const rgb = fn.apply(colorConvert, arguments);
- return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
-};
-function assembleStyles() {
- const codes = new Map();
- const styles = {
- modifier: {
- reset: [0, 0],
- // 21 isn't widely supported and 22 does the same thing
- bold: [1, 22],
- dim: [2, 22],
- italic: [3, 23],
- underline: [4, 24],
- inverse: [7, 27],
- hidden: [8, 28],
- strikethrough: [9, 29]
- },
- color: {
- black: [30, 39],
- red: [31, 39],
- green: [32, 39],
- yellow: [33, 39],
- blue: [34, 39],
- magenta: [35, 39],
- cyan: [36, 39],
- white: [37, 39],
- gray: [90, 39],
+/***/ }),
+/* 6 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- // Bright color
- redBright: [91, 39],
- greenBright: [92, 39],
- yellowBright: [93, 39],
- blueBright: [94, 39],
- magentaBright: [95, 39],
- cyanBright: [96, 39],
- whiteBright: [97, 39]
- },
- bgColor: {
- bgBlack: [40, 49],
- bgRed: [41, 49],
- bgGreen: [42, 49],
- bgYellow: [43, 49],
- bgBlue: [44, 49],
- bgMagenta: [45, 49],
- bgCyan: [46, 49],
- bgWhite: [47, 49],
-
- // Bright color
- bgBlackBright: [100, 49],
- bgRedBright: [101, 49],
- bgGreenBright: [102, 49],
- bgYellowBright: [103, 49],
- bgBlueBright: [104, 49],
- bgMagentaBright: [105, 49],
- bgCyanBright: [106, 49],
- bgWhiteBright: [107, 49]
- }
- };
-
- // Fix humans
- styles.color.grey = styles.color.gray;
-
- for (const groupName of Object.keys(styles)) {
- const group = styles[groupName];
-
- for (const styleName of Object.keys(group)) {
- const style = group[styleName];
-
- styles[styleName] = {
- open: `\u001B[${style[0]}m`,
- close: `\u001B[${style[1]}m`
- };
-
- group[styleName] = styles[styleName];
-
- codes.set(style[0], style[1]);
- }
-
- Object.defineProperty(styles, groupName, {
- value: group,
- enumerable: false
- });
-
- Object.defineProperty(styles, 'codes', {
- value: codes,
- enumerable: false
- });
- }
-
- const ansi2ansi = n => n;
- const rgb2rgb = (r, g, b) => [r, g, b];
-
- styles.color.close = '\u001B[39m';
- styles.bgColor.close = '\u001B[49m';
-
- styles.color.ansi = {
- ansi: wrapAnsi16(ansi2ansi, 0)
- };
- styles.color.ansi256 = {
- ansi256: wrapAnsi256(ansi2ansi, 0)
- };
- styles.color.ansi16m = {
- rgb: wrapAnsi16m(rgb2rgb, 0)
- };
-
- styles.bgColor.ansi = {
- ansi: wrapAnsi16(ansi2ansi, 10)
- };
- styles.bgColor.ansi256 = {
- ansi256: wrapAnsi256(ansi2ansi, 10)
- };
- styles.bgColor.ansi16m = {
- rgb: wrapAnsi16m(rgb2rgb, 10)
- };
-
- for (let key of Object.keys(colorConvert)) {
- if (typeof colorConvert[key] !== 'object') {
- continue;
- }
-
- const suite = colorConvert[key];
-
- if (key === 'ansi16') {
- key = 'ansi';
- }
-
- if ('ansi16' in suite) {
- styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
- styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
- }
-
- if ('ansi256' in suite) {
- styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
- styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
- }
-
- if ('rgb' in suite) {
- styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
- styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
- }
- }
-
- return styles;
-}
-
-// Make the export immutable
-Object.defineProperty(module, 'exports', {
- enumerable: true,
- get: assembleStyles
-});
-
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(5)(module)))
-
-/***/ }),
-/* 5 */
-/***/ (function(module, exports) {
-
-module.exports = function(module) {
- if (!module.webpackPolyfill) {
- module.deprecate = function() {};
- module.paths = [];
- // module.parent = undefined by default
- if (!module.children) module.children = [];
- Object.defineProperty(module, "loaded", {
- enumerable: true,
- get: function() {
- return module.l;
- }
- });
- Object.defineProperty(module, "id", {
- enumerable: true,
- get: function() {
- return module.i;
- }
- });
- module.webpackPolyfill = 1;
- }
- return module;
-};
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__extends", function() { return __extends; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__assign", function() { return __assign; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__rest", function() { return __rest; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__decorate", function() { return __decorate; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__param", function() { return __param; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__metadata", function() { return __metadata; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__awaiter", function() { return __awaiter; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__generator", function() { return __generator; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__exportStar", function() { return __exportStar; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__values", function() { return __values; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__read", function() { return __read; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spread", function() { return __spread; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__await", function() { return __await; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncGenerator", function() { return __asyncGenerator; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncDelegator", function() { return __asyncDelegator; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncValues", function() { return __asyncValues; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__makeTemplateObject", function() { return __makeTemplateObject; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importStar", function() { return __importStar; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importDefault", function() { return __importDefault; });
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+ extendStatics = Object.setPrototypeOf ||
+ ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+ function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+ return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+ extendStatics(d, b);
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+ __assign = Object.assign || function __assign(t) {
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
+ s = arguments[i];
+ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+ }
+ return t;
+ }
+ return __assign.apply(this, arguments);
+}
+
+function __rest(s, e) {
+ var t = {};
+ for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+ t[p] = s[p];
+ if (s != null && typeof Object.getOwnPropertySymbols === "function")
+ for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+ t[p[i]] = s[p[i]];
+ return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+ return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+ return new (P || (P = Promise))(function (resolve, reject) {
+ function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+ function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+ function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+}
+
+function __generator(thisArg, body) {
+ var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+ return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+ function verb(n) { return function (v) { return step([n, v]); }; }
+ function step(op) {
+ if (f) throw new TypeError("Generator is already executing.");
+ while (_) try {
+ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+ if (y = 0, t) op = [op[0] & 2, t.value];
+ switch (op[0]) {
+ case 0: case 1: t = op; break;
+ case 4: _.label++; return { value: op[1], done: false };
+ case 5: _.label++; y = op[1]; op = [0]; continue;
+ case 7: op = _.ops.pop(); _.trys.pop(); continue;
+ default:
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+ if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+ if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+ if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+ if (t[2]) _.ops.pop();
+ _.trys.pop(); continue;
+ }
+ op = body.call(thisArg, _);
+ } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+ if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+ }
+}
+
+function __exportStar(m, exports) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+
+function __values(o) {
+ var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+ if (m) return m.call(o);
+ return {
+ next: function () {
+ if (o && i >= o.length) o = void 0;
+ return { value: o && o[i++], done: !o };
+ }
+ };
+}
+
+function __read(o, n) {
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
+ if (!m) return o;
+ var i = m.call(o), r, ar = [], e;
+ try {
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+ }
+ catch (error) { e = { error: error }; }
+ finally {
+ try {
+ if (r && !r.done && (m = i["return"])) m.call(i);
+ }
+ finally { if (e) throw e.error; }
+ }
+ return ar;
+}
+
+function __spread() {
+ for (var ar = [], i = 0; i < arguments.length; i++)
+ ar = ar.concat(__read(arguments[i]));
+ return ar;
+}
+
+function __await(v) {
+ return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var g = generator.apply(thisArg, _arguments || []), i, q = [];
+ return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+ function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+ function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+ function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+ function fulfill(value) { resume("next", value); }
+ function reject(value) { resume("throw", value); }
+ function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncDelegator(o) {
+ var i, p;
+ return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+ function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+}
+
+function __asyncValues(o) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var m = o[Symbol.asyncIterator], i;
+ return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+ function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+ function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+function __makeTemplateObject(cooked, raw) {
+ if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+ return cooked;
+};
+
+function __importStar(mod) {
+ if (mod && mod.__esModule) return mod;
+ var result = {};
+ if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+ result.default = mod;
+ return result;
+}
+
+function __importDefault(mod) {
+ return (mod && mod.__esModule) ? mod : { default: mod };
+}
/***/ }),
-/* 6 */
+/* 7 */
/***/ (function(module, exports, __webpack_require__) {
-var conversions = __webpack_require__(7);
-var route = __webpack_require__(9);
-
-var convert = {};
-
-var models = Object.keys(conversions);
-
-function wrapRaw(fn) {
- var wrappedFn = function (args) {
- if (args === undefined || args === null) {
- return args;
- }
-
- if (arguments.length > 1) {
- args = Array.prototype.slice.call(arguments);
- }
-
- return fn(args);
- };
-
- // preserve .conversion property if there is one
- if ('conversion' in fn) {
- wrappedFn.conversion = fn.conversion;
- }
-
- return wrappedFn;
-}
-
-function wrapRounded(fn) {
- var wrappedFn = function (args) {
- if (args === undefined || args === null) {
- return args;
- }
-
- if (arguments.length > 1) {
- args = Array.prototype.slice.call(arguments);
- }
+"use strict";
- var result = fn(args);
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var with_proc_runner_1 = __webpack_require__(8);
+exports.withProcRunner = with_proc_runner_1.withProcRunner;
+var proc_runner_1 = __webpack_require__(9);
+exports.ProcRunner = proc_runner_1.ProcRunner;
- // we're assuming the result is an array here.
- // see notice in conversions.js; don't use box types
- // in conversion functions.
- if (typeof result === 'object') {
- for (var len = result.length, i = 0; i < len; i++) {
- result[i] = Math.round(result[i]);
- }
- }
- return result;
- };
+/***/ }),
+/* 8 */
+/***/ (function(module, exports, __webpack_require__) {
- // preserve .conversion property if there is one
- if ('conversion' in fn) {
- wrappedFn.conversion = fn.conversion;
- }
+"use strict";
- return wrappedFn;
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const proc_runner_1 = __webpack_require__(9);
+/**
+ * Create a ProcRunner and pass it to an async function. When
+ * the async function finishes the ProcRunner is torn-down
+ * automatically
+ *
+ * @param {ToolingLog} log
+ * @param {async Function} fn
+ * @return {Promise}
+ */
+async function withProcRunner(log, fn) {
+ const procs = new proc_runner_1.ProcRunner(log);
+ try {
+ await fn(procs);
+ }
+ finally {
+ await procs.teardown();
+ }
}
-
-models.forEach(function (fromModel) {
- convert[fromModel] = {};
-
- Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
- Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
-
- var routes = route(fromModel);
- var routeModels = Object.keys(routes);
-
- routeModels.forEach(function (toModel) {
- var fn = routes[toModel];
-
- convert[fromModel][toModel] = wrapRounded(fn);
- convert[fromModel][toModel].raw = wrapRaw(fn);
- });
-});
-
-module.exports = convert;
+exports.withProcRunner = withProcRunner;
/***/ }),
-/* 7 */
+/* 9 */
/***/ (function(module, exports, __webpack_require__) {
-/* MIT license */
-var cssKeywords = __webpack_require__(8);
-
-// NOTE: conversions should only return primitive values (i.e. arrays, or
-// values that give correct `typeof` results).
-// do not use box values types (i.e. Number(), String(), etc.)
-
-var reverseKeywords = {};
-for (var key in cssKeywords) {
- if (cssKeywords.hasOwnProperty(key)) {
- reverseKeywords[cssKeywords[key]] = key;
- }
-}
+"use strict";
-var convert = module.exports = {
- rgb: {channels: 3, labels: 'rgb'},
- hsl: {channels: 3, labels: 'hsl'},
- hsv: {channels: 3, labels: 'hsv'},
- hwb: {channels: 3, labels: 'hwb'},
- cmyk: {channels: 4, labels: 'cmyk'},
- xyz: {channels: 3, labels: 'xyz'},
- lab: {channels: 3, labels: 'lab'},
- lch: {channels: 3, labels: 'lch'},
- hex: {channels: 1, labels: ['hex']},
- keyword: {channels: 1, labels: ['keyword']},
- ansi16: {channels: 1, labels: ['ansi16']},
- ansi256: {channels: 1, labels: ['ansi256']},
- hcg: {channels: 3, labels: ['h', 'c', 'g']},
- apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
- gray: {channels: 1, labels: ['gray']}
-};
-
-// hide .channels and .labels properties
-for (var model in convert) {
- if (convert.hasOwnProperty(model)) {
- if (!('channels' in convert[model])) {
- throw new Error('missing channels property: ' + model);
- }
-
- if (!('labels' in convert[model])) {
- throw new Error('missing channel labels property: ' + model);
- }
-
- if (convert[model].labels.length !== convert[model].channels) {
- throw new Error('channel and label counts mismatch: ' + model);
- }
-
- var channels = convert[model].channels;
- var labels = convert[model].labels;
- delete convert[model].channels;
- delete convert[model].labels;
- Object.defineProperty(convert[model], 'channels', {value: channels});
- Object.defineProperty(convert[model], 'labels', {value: labels});
- }
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+const moment_1 = tslib_1.__importDefault(__webpack_require__(10));
+const Rx = tslib_1.__importStar(__webpack_require__(140));
+const operators_1 = __webpack_require__(241);
+const exit_hook_1 = tslib_1.__importDefault(__webpack_require__(339));
+const errors_1 = __webpack_require__(340);
+const proc_1 = __webpack_require__(341);
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const noop = () => { };
+/**
+ * Helper for starting and managing processes. In many ways it resembles the
+ * API from `grunt_run`, processes are named and can be started, waited for,
+ * backgrounded once they log something matching a RegExp...
+ *
+ * @class ProcRunner
+ */
+class ProcRunner {
+ constructor(log) {
+ this.log = log;
+ this.closing = false;
+ this.procs = [];
+ this.signalUnsubscribe = exit_hook_1.default(() => {
+ this.teardown().catch((error) => {
+ log.error(`ProcRunner teardown error: ${error.stack}`);
+ });
+ });
+ }
+ /**
+ * Start a process, tracking it by `name`
+ * @param {String} name
+ * @param {Object} options
+ * @property {String} options.cmd executable to run
+ * @property {Array?} options.args arguments to provide the executable
+ * @property {String?} options.cwd current working directory for the process
+ * @property {RegExp|Boolean} options.wait Should start() wait for some time? Use
+ * `true` will wait until the proc exits,
+ * a `RegExp` will wait until that log line
+ * is found
+ * @return {Promise}
+ */
+ async run(name, options) {
+ const { cmd, args = [], cwd = process.cwd(), stdin = undefined, wait = false, waitTimeout = 15 * MINUTE, env = process.env, } = options;
+ if (this.closing) {
+ throw new Error('ProcRunner is closing');
+ }
+ if (wait && !(wait instanceof RegExp) && wait !== true) {
+ throw new TypeError('wait param should either be a RegExp or `true`');
+ }
+ if (!!this.getProc(name)) {
+ throw new Error(`Process with name "${name}" already running`);
+ }
+ const proc = this.startProc(name, {
+ cmd,
+ args,
+ cwd,
+ env,
+ stdin,
+ });
+ try {
+ if (wait instanceof RegExp) {
+ // wait for process to log matching line
+ await Rx.race(proc.lines$.pipe(operators_1.filter((line) => wait.test(line)), operators_1.first(), operators_1.catchError((err) => {
+ if (err.name !== 'EmptyError') {
+ throw errors_1.createCliError(`[${name}] exited without matching pattern: ${wait}`);
+ }
+ else {
+ throw err;
+ }
+ })), waitTimeout === false
+ ? Rx.NEVER
+ : Rx.timer(waitTimeout).pipe(operators_1.map(() => {
+ const sec = waitTimeout / SECOND;
+ throw errors_1.createCliError(`[${name}] failed to match pattern within ${sec} seconds [pattern=${wait}]`);
+ }))).toPromise();
+ }
+ if (wait === true) {
+ // wait for process to complete
+ await proc.outcomePromise;
+ }
+ }
+ finally {
+ // while the procRunner closes promises will resolve/reject because
+ // processes and stopping, but consumers of run() shouldn't have to
+ // prepare for that, so just return a never-resolving promise
+ if (this.closing) {
+ await new Promise(noop);
+ }
+ }
+ }
+ /**
+ * Stop a named proc
+ */
+ async stop(name, signal = 'SIGTERM') {
+ const proc = this.getProc(name);
+ if (proc) {
+ await proc.stop(signal);
+ }
+ else {
+ this.log.warning('[%s] already stopped', name);
+ }
+ }
+ /**
+ * Wait for all running processes to stop naturally
+ * @return {Promise}
+ */
+ async waitForAllToStop() {
+ await Promise.all(this.procs.map((proc) => proc.outcomePromise));
+ }
+ /**
+ * Close the ProcRunner and stop all running
+ * processes with `signal`
+ *
+ * @param {String} [signal=undefined]
+ * @return {Promise}
+ */
+ async teardown(signal = 'exit') {
+ if (this.closing) {
+ return;
+ }
+ this.closing = true;
+ this.signalUnsubscribe();
+ if (!signal && this.procs.length > 0) {
+ this.log.warning('%d processes left running, stop them with procs.stop(name):', this.procs.length, this.procs.map((proc) => proc.name));
+ }
+ await Promise.all(this.procs.map(async (proc) => {
+ await proc.stop(signal === 'exit' ? 'SIGKILL' : signal);
+ }));
+ }
+ getProc(name) {
+ return this.procs.find((proc) => {
+ return proc.name === name;
+ });
+ }
+ startProc(name, options) {
+ const startMs = Date.now();
+ const proc = proc_1.startProc(name, options, this.log);
+ this.procs.push(proc);
+ const remove = () => {
+ this.procs.splice(this.procs.indexOf(proc), 1);
+ };
+ // tie into proc outcome$, remove from _procs on compete
+ proc.outcome$.subscribe({
+ next: (code) => {
+ const duration = moment_1.default.duration(Date.now() - startMs);
+ this.log.info('[%s] exited with %s after %s', name, code, duration.humanize());
+ },
+ complete: () => {
+ remove();
+ },
+ error: (error) => {
+ if (this.closing) {
+ this.log.error(error);
+ }
+ remove();
+ },
+ });
+ return proc;
+ }
}
+exports.ProcRunner = ProcRunner;
-convert.rgb.hsl = function (rgb) {
- var r = rgb[0] / 255;
- var g = rgb[1] / 255;
- var b = rgb[2] / 255;
- var min = Math.min(r, g, b);
- var max = Math.max(r, g, b);
- var delta = max - min;
- var h;
- var s;
- var l;
-
- if (max === min) {
- h = 0;
- } else if (r === max) {
- h = (g - b) / delta;
- } else if (g === max) {
- h = 2 + (b - r) / delta;
- } else if (b === max) {
- h = 4 + (r - g) / delta;
- }
-
- h = Math.min(h * 60, 360);
-
- if (h < 0) {
- h += 360;
- }
- l = (min + max) / 2;
+/***/ }),
+/* 10 */
+/***/ (function(module, exports, __webpack_require__) {
- if (max === min) {
- s = 0;
- } else if (l <= 0.5) {
- s = delta / (max + min);
- } else {
- s = delta / (2 - max - min);
- }
+/* WEBPACK VAR INJECTION */(function(module) {var require;//! moment.js
- return [h, s * 100, l * 100];
-};
+;(function (global, factory) {
+ true ? module.exports = factory() :
+ undefined
+}(this, (function () { 'use strict';
-convert.rgb.hsv = function (rgb) {
- var r = rgb[0];
- var g = rgb[1];
- var b = rgb[2];
- var min = Math.min(r, g, b);
- var max = Math.max(r, g, b);
- var delta = max - min;
- var h;
- var s;
- var v;
+ var hookCallback;
- if (max === 0) {
- s = 0;
- } else {
- s = (delta / max * 1000) / 10;
- }
+ function hooks () {
+ return hookCallback.apply(null, arguments);
+ }
- if (max === min) {
- h = 0;
- } else if (r === max) {
- h = (g - b) / delta;
- } else if (g === max) {
- h = 2 + (b - r) / delta;
- } else if (b === max) {
- h = 4 + (r - g) / delta;
- }
+ // This is done to register the method called with moment()
+ // without creating circular dependencies.
+ function setHookCallback (callback) {
+ hookCallback = callback;
+ }
- h = Math.min(h * 60, 360);
+ function isArray(input) {
+ return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
+ }
- if (h < 0) {
- h += 360;
- }
+ function isObject(input) {
+ // IE8 will treat undefined and null as object if it wasn't for
+ // input != null
+ return input != null && Object.prototype.toString.call(input) === '[object Object]';
+ }
- v = ((max / 255) * 1000) / 10;
+ function isObjectEmpty(obj) {
+ if (Object.getOwnPropertyNames) {
+ return (Object.getOwnPropertyNames(obj).length === 0);
+ } else {
+ var k;
+ for (k in obj) {
+ if (obj.hasOwnProperty(k)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
- return [h, s, v];
-};
+ function isUndefined(input) {
+ return input === void 0;
+ }
-convert.rgb.hwb = function (rgb) {
- var r = rgb[0];
- var g = rgb[1];
- var b = rgb[2];
- var h = convert.rgb.hsl(rgb)[0];
- var w = 1 / 255 * Math.min(r, Math.min(g, b));
+ function isNumber(input) {
+ return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
+ }
- b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+ function isDate(input) {
+ return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
+ }
- return [h, w * 100, b * 100];
-};
+ function map(arr, fn) {
+ var res = [], i;
+ for (i = 0; i < arr.length; ++i) {
+ res.push(fn(arr[i], i));
+ }
+ return res;
+ }
-convert.rgb.cmyk = function (rgb) {
- var r = rgb[0] / 255;
- var g = rgb[1] / 255;
- var b = rgb[2] / 255;
- var c;
- var m;
- var y;
- var k;
+ function hasOwnProp(a, b) {
+ return Object.prototype.hasOwnProperty.call(a, b);
+ }
- k = Math.min(1 - r, 1 - g, 1 - b);
- c = (1 - r - k) / (1 - k) || 0;
- m = (1 - g - k) / (1 - k) || 0;
- y = (1 - b - k) / (1 - k) || 0;
+ function extend(a, b) {
+ for (var i in b) {
+ if (hasOwnProp(b, i)) {
+ a[i] = b[i];
+ }
+ }
- return [c * 100, m * 100, y * 100, k * 100];
-};
+ if (hasOwnProp(b, 'toString')) {
+ a.toString = b.toString;
+ }
-/**
- * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
- * */
-function comparativeDistance(x, y) {
- return (
- Math.pow(x[0] - y[0], 2) +
- Math.pow(x[1] - y[1], 2) +
- Math.pow(x[2] - y[2], 2)
- );
-}
+ if (hasOwnProp(b, 'valueOf')) {
+ a.valueOf = b.valueOf;
+ }
-convert.rgb.keyword = function (rgb) {
- var reversed = reverseKeywords[rgb];
- if (reversed) {
- return reversed;
- }
+ return a;
+ }
- var currentClosestDistance = Infinity;
- var currentClosestKeyword;
+ function createUTC (input, format, locale, strict) {
+ return createLocalOrUTC(input, format, locale, strict, true).utc();
+ }
- for (var keyword in cssKeywords) {
- if (cssKeywords.hasOwnProperty(keyword)) {
- var value = cssKeywords[keyword];
+ function defaultParsingFlags() {
+ // We need to deep clone this object.
+ return {
+ empty : false,
+ unusedTokens : [],
+ unusedInput : [],
+ overflow : -2,
+ charsLeftOver : 0,
+ nullInput : false,
+ invalidMonth : null,
+ invalidFormat : false,
+ userInvalidated : false,
+ iso : false,
+ parsedDateParts : [],
+ meridiem : null,
+ rfc2822 : false,
+ weekdayMismatch : false
+ };
+ }
- // Compute comparative distance
- var distance = comparativeDistance(rgb, value);
+ function getParsingFlags(m) {
+ if (m._pf == null) {
+ m._pf = defaultParsingFlags();
+ }
+ return m._pf;
+ }
- // Check if its less, if so set as closest
- if (distance < currentClosestDistance) {
- currentClosestDistance = distance;
- currentClosestKeyword = keyword;
- }
- }
- }
+ var some;
+ if (Array.prototype.some) {
+ some = Array.prototype.some;
+ } else {
+ some = function (fun) {
+ var t = Object(this);
+ var len = t.length >>> 0;
- return currentClosestKeyword;
-};
+ for (var i = 0; i < len; i++) {
+ if (i in t && fun.call(this, t[i], i, t)) {
+ return true;
+ }
+ }
-convert.keyword.rgb = function (keyword) {
- return cssKeywords[keyword];
-};
+ return false;
+ };
+ }
-convert.rgb.xyz = function (rgb) {
- var r = rgb[0] / 255;
- var g = rgb[1] / 255;
- var b = rgb[2] / 255;
+ function isValid(m) {
+ if (m._isValid == null) {
+ var flags = getParsingFlags(m);
+ var parsedParts = some.call(flags.parsedDateParts, function (i) {
+ return i != null;
+ });
+ var isNowValid = !isNaN(m._d.getTime()) &&
+ flags.overflow < 0 &&
+ !flags.empty &&
+ !flags.invalidMonth &&
+ !flags.invalidWeekday &&
+ !flags.weekdayMismatch &&
+ !flags.nullInput &&
+ !flags.invalidFormat &&
+ !flags.userInvalidated &&
+ (!flags.meridiem || (flags.meridiem && parsedParts));
- // assume sRGB
- r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
- g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
- b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);
+ if (m._strict) {
+ isNowValid = isNowValid &&
+ flags.charsLeftOver === 0 &&
+ flags.unusedTokens.length === 0 &&
+ flags.bigHour === undefined;
+ }
- var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
- var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
- var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
+ if (Object.isFrozen == null || !Object.isFrozen(m)) {
+ m._isValid = isNowValid;
+ }
+ else {
+ return isNowValid;
+ }
+ }
+ return m._isValid;
+ }
- return [x * 100, y * 100, z * 100];
-};
+ function createInvalid (flags) {
+ var m = createUTC(NaN);
+ if (flags != null) {
+ extend(getParsingFlags(m), flags);
+ }
+ else {
+ getParsingFlags(m).userInvalidated = true;
+ }
-convert.rgb.lab = function (rgb) {
- var xyz = convert.rgb.xyz(rgb);
- var x = xyz[0];
- var y = xyz[1];
- var z = xyz[2];
- var l;
- var a;
- var b;
+ return m;
+ }
- x /= 95.047;
- y /= 100;
- z /= 108.883;
+ // Plugins that add properties should also add the key here (null value),
+ // so we can properly clone ourselves.
+ var momentProperties = hooks.momentProperties = [];
- x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
- y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
- z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
+ function copyConfig(to, from) {
+ var i, prop, val;
- l = (116 * y) - 16;
- a = 500 * (x - y);
- b = 200 * (y - z);
-
- return [l, a, b];
-};
+ if (!isUndefined(from._isAMomentObject)) {
+ to._isAMomentObject = from._isAMomentObject;
+ }
+ if (!isUndefined(from._i)) {
+ to._i = from._i;
+ }
+ if (!isUndefined(from._f)) {
+ to._f = from._f;
+ }
+ if (!isUndefined(from._l)) {
+ to._l = from._l;
+ }
+ if (!isUndefined(from._strict)) {
+ to._strict = from._strict;
+ }
+ if (!isUndefined(from._tzm)) {
+ to._tzm = from._tzm;
+ }
+ if (!isUndefined(from._isUTC)) {
+ to._isUTC = from._isUTC;
+ }
+ if (!isUndefined(from._offset)) {
+ to._offset = from._offset;
+ }
+ if (!isUndefined(from._pf)) {
+ to._pf = getParsingFlags(from);
+ }
+ if (!isUndefined(from._locale)) {
+ to._locale = from._locale;
+ }
-convert.hsl.rgb = function (hsl) {
- var h = hsl[0] / 360;
- var s = hsl[1] / 100;
- var l = hsl[2] / 100;
- var t1;
- var t2;
- var t3;
- var rgb;
- var val;
+ if (momentProperties.length > 0) {
+ for (i = 0; i < momentProperties.length; i++) {
+ prop = momentProperties[i];
+ val = from[prop];
+ if (!isUndefined(val)) {
+ to[prop] = val;
+ }
+ }
+ }
- if (s === 0) {
- val = l * 255;
- return [val, val, val];
- }
+ return to;
+ }
- if (l < 0.5) {
- t2 = l * (1 + s);
- } else {
- t2 = l + s - l * s;
- }
+ var updateInProgress = false;
- t1 = 2 * l - t2;
+ // Moment prototype object
+ function Moment(config) {
+ copyConfig(this, config);
+ this._d = new Date(config._d != null ? config._d.getTime() : NaN);
+ if (!this.isValid()) {
+ this._d = new Date(NaN);
+ }
+ // Prevent infinite loop in case updateOffset creates new moment
+ // objects.
+ if (updateInProgress === false) {
+ updateInProgress = true;
+ hooks.updateOffset(this);
+ updateInProgress = false;
+ }
+ }
- rgb = [0, 0, 0];
- for (var i = 0; i < 3; i++) {
- t3 = h + 1 / 3 * -(i - 1);
- if (t3 < 0) {
- t3++;
- }
- if (t3 > 1) {
- t3--;
- }
+ function isMoment (obj) {
+ return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
+ }
- if (6 * t3 < 1) {
- val = t1 + (t2 - t1) * 6 * t3;
- } else if (2 * t3 < 1) {
- val = t2;
- } else if (3 * t3 < 2) {
- val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
- } else {
- val = t1;
- }
+ function absFloor (number) {
+ if (number < 0) {
+ // -0 -> 0
+ return Math.ceil(number) || 0;
+ } else {
+ return Math.floor(number);
+ }
+ }
- rgb[i] = val * 255;
- }
+ function toInt(argumentForCoercion) {
+ var coercedNumber = +argumentForCoercion,
+ value = 0;
- return rgb;
-};
+ if (coercedNumber !== 0 && isFinite(coercedNumber)) {
+ value = absFloor(coercedNumber);
+ }
-convert.hsl.hsv = function (hsl) {
- var h = hsl[0];
- var s = hsl[1] / 100;
- var l = hsl[2] / 100;
- var smin = s;
- var lmin = Math.max(l, 0.01);
- var sv;
- var v;
+ return value;
+ }
- l *= 2;
- s *= (l <= 1) ? l : 2 - l;
- smin *= lmin <= 1 ? lmin : 2 - lmin;
- v = (l + s) / 2;
- sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
+ // compare two arrays, return the number of differences
+ function compareArrays(array1, array2, dontConvert) {
+ var len = Math.min(array1.length, array2.length),
+ lengthDiff = Math.abs(array1.length - array2.length),
+ diffs = 0,
+ i;
+ for (i = 0; i < len; i++) {
+ if ((dontConvert && array1[i] !== array2[i]) ||
+ (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
+ diffs++;
+ }
+ }
+ return diffs + lengthDiff;
+ }
- return [h, sv * 100, v * 100];
-};
+ function warn(msg) {
+ if (hooks.suppressDeprecationWarnings === false &&
+ (typeof console !== 'undefined') && console.warn) {
+ console.warn('Deprecation warning: ' + msg);
+ }
+ }
-convert.hsv.rgb = function (hsv) {
- var h = hsv[0] / 60;
- var s = hsv[1] / 100;
- var v = hsv[2] / 100;
- var hi = Math.floor(h) % 6;
+ function deprecate(msg, fn) {
+ var firstTime = true;
- var f = h - Math.floor(h);
- var p = 255 * v * (1 - s);
- var q = 255 * v * (1 - (s * f));
- var t = 255 * v * (1 - (s * (1 - f)));
- v *= 255;
+ return extend(function () {
+ if (hooks.deprecationHandler != null) {
+ hooks.deprecationHandler(null, msg);
+ }
+ if (firstTime) {
+ var args = [];
+ var arg;
+ for (var i = 0; i < arguments.length; i++) {
+ arg = '';
+ if (typeof arguments[i] === 'object') {
+ arg += '\n[' + i + '] ';
+ for (var key in arguments[0]) {
+ arg += key + ': ' + arguments[0][key] + ', ';
+ }
+ arg = arg.slice(0, -2); // Remove trailing comma and space
+ } else {
+ arg = arguments[i];
+ }
+ args.push(arg);
+ }
+ warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
+ firstTime = false;
+ }
+ return fn.apply(this, arguments);
+ }, fn);
+ }
- switch (hi) {
- case 0:
- return [v, t, p];
- case 1:
- return [q, v, p];
- case 2:
- return [p, v, t];
- case 3:
- return [p, q, v];
- case 4:
- return [t, p, v];
- case 5:
- return [v, p, q];
- }
-};
+ var deprecations = {};
-convert.hsv.hsl = function (hsv) {
- var h = hsv[0];
- var s = hsv[1] / 100;
- var v = hsv[2] / 100;
- var vmin = Math.max(v, 0.01);
- var lmin;
- var sl;
- var l;
+ function deprecateSimple(name, msg) {
+ if (hooks.deprecationHandler != null) {
+ hooks.deprecationHandler(name, msg);
+ }
+ if (!deprecations[name]) {
+ warn(msg);
+ deprecations[name] = true;
+ }
+ }
- l = (2 - s) * v;
- lmin = (2 - s) * vmin;
- sl = s * vmin;
- sl /= (lmin <= 1) ? lmin : 2 - lmin;
- sl = sl || 0;
- l /= 2;
+ hooks.suppressDeprecationWarnings = false;
+ hooks.deprecationHandler = null;
- return [h, sl * 100, l * 100];
-};
+ function isFunction(input) {
+ return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
+ }
-// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
-convert.hwb.rgb = function (hwb) {
- var h = hwb[0] / 360;
- var wh = hwb[1] / 100;
- var bl = hwb[2] / 100;
- var ratio = wh + bl;
- var i;
- var v;
- var f;
- var n;
+ function set (config) {
+ var prop, i;
+ for (i in config) {
+ prop = config[i];
+ if (isFunction(prop)) {
+ this[i] = prop;
+ } else {
+ this['_' + i] = prop;
+ }
+ }
+ this._config = config;
+ // Lenient ordinal parsing accepts just a number in addition to
+ // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
+ // TODO: Remove "ordinalParse" fallback in next major release.
+ this._dayOfMonthOrdinalParseLenient = new RegExp(
+ (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
+ '|' + (/\d{1,2}/).source);
+ }
- // wh + bl cant be > 1
- if (ratio > 1) {
- wh /= ratio;
- bl /= ratio;
- }
+ function mergeConfigs(parentConfig, childConfig) {
+ var res = extend({}, parentConfig), prop;
+ for (prop in childConfig) {
+ if (hasOwnProp(childConfig, prop)) {
+ if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
+ res[prop] = {};
+ extend(res[prop], parentConfig[prop]);
+ extend(res[prop], childConfig[prop]);
+ } else if (childConfig[prop] != null) {
+ res[prop] = childConfig[prop];
+ } else {
+ delete res[prop];
+ }
+ }
+ }
+ for (prop in parentConfig) {
+ if (hasOwnProp(parentConfig, prop) &&
+ !hasOwnProp(childConfig, prop) &&
+ isObject(parentConfig[prop])) {
+ // make sure changes to properties don't modify parent config
+ res[prop] = extend({}, res[prop]);
+ }
+ }
+ return res;
+ }
- i = Math.floor(6 * h);
- v = 1 - bl;
- f = 6 * h - i;
+ function Locale(config) {
+ if (config != null) {
+ this.set(config);
+ }
+ }
- if ((i & 0x01) !== 0) {
- f = 1 - f;
- }
+ var keys;
- n = wh + f * (v - wh); // linear interpolation
+ if (Object.keys) {
+ keys = Object.keys;
+ } else {
+ keys = function (obj) {
+ var i, res = [];
+ for (i in obj) {
+ if (hasOwnProp(obj, i)) {
+ res.push(i);
+ }
+ }
+ return res;
+ };
+ }
- var r;
- var g;
- var b;
- switch (i) {
- default:
- case 6:
- case 0: r = v; g = n; b = wh; break;
- case 1: r = n; g = v; b = wh; break;
- case 2: r = wh; g = v; b = n; break;
- case 3: r = wh; g = n; b = v; break;
- case 4: r = n; g = wh; b = v; break;
- case 5: r = v; g = wh; b = n; break;
- }
+ var defaultCalendar = {
+ sameDay : '[Today at] LT',
+ nextDay : '[Tomorrow at] LT',
+ nextWeek : 'dddd [at] LT',
+ lastDay : '[Yesterday at] LT',
+ lastWeek : '[Last] dddd [at] LT',
+ sameElse : 'L'
+ };
- return [r * 255, g * 255, b * 255];
-};
+ function calendar (key, mom, now) {
+ var output = this._calendar[key] || this._calendar['sameElse'];
+ return isFunction(output) ? output.call(mom, now) : output;
+ }
-convert.cmyk.rgb = function (cmyk) {
- var c = cmyk[0] / 100;
- var m = cmyk[1] / 100;
- var y = cmyk[2] / 100;
- var k = cmyk[3] / 100;
- var r;
- var g;
- var b;
+ var defaultLongDateFormat = {
+ LTS : 'h:mm:ss A',
+ LT : 'h:mm A',
+ L : 'MM/DD/YYYY',
+ LL : 'MMMM D, YYYY',
+ LLL : 'MMMM D, YYYY h:mm A',
+ LLLL : 'dddd, MMMM D, YYYY h:mm A'
+ };
- r = 1 - Math.min(1, c * (1 - k) + k);
- g = 1 - Math.min(1, m * (1 - k) + k);
- b = 1 - Math.min(1, y * (1 - k) + k);
+ function longDateFormat (key) {
+ var format = this._longDateFormat[key],
+ formatUpper = this._longDateFormat[key.toUpperCase()];
- return [r * 255, g * 255, b * 255];
-};
+ if (format || !formatUpper) {
+ return format;
+ }
-convert.xyz.rgb = function (xyz) {
- var x = xyz[0] / 100;
- var y = xyz[1] / 100;
- var z = xyz[2] / 100;
- var r;
- var g;
- var b;
+ this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
+ return val.slice(1);
+ });
- r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
- g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
- b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
+ return this._longDateFormat[key];
+ }
- // assume sRGB
- r = r > 0.0031308
- ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
- : r * 12.92;
+ var defaultInvalidDate = 'Invalid date';
- g = g > 0.0031308
- ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
- : g * 12.92;
+ function invalidDate () {
+ return this._invalidDate;
+ }
- b = b > 0.0031308
- ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
- : b * 12.92;
+ var defaultOrdinal = '%d';
+ var defaultDayOfMonthOrdinalParse = /\d{1,2}/;
- r = Math.min(Math.max(0, r), 1);
- g = Math.min(Math.max(0, g), 1);
- b = Math.min(Math.max(0, b), 1);
+ function ordinal (number) {
+ return this._ordinal.replace('%d', number);
+ }
- return [r * 255, g * 255, b * 255];
-};
+ var defaultRelativeTime = {
+ future : 'in %s',
+ past : '%s ago',
+ s : 'a few seconds',
+ ss : '%d seconds',
+ m : 'a minute',
+ mm : '%d minutes',
+ h : 'an hour',
+ hh : '%d hours',
+ d : 'a day',
+ dd : '%d days',
+ M : 'a month',
+ MM : '%d months',
+ y : 'a year',
+ yy : '%d years'
+ };
-convert.xyz.lab = function (xyz) {
- var x = xyz[0];
- var y = xyz[1];
- var z = xyz[2];
- var l;
- var a;
- var b;
+ function relativeTime (number, withoutSuffix, string, isFuture) {
+ var output = this._relativeTime[string];
+ return (isFunction(output)) ?
+ output(number, withoutSuffix, string, isFuture) :
+ output.replace(/%d/i, number);
+ }
- x /= 95.047;
- y /= 100;
- z /= 108.883;
+ function pastFuture (diff, output) {
+ var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
+ return isFunction(format) ? format(output) : format.replace(/%s/i, output);
+ }
- x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
- y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
- z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
+ var aliases = {};
- l = (116 * y) - 16;
- a = 500 * (x - y);
- b = 200 * (y - z);
+ function addUnitAlias (unit, shorthand) {
+ var lowerCase = unit.toLowerCase();
+ aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
+ }
- return [l, a, b];
-};
+ function normalizeUnits(units) {
+ return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
+ }
-convert.lab.xyz = function (lab) {
- var l = lab[0];
- var a = lab[1];
- var b = lab[2];
- var x;
- var y;
- var z;
+ function normalizeObjectUnits(inputObject) {
+ var normalizedInput = {},
+ normalizedProp,
+ prop;
- y = (l + 16) / 116;
- x = a / 500 + y;
- z = y - b / 200;
+ for (prop in inputObject) {
+ if (hasOwnProp(inputObject, prop)) {
+ normalizedProp = normalizeUnits(prop);
+ if (normalizedProp) {
+ normalizedInput[normalizedProp] = inputObject[prop];
+ }
+ }
+ }
- var y2 = Math.pow(y, 3);
- var x2 = Math.pow(x, 3);
- var z2 = Math.pow(z, 3);
- y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
- x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
- z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+ return normalizedInput;
+ }
- x *= 95.047;
- y *= 100;
- z *= 108.883;
+ var priorities = {};
- return [x, y, z];
-};
+ function addUnitPriority(unit, priority) {
+ priorities[unit] = priority;
+ }
-convert.lab.lch = function (lab) {
- var l = lab[0];
- var a = lab[1];
- var b = lab[2];
- var hr;
- var h;
- var c;
-
- hr = Math.atan2(b, a);
- h = hr * 360 / 2 / Math.PI;
+ function getPrioritizedUnits(unitsObj) {
+ var units = [];
+ for (var u in unitsObj) {
+ units.push({unit: u, priority: priorities[u]});
+ }
+ units.sort(function (a, b) {
+ return a.priority - b.priority;
+ });
+ return units;
+ }
- if (h < 0) {
- h += 360;
- }
+ function zeroFill(number, targetLength, forceSign) {
+ var absNumber = '' + Math.abs(number),
+ zerosToFill = targetLength - absNumber.length,
+ sign = number >= 0;
+ return (sign ? (forceSign ? '+' : '') : '-') +
+ Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
+ }
- c = Math.sqrt(a * a + b * b);
+ var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
- return [l, c, h];
-};
+ var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
-convert.lch.lab = function (lch) {
- var l = lch[0];
- var c = lch[1];
- var h = lch[2];
- var a;
- var b;
- var hr;
+ var formatFunctions = {};
- hr = h / 360 * 2 * Math.PI;
- a = c * Math.cos(hr);
- b = c * Math.sin(hr);
+ var formatTokenFunctions = {};
- return [l, a, b];
-};
+ // token: 'M'
+ // padded: ['MM', 2]
+ // ordinal: 'Mo'
+ // callback: function () { this.month() + 1 }
+ function addFormatToken (token, padded, ordinal, callback) {
+ var func = callback;
+ if (typeof callback === 'string') {
+ func = function () {
+ return this[callback]();
+ };
+ }
+ if (token) {
+ formatTokenFunctions[token] = func;
+ }
+ if (padded) {
+ formatTokenFunctions[padded[0]] = function () {
+ return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
+ };
+ }
+ if (ordinal) {
+ formatTokenFunctions[ordinal] = function () {
+ return this.localeData().ordinal(func.apply(this, arguments), token);
+ };
+ }
+ }
-convert.rgb.ansi16 = function (args) {
- var r = args[0];
- var g = args[1];
- var b = args[2];
- var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization
+ function removeFormattingTokens(input) {
+ if (input.match(/\[[\s\S]/)) {
+ return input.replace(/^\[|\]$/g, '');
+ }
+ return input.replace(/\\/g, '');
+ }
- value = Math.round(value / 50);
+ function makeFormatFunction(format) {
+ var array = format.match(formattingTokens), i, length;
- if (value === 0) {
- return 30;
- }
+ for (i = 0, length = array.length; i < length; i++) {
+ if (formatTokenFunctions[array[i]]) {
+ array[i] = formatTokenFunctions[array[i]];
+ } else {
+ array[i] = removeFormattingTokens(array[i]);
+ }
+ }
- var ansi = 30
- + ((Math.round(b / 255) << 2)
- | (Math.round(g / 255) << 1)
- | Math.round(r / 255));
+ return function (mom) {
+ var output = '', i;
+ for (i = 0; i < length; i++) {
+ output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];
+ }
+ return output;
+ };
+ }
- if (value === 2) {
- ansi += 60;
- }
+ // format date using native date object
+ function formatMoment(m, format) {
+ if (!m.isValid()) {
+ return m.localeData().invalidDate();
+ }
- return ansi;
-};
+ format = expandFormat(format, m.localeData());
+ formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
-convert.hsv.ansi16 = function (args) {
- // optimization here; we already know the value and don't need to get
- // it converted for us.
- return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
-};
+ return formatFunctions[format](m);
+ }
-convert.rgb.ansi256 = function (args) {
- var r = args[0];
- var g = args[1];
- var b = args[2];
+ function expandFormat(format, locale) {
+ var i = 5;
- // we use the extended greyscale palette here, with the exception of
- // black and white. normal palette only has 4 greyscale shades.
- if (r === g && g === b) {
- if (r < 8) {
- return 16;
- }
+ function replaceLongDateFormatTokens(input) {
+ return locale.longDateFormat(input) || input;
+ }
- if (r > 248) {
- return 231;
- }
+ localFormattingTokens.lastIndex = 0;
+ while (i >= 0 && localFormattingTokens.test(format)) {
+ format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
+ localFormattingTokens.lastIndex = 0;
+ i -= 1;
+ }
- return Math.round(((r - 8) / 247) * 24) + 232;
- }
+ return format;
+ }
- var ansi = 16
- + (36 * Math.round(r / 255 * 5))
- + (6 * Math.round(g / 255 * 5))
- + Math.round(b / 255 * 5);
+ var match1 = /\d/; // 0 - 9
+ var match2 = /\d\d/; // 00 - 99
+ var match3 = /\d{3}/; // 000 - 999
+ var match4 = /\d{4}/; // 0000 - 9999
+ var match6 = /[+-]?\d{6}/; // -999999 - 999999
+ var match1to2 = /\d\d?/; // 0 - 99
+ var match3to4 = /\d\d\d\d?/; // 999 - 9999
+ var match5to6 = /\d\d\d\d\d\d?/; // 99999 - 999999
+ var match1to3 = /\d{1,3}/; // 0 - 999
+ var match1to4 = /\d{1,4}/; // 0 - 9999
+ var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999
- return ansi;
-};
+ var matchUnsigned = /\d+/; // 0 - inf
+ var matchSigned = /[+-]?\d+/; // -inf - inf
-convert.ansi16.rgb = function (args) {
- var color = args % 10;
+ var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
+ var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
- // handle greyscale
- if (color === 0 || color === 7) {
- if (args > 50) {
- color += 3.5;
- }
+ var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
- color = color / 10.5 * 255;
+ // any word (or two) characters or numbers including two/three word month in arabic.
+ // includes scottish gaelic two word and hyphenated months
+ var matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;
- return [color, color, color];
- }
+ var regexes = {};
- var mult = (~~(args > 50) + 1) * 0.5;
- var r = ((color & 1) * mult) * 255;
- var g = (((color >> 1) & 1) * mult) * 255;
- var b = (((color >> 2) & 1) * mult) * 255;
+ function addRegexToken (token, regex, strictRegex) {
+ regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
+ return (isStrict && strictRegex) ? strictRegex : regex;
+ };
+ }
- return [r, g, b];
-};
+ function getParseRegexForToken (token, config) {
+ if (!hasOwnProp(regexes, token)) {
+ return new RegExp(unescapeFormat(token));
+ }
-convert.ansi256.rgb = function (args) {
- // handle greyscale
- if (args >= 232) {
- var c = (args - 232) * 10 + 8;
- return [c, c, c];
- }
+ return regexes[token](config._strict, config._locale);
+ }
- args -= 16;
+ // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
+ function unescapeFormat(s) {
+ return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
+ return p1 || p2 || p3 || p4;
+ }));
+ }
- var rem;
- var r = Math.floor(args / 36) / 5 * 255;
- var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
- var b = (rem % 6) / 5 * 255;
+ function regexEscape(s) {
+ return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+ }
- return [r, g, b];
-};
+ var tokens = {};
-convert.rgb.hex = function (args) {
- var integer = ((Math.round(args[0]) & 0xFF) << 16)
- + ((Math.round(args[1]) & 0xFF) << 8)
- + (Math.round(args[2]) & 0xFF);
+ function addParseToken (token, callback) {
+ var i, func = callback;
+ if (typeof token === 'string') {
+ token = [token];
+ }
+ if (isNumber(callback)) {
+ func = function (input, array) {
+ array[callback] = toInt(input);
+ };
+ }
+ for (i = 0; i < token.length; i++) {
+ tokens[token[i]] = func;
+ }
+ }
- var string = integer.toString(16).toUpperCase();
- return '000000'.substring(string.length) + string;
-};
+ function addWeekParseToken (token, callback) {
+ addParseToken(token, function (input, array, config, token) {
+ config._w = config._w || {};
+ callback(input, config._w, config, token);
+ });
+ }
-convert.hex.rgb = function (args) {
- var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
- if (!match) {
- return [0, 0, 0];
- }
+ function addTimeToArrayFromToken(token, input, config) {
+ if (input != null && hasOwnProp(tokens, token)) {
+ tokens[token](input, config._a, config, token);
+ }
+ }
- var colorString = match[0];
+ var YEAR = 0;
+ var MONTH = 1;
+ var DATE = 2;
+ var HOUR = 3;
+ var MINUTE = 4;
+ var SECOND = 5;
+ var MILLISECOND = 6;
+ var WEEK = 7;
+ var WEEKDAY = 8;
- if (match[0].length === 3) {
- colorString = colorString.split('').map(function (char) {
- return char + char;
- }).join('');
- }
+ // FORMATTING
- var integer = parseInt(colorString, 16);
- var r = (integer >> 16) & 0xFF;
- var g = (integer >> 8) & 0xFF;
- var b = integer & 0xFF;
+ addFormatToken('Y', 0, 0, function () {
+ var y = this.year();
+ return y <= 9999 ? '' + y : '+' + y;
+ });
- return [r, g, b];
-};
+ addFormatToken(0, ['YY', 2], 0, function () {
+ return this.year() % 100;
+ });
-convert.rgb.hcg = function (rgb) {
- var r = rgb[0] / 255;
- var g = rgb[1] / 255;
- var b = rgb[2] / 255;
- var max = Math.max(Math.max(r, g), b);
- var min = Math.min(Math.min(r, g), b);
- var chroma = (max - min);
- var grayscale;
- var hue;
+ addFormatToken(0, ['YYYY', 4], 0, 'year');
+ addFormatToken(0, ['YYYYY', 5], 0, 'year');
+ addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
- if (chroma < 1) {
- grayscale = min / (1 - chroma);
- } else {
- grayscale = 0;
- }
+ // ALIASES
- if (chroma <= 0) {
- hue = 0;
- } else
- if (max === r) {
- hue = ((g - b) / chroma) % 6;
- } else
- if (max === g) {
- hue = 2 + (b - r) / chroma;
- } else {
- hue = 4 + (r - g) / chroma + 4;
- }
+ addUnitAlias('year', 'y');
- hue /= 6;
- hue %= 1;
+ // PRIORITIES
- return [hue * 360, chroma * 100, grayscale * 100];
-};
+ addUnitPriority('year', 1);
-convert.hsl.hcg = function (hsl) {
- var s = hsl[1] / 100;
- var l = hsl[2] / 100;
- var c = 1;
- var f = 0;
+ // PARSING
- if (l < 0.5) {
- c = 2.0 * s * l;
- } else {
- c = 2.0 * s * (1.0 - l);
- }
+ addRegexToken('Y', matchSigned);
+ addRegexToken('YY', match1to2, match2);
+ addRegexToken('YYYY', match1to4, match4);
+ addRegexToken('YYYYY', match1to6, match6);
+ addRegexToken('YYYYYY', match1to6, match6);
- if (c < 1.0) {
- f = (l - 0.5 * c) / (1.0 - c);
- }
+ addParseToken(['YYYYY', 'YYYYYY'], YEAR);
+ addParseToken('YYYY', function (input, array) {
+ array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
+ });
+ addParseToken('YY', function (input, array) {
+ array[YEAR] = hooks.parseTwoDigitYear(input);
+ });
+ addParseToken('Y', function (input, array) {
+ array[YEAR] = parseInt(input, 10);
+ });
- return [hsl[0], c * 100, f * 100];
-};
+ // HELPERS
-convert.hsv.hcg = function (hsv) {
- var s = hsv[1] / 100;
- var v = hsv[2] / 100;
+ function daysInYear(year) {
+ return isLeapYear(year) ? 366 : 365;
+ }
- var c = s * v;
- var f = 0;
+ function isLeapYear(year) {
+ return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+ }
- if (c < 1.0) {
- f = (v - c) / (1 - c);
- }
+ // HOOKS
- return [hsv[0], c * 100, f * 100];
-};
+ hooks.parseTwoDigitYear = function (input) {
+ return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
+ };
-convert.hcg.rgb = function (hcg) {
- var h = hcg[0] / 360;
- var c = hcg[1] / 100;
- var g = hcg[2] / 100;
+ // MOMENTS
- if (c === 0.0) {
- return [g * 255, g * 255, g * 255];
- }
+ var getSetYear = makeGetSet('FullYear', true);
- var pure = [0, 0, 0];
- var hi = (h % 1) * 6;
- var v = hi % 1;
- var w = 1 - v;
- var mg = 0;
+ function getIsLeapYear () {
+ return isLeapYear(this.year());
+ }
- switch (Math.floor(hi)) {
- case 0:
- pure[0] = 1; pure[1] = v; pure[2] = 0; break;
- case 1:
- pure[0] = w; pure[1] = 1; pure[2] = 0; break;
- case 2:
- pure[0] = 0; pure[1] = 1; pure[2] = v; break;
- case 3:
- pure[0] = 0; pure[1] = w; pure[2] = 1; break;
- case 4:
- pure[0] = v; pure[1] = 0; pure[2] = 1; break;
- default:
- pure[0] = 1; pure[1] = 0; pure[2] = w;
- }
+ function makeGetSet (unit, keepTime) {
+ return function (value) {
+ if (value != null) {
+ set$1(this, unit, value);
+ hooks.updateOffset(this, keepTime);
+ return this;
+ } else {
+ return get(this, unit);
+ }
+ };
+ }
- mg = (1.0 - c) * g;
+ function get (mom, unit) {
+ return mom.isValid() ?
+ mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
+ }
- return [
- (c * pure[0] + mg) * 255,
- (c * pure[1] + mg) * 255,
- (c * pure[2] + mg) * 255
- ];
-};
+ function set$1 (mom, unit, value) {
+ if (mom.isValid() && !isNaN(value)) {
+ if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {
+ mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month()));
+ }
+ else {
+ mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
+ }
+ }
+ }
-convert.hcg.hsv = function (hcg) {
- var c = hcg[1] / 100;
- var g = hcg[2] / 100;
+ // MOMENTS
- var v = c + g * (1.0 - c);
- var f = 0;
+ function stringGet (units) {
+ units = normalizeUnits(units);
+ if (isFunction(this[units])) {
+ return this[units]();
+ }
+ return this;
+ }
- if (v > 0.0) {
- f = c / v;
- }
- return [hcg[0], f * 100, v * 100];
-};
+ function stringSet (units, value) {
+ if (typeof units === 'object') {
+ units = normalizeObjectUnits(units);
+ var prioritized = getPrioritizedUnits(units);
+ for (var i = 0; i < prioritized.length; i++) {
+ this[prioritized[i].unit](units[prioritized[i].unit]);
+ }
+ } else {
+ units = normalizeUnits(units);
+ if (isFunction(this[units])) {
+ return this[units](value);
+ }
+ }
+ return this;
+ }
-convert.hcg.hsl = function (hcg) {
- var c = hcg[1] / 100;
- var g = hcg[2] / 100;
+ function mod(n, x) {
+ return ((n % x) + x) % x;
+ }
- var l = g * (1.0 - c) + 0.5 * c;
- var s = 0;
+ var indexOf;
- if (l > 0.0 && l < 0.5) {
- s = c / (2 * l);
- } else
- if (l >= 0.5 && l < 1.0) {
- s = c / (2 * (1 - l));
- }
+ if (Array.prototype.indexOf) {
+ indexOf = Array.prototype.indexOf;
+ } else {
+ indexOf = function (o) {
+ // I know
+ var i;
+ for (i = 0; i < this.length; ++i) {
+ if (this[i] === o) {
+ return i;
+ }
+ }
+ return -1;
+ };
+ }
- return [hcg[0], s * 100, l * 100];
-};
+ function daysInMonth(year, month) {
+ if (isNaN(year) || isNaN(month)) {
+ return NaN;
+ }
+ var modMonth = mod(month, 12);
+ year += (month - modMonth) / 12;
+ return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2);
+ }
-convert.hcg.hwb = function (hcg) {
- var c = hcg[1] / 100;
- var g = hcg[2] / 100;
- var v = c + g * (1.0 - c);
- return [hcg[0], (v - c) * 100, (1 - v) * 100];
-};
+ // FORMATTING
-convert.hwb.hcg = function (hwb) {
- var w = hwb[1] / 100;
- var b = hwb[2] / 100;
- var v = 1 - b;
- var c = v - w;
- var g = 0;
+ addFormatToken('M', ['MM', 2], 'Mo', function () {
+ return this.month() + 1;
+ });
- if (c < 1) {
- g = (v - c) / (1 - c);
- }
+ addFormatToken('MMM', 0, 0, function (format) {
+ return this.localeData().monthsShort(this, format);
+ });
- return [hwb[0], c * 100, g * 100];
-};
+ addFormatToken('MMMM', 0, 0, function (format) {
+ return this.localeData().months(this, format);
+ });
-convert.apple.rgb = function (apple) {
- return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
-};
+ // ALIASES
-convert.rgb.apple = function (rgb) {
- return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
-};
+ addUnitAlias('month', 'M');
-convert.gray.rgb = function (args) {
- return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
-};
+ // PRIORITY
-convert.gray.hsl = convert.gray.hsv = function (args) {
- return [0, 0, args[0]];
-};
+ addUnitPriority('month', 8);
-convert.gray.hwb = function (gray) {
- return [0, 100, gray[0]];
-};
+ // PARSING
-convert.gray.cmyk = function (gray) {
- return [0, 0, 0, gray[0]];
-};
+ addRegexToken('M', match1to2);
+ addRegexToken('MM', match1to2, match2);
+ addRegexToken('MMM', function (isStrict, locale) {
+ return locale.monthsShortRegex(isStrict);
+ });
+ addRegexToken('MMMM', function (isStrict, locale) {
+ return locale.monthsRegex(isStrict);
+ });
-convert.gray.lab = function (gray) {
- return [gray[0], 0, 0];
-};
+ addParseToken(['M', 'MM'], function (input, array) {
+ array[MONTH] = toInt(input) - 1;
+ });
-convert.gray.hex = function (gray) {
- var val = Math.round(gray[0] / 100 * 255) & 0xFF;
- var integer = (val << 16) + (val << 8) + val;
+ addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
+ var month = config._locale.monthsParse(input, token, config._strict);
+ // if we didn't find a month name, mark the date as invalid.
+ if (month != null) {
+ array[MONTH] = month;
+ } else {
+ getParsingFlags(config).invalidMonth = input;
+ }
+ });
- var string = integer.toString(16).toUpperCase();
- return '000000'.substring(string.length) + string;
-};
+ // LOCALES
-convert.rgb.gray = function (rgb) {
- var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
- return [val / 255 * 100];
-};
+ var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
+ var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
+ function localeMonths (m, format) {
+ if (!m) {
+ return isArray(this._months) ? this._months :
+ this._months['standalone'];
+ }
+ return isArray(this._months) ? this._months[m.month()] :
+ this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
+ }
+ var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
+ function localeMonthsShort (m, format) {
+ if (!m) {
+ return isArray(this._monthsShort) ? this._monthsShort :
+ this._monthsShort['standalone'];
+ }
+ return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
+ this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
+ }
-/***/ }),
-/* 8 */
-/***/ (function(module, exports, __webpack_require__) {
+ function handleStrictParse(monthName, format, strict) {
+ var i, ii, mom, llc = monthName.toLocaleLowerCase();
+ if (!this._monthsParse) {
+ // this is not used
+ this._monthsParse = [];
+ this._longMonthsParse = [];
+ this._shortMonthsParse = [];
+ for (i = 0; i < 12; ++i) {
+ mom = createUTC([2000, i]);
+ this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
+ this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
+ }
+ }
-"use strict";
-
-
-module.exports = {
- "aliceblue": [240, 248, 255],
- "antiquewhite": [250, 235, 215],
- "aqua": [0, 255, 255],
- "aquamarine": [127, 255, 212],
- "azure": [240, 255, 255],
- "beige": [245, 245, 220],
- "bisque": [255, 228, 196],
- "black": [0, 0, 0],
- "blanchedalmond": [255, 235, 205],
- "blue": [0, 0, 255],
- "blueviolet": [138, 43, 226],
- "brown": [165, 42, 42],
- "burlywood": [222, 184, 135],
- "cadetblue": [95, 158, 160],
- "chartreuse": [127, 255, 0],
- "chocolate": [210, 105, 30],
- "coral": [255, 127, 80],
- "cornflowerblue": [100, 149, 237],
- "cornsilk": [255, 248, 220],
- "crimson": [220, 20, 60],
- "cyan": [0, 255, 255],
- "darkblue": [0, 0, 139],
- "darkcyan": [0, 139, 139],
- "darkgoldenrod": [184, 134, 11],
- "darkgray": [169, 169, 169],
- "darkgreen": [0, 100, 0],
- "darkgrey": [169, 169, 169],
- "darkkhaki": [189, 183, 107],
- "darkmagenta": [139, 0, 139],
- "darkolivegreen": [85, 107, 47],
- "darkorange": [255, 140, 0],
- "darkorchid": [153, 50, 204],
- "darkred": [139, 0, 0],
- "darksalmon": [233, 150, 122],
- "darkseagreen": [143, 188, 143],
- "darkslateblue": [72, 61, 139],
- "darkslategray": [47, 79, 79],
- "darkslategrey": [47, 79, 79],
- "darkturquoise": [0, 206, 209],
- "darkviolet": [148, 0, 211],
- "deeppink": [255, 20, 147],
- "deepskyblue": [0, 191, 255],
- "dimgray": [105, 105, 105],
- "dimgrey": [105, 105, 105],
- "dodgerblue": [30, 144, 255],
- "firebrick": [178, 34, 34],
- "floralwhite": [255, 250, 240],
- "forestgreen": [34, 139, 34],
- "fuchsia": [255, 0, 255],
- "gainsboro": [220, 220, 220],
- "ghostwhite": [248, 248, 255],
- "gold": [255, 215, 0],
- "goldenrod": [218, 165, 32],
- "gray": [128, 128, 128],
- "green": [0, 128, 0],
- "greenyellow": [173, 255, 47],
- "grey": [128, 128, 128],
- "honeydew": [240, 255, 240],
- "hotpink": [255, 105, 180],
- "indianred": [205, 92, 92],
- "indigo": [75, 0, 130],
- "ivory": [255, 255, 240],
- "khaki": [240, 230, 140],
- "lavender": [230, 230, 250],
- "lavenderblush": [255, 240, 245],
- "lawngreen": [124, 252, 0],
- "lemonchiffon": [255, 250, 205],
- "lightblue": [173, 216, 230],
- "lightcoral": [240, 128, 128],
- "lightcyan": [224, 255, 255],
- "lightgoldenrodyellow": [250, 250, 210],
- "lightgray": [211, 211, 211],
- "lightgreen": [144, 238, 144],
- "lightgrey": [211, 211, 211],
- "lightpink": [255, 182, 193],
- "lightsalmon": [255, 160, 122],
- "lightseagreen": [32, 178, 170],
- "lightskyblue": [135, 206, 250],
- "lightslategray": [119, 136, 153],
- "lightslategrey": [119, 136, 153],
- "lightsteelblue": [176, 196, 222],
- "lightyellow": [255, 255, 224],
- "lime": [0, 255, 0],
- "limegreen": [50, 205, 50],
- "linen": [250, 240, 230],
- "magenta": [255, 0, 255],
- "maroon": [128, 0, 0],
- "mediumaquamarine": [102, 205, 170],
- "mediumblue": [0, 0, 205],
- "mediumorchid": [186, 85, 211],
- "mediumpurple": [147, 112, 219],
- "mediumseagreen": [60, 179, 113],
- "mediumslateblue": [123, 104, 238],
- "mediumspringgreen": [0, 250, 154],
- "mediumturquoise": [72, 209, 204],
- "mediumvioletred": [199, 21, 133],
- "midnightblue": [25, 25, 112],
- "mintcream": [245, 255, 250],
- "mistyrose": [255, 228, 225],
- "moccasin": [255, 228, 181],
- "navajowhite": [255, 222, 173],
- "navy": [0, 0, 128],
- "oldlace": [253, 245, 230],
- "olive": [128, 128, 0],
- "olivedrab": [107, 142, 35],
- "orange": [255, 165, 0],
- "orangered": [255, 69, 0],
- "orchid": [218, 112, 214],
- "palegoldenrod": [238, 232, 170],
- "palegreen": [152, 251, 152],
- "paleturquoise": [175, 238, 238],
- "palevioletred": [219, 112, 147],
- "papayawhip": [255, 239, 213],
- "peachpuff": [255, 218, 185],
- "peru": [205, 133, 63],
- "pink": [255, 192, 203],
- "plum": [221, 160, 221],
- "powderblue": [176, 224, 230],
- "purple": [128, 0, 128],
- "rebeccapurple": [102, 51, 153],
- "red": [255, 0, 0],
- "rosybrown": [188, 143, 143],
- "royalblue": [65, 105, 225],
- "saddlebrown": [139, 69, 19],
- "salmon": [250, 128, 114],
- "sandybrown": [244, 164, 96],
- "seagreen": [46, 139, 87],
- "seashell": [255, 245, 238],
- "sienna": [160, 82, 45],
- "silver": [192, 192, 192],
- "skyblue": [135, 206, 235],
- "slateblue": [106, 90, 205],
- "slategray": [112, 128, 144],
- "slategrey": [112, 128, 144],
- "snow": [255, 250, 250],
- "springgreen": [0, 255, 127],
- "steelblue": [70, 130, 180],
- "tan": [210, 180, 140],
- "teal": [0, 128, 128],
- "thistle": [216, 191, 216],
- "tomato": [255, 99, 71],
- "turquoise": [64, 224, 208],
- "violet": [238, 130, 238],
- "wheat": [245, 222, 179],
- "white": [255, 255, 255],
- "whitesmoke": [245, 245, 245],
- "yellow": [255, 255, 0],
- "yellowgreen": [154, 205, 50]
-};
+ if (strict) {
+ if (format === 'MMM') {
+ ii = indexOf.call(this._shortMonthsParse, llc);
+ return ii !== -1 ? ii : null;
+ } else {
+ ii = indexOf.call(this._longMonthsParse, llc);
+ return ii !== -1 ? ii : null;
+ }
+ } else {
+ if (format === 'MMM') {
+ ii = indexOf.call(this._shortMonthsParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._longMonthsParse, llc);
+ return ii !== -1 ? ii : null;
+ } else {
+ ii = indexOf.call(this._longMonthsParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._shortMonthsParse, llc);
+ return ii !== -1 ? ii : null;
+ }
+ }
+ }
+ function localeMonthsParse (monthName, format, strict) {
+ var i, mom, regex;
-/***/ }),
-/* 9 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (this._monthsParseExact) {
+ return handleStrictParse.call(this, monthName, format, strict);
+ }
-var conversions = __webpack_require__(7);
+ if (!this._monthsParse) {
+ this._monthsParse = [];
+ this._longMonthsParse = [];
+ this._shortMonthsParse = [];
+ }
-/*
- this function routes a model to all other models.
+ // TODO: add sorting
+ // Sorting makes sure if one month (or abbr) is a prefix of another
+ // see sorting in computeMonthsParse
+ for (i = 0; i < 12; i++) {
+ // make the regex if we don't have it already
+ mom = createUTC([2000, i]);
+ if (strict && !this._longMonthsParse[i]) {
+ this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
+ this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');
+ }
+ if (!strict && !this._monthsParse[i]) {
+ regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
+ this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');
+ }
+ // test the regex
+ if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
+ return i;
+ } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
+ return i;
+ } else if (!strict && this._monthsParse[i].test(monthName)) {
+ return i;
+ }
+ }
+ }
- all functions that are routed have a property `.conversion` attached
- to the returned synthetic function. This property is an array
- of strings, each with the steps in between the 'from' and 'to'
- color models (inclusive).
+ // MOMENTS
- conversions that are not possible simply are not included.
-*/
+ function setMonth (mom, value) {
+ var dayOfMonth;
-function buildGraph() {
- var graph = {};
- // https://jsperf.com/object-keys-vs-for-in-with-closure/3
- var models = Object.keys(conversions);
+ if (!mom.isValid()) {
+ // No op
+ return mom;
+ }
- for (var len = models.length, i = 0; i < len; i++) {
- graph[models[i]] = {
- // http://jsperf.com/1-vs-infinity
- // micro-opt, but this is simple.
- distance: -1,
- parent: null
- };
- }
+ if (typeof value === 'string') {
+ if (/^\d+$/.test(value)) {
+ value = toInt(value);
+ } else {
+ value = mom.localeData().monthsParse(value);
+ // TODO: Another silent failure?
+ if (!isNumber(value)) {
+ return mom;
+ }
+ }
+ }
- return graph;
-}
+ dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
+ mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
+ return mom;
+ }
-// https://en.wikipedia.org/wiki/Breadth-first_search
-function deriveBFS(fromModel) {
- var graph = buildGraph();
- var queue = [fromModel]; // unshift -> queue -> pop
+ function getSetMonth (value) {
+ if (value != null) {
+ setMonth(this, value);
+ hooks.updateOffset(this, true);
+ return this;
+ } else {
+ return get(this, 'Month');
+ }
+ }
- graph[fromModel].distance = 0;
+ function getDaysInMonth () {
+ return daysInMonth(this.year(), this.month());
+ }
- while (queue.length) {
- var current = queue.pop();
- var adjacents = Object.keys(conversions[current]);
+ var defaultMonthsShortRegex = matchWord;
+ function monthsShortRegex (isStrict) {
+ if (this._monthsParseExact) {
+ if (!hasOwnProp(this, '_monthsRegex')) {
+ computeMonthsParse.call(this);
+ }
+ if (isStrict) {
+ return this._monthsShortStrictRegex;
+ } else {
+ return this._monthsShortRegex;
+ }
+ } else {
+ if (!hasOwnProp(this, '_monthsShortRegex')) {
+ this._monthsShortRegex = defaultMonthsShortRegex;
+ }
+ return this._monthsShortStrictRegex && isStrict ?
+ this._monthsShortStrictRegex : this._monthsShortRegex;
+ }
+ }
- for (var len = adjacents.length, i = 0; i < len; i++) {
- var adjacent = adjacents[i];
- var node = graph[adjacent];
+ var defaultMonthsRegex = matchWord;
+ function monthsRegex (isStrict) {
+ if (this._monthsParseExact) {
+ if (!hasOwnProp(this, '_monthsRegex')) {
+ computeMonthsParse.call(this);
+ }
+ if (isStrict) {
+ return this._monthsStrictRegex;
+ } else {
+ return this._monthsRegex;
+ }
+ } else {
+ if (!hasOwnProp(this, '_monthsRegex')) {
+ this._monthsRegex = defaultMonthsRegex;
+ }
+ return this._monthsStrictRegex && isStrict ?
+ this._monthsStrictRegex : this._monthsRegex;
+ }
+ }
- if (node.distance === -1) {
- node.distance = graph[current].distance + 1;
- node.parent = current;
- queue.unshift(adjacent);
- }
- }
- }
+ function computeMonthsParse () {
+ function cmpLenRev(a, b) {
+ return b.length - a.length;
+ }
- return graph;
-}
+ var shortPieces = [], longPieces = [], mixedPieces = [],
+ i, mom;
+ for (i = 0; i < 12; i++) {
+ // make the regex if we don't have it already
+ mom = createUTC([2000, i]);
+ shortPieces.push(this.monthsShort(mom, ''));
+ longPieces.push(this.months(mom, ''));
+ mixedPieces.push(this.months(mom, ''));
+ mixedPieces.push(this.monthsShort(mom, ''));
+ }
+ // Sorting makes sure if one month (or abbr) is a prefix of another it
+ // will match the longer piece.
+ shortPieces.sort(cmpLenRev);
+ longPieces.sort(cmpLenRev);
+ mixedPieces.sort(cmpLenRev);
+ for (i = 0; i < 12; i++) {
+ shortPieces[i] = regexEscape(shortPieces[i]);
+ longPieces[i] = regexEscape(longPieces[i]);
+ }
+ for (i = 0; i < 24; i++) {
+ mixedPieces[i] = regexEscape(mixedPieces[i]);
+ }
-function link(from, to) {
- return function (args) {
- return to(from(args));
- };
-}
+ this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+ this._monthsShortRegex = this._monthsRegex;
+ this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
+ this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
+ }
-function wrapConversion(toModel, graph) {
- var path = [graph[toModel].parent, toModel];
- var fn = conversions[graph[toModel].parent][toModel];
+ function createDate (y, m, d, h, M, s, ms) {
+ // can't just apply() to create a date:
+ // https://stackoverflow.com/q/181348
+ var date;
+ // the date constructor remaps years 0-99 to 1900-1999
+ if (y < 100 && y >= 0) {
+ // preserve leap years using a full 400 year cycle, then reset
+ date = new Date(y + 400, m, d, h, M, s, ms);
+ if (isFinite(date.getFullYear())) {
+ date.setFullYear(y);
+ }
+ } else {
+ date = new Date(y, m, d, h, M, s, ms);
+ }
- var cur = graph[toModel].parent;
- while (graph[cur].parent) {
- path.unshift(graph[cur].parent);
- fn = link(conversions[graph[cur].parent][cur], fn);
- cur = graph[cur].parent;
- }
-
- fn.conversion = path;
- return fn;
-}
-
-module.exports = function (fromModel) {
- var graph = deriveBFS(fromModel);
- var conversion = {};
-
- var models = Object.keys(graph);
- for (var len = models.length, i = 0; i < len; i++) {
- var toModel = models[i];
- var node = graph[toModel];
+ return date;
+ }
- if (node.parent === null) {
- // no possible conversion, or this node is the source model.
- continue;
- }
+ function createUTCDate (y) {
+ var date;
+ // the Date.UTC function remaps years 0-99 to 1900-1999
+ if (y < 100 && y >= 0) {
+ var args = Array.prototype.slice.call(arguments);
+ // preserve leap years using a full 400 year cycle, then reset
+ args[0] = y + 400;
+ date = new Date(Date.UTC.apply(null, args));
+ if (isFinite(date.getUTCFullYear())) {
+ date.setUTCFullYear(y);
+ }
+ } else {
+ date = new Date(Date.UTC.apply(null, arguments));
+ }
- conversion[toModel] = wrapConversion(toModel, graph);
- }
+ return date;
+ }
- return conversion;
-};
+ // start-of-first-week - start-of-year
+ function firstWeekOffset(year, dow, doy) {
+ var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
+ fwd = 7 + dow - doy,
+ // first-week day local weekday -- which local weekday is fwd
+ fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
+ return -fwdlw + fwd - 1;
+ }
+ // https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
+ function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
+ var localWeekday = (7 + weekday - dow) % 7,
+ weekOffset = firstWeekOffset(year, dow, doy),
+ dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,
+ resYear, resDayOfYear;
-/***/ }),
-/* 10 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (dayOfYear <= 0) {
+ resYear = year - 1;
+ resDayOfYear = daysInYear(resYear) + dayOfYear;
+ } else if (dayOfYear > daysInYear(year)) {
+ resYear = year + 1;
+ resDayOfYear = dayOfYear - daysInYear(year);
+ } else {
+ resYear = year;
+ resDayOfYear = dayOfYear;
+ }
-"use strict";
+ return {
+ year: resYear,
+ dayOfYear: resDayOfYear
+ };
+ }
-const os = __webpack_require__(11);
-const hasFlag = __webpack_require__(12);
+ function weekOfYear(mom, dow, doy) {
+ var weekOffset = firstWeekOffset(mom.year(), dow, doy),
+ week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,
+ resWeek, resYear;
-const env = process.env;
+ if (week < 1) {
+ resYear = mom.year() - 1;
+ resWeek = week + weeksInYear(resYear, dow, doy);
+ } else if (week > weeksInYear(mom.year(), dow, doy)) {
+ resWeek = week - weeksInYear(mom.year(), dow, doy);
+ resYear = mom.year() + 1;
+ } else {
+ resYear = mom.year();
+ resWeek = week;
+ }
-let forceColor;
-if (hasFlag('no-color') ||
- hasFlag('no-colors') ||
- hasFlag('color=false')) {
- forceColor = false;
-} else if (hasFlag('color') ||
- hasFlag('colors') ||
- hasFlag('color=true') ||
- hasFlag('color=always')) {
- forceColor = true;
-}
-if ('FORCE_COLOR' in env) {
- forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
-}
+ return {
+ week: resWeek,
+ year: resYear
+ };
+ }
-function translateLevel(level) {
- if (level === 0) {
- return false;
- }
+ function weeksInYear(year, dow, doy) {
+ var weekOffset = firstWeekOffset(year, dow, doy),
+ weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
+ return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
+ }
- return {
- level,
- hasBasic: true,
- has256: level >= 2,
- has16m: level >= 3
- };
-}
+ // FORMATTING
-function supportsColor(stream) {
- if (forceColor === false) {
- return 0;
- }
+ addFormatToken('w', ['ww', 2], 'wo', 'week');
+ addFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');
- if (hasFlag('color=16m') ||
- hasFlag('color=full') ||
- hasFlag('color=truecolor')) {
- return 3;
- }
+ // ALIASES
- if (hasFlag('color=256')) {
- return 2;
- }
+ addUnitAlias('week', 'w');
+ addUnitAlias('isoWeek', 'W');
- if (stream && !stream.isTTY && forceColor !== true) {
- // VS code debugger doesn't have isTTY set
- if (env.VSCODE_PID) {
- return 1;
- }
- return 0;
- }
+ // PRIORITIES
- const min = forceColor ? 1 : 0;
+ addUnitPriority('week', 5);
+ addUnitPriority('isoWeek', 5);
- if (process.platform === 'win32') {
- // Node.js 7.5.0 is the first version of Node.js to include a patch to
- // libuv that enables 256 color output on Windows. Anything earlier and it
- // won't work. However, here we target Node.js 8 at minimum as it is an LTS
- // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
- // release that supports 256 colors. Windows 10 build 14931 is the first release
- // that supports 16m/TrueColor.
- const osRelease = os.release().split('.');
- if (
- Number(process.versions.node.split('.')[0]) >= 8 &&
- Number(osRelease[0]) >= 10 &&
- Number(osRelease[2]) >= 10586
- ) {
- return Number(osRelease[2]) >= 14931 ? 3 : 2;
- }
+ // PARSING
- return 1;
- }
+ addRegexToken('w', match1to2);
+ addRegexToken('ww', match1to2, match2);
+ addRegexToken('W', match1to2);
+ addRegexToken('WW', match1to2, match2);
- if ('CI' in env) {
- if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
- return 1;
- }
+ addWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {
+ week[token.substr(0, 1)] = toInt(input);
+ });
- return min;
- }
+ // HELPERS
- if ('TEAMCITY_VERSION' in env) {
- return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
- }
+ // LOCALES
- if (env.COLORTERM === 'truecolor') {
- return 3;
- }
+ function localeWeek (mom) {
+ return weekOfYear(mom, this._week.dow, this._week.doy).week;
+ }
- if ('TERM_PROGRAM' in env) {
- const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+ var defaultLocaleWeek = {
+ dow : 0, // Sunday is the first day of the week.
+ doy : 6 // The week that contains Jan 6th is the first week of the year.
+ };
- switch (env.TERM_PROGRAM) {
- case 'iTerm.app':
- return version >= 3 ? 3 : 2;
- case 'Apple_Terminal':
- return 2;
- // No default
- }
- }
+ function localeFirstDayOfWeek () {
+ return this._week.dow;
+ }
- if (/-256(color)?$/i.test(env.TERM)) {
- return 2;
- }
+ function localeFirstDayOfYear () {
+ return this._week.doy;
+ }
- if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
- return 1;
- }
+ // MOMENTS
- if ('COLORTERM' in env) {
- return 1;
- }
+ function getSetWeek (input) {
+ var week = this.localeData().week(this);
+ return input == null ? week : this.add((input - week) * 7, 'd');
+ }
- if (env.TERM === 'dumb') {
- return min;
- }
+ function getSetISOWeek (input) {
+ var week = weekOfYear(this, 1, 4).week;
+ return input == null ? week : this.add((input - week) * 7, 'd');
+ }
- return min;
-}
+ // FORMATTING
-function getSupportLevel(stream) {
- const level = supportsColor(stream);
- return translateLevel(level);
-}
+ addFormatToken('d', 0, 'do', 'day');
-module.exports = {
- supportsColor: getSupportLevel,
- stdout: getSupportLevel(process.stdout),
- stderr: getSupportLevel(process.stderr)
-};
+ addFormatToken('dd', 0, 0, function (format) {
+ return this.localeData().weekdaysMin(this, format);
+ });
+ addFormatToken('ddd', 0, 0, function (format) {
+ return this.localeData().weekdaysShort(this, format);
+ });
-/***/ }),
-/* 11 */
-/***/ (function(module, exports) {
+ addFormatToken('dddd', 0, 0, function (format) {
+ return this.localeData().weekdays(this, format);
+ });
-module.exports = require("os");
+ addFormatToken('e', 0, 0, 'weekday');
+ addFormatToken('E', 0, 0, 'isoWeekday');
-/***/ }),
-/* 12 */
-/***/ (function(module, exports, __webpack_require__) {
+ // ALIASES
-"use strict";
+ addUnitAlias('day', 'd');
+ addUnitAlias('weekday', 'e');
+ addUnitAlias('isoWeekday', 'E');
-module.exports = (flag, argv) => {
- argv = argv || process.argv;
- const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
- const pos = argv.indexOf(prefix + flag);
- const terminatorPos = argv.indexOf('--');
- return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
-};
+ // PRIORITY
+ addUnitPriority('day', 11);
+ addUnitPriority('weekday', 11);
+ addUnitPriority('isoWeekday', 11);
+ // PARSING
-/***/ }),
-/* 13 */
-/***/ (function(module, exports, __webpack_require__) {
+ addRegexToken('d', match1to2);
+ addRegexToken('e', match1to2);
+ addRegexToken('E', match1to2);
+ addRegexToken('dd', function (isStrict, locale) {
+ return locale.weekdaysMinRegex(isStrict);
+ });
+ addRegexToken('ddd', function (isStrict, locale) {
+ return locale.weekdaysShortRegex(isStrict);
+ });
+ addRegexToken('dddd', function (isStrict, locale) {
+ return locale.weekdaysRegex(isStrict);
+ });
-"use strict";
+ addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {
+ var weekday = config._locale.weekdaysParse(input, token, config._strict);
+ // if we didn't get a weekday name, mark the date as invalid
+ if (weekday != null) {
+ week.d = weekday;
+ } else {
+ getParsingFlags(config).invalidWeekday = input;
+ }
+ });
-const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
-const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
-const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
-const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
+ addWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {
+ week[token] = toInt(input);
+ });
-const ESCAPES = new Map([
- ['n', '\n'],
- ['r', '\r'],
- ['t', '\t'],
- ['b', '\b'],
- ['f', '\f'],
- ['v', '\v'],
- ['0', '\0'],
- ['\\', '\\'],
- ['e', '\u001B'],
- ['a', '\u0007']
-]);
+ // HELPERS
-function unescape(c) {
- if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
- return String.fromCharCode(parseInt(c.slice(1), 16));
- }
+ function parseWeekday(input, locale) {
+ if (typeof input !== 'string') {
+ return input;
+ }
- return ESCAPES.get(c) || c;
-}
+ if (!isNaN(input)) {
+ return parseInt(input, 10);
+ }
-function parseArguments(name, args) {
- const results = [];
- const chunks = args.trim().split(/\s*,\s*/g);
- let matches;
+ input = locale.weekdaysParse(input);
+ if (typeof input === 'number') {
+ return input;
+ }
- for (const chunk of chunks) {
- if (!isNaN(chunk)) {
- results.push(Number(chunk));
- } else if ((matches = chunk.match(STRING_REGEX))) {
- results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
- } else {
- throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
- }
- }
+ return null;
+ }
- return results;
-}
+ function parseIsoWeekday(input, locale) {
+ if (typeof input === 'string') {
+ return locale.weekdaysParse(input) % 7 || 7;
+ }
+ return isNaN(input) ? null : input;
+ }
-function parseStyle(style) {
- STYLE_REGEX.lastIndex = 0;
+ // LOCALES
+ function shiftWeekdays (ws, n) {
+ return ws.slice(n, 7).concat(ws.slice(0, n));
+ }
- const results = [];
- let matches;
+ var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
+ function localeWeekdays (m, format) {
+ var weekdays = isArray(this._weekdays) ? this._weekdays :
+ this._weekdays[(m && m !== true && this._weekdays.isFormat.test(format)) ? 'format' : 'standalone'];
+ return (m === true) ? shiftWeekdays(weekdays, this._week.dow)
+ : (m) ? weekdays[m.day()] : weekdays;
+ }
- while ((matches = STYLE_REGEX.exec(style)) !== null) {
- const name = matches[1];
+ var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
+ function localeWeekdaysShort (m) {
+ return (m === true) ? shiftWeekdays(this._weekdaysShort, this._week.dow)
+ : (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;
+ }
- if (matches[2]) {
- const args = parseArguments(name, matches[2]);
- results.push([name].concat(args));
- } else {
- results.push([name]);
- }
- }
+ var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
+ function localeWeekdaysMin (m) {
+ return (m === true) ? shiftWeekdays(this._weekdaysMin, this._week.dow)
+ : (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;
+ }
- return results;
-}
+ function handleStrictParse$1(weekdayName, format, strict) {
+ var i, ii, mom, llc = weekdayName.toLocaleLowerCase();
+ if (!this._weekdaysParse) {
+ this._weekdaysParse = [];
+ this._shortWeekdaysParse = [];
+ this._minWeekdaysParse = [];
-function buildStyle(chalk, styles) {
- const enabled = {};
+ for (i = 0; i < 7; ++i) {
+ mom = createUTC([2000, 1]).day(i);
+ this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();
+ this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();
+ this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();
+ }
+ }
- for (const layer of styles) {
- for (const style of layer.styles) {
- enabled[style[0]] = layer.inverse ? null : style.slice(1);
- }
- }
+ if (strict) {
+ if (format === 'dddd') {
+ ii = indexOf.call(this._weekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ } else if (format === 'ddd') {
+ ii = indexOf.call(this._shortWeekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ } else {
+ ii = indexOf.call(this._minWeekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ }
+ } else {
+ if (format === 'dddd') {
+ ii = indexOf.call(this._weekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._shortWeekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._minWeekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ } else if (format === 'ddd') {
+ ii = indexOf.call(this._shortWeekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._weekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._minWeekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ } else {
+ ii = indexOf.call(this._minWeekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._weekdaysParse, llc);
+ if (ii !== -1) {
+ return ii;
+ }
+ ii = indexOf.call(this._shortWeekdaysParse, llc);
+ return ii !== -1 ? ii : null;
+ }
+ }
+ }
- let current = chalk;
- for (const styleName of Object.keys(enabled)) {
- if (Array.isArray(enabled[styleName])) {
- if (!(styleName in current)) {
- throw new Error(`Unknown Chalk style: ${styleName}`);
- }
+ function localeWeekdaysParse (weekdayName, format, strict) {
+ var i, mom, regex;
- if (enabled[styleName].length > 0) {
- current = current[styleName].apply(current, enabled[styleName]);
- } else {
- current = current[styleName];
- }
- }
- }
+ if (this._weekdaysParseExact) {
+ return handleStrictParse$1.call(this, weekdayName, format, strict);
+ }
- return current;
-}
+ if (!this._weekdaysParse) {
+ this._weekdaysParse = [];
+ this._minWeekdaysParse = [];
+ this._shortWeekdaysParse = [];
+ this._fullWeekdaysParse = [];
+ }
-module.exports = (chalk, tmp) => {
- const styles = [];
- const chunks = [];
- let chunk = [];
+ for (i = 0; i < 7; i++) {
+ // make the regex if we don't have it already
- // eslint-disable-next-line max-params
- tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
- if (escapeChar) {
- chunk.push(unescape(escapeChar));
- } else if (style) {
- const str = chunk.join('');
- chunk = [];
- chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
- styles.push({inverse, styles: parseStyle(style)});
- } else if (close) {
- if (styles.length === 0) {
- throw new Error('Found extraneous } in Chalk template literal');
- }
+ mom = createUTC([2000, 1]).day(i);
+ if (strict && !this._fullWeekdaysParse[i]) {
+ this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 'i');
+ this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 'i');
+ this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 'i');
+ }
+ if (!this._weekdaysParse[i]) {
+ regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
+ this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');
+ }
+ // test the regex
+ if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
+ return i;
+ } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
+ return i;
+ } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
+ return i;
+ } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
+ return i;
+ }
+ }
+ }
- chunks.push(buildStyle(chalk, styles)(chunk.join('')));
- chunk = [];
- styles.pop();
- } else {
- chunk.push(chr);
- }
- });
+ // MOMENTS
- chunks.push(chunk.join(''));
+ function getSetDayOfWeek (input) {
+ if (!this.isValid()) {
+ return input != null ? this : NaN;
+ }
+ var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
+ if (input != null) {
+ input = parseWeekday(input, this.localeData());
+ return this.add(input - day, 'd');
+ } else {
+ return day;
+ }
+ }
- if (styles.length > 0) {
- const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
- throw new Error(errMsg);
- }
+ function getSetLocaleDayOfWeek (input) {
+ if (!this.isValid()) {
+ return input != null ? this : NaN;
+ }
+ var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
+ return input == null ? weekday : this.add(input - weekday, 'd');
+ }
- return chunks.join('');
-};
+ function getSetISODayOfWeek (input) {
+ if (!this.isValid()) {
+ return input != null ? this : NaN;
+ }
+ // behaves the same as moment#day except
+ // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
+ // as a setter, sunday should belong to the previous week.
-/***/ }),
-/* 14 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (input != null) {
+ var weekday = parseIsoWeekday(input, this.localeData());
+ return this.day(this.day() % 7 ? weekday : weekday - 7);
+ } else {
+ return this.day() || 7;
+ }
+ }
-"use strict";
+ var defaultWeekdaysRegex = matchWord;
+ function weekdaysRegex (isStrict) {
+ if (this._weekdaysParseExact) {
+ if (!hasOwnProp(this, '_weekdaysRegex')) {
+ computeWeekdaysParse.call(this);
+ }
+ if (isStrict) {
+ return this._weekdaysStrictRegex;
+ } else {
+ return this._weekdaysRegex;
+ }
+ } else {
+ if (!hasOwnProp(this, '_weekdaysRegex')) {
+ this._weekdaysRegex = defaultWeekdaysRegex;
+ }
+ return this._weekdaysStrictRegex && isStrict ?
+ this._weekdaysStrictRegex : this._weekdaysRegex;
+ }
+ }
+ var defaultWeekdaysShortRegex = matchWord;
+ function weekdaysShortRegex (isStrict) {
+ if (this._weekdaysParseExact) {
+ if (!hasOwnProp(this, '_weekdaysRegex')) {
+ computeWeekdaysParse.call(this);
+ }
+ if (isStrict) {
+ return this._weekdaysShortStrictRegex;
+ } else {
+ return this._weekdaysShortRegex;
+ }
+ } else {
+ if (!hasOwnProp(this, '_weekdaysShortRegex')) {
+ this._weekdaysShortRegex = defaultWeekdaysShortRegex;
+ }
+ return this._weekdaysShortStrictRegex && isStrict ?
+ this._weekdaysShortStrictRegex : this._weekdaysShortRegex;
+ }
+ }
-function dedent(strings) {
+ var defaultWeekdaysMinRegex = matchWord;
+ function weekdaysMinRegex (isStrict) {
+ if (this._weekdaysParseExact) {
+ if (!hasOwnProp(this, '_weekdaysRegex')) {
+ computeWeekdaysParse.call(this);
+ }
+ if (isStrict) {
+ return this._weekdaysMinStrictRegex;
+ } else {
+ return this._weekdaysMinRegex;
+ }
+ } else {
+ if (!hasOwnProp(this, '_weekdaysMinRegex')) {
+ this._weekdaysMinRegex = defaultWeekdaysMinRegex;
+ }
+ return this._weekdaysMinStrictRegex && isStrict ?
+ this._weekdaysMinStrictRegex : this._weekdaysMinRegex;
+ }
+ }
- var raw = void 0;
- if (typeof strings === "string") {
- // dedent can be used as a plain function
- raw = [strings];
- } else {
- raw = strings.raw;
- }
- // first, perform interpolation
- var result = "";
- for (var i = 0; i < raw.length; i++) {
- result += raw[i].
- // join lines when there is a suppressed newline
- replace(/\\\n[ \t]*/g, "").
+ function computeWeekdaysParse () {
+ function cmpLenRev(a, b) {
+ return b.length - a.length;
+ }
- // handle escaped backticks
- replace(/\\`/g, "`");
+ var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],
+ i, mom, minp, shortp, longp;
+ for (i = 0; i < 7; i++) {
+ // make the regex if we don't have it already
+ mom = createUTC([2000, 1]).day(i);
+ minp = this.weekdaysMin(mom, '');
+ shortp = this.weekdaysShort(mom, '');
+ longp = this.weekdays(mom, '');
+ minPieces.push(minp);
+ shortPieces.push(shortp);
+ longPieces.push(longp);
+ mixedPieces.push(minp);
+ mixedPieces.push(shortp);
+ mixedPieces.push(longp);
+ }
+ // Sorting makes sure if one weekday (or abbr) is a prefix of another it
+ // will match the longer piece.
+ minPieces.sort(cmpLenRev);
+ shortPieces.sort(cmpLenRev);
+ longPieces.sort(cmpLenRev);
+ mixedPieces.sort(cmpLenRev);
+ for (i = 0; i < 7; i++) {
+ shortPieces[i] = regexEscape(shortPieces[i]);
+ longPieces[i] = regexEscape(longPieces[i]);
+ mixedPieces[i] = regexEscape(mixedPieces[i]);
+ }
- if (i < (arguments.length <= 1 ? 0 : arguments.length - 1)) {
- result += arguments.length <= i + 1 ? undefined : arguments[i + 1];
- }
- }
+ this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+ this._weekdaysShortRegex = this._weekdaysRegex;
+ this._weekdaysMinRegex = this._weekdaysRegex;
- // now strip indentation
- var lines = result.split("\n");
- var mindent = null;
- lines.forEach(function (l) {
- var m = l.match(/^(\s+)\S+/);
- if (m) {
- var indent = m[1].length;
- if (!mindent) {
- // this is the first indented line
- mindent = indent;
- } else {
- mindent = Math.min(mindent, indent);
- }
+ this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
+ this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
+ this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');
}
- });
- if (mindent !== null) {
- result = lines.map(function (l) {
- return l[0] === " " ? l.slice(mindent) : l;
- }).join("\n");
- }
+ // FORMATTING
- // dedent eats leading and trailing whitespace too
- result = result.trim();
+ function hFormat() {
+ return this.hours() % 12 || 12;
+ }
- // handle escaped newlines at the end to ensure they don't get stripped too
- return result.replace(/\\n/g, "\n");
-}
+ function kFormat() {
+ return this.hours() || 24;
+ }
-if (true) {
- module.exports = dedent;
-}
+ addFormatToken('H', ['HH', 2], 0, 'hour');
+ addFormatToken('h', ['hh', 2], 0, hFormat);
+ addFormatToken('k', ['kk', 2], 0, kFormat);
+ addFormatToken('hmm', 0, 0, function () {
+ return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
+ });
-/***/ }),
-/* 15 */
-/***/ (function(module, exports, __webpack_require__) {
+ addFormatToken('hmmss', 0, 0, function () {
+ return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
+ zeroFill(this.seconds(), 2);
+ });
-"use strict";
+ addFormatToken('Hmm', 0, 0, function () {
+ return '' + this.hours() + zeroFill(this.minutes(), 2);
+ });
+ addFormatToken('Hmmss', 0, 0, function () {
+ return '' + this.hours() + zeroFill(this.minutes(), 2) +
+ zeroFill(this.seconds(), 2);
+ });
-const EMPTYARR = []
-const SHORTSPLIT = /$|[!-@[-`{-~][\s\S]*/g
-const isArray = Array.isArray
+ function meridiem (token, lowercase) {
+ addFormatToken(token, 0, 0, function () {
+ return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);
+ });
+ }
-const parseValue = function(any) {
- if (any === "") return ""
- if (any === "false") return false
- const maybe = Number(any)
- return maybe * 0 === 0 ? maybe : any
-}
+ meridiem('a', true);
+ meridiem('A', false);
-const parseAlias = function(aliases) {
- let out = {},
- key,
- alias,
- prev,
- len,
- any,
- i,
- k
+ // ALIASES
- for (key in aliases) {
- any = aliases[key]
- alias = out[key] = isArray(any) ? any : [any]
+ addUnitAlias('hour', 'h');
- for (i = 0, len = alias.length; i < len; i++) {
- prev = out[alias[i]] = [key]
+ // PRIORITY
+ addUnitPriority('hour', 13);
- for (k = 0; k < len; k++) {
- if (i !== k) prev.push(alias[k])
- }
+ // PARSING
+
+ function matchMeridiem (isStrict, locale) {
+ return locale._meridiemParse;
}
- }
- return out
-}
+ addRegexToken('a', matchMeridiem);
+ addRegexToken('A', matchMeridiem);
+ addRegexToken('H', match1to2);
+ addRegexToken('h', match1to2);
+ addRegexToken('k', match1to2);
+ addRegexToken('HH', match1to2, match2);
+ addRegexToken('hh', match1to2, match2);
+ addRegexToken('kk', match1to2, match2);
-const parseDefault = function(aliases, defaults) {
- let out = {},
- key,
- alias,
- value,
- len,
- i
+ addRegexToken('hmm', match3to4);
+ addRegexToken('hmmss', match5to6);
+ addRegexToken('Hmm', match3to4);
+ addRegexToken('Hmmss', match5to6);
- for (key in defaults) {
- value = defaults[key]
- alias = aliases[key]
+ addParseToken(['H', 'HH'], HOUR);
+ addParseToken(['k', 'kk'], function (input, array, config) {
+ var kInput = toInt(input);
+ array[HOUR] = kInput === 24 ? 0 : kInput;
+ });
+ addParseToken(['a', 'A'], function (input, array, config) {
+ config._isPm = config._locale.isPM(input);
+ config._meridiem = input;
+ });
+ addParseToken(['h', 'hh'], function (input, array, config) {
+ array[HOUR] = toInt(input);
+ getParsingFlags(config).bigHour = true;
+ });
+ addParseToken('hmm', function (input, array, config) {
+ var pos = input.length - 2;
+ array[HOUR] = toInt(input.substr(0, pos));
+ array[MINUTE] = toInt(input.substr(pos));
+ getParsingFlags(config).bigHour = true;
+ });
+ addParseToken('hmmss', function (input, array, config) {
+ var pos1 = input.length - 4;
+ var pos2 = input.length - 2;
+ array[HOUR] = toInt(input.substr(0, pos1));
+ array[MINUTE] = toInt(input.substr(pos1, 2));
+ array[SECOND] = toInt(input.substr(pos2));
+ getParsingFlags(config).bigHour = true;
+ });
+ addParseToken('Hmm', function (input, array, config) {
+ var pos = input.length - 2;
+ array[HOUR] = toInt(input.substr(0, pos));
+ array[MINUTE] = toInt(input.substr(pos));
+ });
+ addParseToken('Hmmss', function (input, array, config) {
+ var pos1 = input.length - 4;
+ var pos2 = input.length - 2;
+ array[HOUR] = toInt(input.substr(0, pos1));
+ array[MINUTE] = toInt(input.substr(pos1, 2));
+ array[SECOND] = toInt(input.substr(pos2));
+ });
- out[key] = value
+ // LOCALES
- if (alias === undefined) {
- aliases[key] = EMPTYARR
- } else {
- for (i = 0, len = alias.length; i < len; i++) {
- out[alias[i]] = value
- }
+ function localeIsPM (input) {
+ // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
+ // Using charAt should be more compatible.
+ return ((input + '').toLowerCase().charAt(0) === 'p');
}
- }
- return out
-}
+ var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
+ function localeMeridiem (hours, minutes, isLower) {
+ if (hours > 11) {
+ return isLower ? 'pm' : 'PM';
+ } else {
+ return isLower ? 'am' : 'AM';
+ }
+ }
-const parseOptions = function(aliases, options, value) {
- let out = {},
- key,
- alias,
- len,
- end,
- i,
- k
- if (options !== undefined) {
- for (i = 0, len = options.length; i < len; i++) {
- key = options[i]
- alias = aliases[key]
+ // MOMENTS
- out[key] = value
+ // Setting the hour should keep the time, because the user explicitly
+ // specified which hour they want. So trying to maintain the same hour (in
+ // a new timezone) makes sense. Adding/subtracting hours does not follow
+ // this rule.
+ var getSetHour = makeGetSet('Hours', true);
- if (alias === undefined) {
- aliases[key] = EMPTYARR
- } else {
- for (k = 0, end = alias.length; k < end; k++) {
- out[alias[k]] = value
- }
- }
- }
- }
+ var baseConfig = {
+ calendar: defaultCalendar,
+ longDateFormat: defaultLongDateFormat,
+ invalidDate: defaultInvalidDate,
+ ordinal: defaultOrdinal,
+ dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
+ relativeTime: defaultRelativeTime,
- return out
-}
+ months: defaultLocaleMonths,
+ monthsShort: defaultLocaleMonthsShort,
-const write = function(out, key, value, aliases, unknown) {
- let i,
- prev,
- alias = aliases[key],
- len = alias === undefined ? -1 : alias.length
+ week: defaultLocaleWeek,
- if (len >= 0 || unknown === undefined || unknown(key)) {
- prev = out[key]
+ weekdays: defaultLocaleWeekdays,
+ weekdaysMin: defaultLocaleWeekdaysMin,
+ weekdaysShort: defaultLocaleWeekdaysShort,
- if (prev === undefined) {
- out[key] = value
- } else {
- if (isArray(prev)) {
- prev.push(value)
- } else {
- out[key] = [prev, value]
- }
- }
+ meridiemParse: defaultLocaleMeridiemParse
+ };
- for (i = 0; i < len; i++) {
- out[alias[i]] = out[key]
+ // internal storage for locale config files
+ var locales = {};
+ var localeFamilies = {};
+ var globalLocale;
+
+ function normalizeLocale(key) {
+ return key ? key.toLowerCase().replace('_', '-') : key;
}
- }
-}
-const getopts = function(argv, opts) {
- let unknown = (opts = opts || {}).unknown,
- aliases = parseAlias(opts.alias),
- strings = parseOptions(aliases, opts.string, ""),
- values = parseDefault(aliases, opts.default),
- bools = parseOptions(aliases, opts.boolean, false),
- stopEarly = opts.stopEarly,
- _ = [],
- out = { _ },
- i = 0,
- k = 0,
- len = argv.length,
- key,
- arg,
- end,
- match,
- value
+ // pick the locale from the array
+ // try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
+ // substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
+ function chooseLocale(names) {
+ var i = 0, j, next, locale, split;
- for (; i < len; i++) {
- arg = argv[i]
+ while (i < names.length) {
+ split = normalizeLocale(names[i]).split('-');
+ j = split.length;
+ next = normalizeLocale(names[i + 1]);
+ next = next ? next.split('-') : null;
+ while (j > 0) {
+ locale = loadLocale(split.slice(0, j).join('-'));
+ if (locale) {
+ return locale;
+ }
+ if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
+ //the next array item is better than a shallower substring of this one
+ break;
+ }
+ j--;
+ }
+ i++;
+ }
+ return globalLocale;
+ }
- if (arg[0] !== "-" || arg === "-") {
- if (stopEarly) while (i < len) _.push(argv[i++])
- else _.push(arg)
- } else if (arg === "--") {
- while (++i < len) _.push(argv[i])
- } else if (arg[1] === "-") {
- end = arg.indexOf("=", 2)
- if (arg[2] === "n" && arg[3] === "o" && arg[4] === "-") {
- key = arg.slice(5, end >= 0 ? end : undefined)
- value = false
- } else if (end >= 0) {
- key = arg.slice(2, end)
- value =
- bools[key] !== undefined ||
- (strings[key] === undefined
- ? parseValue(arg.slice(end + 1))
- : arg.slice(end + 1))
- } else {
- key = arg.slice(2)
- value =
- bools[key] !== undefined ||
- (len === i + 1 || argv[i + 1][0] === "-"
- ? strings[key] === undefined
- ? true
- : ""
- : strings[key] === undefined
- ? parseValue(argv[++i])
- : argv[++i])
- }
- write(out, key, value, aliases, unknown)
- } else {
- SHORTSPLIT.lastIndex = 2
- match = SHORTSPLIT.exec(arg)
- end = match.index
- value = match[0]
-
- for (k = 1; k < end; k++) {
- write(
- out,
- (key = arg[k]),
- k + 1 < end
- ? strings[key] === undefined ||
- arg.substring(k + 1, (k = end)) + value
- : value === ""
- ? len === i + 1 || argv[i + 1][0] === "-"
- ? strings[key] === undefined || ""
- : bools[key] !== undefined ||
- (strings[key] === undefined ? parseValue(argv[++i]) : argv[++i])
- : bools[key] !== undefined ||
- (strings[key] === undefined ? parseValue(value) : value),
- aliases,
- unknown
- )
- }
+ function loadLocale(name) {
+ var oldLocale = null;
+ // TODO: Find a better way to register and load all the locales in Node
+ if (!locales[name] && (typeof module !== 'undefined') &&
+ module && module.exports) {
+ try {
+ oldLocale = globalLocale._abbr;
+ var aliasedRequire = require;
+ __webpack_require__(12)("./" + name);
+ getSetGlobalLocale(oldLocale);
+ } catch (e) {}
+ }
+ return locales[name];
}
- }
-
- for (key in values) if (out[key] === undefined) out[key] = values[key]
- for (key in bools) if (out[key] === undefined) out[key] = false
- for (key in strings) if (out[key] === undefined) out[key] = ""
- return out
-}
+ // This function will load locale and then set the global locale. If
+ // no arguments are passed in, it will simply return the current global
+ // locale key.
+ function getSetGlobalLocale (key, values) {
+ var data;
+ if (key) {
+ if (isUndefined(values)) {
+ data = getLocale(key);
+ }
+ else {
+ data = defineLocale(key, values);
+ }
-module.exports = getopts
+ if (data) {
+ // moment.duration._locale = moment._locale = data;
+ globalLocale = data;
+ }
+ else {
+ if ((typeof console !== 'undefined') && console.warn) {
+ //warn user if arguments are passed but the locale could not be set
+ console.warn('Locale ' + key + ' not found. Did you forget to load it?');
+ }
+ }
+ }
+ return globalLocale._abbr;
+ }
-/***/ }),
-/* 16 */
-/***/ (function(module, exports) {
+ function defineLocale (name, config) {
+ if (config !== null) {
+ var locale, parentConfig = baseConfig;
+ config.abbr = name;
+ if (locales[name] != null) {
+ deprecateSimple('defineLocaleOverride',
+ 'use moment.updateLocale(localeName, config) to change ' +
+ 'an existing locale. moment.defineLocale(localeName, ' +
+ 'config) should only be used for creating a new locale ' +
+ 'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');
+ parentConfig = locales[name]._config;
+ } else if (config.parentLocale != null) {
+ if (locales[config.parentLocale] != null) {
+ parentConfig = locales[config.parentLocale]._config;
+ } else {
+ locale = loadLocale(config.parentLocale);
+ if (locale != null) {
+ parentConfig = locale._config;
+ } else {
+ if (!localeFamilies[config.parentLocale]) {
+ localeFamilies[config.parentLocale] = [];
+ }
+ localeFamilies[config.parentLocale].push({
+ name: name,
+ config: config
+ });
+ return null;
+ }
+ }
+ }
+ locales[name] = new Locale(mergeConfigs(parentConfig, config));
-module.exports = require("path");
+ if (localeFamilies[name]) {
+ localeFamilies[name].forEach(function (x) {
+ defineLocale(x.name, x.config);
+ });
+ }
-/***/ }),
-/* 17 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ // backwards compat for now: also set the locale
+ // make sure we set the locale AFTER all child locales have been
+ // created, so we won't end up with the child locale set.
+ getSetGlobalLocale(name);
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "commands", function() { return commands; });
-/* harmony import */ var _bootstrap__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(18);
-/* harmony import */ var _clean__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(586);
-/* harmony import */ var _run__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(686);
-/* harmony import */ var _watch__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(687);
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
+ return locales[name];
+ } else {
+ // useful for testing
+ delete locales[name];
+ return null;
+ }
+ }
+ function updateLocale(name, config) {
+ if (config != null) {
+ var locale, tmpLocale, parentConfig = baseConfig;
+ // MERGE
+ tmpLocale = loadLocale(name);
+ if (tmpLocale != null) {
+ parentConfig = tmpLocale._config;
+ }
+ config = mergeConfigs(parentConfig, config);
+ locale = new Locale(config);
+ locale.parentLocale = locales[name];
+ locales[name] = locale;
+ // backwards compat for now: also set the locale
+ getSetGlobalLocale(name);
+ } else {
+ // pass null for config to unupdate, useful for tests
+ if (locales[name] != null) {
+ if (locales[name].parentLocale != null) {
+ locales[name] = locales[name].parentLocale;
+ } else if (locales[name] != null) {
+ delete locales[name];
+ }
+ }
+ }
+ return locales[name];
+ }
-const commands = {
- bootstrap: _bootstrap__WEBPACK_IMPORTED_MODULE_0__["BootstrapCommand"],
- clean: _clean__WEBPACK_IMPORTED_MODULE_1__["CleanCommand"],
- run: _run__WEBPACK_IMPORTED_MODULE_2__["RunCommand"],
- watch: _watch__WEBPACK_IMPORTED_MODULE_3__["WatchCommand"]
-};
+ // returns locale data
+ function getLocale (key) {
+ var locale;
-/***/ }),
-/* 18 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ if (key && key._locale && key._locale._abbr) {
+ key = key._locale._abbr;
+ }
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BootstrapCommand", function() { return BootstrapCommand; });
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _utils_link_project_executables__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(19);
-/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(34);
-/* harmony import */ var _utils_parallelize__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(501);
-/* harmony import */ var _utils_projects__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(502);
-/* harmony import */ var _utils_project_checksums__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(580);
-/* harmony import */ var _utils_bootstrap_cache_file__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(585);
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
+ if (!key) {
+ return globalLocale;
+ }
+ if (!isArray(key)) {
+ //short-circuit everything else
+ locale = loadLocale(key);
+ if (locale) {
+ return locale;
+ }
+ key = [key];
+ }
+ return chooseLocale(key);
+ }
+ function listLocales() {
+ return keys(locales);
+ }
+ function checkOverflow (m) {
+ var overflow;
+ var a = m._a;
+ if (a && getParsingFlags(m).overflow === -2) {
+ overflow =
+ a[MONTH] < 0 || a[MONTH] > 11 ? MONTH :
+ a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
+ a[HOUR] < 0 || a[HOUR] > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
+ a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE :
+ a[SECOND] < 0 || a[SECOND] > 59 ? SECOND :
+ a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
+ -1;
+ if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
+ overflow = DATE;
+ }
+ if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
+ overflow = WEEK;
+ }
+ if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
+ overflow = WEEKDAY;
+ }
-const BootstrapCommand = {
- description: 'Install dependencies and crosslink projects',
- name: 'bootstrap',
+ getParsingFlags(m).overflow = overflow;
+ }
- async run(projects, projectGraph, {
- options,
- kbn
- }) {
- const batchedProjectsByWorkspace = Object(_utils_projects__WEBPACK_IMPORTED_MODULE_4__["topologicallyBatchProjects"])(projects, projectGraph, {
- batchByWorkspace: true
- });
- const batchedProjects = Object(_utils_projects__WEBPACK_IMPORTED_MODULE_4__["topologicallyBatchProjects"])(projects, projectGraph);
- const extraArgs = [...(options['frozen-lockfile'] === true ? ['--frozen-lockfile'] : []), ...(options['prefer-offline'] === true ? ['--prefer-offline'] : [])];
- _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold('\nRunning installs in topological order:'));
+ return m;
+ }
- for (const batch of batchedProjectsByWorkspace) {
- for (const project of batch) {
- if (project.isWorkspaceProject) {
- _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].write(`Skipping workspace project: ${project.name}`);
- continue;
+ // Pick the first defined of two or three arguments.
+ function defaults(a, b, c) {
+ if (a != null) {
+ return a;
}
-
- if (project.hasDependencies()) {
- await project.installDependencies({
- extraArgs
- });
+ if (b != null) {
+ return b;
}
- }
+ return c;
}
- _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold('\nInstalls completed, linking package executables:\n'));
- await Object(_utils_link_project_executables__WEBPACK_IMPORTED_MODULE_1__["linkProjectExecutables"])(projects, projectGraph);
- /**
- * At the end of the bootstrapping process we call all `kbn:bootstrap` scripts
- * in the list of projects. We do this because some projects need to be
- * transpiled before they can be used. Ideally we shouldn't do this unless we
- * have to, as it will slow down the bootstrapping process.
- */
+ function currentDateArray(config) {
+ // hooks is actually the exported moment object
+ var nowValue = new Date(hooks.now());
+ if (config._useUTC) {
+ return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];
+ }
+ return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];
+ }
- _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold('\nLinking executables completed, running `kbn:bootstrap` scripts\n'));
- const checksums = options.cache ? await Object(_utils_project_checksums__WEBPACK_IMPORTED_MODULE_5__["getAllChecksums"])(kbn, _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"]) : false;
- await Object(_utils_parallelize__WEBPACK_IMPORTED_MODULE_3__["parallelizeBatches"])(batchedProjects, async project => {
- if (project.hasScript('kbn:bootstrap')) {
- const cacheFile = new _utils_bootstrap_cache_file__WEBPACK_IMPORTED_MODULE_6__["BootstrapCacheFile"](kbn, project, checksums);
+ // convert an array to a date.
+ // the array should mirror the parameters below
+ // note: all values past the year are optional and will default to the lowest possible value.
+ // [year, month, day , hour, minute, second, millisecond]
+ function configFromArray (config) {
+ var i, date, input = [], currentDate, expectedWeekday, yearToUse;
- if (cacheFile.isValid()) {
- _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].success(`[${project.name}] cache up to date`);
- } else {
- cacheFile.delete();
- await project.runScriptStreaming('kbn:bootstrap');
- cacheFile.write();
+ if (config._d) {
+ return;
}
- }
- });
- _utils_log__WEBPACK_IMPORTED_MODULE_2__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.green.bold('\nBootstrapping completed!\n'));
- }
-};
-
-/***/ }),
-/* 19 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ currentDate = currentDateArray(config);
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "linkProjectExecutables", function() { return linkProjectExecutables; });
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(16);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var _fs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(20);
-/* harmony import */ var _log__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(34);
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
+ //compute day of the year from weeks and weekdays
+ if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
+ dayOfYearFromWeekInfo(config);
+ }
+ //if the day of the year is set, figure out what it is
+ if (config._dayOfYear != null) {
+ yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
+ if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
+ getParsingFlags(config)._overflowDayOfYear = true;
+ }
+ date = createUTCDate(yearToUse, 0, config._dayOfYear);
+ config._a[MONTH] = date.getUTCMonth();
+ config._a[DATE] = date.getUTCDate();
+ }
+ // Default to current date.
+ // * if no year, month, day of month are given, default to today
+ // * if day of month is given, default month and year
+ // * if month is given, default only year
+ // * if year is given, don't default anything
+ for (i = 0; i < 3 && config._a[i] == null; ++i) {
+ config._a[i] = input[i] = currentDate[i];
+ }
-/**
- * Yarn does not link the executables from dependencies that are installed
- * using `link:` https://github.com/yarnpkg/yarn/pull/5046
- *
- * We simulate this functionality by walking through each project's project
- * dependencies, and manually linking their executables if defined. The logic
- * for linking was mostly adapted from lerna: https://github.com/lerna/lerna/blob/1d7eb9eeff65d5a7de64dea73613b1bf6bfa8d57/src/PackageUtilities.js#L348
- */
-async function linkProjectExecutables(projectsByName, projectGraph) {
- for (const [projectName, projectDeps] of projectGraph) {
- const project = projectsByName.get(projectName);
- const binsDir = Object(path__WEBPACK_IMPORTED_MODULE_0__["resolve"])(project.nodeModulesLocation, '.bin');
+ // Zero out whatever was not defaulted, including time
+ for (; i < 7; i++) {
+ config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
+ }
- for (const projectDep of projectDeps) {
- const executables = projectDep.getExecutables();
+ // Check for 24:00:00.000
+ if (config._a[HOUR] === 24 &&
+ config._a[MINUTE] === 0 &&
+ config._a[SECOND] === 0 &&
+ config._a[MILLISECOND] === 0) {
+ config._nextDay = true;
+ config._a[HOUR] = 0;
+ }
- for (const name of Object.keys(executables)) {
- const srcPath = executables[name]; // existing logic from lerna -- ensure that the bin we are going to
- // point to exists or ignore it
+ config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
+ expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
- if (!(await Object(_fs__WEBPACK_IMPORTED_MODULE_2__["isFile"])(srcPath))) {
- continue;
+ // Apply timezone offset from input. The actual utcOffset can be changed
+ // with parseZone.
+ if (config._tzm != null) {
+ config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
}
- const dest = Object(path__WEBPACK_IMPORTED_MODULE_0__["resolve"])(binsDir, name); // Get relative project path with normalized path separators.
+ if (config._nextDay) {
+ config._a[HOUR] = 24;
+ }
- const projectRelativePath = Object(path__WEBPACK_IMPORTED_MODULE_0__["relative"])(project.path, srcPath).split(path__WEBPACK_IMPORTED_MODULE_0__["sep"]).join('/');
- _log__WEBPACK_IMPORTED_MODULE_3__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_1___default.a`{dim [${project.name}]} ${name} -> {dim ${projectRelativePath}}`);
- await Object(_fs__WEBPACK_IMPORTED_MODULE_2__["mkdirp"])(Object(path__WEBPACK_IMPORTED_MODULE_0__["dirname"])(dest));
- await Object(_fs__WEBPACK_IMPORTED_MODULE_2__["createSymlink"])(srcPath, dest, 'exec');
- await Object(_fs__WEBPACK_IMPORTED_MODULE_2__["chmod"])(dest, '755');
- }
+ // check for mismatching day of week
+ if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {
+ getParsingFlags(config).weekdayMismatch = true;
+ }
}
- }
-}
-
-/***/ }),
-/* 20 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "readFile", function() { return readFile; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chmod", function() { return chmod; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mkdirp", function() { return mkdirp; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "unlink", function() { return unlink; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copyDirectory", function() { return copyDirectory; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isSymlink", function() { return isSymlink; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isDirectory", function() { return isDirectory; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isFile", function() { return isFile; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createSymlink", function() { return createSymlink; });
-/* harmony import */ var cmd_shim__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(21);
-/* harmony import */ var cmd_shim__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(cmd_shim__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(23);
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var ncp__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(33);
-/* harmony import */ var ncp__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(ncp__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(16);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(29);
-/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(util__WEBPACK_IMPORTED_MODULE_4__);
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-
-
+ function dayOfYearFromWeekInfo(config) {
+ var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
-const lstat = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.lstat);
-const readFile = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.readFile);
-const symlink = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.symlink);
-const chmod = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.chmod);
-const cmdShim = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(cmd_shim__WEBPACK_IMPORTED_MODULE_0___default.a);
-const mkdir = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.mkdir);
-const mkdirp = async path => await mkdir(path, {
- recursive: true
-});
-const unlink = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.unlink);
-const copyDirectory = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(ncp__WEBPACK_IMPORTED_MODULE_2__["ncp"]);
+ w = config._w;
+ if (w.GG != null || w.W != null || w.E != null) {
+ dow = 1;
+ doy = 4;
-async function statTest(path, block) {
- try {
- return block((await lstat(path)));
- } catch (e) {
- if (e.code === 'ENOENT') {
- return false;
- }
+ // TODO: We need to take the current isoWeekYear, but that depends on
+ // how we interpret now (local, utc, fixed offset). So create
+ // a now version of current config (take local/utc/offset flags, and
+ // create now).
+ weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
+ week = defaults(w.W, 1);
+ weekday = defaults(w.E, 1);
+ if (weekday < 1 || weekday > 7) {
+ weekdayOverflow = true;
+ }
+ } else {
+ dow = config._locale._week.dow;
+ doy = config._locale._week.doy;
- throw e;
- }
-}
-/**
- * Test if a path points to a symlink.
- * @param path
- */
+ var curWeek = weekOfYear(createLocal(), dow, doy);
+ weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);
-async function isSymlink(path) {
- return await statTest(path, stats => stats.isSymbolicLink());
-}
-/**
- * Test if a path points to a directory.
- * @param path
- */
+ // Default to current week.
+ week = defaults(w.w, curWeek.week);
-async function isDirectory(path) {
- return await statTest(path, stats => stats.isDirectory());
-}
-/**
- * Test if a path points to a regular file.
- * @param path
- */
-
-async function isFile(path) {
- return await statTest(path, stats => stats.isFile());
-}
-/**
- * Create a symlink at dest that points to src. Adapted from
- * https://github.com/lerna/lerna/blob/2f1b87d9e2295f587e4ac74269f714271d8ed428/src/FileSystemUtilities.js#L103.
- *
- * @param src
- * @param dest
- * @param type 'dir', 'file', 'junction', or 'exec'. 'exec' on
- * windows will use the `cmd-shim` module since symlinks can't be used
- * for executable files on windows.
- */
-
-async function createSymlink(src, dest, type) {
- if (process.platform === 'win32') {
- if (type === 'exec') {
- await cmdShim(src, dest);
- } else {
- await forceCreate(src, dest, type);
+ if (w.d != null) {
+ // weekday -- low day numbers are considered next week
+ weekday = w.d;
+ if (weekday < 0 || weekday > 6) {
+ weekdayOverflow = true;
+ }
+ } else if (w.e != null) {
+ // local weekday -- counting starts from beginning of week
+ weekday = w.e + dow;
+ if (w.e < 0 || w.e > 6) {
+ weekdayOverflow = true;
+ }
+ } else {
+ // default to beginning of week
+ weekday = dow;
+ }
+ }
+ if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
+ getParsingFlags(config)._overflowWeeks = true;
+ } else if (weekdayOverflow != null) {
+ getParsingFlags(config)._overflowWeekday = true;
+ } else {
+ temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
+ config._a[YEAR] = temp.year;
+ config._dayOfYear = temp.dayOfYear;
+ }
}
- } else {
- const posixType = type === 'exec' ? 'file' : type;
- const relativeSource = Object(path__WEBPACK_IMPORTED_MODULE_3__["relative"])(Object(path__WEBPACK_IMPORTED_MODULE_3__["dirname"])(dest), src);
- await forceCreate(relativeSource, dest, posixType);
- }
-}
-async function forceCreate(src, dest, type) {
- try {
- // If something exists at `dest` we need to remove it first.
- await unlink(dest);
- } catch (error) {
- if (error.code !== 'ENOENT') {
- throw error;
- }
- }
+ // iso 8601 regex
+ // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
+ var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
+ var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
- await symlink(src, dest, type);
-}
+ var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
-/***/ }),
-/* 21 */
-/***/ (function(module, exports, __webpack_require__) {
+ var isoDates = [
+ ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/],
+ ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/],
+ ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/],
+ ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
+ ['YYYY-DDD', /\d{4}-\d{3}/],
+ ['YYYY-MM', /\d{4}-\d\d/, false],
+ ['YYYYYYMMDD', /[+-]\d{10}/],
+ ['YYYYMMDD', /\d{8}/],
+ // YYYYMM is NOT allowed by the standard
+ ['GGGG[W]WWE', /\d{4}W\d{3}/],
+ ['GGGG[W]WW', /\d{4}W\d{2}/, false],
+ ['YYYYDDD', /\d{7}/]
+ ];
-// On windows, create a .cmd file.
-// Read the #! in the file to see what it uses. The vast majority
-// of the time, this will be either:
-// "#!/usr/bin/env "
-// or:
-// "#! "
-//
-// Write a binroot/pkg.bin + ".cmd" file that has this line in it:
-// @ %~dp0 %*
+ // iso time formats and regexes
+ var isoTimes = [
+ ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
+ ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
+ ['HH:mm:ss', /\d\d:\d\d:\d\d/],
+ ['HH:mm', /\d\d:\d\d/],
+ ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
+ ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
+ ['HHmmss', /\d\d\d\d\d\d/],
+ ['HHmm', /\d\d\d\d/],
+ ['HH', /\d\d/]
+ ];
-module.exports = cmdShim
-cmdShim.ifExists = cmdShimIfExists
+ var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
-var fs = __webpack_require__(22)
+ // date from iso format
+ function configFromISO(config) {
+ var i, l,
+ string = config._i,
+ match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),
+ allowTime, dateFormat, timeFormat, tzFormat;
-var mkdir = __webpack_require__(31)
- , path = __webpack_require__(16)
- , toBatchSyntax = __webpack_require__(32)
- , shebangExpr = /^#\!\s*(?:\/usr\/bin\/env)?\s*([^ \t]+=[^ \t]+\s+)*\s*([^ \t]+)(.*)$/
+ if (match) {
+ getParsingFlags(config).iso = true;
-function cmdShimIfExists (from, to, cb) {
- fs.stat(from, function (er) {
- if (er) return cb()
- cmdShim(from, to, cb)
- })
-}
+ for (i = 0, l = isoDates.length; i < l; i++) {
+ if (isoDates[i][1].exec(match[1])) {
+ dateFormat = isoDates[i][0];
+ allowTime = isoDates[i][2] !== false;
+ break;
+ }
+ }
+ if (dateFormat == null) {
+ config._isValid = false;
+ return;
+ }
+ if (match[3]) {
+ for (i = 0, l = isoTimes.length; i < l; i++) {
+ if (isoTimes[i][1].exec(match[3])) {
+ // match[2] should be 'T' or space
+ timeFormat = (match[2] || ' ') + isoTimes[i][0];
+ break;
+ }
+ }
+ if (timeFormat == null) {
+ config._isValid = false;
+ return;
+ }
+ }
+ if (!allowTime && timeFormat != null) {
+ config._isValid = false;
+ return;
+ }
+ if (match[4]) {
+ if (tzRegex.exec(match[4])) {
+ tzFormat = 'Z';
+ } else {
+ config._isValid = false;
+ return;
+ }
+ }
+ config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
+ configFromStringAndFormat(config);
+ } else {
+ config._isValid = false;
+ }
+ }
-// Try to unlink, but ignore errors.
-// Any problems will surface later.
-function rm (path, cb) {
- fs.unlink(path, function(er) {
- cb()
- })
-}
+ // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
+ var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/;
-function cmdShim (from, to, cb) {
- fs.stat(from, function (er, stat) {
- if (er)
- return cb(er)
+ function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
+ var result = [
+ untruncateYear(yearStr),
+ defaultLocaleMonthsShort.indexOf(monthStr),
+ parseInt(dayStr, 10),
+ parseInt(hourStr, 10),
+ parseInt(minuteStr, 10)
+ ];
- cmdShim_(from, to, cb)
- })
-}
+ if (secondStr) {
+ result.push(parseInt(secondStr, 10));
+ }
-function cmdShim_ (from, to, cb) {
- var then = times(2, next, cb)
- rm(to, then)
- rm(to + ".cmd", then)
+ return result;
+ }
- function next(er) {
- writeShim(from, to, cb)
- }
-}
+ function untruncateYear(yearStr) {
+ var year = parseInt(yearStr, 10);
+ if (year <= 49) {
+ return 2000 + year;
+ } else if (year <= 999) {
+ return 1900 + year;
+ }
+ return year;
+ }
-function writeShim (from, to, cb) {
- // make a cmd file and a sh script
- // First, check if the bin is a #! of some sort.
- // If not, then assume it's something that'll be compiled, or some other
- // sort of script, and just call it directly.
- mkdir(path.dirname(to), function (er) {
- if (er)
- return cb(er)
- fs.readFile(from, "utf8", function (er, data) {
- if (er) return writeShim_(from, to, null, null, cb)
- var firstLine = data.trim().split(/\r*\n/)[0]
- , shebang = firstLine.match(shebangExpr)
- if (!shebang) return writeShim_(from, to, null, null, null, cb)
- var vars = shebang[1] || ""
- , prog = shebang[2]
- , args = shebang[3] || ""
- return writeShim_(from, to, prog, args, vars, cb)
- })
- })
-}
+ function preprocessRFC2822(s) {
+ // Remove comments and folding whitespace and replace multiple-spaces with a single space
+ return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+ }
+
+ function checkWeekday(weekdayStr, parsedInput, config) {
+ if (weekdayStr) {
+ // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
+ var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
+ weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();
+ if (weekdayProvided !== weekdayActual) {
+ getParsingFlags(config).weekdayMismatch = true;
+ config._isValid = false;
+ return false;
+ }
+ }
+ return true;
+ }
+ var obsOffsets = {
+ UT: 0,
+ GMT: 0,
+ EDT: -4 * 60,
+ EST: -5 * 60,
+ CDT: -5 * 60,
+ CST: -6 * 60,
+ MDT: -6 * 60,
+ MST: -7 * 60,
+ PDT: -7 * 60,
+ PST: -8 * 60
+ };
-function writeShim_ (from, to, prog, args, variables, cb) {
- var shTarget = path.relative(path.dirname(to), from)
- , target = shTarget.split("/").join("\\")
- , longProg
- , shProg = prog && prog.split("\\").join("/")
- , shLongProg
- , pwshProg = shProg && "\"" + shProg + "$exe\""
- , pwshLongProg
- shTarget = shTarget.split("\\").join("/")
- args = args || ""
- variables = variables || ""
- if (!prog) {
- prog = "\"%~dp0\\" + target + "\""
- shProg = "\"$basedir/" + shTarget + "\""
- pwshProg = shProg
- args = ""
- target = ""
- shTarget = ""
- } else {
- longProg = "\"%~dp0\\" + prog + ".exe\""
- shLongProg = "\"$basedir/" + prog + "\""
- pwshLongProg = "\"$basedir/" + prog + "$exe\""
- target = "\"%~dp0\\" + target + "\""
- shTarget = "\"$basedir/" + shTarget + "\""
- }
+ function calculateOffset(obsOffset, militaryOffset, numOffset) {
+ if (obsOffset) {
+ return obsOffsets[obsOffset];
+ } else if (militaryOffset) {
+ // the only allowed military tz is Z
+ return 0;
+ } else {
+ var hm = parseInt(numOffset, 10);
+ var m = hm % 100, h = (hm - m) / 100;
+ return h * 60 + m;
+ }
+ }
- // @SETLOCAL
- //
- // @IF EXIST "%~dp0\node.exe" (
- // @SET "_prog=%~dp0\node.exe"
- // ) ELSE (
- // @SET "_prog=node"
- // @SET PATHEXT=%PATHEXT:;.JS;=;%
- // )
- //
- // "%_prog%" "%~dp0\.\node_modules\npm\bin\npm-cli.js" %*
- // @ENDLOCAL
- var cmd
- if (longProg) {
- shLongProg = shLongProg.trim();
- args = args.trim();
- var variableDeclarationsAsBatch = toBatchSyntax.convertToSetCommands(variables)
- cmd = "@SETLOCAL\r\n"
- + variableDeclarationsAsBatch
- + "\r\n"
- + "@IF EXIST " + longProg + " (\r\n"
- + " @SET \"_prog=" + longProg.replace(/(^")|("$)/g, '') + "\"\r\n"
- + ") ELSE (\r\n"
- + " @SET \"_prog=" + prog.replace(/(^")|("$)/g, '') + "\"\r\n"
- + " @SET PATHEXT=%PATHEXT:;.JS;=;%\r\n"
- + ")\r\n"
- + "\r\n"
- + "\"%_prog%\" " + args + " " + target + " %*\r\n"
- + '@ENDLOCAL\r\n'
- } else {
- cmd = "@" + prog + " " + args + " " + target + " %*\r\n"
- }
+ // date and time from ref 2822 format
+ function configFromRFC2822(config) {
+ var match = rfc2822.exec(preprocessRFC2822(config._i));
+ if (match) {
+ var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);
+ if (!checkWeekday(match[1], parsedArray, config)) {
+ return;
+ }
- // #!/bin/sh
- // basedir=`dirname "$0"`
- //
- // case `uname` in
- // *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
- // esac
- //
- // if [ -x "$basedir/node.exe" ]; then
- // "$basedir/node.exe" "$basedir/node_modules/npm/bin/npm-cli.js" "$@"
- // ret=$?
- // else
- // node "$basedir/node_modules/npm/bin/npm-cli.js" "$@"
- // ret=$?
- // fi
- // exit $ret
+ config._a = parsedArray;
+ config._tzm = calculateOffset(match[8], match[9], match[10]);
- var sh = "#!/bin/sh\n"
+ config._d = createUTCDate.apply(null, config._a);
+ config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
- sh = sh
- + "basedir=$(dirname \"$(echo \"$0\" | sed -e 's,\\\\,/,g')\")\n"
- + "\n"
- + "case `uname` in\n"
- + " *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w \"$basedir\"`;;\n"
- + "esac\n"
- + "\n"
+ getParsingFlags(config).rfc2822 = true;
+ } else {
+ config._isValid = false;
+ }
+ }
- if (shLongProg) {
- sh = sh
- + "if [ -x "+shLongProg+" ]; then\n"
- + " " + variables + shLongProg + " " + args + " " + shTarget + " \"$@\"\n"
- + " ret=$?\n"
- + "else \n"
- + " " + variables + shProg + " " + args + " " + shTarget + " \"$@\"\n"
- + " ret=$?\n"
- + "fi\n"
- + "exit $ret\n"
- } else {
- sh = sh
- + shProg + " " + args + " " + shTarget + " \"$@\"\n"
- + "exit $?\n"
- }
+ // date from iso format or fallback
+ function configFromString(config) {
+ var matched = aspNetJsonRegex.exec(config._i);
- // #!/usr/bin/env pwsh
- // $basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
- //
- // $ret=0
- // $exe = ""
- // if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
- // # Fix case when both the Windows and Linux builds of Node
- // # are installed in the same directory
- // $exe = ".exe"
- // }
- // if (Test-Path "$basedir/node") {
- // & "$basedir/node$exe" "$basedir/node_modules/npm/bin/npm-cli.js" $args
- // $ret=$LASTEXITCODE
- // } else {
- // & "node$exe" "$basedir/node_modules/npm/bin/npm-cli.js" $args
- // $ret=$LASTEXITCODE
- // }
- // exit $ret
- var pwsh = "#!/usr/bin/env pwsh\n"
- + "$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent\n"
- + "\n"
- + "$exe=\"\"\n"
- + "if ($PSVersionTable.PSVersion -lt \"6.0\" -or $IsWindows) {\n"
- + " # Fix case when both the Windows and Linux builds of Node\n"
- + " # are installed in the same directory\n"
- + " $exe=\".exe\"\n"
- + "}\n"
- if (shLongProg) {
- pwsh = pwsh
- + "$ret=0\n"
- + "if (Test-Path " + pwshLongProg + ") {\n"
- + " & " + pwshLongProg + " " + args + " " + shTarget + " $args\n"
- + " $ret=$LASTEXITCODE\n"
- + "} else {\n"
- + " & " + pwshProg + " " + args + " " + shTarget + " $args\n"
- + " $ret=$LASTEXITCODE\n"
- + "}\n"
- + "exit $ret\n"
- } else {
- pwsh = pwsh
- + "& " + pwshProg + " " + args + " " + shTarget + " $args\n"
- + "exit $LASTEXITCODE\n"
- }
+ if (matched !== null) {
+ config._d = new Date(+matched[1]);
+ return;
+ }
- var then = times(3, next, cb)
- fs.writeFile(to + ".ps1", pwsh, "utf8", then)
- fs.writeFile(to + ".cmd", cmd, "utf8", then)
- fs.writeFile(to, sh, "utf8", then)
- function next () {
- chmodShim(to, cb)
- }
-}
+ configFromISO(config);
+ if (config._isValid === false) {
+ delete config._isValid;
+ } else {
+ return;
+ }
-function chmodShim (to, cb) {
- var then = times(2, cb, cb)
- fs.chmod(to, "0755", then)
- fs.chmod(to + ".cmd", "0755", then)
- fs.chmod(to + ".ps1", "0755", then)
-}
+ configFromRFC2822(config);
+ if (config._isValid === false) {
+ delete config._isValid;
+ } else {
+ return;
+ }
-function times(n, ok, cb) {
- var errState = null
- return function(er) {
- if (!errState) {
- if (er)
- cb(errState = er)
- else if (--n === 0)
- ok()
+ // Final attempt, use Input Fallback
+ hooks.createFromInputFallback(config);
}
- }
-}
+ hooks.createFromInputFallback = deprecate(
+ 'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
+ 'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
+ 'discouraged and will be removed in an upcoming major release. Please refer to ' +
+ 'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
+ function (config) {
+ config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
+ }
+ );
-/***/ }),
-/* 22 */
-/***/ (function(module, exports, __webpack_require__) {
+ // constant that refers to the ISO standard
+ hooks.ISO_8601 = function () {};
-var fs = __webpack_require__(23)
-var polyfills = __webpack_require__(24)
-var legacy = __webpack_require__(26)
-var clone = __webpack_require__(28)
+ // constant that refers to the RFC 2822 form
+ hooks.RFC_2822 = function () {};
-var util = __webpack_require__(29)
+ // date from string and format string
+ function configFromStringAndFormat(config) {
+ // TODO: Move this to another part of the creation flow to prevent circular deps
+ if (config._f === hooks.ISO_8601) {
+ configFromISO(config);
+ return;
+ }
+ if (config._f === hooks.RFC_2822) {
+ configFromRFC2822(config);
+ return;
+ }
+ config._a = [];
+ getParsingFlags(config).empty = true;
-/* istanbul ignore next - node 0.x polyfill */
-var gracefulQueue
-var previousSymbol
-
-/* istanbul ignore else - node 0.x polyfill */
-if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
- gracefulQueue = Symbol.for('graceful-fs.queue')
- // This is used in testing by future versions
- previousSymbol = Symbol.for('graceful-fs.previous')
-} else {
- gracefulQueue = '___graceful-fs.queue'
- previousSymbol = '___graceful-fs.previous'
-}
+ // This array is used to make a Date, either with `new Date` or `Date.UTC`
+ var string = '' + config._i,
+ i, parsedInput, tokens, token, skipped,
+ stringLength = string.length,
+ totalParsedInputLength = 0;
-function noop () {}
+ tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
-var debug = noop
-if (util.debuglog)
- debug = util.debuglog('gfs4')
-else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
- debug = function() {
- var m = util.format.apply(util, arguments)
- m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
- console.error(m)
- }
+ for (i = 0; i < tokens.length; i++) {
+ token = tokens[i];
+ parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
+ // console.log('token', token, 'parsedInput', parsedInput,
+ // 'regex', getParseRegexForToken(token, config));
+ if (parsedInput) {
+ skipped = string.substr(0, string.indexOf(parsedInput));
+ if (skipped.length > 0) {
+ getParsingFlags(config).unusedInput.push(skipped);
+ }
+ string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
+ totalParsedInputLength += parsedInput.length;
+ }
+ // don't parse if it's not a known token
+ if (formatTokenFunctions[token]) {
+ if (parsedInput) {
+ getParsingFlags(config).empty = false;
+ }
+ else {
+ getParsingFlags(config).unusedTokens.push(token);
+ }
+ addTimeToArrayFromToken(token, parsedInput, config);
+ }
+ else if (config._strict && !parsedInput) {
+ getParsingFlags(config).unusedTokens.push(token);
+ }
+ }
-// Once time initialization
-if (!global[gracefulQueue]) {
- // This queue can be shared by multiple loaded instances
- var queue = []
- Object.defineProperty(global, gracefulQueue, {
- get: function() {
- return queue
- }
- })
+ // add remaining unparsed input length to the string
+ getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
+ if (string.length > 0) {
+ getParsingFlags(config).unusedInput.push(string);
+ }
- // Patch fs.close/closeSync to shared queue version, because we need
- // to retry() whenever a close happens *anywhere* in the program.
- // This is essential when multiple graceful-fs instances are
- // in play at the same time.
- fs.close = (function (fs$close) {
- function close (fd, cb) {
- return fs$close.call(fs, fd, function (err) {
- // This function uses the graceful-fs shared queue
- if (!err) {
- retry()
+ // clear _12h flag if hour is <= 12
+ if (config._a[HOUR] <= 12 &&
+ getParsingFlags(config).bigHour === true &&
+ config._a[HOUR] > 0) {
+ getParsingFlags(config).bigHour = undefined;
}
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- })
+ getParsingFlags(config).parsedDateParts = config._a.slice(0);
+ getParsingFlags(config).meridiem = config._meridiem;
+ // handle meridiem
+ config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
+
+ configFromArray(config);
+ checkOverflow(config);
}
- Object.defineProperty(close, previousSymbol, {
- value: fs$close
- })
- return close
- })(fs.close)
- fs.closeSync = (function (fs$closeSync) {
- function closeSync (fd) {
- // This function uses the graceful-fs shared queue
- fs$closeSync.apply(fs, arguments)
- retry()
+ function meridiemFixWrap (locale, hour, meridiem) {
+ var isPm;
+
+ if (meridiem == null) {
+ // nothing to do
+ return hour;
+ }
+ if (locale.meridiemHour != null) {
+ return locale.meridiemHour(hour, meridiem);
+ } else if (locale.isPM != null) {
+ // Fallback
+ isPm = locale.isPM(meridiem);
+ if (isPm && hour < 12) {
+ hour += 12;
+ }
+ if (!isPm && hour === 12) {
+ hour = 0;
+ }
+ return hour;
+ } else {
+ // this is not supposed to happen
+ return hour;
+ }
}
- Object.defineProperty(closeSync, previousSymbol, {
- value: fs$closeSync
- })
- return closeSync
- })(fs.closeSync)
+ // date from string and array of format strings
+ function configFromStringAndArray(config) {
+ var tempConfig,
+ bestMoment,
- if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
- process.on('exit', function() {
- debug(global[gracefulQueue])
- __webpack_require__(30).equal(global[gracefulQueue].length, 0)
- })
- }
-}
+ scoreToBeat,
+ i,
+ currentScore;
-module.exports = patch(clone(fs))
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
- module.exports = patch(fs)
- fs.__patched = true;
-}
+ if (config._f.length === 0) {
+ getParsingFlags(config).invalidFormat = true;
+ config._d = new Date(NaN);
+ return;
+ }
-function patch (fs) {
- // Everything that references the open() function needs to be in here
- polyfills(fs)
- fs.gracefulify = patch
+ for (i = 0; i < config._f.length; i++) {
+ currentScore = 0;
+ tempConfig = copyConfig({}, config);
+ if (config._useUTC != null) {
+ tempConfig._useUTC = config._useUTC;
+ }
+ tempConfig._f = config._f[i];
+ configFromStringAndFormat(tempConfig);
- fs.createReadStream = createReadStream
- fs.createWriteStream = createWriteStream
- var fs$readFile = fs.readFile
- fs.readFile = readFile
- function readFile (path, options, cb) {
- if (typeof options === 'function')
- cb = options, options = null
+ if (!isValid(tempConfig)) {
+ continue;
+ }
- return go$readFile(path, options, cb)
+ // if there is any input that was not parsed add a penalty for that format
+ currentScore += getParsingFlags(tempConfig).charsLeftOver;
- function go$readFile (path, options, cb) {
- return fs$readFile(path, options, function (err) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$readFile, [path, options, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
+ //or tokens
+ currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
+
+ getParsingFlags(tempConfig).score = currentScore;
+
+ if (scoreToBeat == null || currentScore < scoreToBeat) {
+ scoreToBeat = currentScore;
+ bestMoment = tempConfig;
+ }
}
- })
+
+ extend(config, bestMoment || tempConfig);
}
- }
- var fs$writeFile = fs.writeFile
- fs.writeFile = writeFile
- function writeFile (path, data, options, cb) {
- if (typeof options === 'function')
- cb = options, options = null
+ function configFromObject(config) {
+ if (config._d) {
+ return;
+ }
- return go$writeFile(path, data, options, cb)
+ var i = normalizeObjectUnits(config._i);
+ config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {
+ return obj && parseInt(obj, 10);
+ });
- function go$writeFile (path, data, options, cb) {
- return fs$writeFile(path, data, options, function (err) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$writeFile, [path, data, options, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
+ configFromArray(config);
+ }
+
+ function createFromConfig (config) {
+ var res = new Moment(checkOverflow(prepareConfig(config)));
+ if (res._nextDay) {
+ // Adding is smart enough around DST
+ res.add(1, 'd');
+ res._nextDay = undefined;
}
- })
+
+ return res;
}
- }
- var fs$appendFile = fs.appendFile
- if (fs$appendFile)
- fs.appendFile = appendFile
- function appendFile (path, data, options, cb) {
- if (typeof options === 'function')
- cb = options, options = null
+ function prepareConfig (config) {
+ var input = config._i,
+ format = config._f;
- return go$appendFile(path, data, options, cb)
+ config._locale = config._locale || getLocale(config._l);
- function go$appendFile (path, data, options, cb) {
- return fs$appendFile(path, data, options, function (err) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$appendFile, [path, data, options, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
+ if (input === null || (format === undefined && input === '')) {
+ return createInvalid({nullInput: true});
}
- })
- }
- }
-
- var fs$readdir = fs.readdir
- fs.readdir = readdir
- function readdir (path, options, cb) {
- var args = [path]
- if (typeof options !== 'function') {
- args.push(options)
- } else {
- cb = options
- }
- args.push(go$readdir$cb)
- return go$readdir(args)
+ if (typeof input === 'string') {
+ config._i = input = config._locale.preparse(input);
+ }
- function go$readdir$cb (err, files) {
- if (files && files.sort)
- files.sort()
+ if (isMoment(input)) {
+ return new Moment(checkOverflow(input));
+ } else if (isDate(input)) {
+ config._d = input;
+ } else if (isArray(format)) {
+ configFromStringAndArray(config);
+ } else if (format) {
+ configFromStringAndFormat(config);
+ } else {
+ configFromInput(config);
+ }
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$readdir, [args]])
+ if (!isValid(config)) {
+ config._d = null;
+ }
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
- }
+ return config;
}
- }
- function go$readdir (args) {
- return fs$readdir.apply(fs, args)
- }
+ function configFromInput(config) {
+ var input = config._i;
+ if (isUndefined(input)) {
+ config._d = new Date(hooks.now());
+ } else if (isDate(input)) {
+ config._d = new Date(input.valueOf());
+ } else if (typeof input === 'string') {
+ configFromString(config);
+ } else if (isArray(input)) {
+ config._a = map(input.slice(0), function (obj) {
+ return parseInt(obj, 10);
+ });
+ configFromArray(config);
+ } else if (isObject(input)) {
+ configFromObject(config);
+ } else if (isNumber(input)) {
+ // from milliseconds
+ config._d = new Date(input);
+ } else {
+ hooks.createFromInputFallback(config);
+ }
+ }
- if (process.version.substr(0, 4) === 'v0.8') {
- var legStreams = legacy(fs)
- ReadStream = legStreams.ReadStream
- WriteStream = legStreams.WriteStream
- }
+ function createLocalOrUTC (input, format, locale, strict, isUTC) {
+ var c = {};
- var fs$ReadStream = fs.ReadStream
- if (fs$ReadStream) {
- ReadStream.prototype = Object.create(fs$ReadStream.prototype)
- ReadStream.prototype.open = ReadStream$open
- }
+ if (locale === true || locale === false) {
+ strict = locale;
+ locale = undefined;
+ }
- var fs$WriteStream = fs.WriteStream
- if (fs$WriteStream) {
- WriteStream.prototype = Object.create(fs$WriteStream.prototype)
- WriteStream.prototype.open = WriteStream$open
- }
+ if ((isObject(input) && isObjectEmpty(input)) ||
+ (isArray(input) && input.length === 0)) {
+ input = undefined;
+ }
+ // object construction must be done this way.
+ // https://github.com/moment/moment/issues/1423
+ c._isAMomentObject = true;
+ c._useUTC = c._isUTC = isUTC;
+ c._l = locale;
+ c._i = input;
+ c._f = format;
+ c._strict = strict;
- Object.defineProperty(fs, 'ReadStream', {
- get: function () {
- return ReadStream
- },
- set: function (val) {
- ReadStream = val
- },
- enumerable: true,
- configurable: true
- })
- Object.defineProperty(fs, 'WriteStream', {
- get: function () {
- return WriteStream
- },
- set: function (val) {
- WriteStream = val
- },
- enumerable: true,
- configurable: true
- })
+ return createFromConfig(c);
+ }
- // legacy names
- var FileReadStream = ReadStream
- Object.defineProperty(fs, 'FileReadStream', {
- get: function () {
- return FileReadStream
- },
- set: function (val) {
- FileReadStream = val
- },
- enumerable: true,
- configurable: true
- })
- var FileWriteStream = WriteStream
- Object.defineProperty(fs, 'FileWriteStream', {
- get: function () {
- return FileWriteStream
- },
- set: function (val) {
- FileWriteStream = val
- },
- enumerable: true,
- configurable: true
- })
+ function createLocal (input, format, locale, strict) {
+ return createLocalOrUTC(input, format, locale, strict, false);
+ }
- function ReadStream (path, options) {
- if (this instanceof ReadStream)
- return fs$ReadStream.apply(this, arguments), this
- else
- return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
- }
+ var prototypeMin = deprecate(
+ 'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',
+ function () {
+ var other = createLocal.apply(null, arguments);
+ if (this.isValid() && other.isValid()) {
+ return other < this ? this : other;
+ } else {
+ return createInvalid();
+ }
+ }
+ );
- function ReadStream$open () {
- var that = this
- open(that.path, that.flags, that.mode, function (err, fd) {
- if (err) {
- if (that.autoClose)
- that.destroy()
+ var prototypeMax = deprecate(
+ 'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',
+ function () {
+ var other = createLocal.apply(null, arguments);
+ if (this.isValid() && other.isValid()) {
+ return other > this ? this : other;
+ } else {
+ return createInvalid();
+ }
+ }
+ );
- that.emit('error', err)
- } else {
- that.fd = fd
- that.emit('open', fd)
- that.read()
- }
- })
- }
+ // Pick a moment m from moments so that m[fn](other) is true for all
+ // other. This relies on the function fn to be transitive.
+ //
+ // moments should either be an array of moment objects or an array, whose
+ // first element is an array of moment objects.
+ function pickBy(fn, moments) {
+ var res, i;
+ if (moments.length === 1 && isArray(moments[0])) {
+ moments = moments[0];
+ }
+ if (!moments.length) {
+ return createLocal();
+ }
+ res = moments[0];
+ for (i = 1; i < moments.length; ++i) {
+ if (!moments[i].isValid() || moments[i][fn](res)) {
+ res = moments[i];
+ }
+ }
+ return res;
+ }
- function WriteStream (path, options) {
- if (this instanceof WriteStream)
- return fs$WriteStream.apply(this, arguments), this
- else
- return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
- }
+ // TODO: Use [].sort instead?
+ function min () {
+ var args = [].slice.call(arguments, 0);
- function WriteStream$open () {
- var that = this
- open(that.path, that.flags, that.mode, function (err, fd) {
- if (err) {
- that.destroy()
- that.emit('error', err)
- } else {
- that.fd = fd
- that.emit('open', fd)
- }
- })
- }
+ return pickBy('isBefore', args);
+ }
- function createReadStream (path, options) {
- return new fs.ReadStream(path, options)
- }
+ function max () {
+ var args = [].slice.call(arguments, 0);
- function createWriteStream (path, options) {
- return new fs.WriteStream(path, options)
- }
+ return pickBy('isAfter', args);
+ }
- var fs$open = fs.open
- fs.open = open
- function open (path, flags, mode, cb) {
- if (typeof mode === 'function')
- cb = mode, mode = null
+ var now = function () {
+ return Date.now ? Date.now() : +(new Date());
+ };
- return go$open(path, flags, mode, cb)
+ var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
- function go$open (path, flags, mode, cb) {
- return fs$open(path, flags, mode, function (err, fd) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$open, [path, flags, mode, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
+ function isDurationValid(m) {
+ for (var key in m) {
+ if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
+ return false;
+ }
}
- })
- }
- }
- return fs
-}
+ var unitHasDecimal = false;
+ for (var i = 0; i < ordering.length; ++i) {
+ if (m[ordering[i]]) {
+ if (unitHasDecimal) {
+ return false; // only allow non-integers for smallest unit
+ }
+ if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
+ unitHasDecimal = true;
+ }
+ }
+ }
-function enqueue (elem) {
- debug('ENQUEUE', elem[0].name, elem[1])
- global[gracefulQueue].push(elem)
-}
+ return true;
+ }
-function retry () {
- var elem = global[gracefulQueue].shift()
- if (elem) {
- debug('RETRY', elem[0].name, elem[1])
- elem[0].apply(null, elem[1])
- }
-}
+ function isValid$1() {
+ return this._isValid;
+ }
+ function createInvalid$1() {
+ return createDuration(NaN);
+ }
-/***/ }),
-/* 23 */
-/***/ (function(module, exports) {
+ function Duration (duration) {
+ var normalizedInput = normalizeObjectUnits(duration),
+ years = normalizedInput.year || 0,
+ quarters = normalizedInput.quarter || 0,
+ months = normalizedInput.month || 0,
+ weeks = normalizedInput.week || normalizedInput.isoWeek || 0,
+ days = normalizedInput.day || 0,
+ hours = normalizedInput.hour || 0,
+ minutes = normalizedInput.minute || 0,
+ seconds = normalizedInput.second || 0,
+ milliseconds = normalizedInput.millisecond || 0;
-module.exports = require("fs");
+ this._isValid = isDurationValid(normalizedInput);
-/***/ }),
-/* 24 */
-/***/ (function(module, exports, __webpack_require__) {
+ // representation for dateAddRemove
+ this._milliseconds = +milliseconds +
+ seconds * 1e3 + // 1000
+ minutes * 6e4 + // 1000 * 60
+ hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
+ // Because of dateAddRemove treats 24 hours as different from a
+ // day when working around DST, we need to store them separately
+ this._days = +days +
+ weeks * 7;
+ // It is impossible to translate months into days without knowing
+ // which months you are are talking about, so we have to store
+ // it separately.
+ this._months = +months +
+ quarters * 3 +
+ years * 12;
-var constants = __webpack_require__(25)
+ this._data = {};
-var origCwd = process.cwd
-var cwd = null
+ this._locale = getLocale();
-var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
+ this._bubble();
+ }
-process.cwd = function() {
- if (!cwd)
- cwd = origCwd.call(process)
- return cwd
-}
-try {
- process.cwd()
-} catch (er) {}
+ function isDuration (obj) {
+ return obj instanceof Duration;
+ }
-var chdir = process.chdir
-process.chdir = function(d) {
- cwd = null
- chdir.call(process, d)
-}
+ function absRound (number) {
+ if (number < 0) {
+ return Math.round(-1 * number) * -1;
+ } else {
+ return Math.round(number);
+ }
+ }
-module.exports = patch
+ // FORMATTING
-function patch (fs) {
- // (re-)implement some things that are known busted or missing.
+ function offset (token, separator) {
+ addFormatToken(token, 0, 0, function () {
+ var offset = this.utcOffset();
+ var sign = '+';
+ if (offset < 0) {
+ offset = -offset;
+ sign = '-';
+ }
+ return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
+ });
+ }
- // lchmod, broken prior to 0.6.2
- // back-port the fix here.
- if (constants.hasOwnProperty('O_SYMLINK') &&
- process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
- patchLchmod(fs)
- }
+ offset('Z', ':');
+ offset('ZZ', '');
- // lutimes implementation, or no-op
- if (!fs.lutimes) {
- patchLutimes(fs)
- }
+ // PARSING
- // https://github.com/isaacs/node-graceful-fs/issues/4
- // Chown should not fail on einval or eperm if non-root.
- // It should not fail on enosys ever, as this just indicates
- // that a fs doesn't support the intended operation.
+ addRegexToken('Z', matchShortOffset);
+ addRegexToken('ZZ', matchShortOffset);
+ addParseToken(['Z', 'ZZ'], function (input, array, config) {
+ config._useUTC = true;
+ config._tzm = offsetFromString(matchShortOffset, input);
+ });
- fs.chown = chownFix(fs.chown)
- fs.fchown = chownFix(fs.fchown)
- fs.lchown = chownFix(fs.lchown)
+ // HELPERS
- fs.chmod = chmodFix(fs.chmod)
- fs.fchmod = chmodFix(fs.fchmod)
- fs.lchmod = chmodFix(fs.lchmod)
+ // timezone chunker
+ // '+10:00' > ['10', '00']
+ // '-1530' > ['-15', '30']
+ var chunkOffset = /([\+\-]|\d\d)/gi;
- fs.chownSync = chownFixSync(fs.chownSync)
- fs.fchownSync = chownFixSync(fs.fchownSync)
- fs.lchownSync = chownFixSync(fs.lchownSync)
+ function offsetFromString(matcher, string) {
+ var matches = (string || '').match(matcher);
- fs.chmodSync = chmodFixSync(fs.chmodSync)
- fs.fchmodSync = chmodFixSync(fs.fchmodSync)
- fs.lchmodSync = chmodFixSync(fs.lchmodSync)
+ if (matches === null) {
+ return null;
+ }
- fs.stat = statFix(fs.stat)
- fs.fstat = statFix(fs.fstat)
- fs.lstat = statFix(fs.lstat)
+ var chunk = matches[matches.length - 1] || [];
+ var parts = (chunk + '').match(chunkOffset) || ['-', 0, 0];
+ var minutes = +(parts[1] * 60) + toInt(parts[2]);
- fs.statSync = statFixSync(fs.statSync)
- fs.fstatSync = statFixSync(fs.fstatSync)
- fs.lstatSync = statFixSync(fs.lstatSync)
+ return minutes === 0 ?
+ 0 :
+ parts[0] === '+' ? minutes : -minutes;
+ }
- // if lchmod/lchown do not exist, then make them no-ops
- if (!fs.lchmod) {
- fs.lchmod = function (path, mode, cb) {
- if (cb) process.nextTick(cb)
+ // Return a moment from input, that is local/utc/zone equivalent to model.
+ function cloneWithOffset(input, model) {
+ var res, diff;
+ if (model._isUTC) {
+ res = model.clone();
+ diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
+ // Use low-level api, because this fn is low-level api.
+ res._d.setTime(res._d.valueOf() + diff);
+ hooks.updateOffset(res, false);
+ return res;
+ } else {
+ return createLocal(input).local();
+ }
}
- fs.lchmodSync = function () {}
- }
- if (!fs.lchown) {
- fs.lchown = function (path, uid, gid, cb) {
- if (cb) process.nextTick(cb)
+
+ function getDateOffset (m) {
+ // On Firefox.24 Date#getTimezoneOffset returns a floating point.
+ // https://github.com/moment/moment/pull/1871
+ return -Math.round(m._d.getTimezoneOffset() / 15) * 15;
}
- fs.lchownSync = function () {}
- }
- // on Windows, A/V software can lock the directory, causing this
- // to fail with an EACCES or EPERM if the directory contains newly
- // created files. Try again on failure, for up to 60 seconds.
+ // HOOKS
- // Set the timeout this long because some Windows Anti-Virus, such as Parity
- // bit9, may lock files for up to a minute, causing npm package install
- // failures. Also, take care to yield the scheduler. Windows scheduling gives
- // CPU to a busy looping process, which can cause the program causing the lock
- // contention to be starved of CPU by node, so the contention doesn't resolve.
- if (platform === "win32") {
- fs.rename = (function (fs$rename) { return function (from, to, cb) {
- var start = Date.now()
- var backoff = 0;
- fs$rename(from, to, function CB (er) {
- if (er
- && (er.code === "EACCES" || er.code === "EPERM")
- && Date.now() - start < 60000) {
- setTimeout(function() {
- fs.stat(to, function (stater, st) {
- if (stater && stater.code === "ENOENT")
- fs$rename(from, to, CB);
- else
- cb(er)
- })
- }, backoff)
- if (backoff < 100)
- backoff += 10;
- return;
- }
- if (cb) cb(er)
- })
- }})(fs.rename)
- }
+ // This function will be called whenever a moment is mutated.
+ // It is intended to keep the offset in sync with the timezone.
+ hooks.updateOffset = function () {};
- // if read() returns EAGAIN, then just try it again.
- fs.read = (function (fs$read) {
- function read (fd, buffer, offset, length, position, callback_) {
- var callback
- if (callback_ && typeof callback_ === 'function') {
- var eagCounter = 0
- callback = function (er, _, __) {
- if (er && er.code === 'EAGAIN' && eagCounter < 10) {
- eagCounter ++
- return fs$read.call(fs, fd, buffer, offset, length, position, callback)
- }
- callback_.apply(this, arguments)
+ // MOMENTS
+
+ // keepLocalTime = true means only change the timezone, without
+ // affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
+ // 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
+ // +0200, so we adjust the time as needed, to be valid.
+ //
+ // Keeping the time actually adds/subtracts (one hour)
+ // from the actual represented time. That is why we call updateOffset
+ // a second time. In case it wants us to change the offset again
+ // _changeInProgress == true case, then we have to adjust, because
+ // there is no such time in the given timezone.
+ function getSetOffset (input, keepLocalTime, keepMinutes) {
+ var offset = this._offset || 0,
+ localAdjust;
+ if (!this.isValid()) {
+ return input != null ? this : NaN;
+ }
+ if (input != null) {
+ if (typeof input === 'string') {
+ input = offsetFromString(matchShortOffset, input);
+ if (input === null) {
+ return this;
+ }
+ } else if (Math.abs(input) < 16 && !keepMinutes) {
+ input = input * 60;
+ }
+ if (!this._isUTC && keepLocalTime) {
+ localAdjust = getDateOffset(this);
+ }
+ this._offset = input;
+ this._isUTC = true;
+ if (localAdjust != null) {
+ this.add(localAdjust, 'm');
+ }
+ if (offset !== input) {
+ if (!keepLocalTime || this._changeInProgress) {
+ addSubtract(this, createDuration(input - offset, 'm'), 1, false);
+ } else if (!this._changeInProgress) {
+ this._changeInProgress = true;
+ hooks.updateOffset(this, true);
+ this._changeInProgress = null;
+ }
+ }
+ return this;
+ } else {
+ return this._isUTC ? offset : getDateOffset(this);
}
- }
- return fs$read.call(fs, fd, buffer, offset, length, position, callback)
}
- // This ensures `util.promisify` works as it does for native `fs.read`.
- read.__proto__ = fs$read
- return read
- })(fs.read)
+ function getSetZone (input, keepLocalTime) {
+ if (input != null) {
+ if (typeof input !== 'string') {
+ input = -input;
+ }
- fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
- var eagCounter = 0
- while (true) {
- try {
- return fs$readSync.call(fs, fd, buffer, offset, length, position)
- } catch (er) {
- if (er.code === 'EAGAIN' && eagCounter < 10) {
- eagCounter ++
- continue
+ this.utcOffset(input, keepLocalTime);
+
+ return this;
+ } else {
+ return -this.utcOffset();
}
- throw er
- }
}
- }})(fs.readSync)
- function patchLchmod (fs) {
- fs.lchmod = function (path, mode, callback) {
- fs.open( path
- , constants.O_WRONLY | constants.O_SYMLINK
- , mode
- , function (err, fd) {
- if (err) {
- if (callback) callback(err)
- return
- }
- // prefer to return the chmod error, if one occurs,
- // but still try to close, and report closing errors if they occur.
- fs.fchmod(fd, mode, function (err) {
- fs.close(fd, function(err2) {
- if (callback) callback(err || err2)
- })
- })
- })
+ function setOffsetToUTC (keepLocalTime) {
+ return this.utcOffset(0, keepLocalTime);
}
- fs.lchmodSync = function (path, mode) {
- var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
+ function setOffsetToLocal (keepLocalTime) {
+ if (this._isUTC) {
+ this.utcOffset(0, keepLocalTime);
+ this._isUTC = false;
- // prefer to return the chmod error, if one occurs,
- // but still try to close, and report closing errors if they occur.
- var threw = true
- var ret
- try {
- ret = fs.fchmodSync(fd, mode)
- threw = false
- } finally {
- if (threw) {
- try {
- fs.closeSync(fd)
- } catch (er) {}
- } else {
- fs.closeSync(fd)
+ if (keepLocalTime) {
+ this.subtract(getDateOffset(this), 'm');
+ }
}
- }
- return ret
+ return this;
}
- }
- function patchLutimes (fs) {
- if (constants.hasOwnProperty("O_SYMLINK")) {
- fs.lutimes = function (path, at, mt, cb) {
- fs.open(path, constants.O_SYMLINK, function (er, fd) {
- if (er) {
- if (cb) cb(er)
- return
- }
- fs.futimes(fd, at, mt, function (er) {
- fs.close(fd, function (er2) {
- if (cb) cb(er || er2)
- })
- })
- })
- }
+ function setOffsetToParsedOffset () {
+ if (this._tzm != null) {
+ this.utcOffset(this._tzm, false, true);
+ } else if (typeof this._i === 'string') {
+ var tZone = offsetFromString(matchOffset, this._i);
+ if (tZone != null) {
+ this.utcOffset(tZone);
+ }
+ else {
+ this.utcOffset(0, true);
+ }
+ }
+ return this;
+ }
- fs.lutimesSync = function (path, at, mt) {
- var fd = fs.openSync(path, constants.O_SYMLINK)
- var ret
- var threw = true
- try {
- ret = fs.futimesSync(fd, at, mt)
- threw = false
- } finally {
- if (threw) {
- try {
- fs.closeSync(fd)
- } catch (er) {}
- } else {
- fs.closeSync(fd)
- }
+ function hasAlignedHourOffset (input) {
+ if (!this.isValid()) {
+ return false;
}
- return ret
- }
+ input = input ? createLocal(input).utcOffset() : 0;
- } else {
- fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
- fs.lutimesSync = function () {}
+ return (this.utcOffset() - input) % 60 === 0;
}
- }
- function chmodFix (orig) {
- if (!orig) return orig
- return function (target, mode, cb) {
- return orig.call(fs, target, mode, function (er) {
- if (chownErOk(er)) er = null
- if (cb) cb.apply(this, arguments)
- })
+ function isDaylightSavingTime () {
+ return (
+ this.utcOffset() > this.clone().month(0).utcOffset() ||
+ this.utcOffset() > this.clone().month(5).utcOffset()
+ );
}
- }
- function chmodFixSync (orig) {
- if (!orig) return orig
- return function (target, mode) {
- try {
- return orig.call(fs, target, mode)
- } catch (er) {
- if (!chownErOk(er)) throw er
- }
+ function isDaylightSavingTimeShifted () {
+ if (!isUndefined(this._isDSTShifted)) {
+ return this._isDSTShifted;
+ }
+
+ var c = {};
+
+ copyConfig(c, this);
+ c = prepareConfig(c);
+
+ if (c._a) {
+ var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
+ this._isDSTShifted = this.isValid() &&
+ compareArrays(c._a, other.toArray()) > 0;
+ } else {
+ this._isDSTShifted = false;
+ }
+
+ return this._isDSTShifted;
}
- }
+ function isLocal () {
+ return this.isValid() ? !this._isUTC : false;
+ }
- function chownFix (orig) {
- if (!orig) return orig
- return function (target, uid, gid, cb) {
- return orig.call(fs, target, uid, gid, function (er) {
- if (chownErOk(er)) er = null
- if (cb) cb.apply(this, arguments)
- })
+ function isUtcOffset () {
+ return this.isValid() ? this._isUTC : false;
}
- }
- function chownFixSync (orig) {
- if (!orig) return orig
- return function (target, uid, gid) {
- try {
- return orig.call(fs, target, uid, gid)
- } catch (er) {
- if (!chownErOk(er)) throw er
- }
+ function isUtc () {
+ return this.isValid() ? this._isUTC && this._offset === 0 : false;
}
- }
- function statFix (orig) {
- if (!orig) return orig
- // Older versions of Node erroneously returned signed integers for
- // uid + gid.
- return function (target, options, cb) {
- if (typeof options === 'function') {
- cb = options
- options = null
- }
- function callback (er, stats) {
- if (stats) {
- if (stats.uid < 0) stats.uid += 0x100000000
- if (stats.gid < 0) stats.gid += 0x100000000
- }
- if (cb) cb.apply(this, arguments)
- }
- return options ? orig.call(fs, target, options, callback)
- : orig.call(fs, target, callback)
- }
- }
-
- function statFixSync (orig) {
- if (!orig) return orig
- // Older versions of Node erroneously returned signed integers for
- // uid + gid.
- return function (target, options) {
- var stats = options ? orig.call(fs, target, options)
- : orig.call(fs, target)
- if (stats.uid < 0) stats.uid += 0x100000000
- if (stats.gid < 0) stats.gid += 0x100000000
- return stats;
- }
- }
+ // ASP.NET json date format regex
+ var aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
- // ENOSYS means that the fs doesn't support the op. Just ignore
- // that, because it doesn't matter.
- //
- // if there's no getuid, or if getuid() is something other
- // than 0, and the error is EINVAL or EPERM, then just ignore
- // it.
- //
- // This specific case is a silent failure in cp, install, tar,
- // and most other unix tools that manage permissions.
- //
- // When running as root, or if other types of errors are
- // encountered, then it's strict.
- function chownErOk (er) {
- if (!er)
- return true
+ // from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
+ // somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
+ // and further modified to allow for strings containing both week and day
+ var isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
- if (er.code === "ENOSYS")
- return true
+ function createDuration (input, key) {
+ var duration = input,
+ // matching against regexp is expensive, do it on demand
+ match = null,
+ sign,
+ ret,
+ diffRes;
- var nonroot = !process.getuid || process.getuid() !== 0
- if (nonroot) {
- if (er.code === "EINVAL" || er.code === "EPERM")
- return true
- }
+ if (isDuration(input)) {
+ duration = {
+ ms : input._milliseconds,
+ d : input._days,
+ M : input._months
+ };
+ } else if (isNumber(input)) {
+ duration = {};
+ if (key) {
+ duration[key] = input;
+ } else {
+ duration.milliseconds = input;
+ }
+ } else if (!!(match = aspNetRegex.exec(input))) {
+ sign = (match[1] === '-') ? -1 : 1;
+ duration = {
+ y : 0,
+ d : toInt(match[DATE]) * sign,
+ h : toInt(match[HOUR]) * sign,
+ m : toInt(match[MINUTE]) * sign,
+ s : toInt(match[SECOND]) * sign,
+ ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match
+ };
+ } else if (!!(match = isoRegex.exec(input))) {
+ sign = (match[1] === '-') ? -1 : 1;
+ duration = {
+ y : parseIso(match[2], sign),
+ M : parseIso(match[3], sign),
+ w : parseIso(match[4], sign),
+ d : parseIso(match[5], sign),
+ h : parseIso(match[6], sign),
+ m : parseIso(match[7], sign),
+ s : parseIso(match[8], sign)
+ };
+ } else if (duration == null) {// checks for null or undefined
+ duration = {};
+ } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
+ diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));
- return false
- }
-}
+ duration = {};
+ duration.ms = diffRes.milliseconds;
+ duration.M = diffRes.months;
+ }
+ ret = new Duration(duration);
-/***/ }),
-/* 25 */
-/***/ (function(module, exports) {
+ if (isDuration(input) && hasOwnProp(input, '_locale')) {
+ ret._locale = input._locale;
+ }
-module.exports = require("constants");
+ return ret;
+ }
-/***/ }),
-/* 26 */
-/***/ (function(module, exports, __webpack_require__) {
+ createDuration.fn = Duration.prototype;
+ createDuration.invalid = createInvalid$1;
-var Stream = __webpack_require__(27).Stream
+ function parseIso (inp, sign) {
+ // We'd normally use ~~inp for this, but unfortunately it also
+ // converts floats to ints.
+ // inp may be undefined, so careful calling replace on it.
+ var res = inp && parseFloat(inp.replace(',', '.'));
+ // apply sign while we're at it
+ return (isNaN(res) ? 0 : res) * sign;
+ }
-module.exports = legacy
+ function positiveMomentsDifference(base, other) {
+ var res = {};
-function legacy (fs) {
- return {
- ReadStream: ReadStream,
- WriteStream: WriteStream
- }
+ res.months = other.month() - base.month() +
+ (other.year() - base.year()) * 12;
+ if (base.clone().add(res.months, 'M').isAfter(other)) {
+ --res.months;
+ }
- function ReadStream (path, options) {
- if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+ res.milliseconds = +other - +(base.clone().add(res.months, 'M'));
- Stream.call(this);
+ return res;
+ }
- var self = this;
+ function momentsDifference(base, other) {
+ var res;
+ if (!(base.isValid() && other.isValid())) {
+ return {milliseconds: 0, months: 0};
+ }
- this.path = path;
- this.fd = null;
- this.readable = true;
- this.paused = false;
+ other = cloneWithOffset(other, base);
+ if (base.isBefore(other)) {
+ res = positiveMomentsDifference(base, other);
+ } else {
+ res = positiveMomentsDifference(other, base);
+ res.milliseconds = -res.milliseconds;
+ res.months = -res.months;
+ }
- this.flags = 'r';
- this.mode = 438; /*=0666*/
- this.bufferSize = 64 * 1024;
+ return res;
+ }
- options = options || {};
+ // TODO: remove 'name' arg after deprecation is removed
+ function createAdder(direction, name) {
+ return function (val, period) {
+ var dur, tmp;
+ //invert the arguments, but complain about it
+ if (period !== null && !isNaN(+period)) {
+ deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +
+ 'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');
+ tmp = val; val = period; period = tmp;
+ }
- // Mixin options into this
- var keys = Object.keys(options);
- for (var index = 0, length = keys.length; index < length; index++) {
- var key = keys[index];
- this[key] = options[key];
+ val = typeof val === 'string' ? +val : val;
+ dur = createDuration(val, period);
+ addSubtract(this, dur, direction);
+ return this;
+ };
}
- if (this.encoding) this.setEncoding(this.encoding);
-
- if (this.start !== undefined) {
- if ('number' !== typeof this.start) {
- throw TypeError('start must be a Number');
- }
- if (this.end === undefined) {
- this.end = Infinity;
- } else if ('number' !== typeof this.end) {
- throw TypeError('end must be a Number');
- }
+ function addSubtract (mom, duration, isAdding, updateOffset) {
+ var milliseconds = duration._milliseconds,
+ days = absRound(duration._days),
+ months = absRound(duration._months);
- if (this.start > this.end) {
- throw new Error('start must be <= end');
- }
+ if (!mom.isValid()) {
+ // No op
+ return;
+ }
- this.pos = this.start;
- }
+ updateOffset = updateOffset == null ? true : updateOffset;
- if (this.fd !== null) {
- process.nextTick(function() {
- self._read();
- });
- return;
+ if (months) {
+ setMonth(mom, get(mom, 'Month') + months * isAdding);
+ }
+ if (days) {
+ set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
+ }
+ if (milliseconds) {
+ mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);
+ }
+ if (updateOffset) {
+ hooks.updateOffset(mom, days || months);
+ }
}
- fs.open(this.path, this.flags, this.mode, function (err, fd) {
- if (err) {
- self.emit('error', err);
- self.readable = false;
- return;
- }
+ var add = createAdder(1, 'add');
+ var subtract = createAdder(-1, 'subtract');
- self.fd = fd;
- self.emit('open', fd);
- self._read();
- })
- }
+ function getCalendarFormat(myMoment, now) {
+ var diff = myMoment.diff(now, 'days', true);
+ return diff < -6 ? 'sameElse' :
+ diff < -1 ? 'lastWeek' :
+ diff < 0 ? 'lastDay' :
+ diff < 1 ? 'sameDay' :
+ diff < 2 ? 'nextDay' :
+ diff < 7 ? 'nextWeek' : 'sameElse';
+ }
- function WriteStream (path, options) {
- if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+ function calendar$1 (time, formats) {
+ // We want to compare the start of today, vs this.
+ // Getting start-of-today depends on whether we're local/utc/offset or not.
+ var now = time || createLocal(),
+ sod = cloneWithOffset(now, this).startOf('day'),
+ format = hooks.calendarFormat(this, sod) || 'sameElse';
- Stream.call(this);
+ var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);
- this.path = path;
- this.fd = null;
- this.writable = true;
+ return this.format(output || this.localeData().calendar(format, this, createLocal(now)));
+ }
- this.flags = 'w';
- this.encoding = 'binary';
- this.mode = 438; /*=0666*/
- this.bytesWritten = 0;
+ function clone () {
+ return new Moment(this);
+ }
- options = options || {};
+ function isAfter (input, units) {
+ var localInput = isMoment(input) ? input : createLocal(input);
+ if (!(this.isValid() && localInput.isValid())) {
+ return false;
+ }
+ units = normalizeUnits(units) || 'millisecond';
+ if (units === 'millisecond') {
+ return this.valueOf() > localInput.valueOf();
+ } else {
+ return localInput.valueOf() < this.clone().startOf(units).valueOf();
+ }
+ }
- // Mixin options into this
- var keys = Object.keys(options);
- for (var index = 0, length = keys.length; index < length; index++) {
- var key = keys[index];
- this[key] = options[key];
+ function isBefore (input, units) {
+ var localInput = isMoment(input) ? input : createLocal(input);
+ if (!(this.isValid() && localInput.isValid())) {
+ return false;
+ }
+ units = normalizeUnits(units) || 'millisecond';
+ if (units === 'millisecond') {
+ return this.valueOf() < localInput.valueOf();
+ } else {
+ return this.clone().endOf(units).valueOf() < localInput.valueOf();
+ }
}
- if (this.start !== undefined) {
- if ('number' !== typeof this.start) {
- throw TypeError('start must be a Number');
- }
- if (this.start < 0) {
- throw new Error('start must be >= zero');
- }
+ function isBetween (from, to, units, inclusivity) {
+ var localFrom = isMoment(from) ? from : createLocal(from),
+ localTo = isMoment(to) ? to : createLocal(to);
+ if (!(this.isValid() && localFrom.isValid() && localTo.isValid())) {
+ return false;
+ }
+ inclusivity = inclusivity || '()';
+ return (inclusivity[0] === '(' ? this.isAfter(localFrom, units) : !this.isBefore(localFrom, units)) &&
+ (inclusivity[1] === ')' ? this.isBefore(localTo, units) : !this.isAfter(localTo, units));
+ }
- this.pos = this.start;
+ function isSame (input, units) {
+ var localInput = isMoment(input) ? input : createLocal(input),
+ inputMs;
+ if (!(this.isValid() && localInput.isValid())) {
+ return false;
+ }
+ units = normalizeUnits(units) || 'millisecond';
+ if (units === 'millisecond') {
+ return this.valueOf() === localInput.valueOf();
+ } else {
+ inputMs = localInput.valueOf();
+ return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();
+ }
}
- this.busy = false;
- this._queue = [];
+ function isSameOrAfter (input, units) {
+ return this.isSame(input, units) || this.isAfter(input, units);
+ }
- if (this.fd === null) {
- this._open = fs.open;
- this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
- this.flush();
+ function isSameOrBefore (input, units) {
+ return this.isSame(input, units) || this.isBefore(input, units);
}
- }
-}
+ function diff (input, units, asFloat) {
+ var that,
+ zoneDelta,
+ output;
-/***/ }),
-/* 27 */
-/***/ (function(module, exports) {
+ if (!this.isValid()) {
+ return NaN;
+ }
-module.exports = require("stream");
+ that = cloneWithOffset(input, this);
-/***/ }),
-/* 28 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (!that.isValid()) {
+ return NaN;
+ }
-"use strict";
+ zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
+ units = normalizeUnits(units);
-module.exports = clone
+ switch (units) {
+ case 'year': output = monthDiff(this, that) / 12; break;
+ case 'month': output = monthDiff(this, that); break;
+ case 'quarter': output = monthDiff(this, that) / 3; break;
+ case 'second': output = (this - that) / 1e3; break; // 1000
+ case 'minute': output = (this - that) / 6e4; break; // 1000 * 60
+ case 'hour': output = (this - that) / 36e5; break; // 1000 * 60 * 60
+ case 'day': output = (this - that - zoneDelta) / 864e5; break; // 1000 * 60 * 60 * 24, negate dst
+ case 'week': output = (this - that - zoneDelta) / 6048e5; break; // 1000 * 60 * 60 * 24 * 7, negate dst
+ default: output = this - that;
+ }
-function clone (obj) {
- if (obj === null || typeof obj !== 'object')
- return obj
+ return asFloat ? output : absFloor(output);
+ }
- if (obj instanceof Object)
- var copy = { __proto__: obj.__proto__ }
- else
- var copy = Object.create(null)
+ function monthDiff (a, b) {
+ // difference in months
+ var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),
+ // b is in (anchor - 1 month, anchor + 1 month)
+ anchor = a.clone().add(wholeMonthDiff, 'months'),
+ anchor2, adjust;
- Object.getOwnPropertyNames(obj).forEach(function (key) {
- Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
- })
+ if (b - anchor < 0) {
+ anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
+ // linear across the month
+ adjust = (b - anchor) / (anchor - anchor2);
+ } else {
+ anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
+ // linear across the month
+ adjust = (b - anchor) / (anchor2 - anchor);
+ }
- return copy
-}
+ //check for negative zero, return zero if negative zero
+ return -(wholeMonthDiff + adjust) || 0;
+ }
+ hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
+ hooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';
-/***/ }),
-/* 29 */
-/***/ (function(module, exports) {
+ function toString () {
+ return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
+ }
-module.exports = require("util");
+ function toISOString(keepOffset) {
+ if (!this.isValid()) {
+ return null;
+ }
+ var utc = keepOffset !== true;
+ var m = utc ? this.clone().utc() : this;
+ if (m.year() < 0 || m.year() > 9999) {
+ return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');
+ }
+ if (isFunction(Date.prototype.toISOString)) {
+ // native implementation is ~50x faster, use it when we can
+ if (utc) {
+ return this.toDate().toISOString();
+ } else {
+ return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m, 'Z'));
+ }
+ }
+ return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ');
+ }
-/***/ }),
-/* 30 */
-/***/ (function(module, exports) {
+ /**
+ * Return a human readable representation of a moment that can
+ * also be evaluated to get a new moment which is the same
+ *
+ * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects
+ */
+ function inspect () {
+ if (!this.isValid()) {
+ return 'moment.invalid(/* ' + this._i + ' */)';
+ }
+ var func = 'moment';
+ var zone = '';
+ if (!this.isLocal()) {
+ func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';
+ zone = 'Z';
+ }
+ var prefix = '[' + func + '("]';
+ var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';
+ var datetime = '-MM-DD[T]HH:mm:ss.SSS';
+ var suffix = zone + '[")]';
-module.exports = require("assert");
+ return this.format(prefix + year + datetime + suffix);
+ }
-/***/ }),
-/* 31 */
-/***/ (function(module, exports, __webpack_require__) {
+ function format (inputString) {
+ if (!inputString) {
+ inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;
+ }
+ var output = formatMoment(this, inputString);
+ return this.localeData().postformat(output);
+ }
-var path = __webpack_require__(16);
-var fs = __webpack_require__(23);
-var _0777 = parseInt('0777', 8);
+ function from (time, withoutSuffix) {
+ if (this.isValid() &&
+ ((isMoment(time) && time.isValid()) ||
+ createLocal(time).isValid())) {
+ return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);
+ } else {
+ return this.localeData().invalidDate();
+ }
+ }
-module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
+ function fromNow (withoutSuffix) {
+ return this.from(createLocal(), withoutSuffix);
+ }
-function mkdirP (p, opts, f, made) {
- if (typeof opts === 'function') {
- f = opts;
- opts = {};
+ function to (time, withoutSuffix) {
+ if (this.isValid() &&
+ ((isMoment(time) && time.isValid()) ||
+ createLocal(time).isValid())) {
+ return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);
+ } else {
+ return this.localeData().invalidDate();
+ }
}
- else if (!opts || typeof opts !== 'object') {
- opts = { mode: opts };
+
+ function toNow (withoutSuffix) {
+ return this.to(createLocal(), withoutSuffix);
}
-
- var mode = opts.mode;
- var xfs = opts.fs || fs;
-
- if (mode === undefined) {
- mode = _0777 & (~process.umask());
- }
- if (!made) made = null;
-
- var cb = f || function () {};
- p = path.resolve(p);
-
- xfs.mkdir(p, mode, function (er) {
- if (!er) {
- made = made || p;
- return cb(null, made);
+
+ // If passed a locale key, it will set the locale for this
+ // instance. Otherwise, it will return the locale configuration
+ // variables for this instance.
+ function locale (key) {
+ var newLocaleData;
+
+ if (key === undefined) {
+ return this._locale._abbr;
+ } else {
+ newLocaleData = getLocale(key);
+ if (newLocaleData != null) {
+ this._locale = newLocaleData;
+ }
+ return this;
}
- switch (er.code) {
- case 'ENOENT':
- if (path.dirname(p) === p) return cb(er);
- mkdirP(path.dirname(p), opts, function (er, made) {
- if (er) cb(er, made);
- else mkdirP(p, opts, cb, made);
- });
- break;
+ }
- // In the case of any other error, just see if there's a dir
- // there already. If so, then hooray! If not, then something
- // is borked.
- default:
- xfs.stat(p, function (er2, stat) {
- // if the stat fails, then that's super weird.
- // let the original error be the failure reason.
- if (er2 || !stat.isDirectory()) cb(er, made)
- else cb(null, made);
- });
- break;
+ var lang = deprecate(
+ 'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',
+ function (key) {
+ if (key === undefined) {
+ return this.localeData();
+ } else {
+ return this.locale(key);
+ }
}
- });
-}
+ );
-mkdirP.sync = function sync (p, opts, made) {
- if (!opts || typeof opts !== 'object') {
- opts = { mode: opts };
+ function localeData () {
+ return this._locale;
}
-
- var mode = opts.mode;
- var xfs = opts.fs || fs;
-
- if (mode === undefined) {
- mode = _0777 & (~process.umask());
+
+ var MS_PER_SECOND = 1000;
+ var MS_PER_MINUTE = 60 * MS_PER_SECOND;
+ var MS_PER_HOUR = 60 * MS_PER_MINUTE;
+ var MS_PER_400_YEARS = (365 * 400 + 97) * 24 * MS_PER_HOUR;
+
+ // actual modulo - handles negative numbers (for dates before 1970):
+ function mod$1(dividend, divisor) {
+ return (dividend % divisor + divisor) % divisor;
}
- if (!made) made = null;
- p = path.resolve(p);
+ function localStartOfDate(y, m, d) {
+ // the date constructor remaps years 0-99 to 1900-1999
+ if (y < 100 && y >= 0) {
+ // preserve leap years using a full 400 year cycle, then reset
+ return new Date(y + 400, m, d) - MS_PER_400_YEARS;
+ } else {
+ return new Date(y, m, d).valueOf();
+ }
+ }
- try {
- xfs.mkdirSync(p, mode);
- made = made || p;
+ function utcStartOfDate(y, m, d) {
+ // Date.UTC remaps years 0-99 to 1900-1999
+ if (y < 100 && y >= 0) {
+ // preserve leap years using a full 400 year cycle, then reset
+ return Date.UTC(y + 400, m, d) - MS_PER_400_YEARS;
+ } else {
+ return Date.UTC(y, m, d);
+ }
}
- catch (err0) {
- switch (err0.code) {
- case 'ENOENT' :
- made = sync(path.dirname(p), opts, made);
- sync(p, opts, made);
- break;
- // In the case of any other error, just see if there's a dir
- // there already. If so, then hooray! If not, then something
- // is borked.
- default:
- var stat;
- try {
- stat = xfs.statSync(p);
- }
- catch (err1) {
- throw err0;
- }
- if (!stat.isDirectory()) throw err0;
+ function startOf (units) {
+ var time;
+ units = normalizeUnits(units);
+ if (units === undefined || units === 'millisecond' || !this.isValid()) {
+ return this;
+ }
+
+ var startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
+
+ switch (units) {
+ case 'year':
+ time = startOfDate(this.year(), 0, 1);
+ break;
+ case 'quarter':
+ time = startOfDate(this.year(), this.month() - this.month() % 3, 1);
+ break;
+ case 'month':
+ time = startOfDate(this.year(), this.month(), 1);
+ break;
+ case 'week':
+ time = startOfDate(this.year(), this.month(), this.date() - this.weekday());
+ break;
+ case 'isoWeek':
+ time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1));
+ break;
+ case 'day':
+ case 'date':
+ time = startOfDate(this.year(), this.month(), this.date());
+ break;
+ case 'hour':
+ time = this._d.valueOf();
+ time -= mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR);
+ break;
+ case 'minute':
+ time = this._d.valueOf();
+ time -= mod$1(time, MS_PER_MINUTE);
+ break;
+ case 'second':
+ time = this._d.valueOf();
+ time -= mod$1(time, MS_PER_SECOND);
break;
}
+
+ this._d.setTime(time);
+ hooks.updateOffset(this, true);
+ return this;
}
- return made;
-};
+ function endOf (units) {
+ var time;
+ units = normalizeUnits(units);
+ if (units === undefined || units === 'millisecond' || !this.isValid()) {
+ return this;
+ }
+ var startOfDate = this._isUTC ? utcStartOfDate : localStartOfDate;
-/***/ }),
-/* 32 */
-/***/ (function(module, exports) {
+ switch (units) {
+ case 'year':
+ time = startOfDate(this.year() + 1, 0, 1) - 1;
+ break;
+ case 'quarter':
+ time = startOfDate(this.year(), this.month() - this.month() % 3 + 3, 1) - 1;
+ break;
+ case 'month':
+ time = startOfDate(this.year(), this.month() + 1, 1) - 1;
+ break;
+ case 'week':
+ time = startOfDate(this.year(), this.month(), this.date() - this.weekday() + 7) - 1;
+ break;
+ case 'isoWeek':
+ time = startOfDate(this.year(), this.month(), this.date() - (this.isoWeekday() - 1) + 7) - 1;
+ break;
+ case 'day':
+ case 'date':
+ time = startOfDate(this.year(), this.month(), this.date() + 1) - 1;
+ break;
+ case 'hour':
+ time = this._d.valueOf();
+ time += MS_PER_HOUR - mod$1(time + (this._isUTC ? 0 : this.utcOffset() * MS_PER_MINUTE), MS_PER_HOUR) - 1;
+ break;
+ case 'minute':
+ time = this._d.valueOf();
+ time += MS_PER_MINUTE - mod$1(time, MS_PER_MINUTE) - 1;
+ break;
+ case 'second':
+ time = this._d.valueOf();
+ time += MS_PER_SECOND - mod$1(time, MS_PER_SECOND) - 1;
+ break;
+ }
-exports.replaceDollarWithPercentPair = replaceDollarWithPercentPair
-exports.convertToSetCommand = convertToSetCommand
-exports.convertToSetCommands = convertToSetCommands
-
-function convertToSetCommand(key, value) {
- var line = ""
- key = key || ""
- key = key.trim()
- value = value || ""
- value = value.trim()
- if(key && value && value.length > 0) {
- line = "@SET " + key + "=" + replaceDollarWithPercentPair(value) + "\r\n"
- }
- return line
-}
-
-function extractVariableValuePairs(declarations) {
- var pairs = {}
- declarations.map(function(declaration) {
- var split = declaration.split("=")
- pairs[split[0]]=split[1]
- })
- return pairs
-}
-
-function convertToSetCommands(variableString) {
- var variableValuePairs = extractVariableValuePairs(variableString.split(" "))
- var variableDeclarationsAsBatch = ""
- Object.keys(variableValuePairs).forEach(function (key) {
- variableDeclarationsAsBatch += convertToSetCommand(key, variableValuePairs[key])
- })
- return variableDeclarationsAsBatch
-}
-
-function replaceDollarWithPercentPair(value) {
- var dollarExpressions = /\$\{?([^\$@#\?\- \t{}:]+)\}?/g
- var result = ""
- var startIndex = 0
- value = value || ""
- do {
- var match = dollarExpressions.exec(value)
- if(match) {
- var betweenMatches = value.substring(startIndex, match.index) || ""
- result += betweenMatches + "%" + match[1] + "%"
- startIndex = dollarExpressions.lastIndex
- }
- } while (dollarExpressions.lastIndex > 0)
- result += value.substr(startIndex)
- return result
-}
-
-
+ this._d.setTime(time);
+ hooks.updateOffset(this, true);
+ return this;
+ }
+ function valueOf () {
+ return this._d.valueOf() - ((this._offset || 0) * 60000);
+ }
-/***/ }),
-/* 33 */
-/***/ (function(module, exports, __webpack_require__) {
+ function unix () {
+ return Math.floor(this.valueOf() / 1000);
+ }
-var fs = __webpack_require__(23),
- path = __webpack_require__(16);
+ function toDate () {
+ return new Date(this.valueOf());
+ }
-module.exports = ncp;
-ncp.ncp = ncp;
+ function toArray () {
+ var m = this;
+ return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];
+ }
-function ncp (source, dest, options, callback) {
- var cback = callback;
+ function toObject () {
+ var m = this;
+ return {
+ years: m.year(),
+ months: m.month(),
+ date: m.date(),
+ hours: m.hours(),
+ minutes: m.minutes(),
+ seconds: m.seconds(),
+ milliseconds: m.milliseconds()
+ };
+ }
- if (!callback) {
- cback = options;
- options = {};
- }
+ function toJSON () {
+ // new Date(NaN).toJSON() === null
+ return this.isValid() ? this.toISOString() : null;
+ }
- var basePath = process.cwd(),
- currentPath = path.resolve(basePath, source),
- targetPath = path.resolve(basePath, dest),
- filter = options.filter,
- rename = options.rename,
- transform = options.transform,
- clobber = options.clobber !== false,
- modified = options.modified,
- dereference = options.dereference,
- errs = null,
- started = 0,
- finished = 0,
- running = 0,
- limit = options.limit || ncp.limit || 16;
+ function isValid$2 () {
+ return isValid(this);
+ }
- limit = (limit < 1) ? 1 : (limit > 512) ? 512 : limit;
+ function parsingFlags () {
+ return extend({}, getParsingFlags(this));
+ }
- startCopy(currentPath);
-
- function startCopy(source) {
- started++;
- if (filter) {
- if (filter instanceof RegExp) {
- if (!filter.test(source)) {
- return cb(true);
- }
- }
- else if (typeof filter === 'function') {
- if (!filter(source)) {
- return cb(true);
- }
- }
+ function invalidAt () {
+ return getParsingFlags(this).overflow;
}
- return getStats(source);
- }
- function getStats(source) {
- var stat = dereference ? fs.stat : fs.lstat;
- if (running >= limit) {
- return setImmediate(function () {
- getStats(source);
- });
+ function creationData() {
+ return {
+ input: this._i,
+ format: this._f,
+ locale: this._locale,
+ isUTC: this._isUTC,
+ strict: this._strict
+ };
}
- running++;
- stat(source, function (err, stats) {
- var item = {};
- if (err) {
- return onError(err);
- }
- // We need to get the mode from the stats object and preserve it.
- item.name = source;
- item.mode = stats.mode;
- item.mtime = stats.mtime; //modified time
- item.atime = stats.atime; //access time
+ // FORMATTING
- if (stats.isDirectory()) {
- return onDir(item);
- }
- else if (stats.isFile()) {
- return onFile(item);
- }
- else if (stats.isSymbolicLink()) {
- // Symlinks don't really need to know about the mode.
- return onLink(source);
- }
+ addFormatToken(0, ['gg', 2], 0, function () {
+ return this.weekYear() % 100;
});
- }
- function onFile(file) {
- var target = file.name.replace(currentPath, targetPath);
- if(rename) {
- target = rename(target);
- }
- isWritable(target, function (writable) {
- if (writable) {
- return copyFile(file, target);
- }
- if(clobber) {
- rmFile(target, function () {
- copyFile(file, target);
- });
- }
- if (modified) {
- var stat = dereference ? fs.stat : fs.lstat;
- stat(target, function(err, stats) {
- //if souce modified time greater to target modified time copy file
- if (file.mtime.getTime()>stats.mtime.getTime())
- copyFile(file, target);
- else return cb();
- });
- }
- else {
- return cb();
- }
+ addFormatToken(0, ['GG', 2], 0, function () {
+ return this.isoWeekYear() % 100;
});
- }
- function copyFile(file, target) {
- var readStream = fs.createReadStream(file.name),
- writeStream = fs.createWriteStream(target, { mode: file.mode });
-
- readStream.on('error', onError);
- writeStream.on('error', onError);
-
- if(transform) {
- transform(readStream, writeStream, file);
- } else {
- writeStream.on('open', function() {
- readStream.pipe(writeStream);
- });
+ function addWeekYearFormatToken (token, getter) {
+ addFormatToken(0, [token, token.length], 0, getter);
}
- writeStream.once('finish', function() {
- if (modified) {
- //target file modified date sync.
- fs.utimesSync(target, file.atime, file.mtime);
- cb();
- }
- else cb();
- });
- }
- function rmFile(file, done) {
- fs.unlink(file, function (err) {
- if (err) {
- return onError(err);
- }
- return done();
- });
- }
+ addWeekYearFormatToken('gggg', 'weekYear');
+ addWeekYearFormatToken('ggggg', 'weekYear');
+ addWeekYearFormatToken('GGGG', 'isoWeekYear');
+ addWeekYearFormatToken('GGGGG', 'isoWeekYear');
- function onDir(dir) {
- var target = dir.name.replace(currentPath, targetPath);
- isWritable(target, function (writable) {
- if (writable) {
- return mkDir(dir, target);
- }
- copyDir(dir.name);
- });
- }
+ // ALIASES
- function mkDir(dir, target) {
- fs.mkdir(target, dir.mode, function (err) {
- if (err) {
- return onError(err);
- }
- copyDir(dir.name);
- });
- }
+ addUnitAlias('weekYear', 'gg');
+ addUnitAlias('isoWeekYear', 'GG');
- function copyDir(dir) {
- fs.readdir(dir, function (err, items) {
- if (err) {
- return onError(err);
- }
- items.forEach(function (item) {
- startCopy(path.join(dir, item));
- });
- return cb();
+ // PRIORITY
+
+ addUnitPriority('weekYear', 1);
+ addUnitPriority('isoWeekYear', 1);
+
+
+ // PARSING
+
+ addRegexToken('G', matchSigned);
+ addRegexToken('g', matchSigned);
+ addRegexToken('GG', match1to2, match2);
+ addRegexToken('gg', match1to2, match2);
+ addRegexToken('GGGG', match1to4, match4);
+ addRegexToken('gggg', match1to4, match4);
+ addRegexToken('GGGGG', match1to6, match6);
+ addRegexToken('ggggg', match1to6, match6);
+
+ addWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {
+ week[token.substr(0, 2)] = toInt(input);
});
- }
- function onLink(link) {
- var target = link.replace(currentPath, targetPath);
- fs.readlink(link, function (err, resolvedPath) {
- if (err) {
- return onError(err);
- }
- checkLink(resolvedPath, target);
+ addWeekParseToken(['gg', 'GG'], function (input, week, config, token) {
+ week[token] = hooks.parseTwoDigitYear(input);
});
- }
- function checkLink(resolvedPath, target) {
- if (dereference) {
- resolvedPath = path.resolve(basePath, resolvedPath);
- }
- isWritable(target, function (writable) {
- if (writable) {
- return makeLink(resolvedPath, target);
- }
- fs.readlink(target, function (err, targetDest) {
- if (err) {
- return onError(err);
- }
- if (dereference) {
- targetDest = path.resolve(basePath, targetDest);
- }
- if (targetDest === resolvedPath) {
- return cb();
- }
- return rmFile(target, function () {
- makeLink(resolvedPath, target);
- });
- });
- });
- }
-
- function makeLink(linkPath, target) {
- fs.symlink(linkPath, target, function (err) {
- if (err) {
- return onError(err);
- }
- return cb();
- });
- }
-
- function isWritable(path, done) {
- fs.lstat(path, function (err) {
- if (err) {
- if (err.code === 'ENOENT') return done(true);
- return done(false);
- }
- return done(false);
- });
- }
+ // MOMENTS
- function onError(err) {
- if (options.stopOnError) {
- return cback(err);
+ function getSetWeekYear (input) {
+ return getSetWeekYearHelper.call(this,
+ input,
+ this.week(),
+ this.weekday(),
+ this.localeData()._week.dow,
+ this.localeData()._week.doy);
}
- else if (!errs && options.errs) {
- errs = fs.createWriteStream(options.errs);
+
+ function getSetISOWeekYear (input) {
+ return getSetWeekYearHelper.call(this,
+ input, this.isoWeek(), this.isoWeekday(), 1, 4);
}
- else if (!errs) {
- errs = [];
+
+ function getISOWeeksInYear () {
+ return weeksInYear(this.year(), 1, 4);
}
- if (typeof errs.write === 'undefined') {
- errs.push(err);
+
+ function getWeeksInYear () {
+ var weekInfo = this.localeData()._week;
+ return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);
}
- else {
- errs.write(err.stack + '\n\n');
+
+ function getSetWeekYearHelper(input, week, weekday, dow, doy) {
+ var weeksTarget;
+ if (input == null) {
+ return weekOfYear(this, dow, doy).year;
+ } else {
+ weeksTarget = weeksInYear(input, dow, doy);
+ if (week > weeksTarget) {
+ week = weeksTarget;
+ }
+ return setWeekAll.call(this, input, week, weekday, dow, doy);
+ }
}
- return cb();
- }
- function cb(skipped) {
- if (!skipped) running--;
- finished++;
- if ((started === finished) && (running === 0)) {
- if (cback !== undefined ) {
- return errs ? cback(errs) : cback(null);
- }
+ function setWeekAll(weekYear, week, weekday, dow, doy) {
+ var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),
+ date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
+
+ this.year(date.getUTCFullYear());
+ this.month(date.getUTCMonth());
+ this.date(date.getUTCDate());
+ return this;
}
- }
-}
+ // FORMATTING
+ addFormatToken('Q', 0, 'Qo', 'quarter');
+ // ALIASES
-/***/ }),
-/* 34 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ addUnitAlias('quarter', 'Q');
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "log", function() { return log; });
-/* harmony import */ var _kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(35);
-/* harmony import */ var _kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0__);
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+ // PRIORITY
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
+ addUnitPriority('quarter', 7);
+ // PARSING
-class Log extends _kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0__["ToolingLog"] {
- constructor() {
- super({
- level: 'info',
- writeTo: process.stdout
+ addRegexToken('Q', match1);
+ addParseToken('Q', function (input, array) {
+ array[MONTH] = (toInt(input) - 1) * 3;
});
- _defineProperty(this, "testWriter", void 0);
- }
- /**
- * Log something to the console. Ideally we would use a real logger in
- * kbn-pm, but that's a pretty big change for now.
- * @param ...args
- */
-
+ // MOMENTS
- write(...args) {
- // eslint-disable-next-line no-console
- console.log(...args);
- }
+ function getSetQuarter (input) {
+ return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);
+ }
-}
+ // FORMATTING
-const log = new Log();
+ addFormatToken('D', ['DD', 2], 'Do', 'date');
-/***/ }),
-/* 35 */
-/***/ (function(module, exports, __webpack_require__) {
+ // ALIASES
-"use strict";
+ addUnitAlias('date', 'D');
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-var proc_runner_1 = __webpack_require__(37);
-exports.withProcRunner = proc_runner_1.withProcRunner;
-exports.ProcRunner = proc_runner_1.ProcRunner;
-tslib_1.__exportStar(__webpack_require__(414), exports);
-var serializers_1 = __webpack_require__(419);
-exports.createAbsolutePathSerializer = serializers_1.createAbsolutePathSerializer;
-var certs_1 = __webpack_require__(443);
-exports.CA_CERT_PATH = certs_1.CA_CERT_PATH;
-exports.ES_KEY_PATH = certs_1.ES_KEY_PATH;
-exports.ES_CERT_PATH = certs_1.ES_CERT_PATH;
-exports.ES_P12_PATH = certs_1.ES_P12_PATH;
-exports.ES_P12_PASSWORD = certs_1.ES_P12_PASSWORD;
-exports.ES_EMPTYPASSWORD_P12_PATH = certs_1.ES_EMPTYPASSWORD_P12_PATH;
-exports.ES_NOPASSWORD_P12_PATH = certs_1.ES_NOPASSWORD_P12_PATH;
-exports.KBN_KEY_PATH = certs_1.KBN_KEY_PATH;
-exports.KBN_CERT_PATH = certs_1.KBN_CERT_PATH;
-exports.KBN_P12_PATH = certs_1.KBN_P12_PATH;
-exports.KBN_P12_PASSWORD = certs_1.KBN_P12_PASSWORD;
-var run_1 = __webpack_require__(444);
-exports.run = run_1.run;
-exports.createFailError = run_1.createFailError;
-exports.createFlagError = run_1.createFlagError;
-exports.combineErrors = run_1.combineErrors;
-exports.isFailError = run_1.isFailError;
-var repo_root_1 = __webpack_require__(421);
-exports.REPO_ROOT = repo_root_1.REPO_ROOT;
-var kbn_client_1 = __webpack_require__(449);
-exports.KbnClient = kbn_client_1.KbnClient;
-tslib_1.__exportStar(__webpack_require__(492), exports);
-tslib_1.__exportStar(__webpack_require__(499), exports);
+ // PRIORITY
+ addUnitPriority('date', 9);
+ // PARSING
-/***/ }),
-/* 36 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ addRegexToken('D', match1to2);
+ addRegexToken('DD', match1to2, match2);
+ addRegexToken('Do', function (isStrict, locale) {
+ // TODO: Remove "ordinalParse" fallback in next major release.
+ return isStrict ?
+ (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :
+ locale._dayOfMonthOrdinalParseLenient;
+ });
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__extends", function() { return __extends; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__assign", function() { return __assign; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__rest", function() { return __rest; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__decorate", function() { return __decorate; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__param", function() { return __param; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__metadata", function() { return __metadata; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__awaiter", function() { return __awaiter; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__generator", function() { return __generator; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__exportStar", function() { return __exportStar; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__values", function() { return __values; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__read", function() { return __read; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spread", function() { return __spread; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__await", function() { return __await; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncGenerator", function() { return __asyncGenerator; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncDelegator", function() { return __asyncDelegator; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncValues", function() { return __asyncValues; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__makeTemplateObject", function() { return __makeTemplateObject; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importStar", function() { return __importStar; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importDefault", function() { return __importDefault; });
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-var extendStatics = function(d, b) {
- extendStatics = Object.setPrototypeOf ||
- ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
- function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
- return extendStatics(d, b);
-};
-
-function __extends(d, b) {
- extendStatics(d, b);
- function __() { this.constructor = d; }
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
- __assign = Object.assign || function __assign(t) {
- for (var s, i = 1, n = arguments.length; i < n; i++) {
- s = arguments[i];
- for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
- }
- return t;
- }
- return __assign.apply(this, arguments);
-}
-
-function __rest(s, e) {
- var t = {};
- for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
- t[p] = s[p];
- if (s != null && typeof Object.getOwnPropertySymbols === "function")
- for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
- t[p[i]] = s[p[i]];
- return t;
-}
-
-function __decorate(decorators, target, key, desc) {
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
- return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __param(paramIndex, decorator) {
- return function (target, key) { decorator(target, key, paramIndex); }
-}
-
-function __metadata(metadataKey, metadataValue) {
- if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
- function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
- step((generator = generator.apply(thisArg, _arguments || [])).next());
- });
-}
-
-function __generator(thisArg, body) {
- var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
- return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
- function verb(n) { return function (v) { return step([n, v]); }; }
- function step(op) {
- if (f) throw new TypeError("Generator is already executing.");
- while (_) try {
- if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
- if (y = 0, t) op = [op[0] & 2, t.value];
- switch (op[0]) {
- case 0: case 1: t = op; break;
- case 4: _.label++; return { value: op[1], done: false };
- case 5: _.label++; y = op[1]; op = [0]; continue;
- case 7: op = _.ops.pop(); _.trys.pop(); continue;
- default:
- if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
- if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
- if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
- if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
- if (t[2]) _.ops.pop();
- _.trys.pop(); continue;
- }
- op = body.call(thisArg, _);
- } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
- if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
- }
-}
-
-function __exportStar(m, exports) {
- for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-
-function __values(o) {
- var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
- if (m) return m.call(o);
- return {
- next: function () {
- if (o && i >= o.length) o = void 0;
- return { value: o && o[i++], done: !o };
- }
- };
-}
-
-function __read(o, n) {
- var m = typeof Symbol === "function" && o[Symbol.iterator];
- if (!m) return o;
- var i = m.call(o), r, ar = [], e;
- try {
- while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
- }
- catch (error) { e = { error: error }; }
- finally {
- try {
- if (r && !r.done && (m = i["return"])) m.call(i);
- }
- finally { if (e) throw e.error; }
- }
- return ar;
-}
-
-function __spread() {
- for (var ar = [], i = 0; i < arguments.length; i++)
- ar = ar.concat(__read(arguments[i]));
- return ar;
-}
-
-function __await(v) {
- return this instanceof __await ? (this.v = v, this) : new __await(v);
-}
-
-function __asyncGenerator(thisArg, _arguments, generator) {
- if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
- var g = generator.apply(thisArg, _arguments || []), i, q = [];
- return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
- function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
- function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
- function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
- function fulfill(value) { resume("next", value); }
- function reject(value) { resume("throw", value); }
- function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-}
-
-function __asyncDelegator(o) {
- var i, p;
- return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
- function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
-}
-
-function __asyncValues(o) {
- if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
- var m = o[Symbol.asyncIterator], i;
- return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
- function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
- function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-}
-
-function __makeTemplateObject(cooked, raw) {
- if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
- return cooked;
-};
-
-function __importStar(mod) {
- if (mod && mod.__esModule) return mod;
- var result = {};
- if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
- result.default = mod;
- return result;
-}
-
-function __importDefault(mod) {
- return (mod && mod.__esModule) ? mod : { default: mod };
-}
+ addParseToken(['D', 'DD'], DATE);
+ addParseToken('Do', function (input, array) {
+ array[DATE] = toInt(input.match(match1to2)[0]);
+ });
+ // MOMENTS
-/***/ }),
-/* 37 */
-/***/ (function(module, exports, __webpack_require__) {
+ var getSetDayOfMonth = makeGetSet('Date', true);
-"use strict";
+ // FORMATTING
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-var with_proc_runner_1 = __webpack_require__(38);
-exports.withProcRunner = with_proc_runner_1.withProcRunner;
-var proc_runner_1 = __webpack_require__(39);
-exports.ProcRunner = proc_runner_1.ProcRunner;
+ addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
+ // ALIASES
-/***/ }),
-/* 38 */
-/***/ (function(module, exports, __webpack_require__) {
+ addUnitAlias('dayOfYear', 'DDD');
-"use strict";
+ // PRIORITY
+ addUnitPriority('dayOfYear', 4);
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const proc_runner_1 = __webpack_require__(39);
-/**
- * Create a ProcRunner and pass it to an async function. When
- * the async function finishes the ProcRunner is torn-down
- * automatically
- *
- * @param {ToolingLog} log
- * @param {async Function} fn
- * @return {Promise}
- */
-async function withProcRunner(log, fn) {
- const procs = new proc_runner_1.ProcRunner(log);
- try {
- await fn(procs);
- }
- finally {
- await procs.teardown();
- }
-}
-exports.withProcRunner = withProcRunner;
+ // PARSING
+ addRegexToken('DDD', match1to3);
+ addRegexToken('DDDD', match3);
+ addParseToken(['DDD', 'DDDD'], function (input, array, config) {
+ config._dayOfYear = toInt(input);
+ });
-/***/ }),
-/* 39 */
-/***/ (function(module, exports, __webpack_require__) {
+ // HELPERS
-"use strict";
+ // MOMENTS
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const moment_1 = tslib_1.__importDefault(__webpack_require__(40));
-const Rx = tslib_1.__importStar(__webpack_require__(169));
-const operators_1 = __webpack_require__(270);
-const exit_hook_1 = tslib_1.__importDefault(__webpack_require__(368));
-const errors_1 = __webpack_require__(369);
-const proc_1 = __webpack_require__(370);
-const SECOND = 1000;
-const MINUTE = 60 * SECOND;
-const noop = () => { };
-/**
- * Helper for starting and managing processes. In many ways it resembles the
- * API from `grunt_run`, processes are named and can be started, waited for,
- * backgrounded once they log something matching a RegExp...
- *
- * @class ProcRunner
- */
-class ProcRunner {
- constructor(log) {
- this.log = log;
- this.closing = false;
- this.procs = [];
- this.signalUnsubscribe = exit_hook_1.default(() => {
- this.teardown().catch((error) => {
- log.error(`ProcRunner teardown error: ${error.stack}`);
- });
- });
- }
- /**
- * Start a process, tracking it by `name`
- * @param {String} name
- * @param {Object} options
- * @property {String} options.cmd executable to run
- * @property {Array?} options.args arguments to provide the executable
- * @property {String?} options.cwd current working directory for the process
- * @property {RegExp|Boolean} options.wait Should start() wait for some time? Use
- * `true` will wait until the proc exits,
- * a `RegExp` will wait until that log line
- * is found
- * @return {Promise}
- */
- async run(name, options) {
- const { cmd, args = [], cwd = process.cwd(), stdin = undefined, wait = false, waitTimeout = 15 * MINUTE, env = process.env, } = options;
- if (this.closing) {
- throw new Error('ProcRunner is closing');
- }
- if (wait && !(wait instanceof RegExp) && wait !== true) {
- throw new TypeError('wait param should either be a RegExp or `true`');
- }
- if (!!this.getProc(name)) {
- throw new Error(`Process with name "${name}" already running`);
- }
- const proc = this.startProc(name, {
- cmd,
- args,
- cwd,
- env,
- stdin,
- });
- try {
- if (wait instanceof RegExp) {
- // wait for process to log matching line
- await Rx.race(proc.lines$.pipe(operators_1.filter((line) => wait.test(line)), operators_1.first(), operators_1.catchError((err) => {
- if (err.name !== 'EmptyError') {
- throw errors_1.createCliError(`[${name}] exited without matching pattern: ${wait}`);
- }
- else {
- throw err;
- }
- })), waitTimeout === false
- ? Rx.NEVER
- : Rx.timer(waitTimeout).pipe(operators_1.map(() => {
- const sec = waitTimeout / SECOND;
- throw errors_1.createCliError(`[${name}] failed to match pattern within ${sec} seconds [pattern=${wait}]`);
- }))).toPromise();
- }
- if (wait === true) {
- // wait for process to complete
- await proc.outcomePromise;
- }
- }
- finally {
- // while the procRunner closes promises will resolve/reject because
- // processes and stopping, but consumers of run() shouldn't have to
- // prepare for that, so just return a never-resolving promise
- if (this.closing) {
- await new Promise(noop);
- }
- }
- }
- /**
- * Stop a named proc
- */
- async stop(name, signal = 'SIGTERM') {
- const proc = this.getProc(name);
- if (proc) {
- await proc.stop(signal);
- }
- else {
- this.log.warning('[%s] already stopped', name);
- }
- }
- /**
- * Wait for all running processes to stop naturally
- * @return {Promise}
- */
- async waitForAllToStop() {
- await Promise.all(this.procs.map((proc) => proc.outcomePromise));
- }
- /**
- * Close the ProcRunner and stop all running
- * processes with `signal`
- *
- * @param {String} [signal=undefined]
- * @return {Promise}
- */
- async teardown(signal = 'exit') {
- if (this.closing) {
- return;
- }
- this.closing = true;
- this.signalUnsubscribe();
- if (!signal && this.procs.length > 0) {
- this.log.warning('%d processes left running, stop them with procs.stop(name):', this.procs.length, this.procs.map((proc) => proc.name));
- }
- await Promise.all(this.procs.map(async (proc) => {
- await proc.stop(signal === 'exit' ? 'SIGKILL' : signal);
- }));
- }
- getProc(name) {
- return this.procs.find((proc) => {
- return proc.name === name;
- });
- }
- startProc(name, options) {
- const startMs = Date.now();
- const proc = proc_1.startProc(name, options, this.log);
- this.procs.push(proc);
- const remove = () => {
- this.procs.splice(this.procs.indexOf(proc), 1);
- };
- // tie into proc outcome$, remove from _procs on compete
- proc.outcome$.subscribe({
- next: (code) => {
- const duration = moment_1.default.duration(Date.now() - startMs);
- this.log.info('[%s] exited with %s after %s', name, code, duration.humanize());
- },
- complete: () => {
- remove();
- },
- error: (error) => {
- if (this.closing) {
- this.log.error(error);
- }
- remove();
- },
- });
- return proc;
+ function getSetDayOfYear (input) {
+ var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;
+ return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');
}
-}
-exports.ProcRunner = ProcRunner;
-
-
-/***/ }),
-/* 40 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/* WEBPACK VAR INJECTION */(function(module) {var require;//! moment.js
-;(function (global, factory) {
- true ? module.exports = factory() :
- undefined
-}(this, (function () { 'use strict';
+ // FORMATTING
- var hookCallback;
+ addFormatToken('m', ['mm', 2], 0, 'minute');
- function hooks () {
- return hookCallback.apply(null, arguments);
- }
+ // ALIASES
- // This is done to register the method called with moment()
- // without creating circular dependencies.
- function setHookCallback (callback) {
- hookCallback = callback;
- }
+ addUnitAlias('minute', 'm');
- function isArray(input) {
- return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';
- }
+ // PRIORITY
- function isObject(input) {
- // IE8 will treat undefined and null as object if it wasn't for
- // input != null
- return input != null && Object.prototype.toString.call(input) === '[object Object]';
- }
+ addUnitPriority('minute', 14);
- function isObjectEmpty(obj) {
- if (Object.getOwnPropertyNames) {
- return (Object.getOwnPropertyNames(obj).length === 0);
- } else {
- var k;
- for (k in obj) {
- if (obj.hasOwnProperty(k)) {
- return false;
- }
- }
- return true;
- }
- }
+ // PARSING
- function isUndefined(input) {
- return input === void 0;
- }
+ addRegexToken('m', match1to2);
+ addRegexToken('mm', match1to2, match2);
+ addParseToken(['m', 'mm'], MINUTE);
- function isNumber(input) {
- return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';
- }
+ // MOMENTS
- function isDate(input) {
- return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
- }
+ var getSetMinute = makeGetSet('Minutes', false);
- function map(arr, fn) {
- var res = [], i;
- for (i = 0; i < arr.length; ++i) {
- res.push(fn(arr[i], i));
- }
- return res;
- }
+ // FORMATTING
- function hasOwnProp(a, b) {
- return Object.prototype.hasOwnProperty.call(a, b);
- }
+ addFormatToken('s', ['ss', 2], 0, 'second');
- function extend(a, b) {
- for (var i in b) {
- if (hasOwnProp(b, i)) {
- a[i] = b[i];
- }
- }
+ // ALIASES
- if (hasOwnProp(b, 'toString')) {
- a.toString = b.toString;
- }
+ addUnitAlias('second', 's');
- if (hasOwnProp(b, 'valueOf')) {
- a.valueOf = b.valueOf;
- }
+ // PRIORITY
- return a;
- }
+ addUnitPriority('second', 15);
- function createUTC (input, format, locale, strict) {
- return createLocalOrUTC(input, format, locale, strict, true).utc();
- }
+ // PARSING
- function defaultParsingFlags() {
- // We need to deep clone this object.
- return {
- empty : false,
- unusedTokens : [],
- unusedInput : [],
- overflow : -2,
- charsLeftOver : 0,
- nullInput : false,
- invalidMonth : null,
- invalidFormat : false,
- userInvalidated : false,
- iso : false,
- parsedDateParts : [],
- meridiem : null,
- rfc2822 : false,
- weekdayMismatch : false
- };
- }
+ addRegexToken('s', match1to2);
+ addRegexToken('ss', match1to2, match2);
+ addParseToken(['s', 'ss'], SECOND);
- function getParsingFlags(m) {
- if (m._pf == null) {
- m._pf = defaultParsingFlags();
- }
- return m._pf;
- }
+ // MOMENTS
- var some;
- if (Array.prototype.some) {
- some = Array.prototype.some;
- } else {
- some = function (fun) {
- var t = Object(this);
- var len = t.length >>> 0;
+ var getSetSecond = makeGetSet('Seconds', false);
- for (var i = 0; i < len; i++) {
- if (i in t && fun.call(this, t[i], i, t)) {
- return true;
- }
- }
+ // FORMATTING
- return false;
- };
- }
+ addFormatToken('S', 0, 0, function () {
+ return ~~(this.millisecond() / 100);
+ });
- function isValid(m) {
- if (m._isValid == null) {
- var flags = getParsingFlags(m);
- var parsedParts = some.call(flags.parsedDateParts, function (i) {
- return i != null;
- });
- var isNowValid = !isNaN(m._d.getTime()) &&
- flags.overflow < 0 &&
- !flags.empty &&
- !flags.invalidMonth &&
- !flags.invalidWeekday &&
- !flags.weekdayMismatch &&
- !flags.nullInput &&
- !flags.invalidFormat &&
- !flags.userInvalidated &&
- (!flags.meridiem || (flags.meridiem && parsedParts));
+ addFormatToken(0, ['SS', 2], 0, function () {
+ return ~~(this.millisecond() / 10);
+ });
- if (m._strict) {
- isNowValid = isNowValid &&
- flags.charsLeftOver === 0 &&
- flags.unusedTokens.length === 0 &&
- flags.bigHour === undefined;
- }
+ addFormatToken(0, ['SSS', 3], 0, 'millisecond');
+ addFormatToken(0, ['SSSS', 4], 0, function () {
+ return this.millisecond() * 10;
+ });
+ addFormatToken(0, ['SSSSS', 5], 0, function () {
+ return this.millisecond() * 100;
+ });
+ addFormatToken(0, ['SSSSSS', 6], 0, function () {
+ return this.millisecond() * 1000;
+ });
+ addFormatToken(0, ['SSSSSSS', 7], 0, function () {
+ return this.millisecond() * 10000;
+ });
+ addFormatToken(0, ['SSSSSSSS', 8], 0, function () {
+ return this.millisecond() * 100000;
+ });
+ addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
+ return this.millisecond() * 1000000;
+ });
- if (Object.isFrozen == null || !Object.isFrozen(m)) {
- m._isValid = isNowValid;
- }
- else {
- return isNowValid;
- }
- }
- return m._isValid;
- }
- function createInvalid (flags) {
- var m = createUTC(NaN);
- if (flags != null) {
- extend(getParsingFlags(m), flags);
- }
- else {
- getParsingFlags(m).userInvalidated = true;
- }
+ // ALIASES
- return m;
- }
+ addUnitAlias('millisecond', 'ms');
- // Plugins that add properties should also add the key here (null value),
- // so we can properly clone ourselves.
- var momentProperties = hooks.momentProperties = [];
+ // PRIORITY
- function copyConfig(to, from) {
- var i, prop, val;
+ addUnitPriority('millisecond', 16);
- if (!isUndefined(from._isAMomentObject)) {
- to._isAMomentObject = from._isAMomentObject;
- }
- if (!isUndefined(from._i)) {
- to._i = from._i;
- }
- if (!isUndefined(from._f)) {
- to._f = from._f;
- }
- if (!isUndefined(from._l)) {
- to._l = from._l;
- }
- if (!isUndefined(from._strict)) {
- to._strict = from._strict;
- }
- if (!isUndefined(from._tzm)) {
- to._tzm = from._tzm;
- }
- if (!isUndefined(from._isUTC)) {
- to._isUTC = from._isUTC;
- }
- if (!isUndefined(from._offset)) {
- to._offset = from._offset;
- }
- if (!isUndefined(from._pf)) {
- to._pf = getParsingFlags(from);
- }
- if (!isUndefined(from._locale)) {
- to._locale = from._locale;
- }
+ // PARSING
- if (momentProperties.length > 0) {
- for (i = 0; i < momentProperties.length; i++) {
- prop = momentProperties[i];
- val = from[prop];
- if (!isUndefined(val)) {
- to[prop] = val;
- }
- }
- }
+ addRegexToken('S', match1to3, match1);
+ addRegexToken('SS', match1to3, match2);
+ addRegexToken('SSS', match1to3, match3);
- return to;
+ var token;
+ for (token = 'SSSS'; token.length <= 9; token += 'S') {
+ addRegexToken(token, matchUnsigned);
}
- var updateInProgress = false;
-
- // Moment prototype object
- function Moment(config) {
- copyConfig(this, config);
- this._d = new Date(config._d != null ? config._d.getTime() : NaN);
- if (!this.isValid()) {
- this._d = new Date(NaN);
- }
- // Prevent infinite loop in case updateOffset creates new moment
- // objects.
- if (updateInProgress === false) {
- updateInProgress = true;
- hooks.updateOffset(this);
- updateInProgress = false;
- }
+ function parseMs(input, array) {
+ array[MILLISECOND] = toInt(('0.' + input) * 1000);
}
- function isMoment (obj) {
- return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);
+ for (token = 'S'; token.length <= 9; token += 'S') {
+ addParseToken(token, parseMs);
}
+ // MOMENTS
- function absFloor (number) {
- if (number < 0) {
- // -0 -> 0
- return Math.ceil(number) || 0;
- } else {
- return Math.floor(number);
- }
- }
+ var getSetMillisecond = makeGetSet('Milliseconds', false);
- function toInt(argumentForCoercion) {
- var coercedNumber = +argumentForCoercion,
- value = 0;
+ // FORMATTING
- if (coercedNumber !== 0 && isFinite(coercedNumber)) {
- value = absFloor(coercedNumber);
- }
+ addFormatToken('z', 0, 0, 'zoneAbbr');
+ addFormatToken('zz', 0, 0, 'zoneName');
- return value;
- }
+ // MOMENTS
- // compare two arrays, return the number of differences
- function compareArrays(array1, array2, dontConvert) {
- var len = Math.min(array1.length, array2.length),
- lengthDiff = Math.abs(array1.length - array2.length),
- diffs = 0,
- i;
- for (i = 0; i < len; i++) {
- if ((dontConvert && array1[i] !== array2[i]) ||
- (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {
- diffs++;
- }
- }
- return diffs + lengthDiff;
+ function getZoneAbbr () {
+ return this._isUTC ? 'UTC' : '';
}
- function warn(msg) {
- if (hooks.suppressDeprecationWarnings === false &&
- (typeof console !== 'undefined') && console.warn) {
- console.warn('Deprecation warning: ' + msg);
- }
+ function getZoneName () {
+ return this._isUTC ? 'Coordinated Universal Time' : '';
}
- function deprecate(msg, fn) {
- var firstTime = true;
+ var proto = Moment.prototype;
- return extend(function () {
- if (hooks.deprecationHandler != null) {
- hooks.deprecationHandler(null, msg);
- }
- if (firstTime) {
- var args = [];
- var arg;
- for (var i = 0; i < arguments.length; i++) {
- arg = '';
- if (typeof arguments[i] === 'object') {
- arg += '\n[' + i + '] ';
- for (var key in arguments[0]) {
- arg += key + ': ' + arguments[0][key] + ', ';
- }
- arg = arg.slice(0, -2); // Remove trailing comma and space
- } else {
- arg = arguments[i];
- }
- args.push(arg);
- }
- warn(msg + '\nArguments: ' + Array.prototype.slice.call(args).join('') + '\n' + (new Error()).stack);
- firstTime = false;
- }
- return fn.apply(this, arguments);
- }, fn);
+ proto.add = add;
+ proto.calendar = calendar$1;
+ proto.clone = clone;
+ proto.diff = diff;
+ proto.endOf = endOf;
+ proto.format = format;
+ proto.from = from;
+ proto.fromNow = fromNow;
+ proto.to = to;
+ proto.toNow = toNow;
+ proto.get = stringGet;
+ proto.invalidAt = invalidAt;
+ proto.isAfter = isAfter;
+ proto.isBefore = isBefore;
+ proto.isBetween = isBetween;
+ proto.isSame = isSame;
+ proto.isSameOrAfter = isSameOrAfter;
+ proto.isSameOrBefore = isSameOrBefore;
+ proto.isValid = isValid$2;
+ proto.lang = lang;
+ proto.locale = locale;
+ proto.localeData = localeData;
+ proto.max = prototypeMax;
+ proto.min = prototypeMin;
+ proto.parsingFlags = parsingFlags;
+ proto.set = stringSet;
+ proto.startOf = startOf;
+ proto.subtract = subtract;
+ proto.toArray = toArray;
+ proto.toObject = toObject;
+ proto.toDate = toDate;
+ proto.toISOString = toISOString;
+ proto.inspect = inspect;
+ proto.toJSON = toJSON;
+ proto.toString = toString;
+ proto.unix = unix;
+ proto.valueOf = valueOf;
+ proto.creationData = creationData;
+ proto.year = getSetYear;
+ proto.isLeapYear = getIsLeapYear;
+ proto.weekYear = getSetWeekYear;
+ proto.isoWeekYear = getSetISOWeekYear;
+ proto.quarter = proto.quarters = getSetQuarter;
+ proto.month = getSetMonth;
+ proto.daysInMonth = getDaysInMonth;
+ proto.week = proto.weeks = getSetWeek;
+ proto.isoWeek = proto.isoWeeks = getSetISOWeek;
+ proto.weeksInYear = getWeeksInYear;
+ proto.isoWeeksInYear = getISOWeeksInYear;
+ proto.date = getSetDayOfMonth;
+ proto.day = proto.days = getSetDayOfWeek;
+ proto.weekday = getSetLocaleDayOfWeek;
+ proto.isoWeekday = getSetISODayOfWeek;
+ proto.dayOfYear = getSetDayOfYear;
+ proto.hour = proto.hours = getSetHour;
+ proto.minute = proto.minutes = getSetMinute;
+ proto.second = proto.seconds = getSetSecond;
+ proto.millisecond = proto.milliseconds = getSetMillisecond;
+ proto.utcOffset = getSetOffset;
+ proto.utc = setOffsetToUTC;
+ proto.local = setOffsetToLocal;
+ proto.parseZone = setOffsetToParsedOffset;
+ proto.hasAlignedHourOffset = hasAlignedHourOffset;
+ proto.isDST = isDaylightSavingTime;
+ proto.isLocal = isLocal;
+ proto.isUtcOffset = isUtcOffset;
+ proto.isUtc = isUtc;
+ proto.isUTC = isUtc;
+ proto.zoneAbbr = getZoneAbbr;
+ proto.zoneName = getZoneName;
+ proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
+ proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
+ proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);
+ proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);
+ proto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);
+
+ function createUnix (input) {
+ return createLocal(input * 1000);
}
- var deprecations = {};
+ function createInZone () {
+ return createLocal.apply(null, arguments).parseZone();
+ }
- function deprecateSimple(name, msg) {
- if (hooks.deprecationHandler != null) {
- hooks.deprecationHandler(name, msg);
- }
- if (!deprecations[name]) {
- warn(msg);
- deprecations[name] = true;
- }
+ function preParsePostFormat (string) {
+ return string;
}
- hooks.suppressDeprecationWarnings = false;
- hooks.deprecationHandler = null;
+ var proto$1 = Locale.prototype;
- function isFunction(input) {
- return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';
- }
+ proto$1.calendar = calendar;
+ proto$1.longDateFormat = longDateFormat;
+ proto$1.invalidDate = invalidDate;
+ proto$1.ordinal = ordinal;
+ proto$1.preparse = preParsePostFormat;
+ proto$1.postformat = preParsePostFormat;
+ proto$1.relativeTime = relativeTime;
+ proto$1.pastFuture = pastFuture;
+ proto$1.set = set;
- function set (config) {
- var prop, i;
- for (i in config) {
- prop = config[i];
- if (isFunction(prop)) {
- this[i] = prop;
- } else {
- this['_' + i] = prop;
- }
- }
- this._config = config;
- // Lenient ordinal parsing accepts just a number in addition to
- // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.
- // TODO: Remove "ordinalParse" fallback in next major release.
- this._dayOfMonthOrdinalParseLenient = new RegExp(
- (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +
- '|' + (/\d{1,2}/).source);
+ proto$1.months = localeMonths;
+ proto$1.monthsShort = localeMonthsShort;
+ proto$1.monthsParse = localeMonthsParse;
+ proto$1.monthsRegex = monthsRegex;
+ proto$1.monthsShortRegex = monthsShortRegex;
+ proto$1.week = localeWeek;
+ proto$1.firstDayOfYear = localeFirstDayOfYear;
+ proto$1.firstDayOfWeek = localeFirstDayOfWeek;
+
+ proto$1.weekdays = localeWeekdays;
+ proto$1.weekdaysMin = localeWeekdaysMin;
+ proto$1.weekdaysShort = localeWeekdaysShort;
+ proto$1.weekdaysParse = localeWeekdaysParse;
+
+ proto$1.weekdaysRegex = weekdaysRegex;
+ proto$1.weekdaysShortRegex = weekdaysShortRegex;
+ proto$1.weekdaysMinRegex = weekdaysMinRegex;
+
+ proto$1.isPM = localeIsPM;
+ proto$1.meridiem = localeMeridiem;
+
+ function get$1 (format, index, field, setter) {
+ var locale = getLocale();
+ var utc = createUTC().set(setter, index);
+ return locale[field](utc, format);
}
- function mergeConfigs(parentConfig, childConfig) {
- var res = extend({}, parentConfig), prop;
- for (prop in childConfig) {
- if (hasOwnProp(childConfig, prop)) {
- if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
- res[prop] = {};
- extend(res[prop], parentConfig[prop]);
- extend(res[prop], childConfig[prop]);
- } else if (childConfig[prop] != null) {
- res[prop] = childConfig[prop];
- } else {
- delete res[prop];
- }
- }
+ function listMonthsImpl (format, index, field) {
+ if (isNumber(format)) {
+ index = format;
+ format = undefined;
}
- for (prop in parentConfig) {
- if (hasOwnProp(parentConfig, prop) &&
- !hasOwnProp(childConfig, prop) &&
- isObject(parentConfig[prop])) {
- // make sure changes to properties don't modify parent config
- res[prop] = extend({}, res[prop]);
- }
+
+ format = format || '';
+
+ if (index != null) {
+ return get$1(format, index, field, 'month');
}
- return res;
- }
- function Locale(config) {
- if (config != null) {
- this.set(config);
+ var i;
+ var out = [];
+ for (i = 0; i < 12; i++) {
+ out[i] = get$1(format, i, field, 'month');
}
+ return out;
}
- var keys;
-
- if (Object.keys) {
- keys = Object.keys;
- } else {
- keys = function (obj) {
- var i, res = [];
- for (i in obj) {
- if (hasOwnProp(obj, i)) {
- res.push(i);
- }
+ // ()
+ // (5)
+ // (fmt, 5)
+ // (fmt)
+ // (true)
+ // (true, 5)
+ // (true, fmt, 5)
+ // (true, fmt)
+ function listWeekdaysImpl (localeSorted, format, index, field) {
+ if (typeof localeSorted === 'boolean') {
+ if (isNumber(format)) {
+ index = format;
+ format = undefined;
}
- return res;
- };
- }
- var defaultCalendar = {
- sameDay : '[Today at] LT',
- nextDay : '[Tomorrow at] LT',
- nextWeek : 'dddd [at] LT',
- lastDay : '[Yesterday at] LT',
- lastWeek : '[Last] dddd [at] LT',
- sameElse : 'L'
- };
+ format = format || '';
+ } else {
+ format = localeSorted;
+ index = format;
+ localeSorted = false;
- function calendar (key, mom, now) {
- var output = this._calendar[key] || this._calendar['sameElse'];
- return isFunction(output) ? output.call(mom, now) : output;
- }
+ if (isNumber(format)) {
+ index = format;
+ format = undefined;
+ }
- var defaultLongDateFormat = {
- LTS : 'h:mm:ss A',
- LT : 'h:mm A',
- L : 'MM/DD/YYYY',
- LL : 'MMMM D, YYYY',
- LLL : 'MMMM D, YYYY h:mm A',
- LLLL : 'dddd, MMMM D, YYYY h:mm A'
- };
+ format = format || '';
+ }
- function longDateFormat (key) {
- var format = this._longDateFormat[key],
- formatUpper = this._longDateFormat[key.toUpperCase()];
+ var locale = getLocale(),
+ shift = localeSorted ? locale._week.dow : 0;
- if (format || !formatUpper) {
- return format;
+ if (index != null) {
+ return get$1(format, (index + shift) % 7, field, 'day');
}
- this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
- return val.slice(1);
- });
-
- return this._longDateFormat[key];
+ var i;
+ var out = [];
+ for (i = 0; i < 7; i++) {
+ out[i] = get$1(format, (i + shift) % 7, field, 'day');
+ }
+ return out;
}
- var defaultInvalidDate = 'Invalid date';
-
- function invalidDate () {
- return this._invalidDate;
+ function listMonths (format, index) {
+ return listMonthsImpl(format, index, 'months');
}
- var defaultOrdinal = '%d';
- var defaultDayOfMonthOrdinalParse = /\d{1,2}/;
-
- function ordinal (number) {
- return this._ordinal.replace('%d', number);
+ function listMonthsShort (format, index) {
+ return listMonthsImpl(format, index, 'monthsShort');
}
- var defaultRelativeTime = {
- future : 'in %s',
- past : '%s ago',
- s : 'a few seconds',
- ss : '%d seconds',
- m : 'a minute',
- mm : '%d minutes',
- h : 'an hour',
- hh : '%d hours',
- d : 'a day',
- dd : '%d days',
- M : 'a month',
- MM : '%d months',
- y : 'a year',
- yy : '%d years'
- };
-
- function relativeTime (number, withoutSuffix, string, isFuture) {
- var output = this._relativeTime[string];
- return (isFunction(output)) ?
- output(number, withoutSuffix, string, isFuture) :
- output.replace(/%d/i, number);
+ function listWeekdays (localeSorted, format, index) {
+ return listWeekdaysImpl(localeSorted, format, index, 'weekdays');
}
- function pastFuture (diff, output) {
- var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
- return isFunction(format) ? format(output) : format.replace(/%s/i, output);
+ function listWeekdaysShort (localeSorted, format, index) {
+ return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');
}
- var aliases = {};
-
- function addUnitAlias (unit, shorthand) {
- var lowerCase = unit.toLowerCase();
- aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
+ function listWeekdaysMin (localeSorted, format, index) {
+ return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');
}
- function normalizeUnits(units) {
- return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
- }
+ getSetGlobalLocale('en', {
+ dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+ ordinal : function (number) {
+ var b = number % 10,
+ output = (toInt(number % 100 / 10) === 1) ? 'th' :
+ (b === 1) ? 'st' :
+ (b === 2) ? 'nd' :
+ (b === 3) ? 'rd' : 'th';
+ return number + output;
+ }
+ });
- function normalizeObjectUnits(inputObject) {
- var normalizedInput = {},
- normalizedProp,
- prop;
+ // Side effect imports
- for (prop in inputObject) {
- if (hasOwnProp(inputObject, prop)) {
- normalizedProp = normalizeUnits(prop);
- if (normalizedProp) {
- normalizedInput[normalizedProp] = inputObject[prop];
- }
- }
- }
+ hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);
+ hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);
- return normalizedInput;
- }
+ var mathAbs = Math.abs;
- var priorities = {};
+ function abs () {
+ var data = this._data;
- function addUnitPriority(unit, priority) {
- priorities[unit] = priority;
- }
+ this._milliseconds = mathAbs(this._milliseconds);
+ this._days = mathAbs(this._days);
+ this._months = mathAbs(this._months);
- function getPrioritizedUnits(unitsObj) {
- var units = [];
- for (var u in unitsObj) {
- units.push({unit: u, priority: priorities[u]});
- }
- units.sort(function (a, b) {
- return a.priority - b.priority;
- });
- return units;
- }
+ data.milliseconds = mathAbs(data.milliseconds);
+ data.seconds = mathAbs(data.seconds);
+ data.minutes = mathAbs(data.minutes);
+ data.hours = mathAbs(data.hours);
+ data.months = mathAbs(data.months);
+ data.years = mathAbs(data.years);
- function zeroFill(number, targetLength, forceSign) {
- var absNumber = '' + Math.abs(number),
- zerosToFill = targetLength - absNumber.length,
- sign = number >= 0;
- return (sign ? (forceSign ? '+' : '') : '-') +
- Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;
+ return this;
}
- var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
+ function addSubtract$1 (duration, input, value, direction) {
+ var other = createDuration(input, value);
- var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
+ duration._milliseconds += direction * other._milliseconds;
+ duration._days += direction * other._days;
+ duration._months += direction * other._months;
- var formatFunctions = {};
+ return duration._bubble();
+ }
- var formatTokenFunctions = {};
+ // supports only 2.0-style add(1, 's') or add(duration)
+ function add$1 (input, value) {
+ return addSubtract$1(this, input, value, 1);
+ }
- // token: 'M'
- // padded: ['MM', 2]
- // ordinal: 'Mo'
- // callback: function () { this.month() + 1 }
- function addFormatToken (token, padded, ordinal, callback) {
- var func = callback;
- if (typeof callback === 'string') {
- func = function () {
- return this[callback]();
- };
- }
- if (token) {
- formatTokenFunctions[token] = func;
- }
- if (padded) {
- formatTokenFunctions[padded[0]] = function () {
- return zeroFill(func.apply(this, arguments), padded[1], padded[2]);
- };
- }
- if (ordinal) {
- formatTokenFunctions[ordinal] = function () {
- return this.localeData().ordinal(func.apply(this, arguments), token);
- };
- }
+ // supports only 2.0-style subtract(1, 's') or subtract(duration)
+ function subtract$1 (input, value) {
+ return addSubtract$1(this, input, value, -1);
}
- function removeFormattingTokens(input) {
- if (input.match(/\[[\s\S]/)) {
- return input.replace(/^\[|\]$/g, '');
+ function absCeil (number) {
+ if (number < 0) {
+ return Math.floor(number);
+ } else {
+ return Math.ceil(number);
}
- return input.replace(/\\/g, '');
}
- function makeFormatFunction(format) {
- var array = format.match(formattingTokens), i, length;
+ function bubble () {
+ var milliseconds = this._milliseconds;
+ var days = this._days;
+ var months = this._months;
+ var data = this._data;
+ var seconds, minutes, hours, years, monthsFromDays;
- for (i = 0, length = array.length; i < length; i++) {
- if (formatTokenFunctions[array[i]]) {
- array[i] = formatTokenFunctions[array[i]];
- } else {
- array[i] = removeFormattingTokens(array[i]);
- }
+ // if we have a mix of positive and negative values, bubble down first
+ // check: https://github.com/moment/moment/issues/2166
+ if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
+ (milliseconds <= 0 && days <= 0 && months <= 0))) {
+ milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
+ days = 0;
+ months = 0;
}
- return function (mom) {
- var output = '', i;
- for (i = 0; i < length; i++) {
- output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];
- }
- return output;
- };
- }
+ // The following code bubbles up values, see the tests for
+ // examples of what that means.
+ data.milliseconds = milliseconds % 1000;
- // format date using native date object
- function formatMoment(m, format) {
- if (!m.isValid()) {
- return m.localeData().invalidDate();
- }
+ seconds = absFloor(milliseconds / 1000);
+ data.seconds = seconds % 60;
- format = expandFormat(format, m.localeData());
- formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
+ minutes = absFloor(seconds / 60);
+ data.minutes = minutes % 60;
- return formatFunctions[format](m);
- }
+ hours = absFloor(minutes / 60);
+ data.hours = hours % 24;
- function expandFormat(format, locale) {
- var i = 5;
+ days += absFloor(hours / 24);
- function replaceLongDateFormatTokens(input) {
- return locale.longDateFormat(input) || input;
- }
+ // convert days to months
+ monthsFromDays = absFloor(daysToMonths(days));
+ months += monthsFromDays;
+ days -= absCeil(monthsToDays(monthsFromDays));
- localFormattingTokens.lastIndex = 0;
- while (i >= 0 && localFormattingTokens.test(format)) {
- format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
- localFormattingTokens.lastIndex = 0;
- i -= 1;
- }
-
- return format;
- }
-
- var match1 = /\d/; // 0 - 9
- var match2 = /\d\d/; // 00 - 99
- var match3 = /\d{3}/; // 000 - 999
- var match4 = /\d{4}/; // 0000 - 9999
- var match6 = /[+-]?\d{6}/; // -999999 - 999999
- var match1to2 = /\d\d?/; // 0 - 99
- var match3to4 = /\d\d\d\d?/; // 999 - 9999
- var match5to6 = /\d\d\d\d\d\d?/; // 99999 - 999999
- var match1to3 = /\d{1,3}/; // 0 - 999
- var match1to4 = /\d{1,4}/; // 0 - 9999
- var match1to6 = /[+-]?\d{1,6}/; // -999999 - 999999
-
- var matchUnsigned = /\d+/; // 0 - inf
- var matchSigned = /[+-]?\d+/; // -inf - inf
-
- var matchOffset = /Z|[+-]\d\d:?\d\d/gi; // +00:00 -00:00 +0000 -0000 or Z
- var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z
-
- var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/; // 123456789 123456789.123
-
- // any word (or two) characters or numbers including two/three word month in arabic.
- // includes scottish gaelic two word and hyphenated months
- var matchWord = /[0-9]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){1,2}/i;
+ // 12 months -> 1 year
+ years = absFloor(months / 12);
+ months %= 12;
- var regexes = {};
+ data.days = days;
+ data.months = months;
+ data.years = years;
- function addRegexToken (token, regex, strictRegex) {
- regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
- return (isStrict && strictRegex) ? strictRegex : regex;
- };
+ return this;
}
- function getParseRegexForToken (token, config) {
- if (!hasOwnProp(regexes, token)) {
- return new RegExp(unescapeFormat(token));
- }
-
- return regexes[token](config._strict, config._locale);
+ function daysToMonths (days) {
+ // 400 years have 146097 days (taking into account leap year rules)
+ // 400 years have 12 months === 4800
+ return days * 4800 / 146097;
}
- // Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
- function unescapeFormat(s) {
- return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
- return p1 || p2 || p3 || p4;
- }));
+ function monthsToDays (months) {
+ // the reverse of daysToMonths
+ return months * 146097 / 4800;
}
- function regexEscape(s) {
- return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
- }
+ function as (units) {
+ if (!this.isValid()) {
+ return NaN;
+ }
+ var days;
+ var months;
+ var milliseconds = this._milliseconds;
- var tokens = {};
+ units = normalizeUnits(units);
- function addParseToken (token, callback) {
- var i, func = callback;
- if (typeof token === 'string') {
- token = [token];
- }
- if (isNumber(callback)) {
- func = function (input, array) {
- array[callback] = toInt(input);
- };
- }
- for (i = 0; i < token.length; i++) {
- tokens[token[i]] = func;
+ if (units === 'month' || units === 'quarter' || units === 'year') {
+ days = this._days + milliseconds / 864e5;
+ months = this._months + daysToMonths(days);
+ switch (units) {
+ case 'month': return months;
+ case 'quarter': return months / 3;
+ case 'year': return months / 12;
+ }
+ } else {
+ // handle milliseconds separately because of floating point math errors (issue #1867)
+ days = this._days + Math.round(monthsToDays(this._months));
+ switch (units) {
+ case 'week' : return days / 7 + milliseconds / 6048e5;
+ case 'day' : return days + milliseconds / 864e5;
+ case 'hour' : return days * 24 + milliseconds / 36e5;
+ case 'minute' : return days * 1440 + milliseconds / 6e4;
+ case 'second' : return days * 86400 + milliseconds / 1000;
+ // Math.floor prevents floating point math errors here
+ case 'millisecond': return Math.floor(days * 864e5) + milliseconds;
+ default: throw new Error('Unknown unit ' + units);
+ }
}
}
- function addWeekParseToken (token, callback) {
- addParseToken(token, function (input, array, config, token) {
- config._w = config._w || {};
- callback(input, config._w, config, token);
- });
- }
-
- function addTimeToArrayFromToken(token, input, config) {
- if (input != null && hasOwnProp(tokens, token)) {
- tokens[token](input, config._a, config, token);
+ // TODO: Use this.as('ms')?
+ function valueOf$1 () {
+ if (!this.isValid()) {
+ return NaN;
}
+ return (
+ this._milliseconds +
+ this._days * 864e5 +
+ (this._months % 12) * 2592e6 +
+ toInt(this._months / 12) * 31536e6
+ );
}
- var YEAR = 0;
- var MONTH = 1;
- var DATE = 2;
- var HOUR = 3;
- var MINUTE = 4;
- var SECOND = 5;
- var MILLISECOND = 6;
- var WEEK = 7;
- var WEEKDAY = 8;
-
- // FORMATTING
-
- addFormatToken('Y', 0, 0, function () {
- var y = this.year();
- return y <= 9999 ? '' + y : '+' + y;
- });
+ function makeAs (alias) {
+ return function () {
+ return this.as(alias);
+ };
+ }
- addFormatToken(0, ['YY', 2], 0, function () {
- return this.year() % 100;
- });
+ var asMilliseconds = makeAs('ms');
+ var asSeconds = makeAs('s');
+ var asMinutes = makeAs('m');
+ var asHours = makeAs('h');
+ var asDays = makeAs('d');
+ var asWeeks = makeAs('w');
+ var asMonths = makeAs('M');
+ var asQuarters = makeAs('Q');
+ var asYears = makeAs('y');
- addFormatToken(0, ['YYYY', 4], 0, 'year');
- addFormatToken(0, ['YYYYY', 5], 0, 'year');
- addFormatToken(0, ['YYYYYY', 6, true], 0, 'year');
+ function clone$1 () {
+ return createDuration(this);
+ }
- // ALIASES
+ function get$2 (units) {
+ units = normalizeUnits(units);
+ return this.isValid() ? this[units + 's']() : NaN;
+ }
- addUnitAlias('year', 'y');
+ function makeGetter(name) {
+ return function () {
+ return this.isValid() ? this._data[name] : NaN;
+ };
+ }
- // PRIORITIES
+ var milliseconds = makeGetter('milliseconds');
+ var seconds = makeGetter('seconds');
+ var minutes = makeGetter('minutes');
+ var hours = makeGetter('hours');
+ var days = makeGetter('days');
+ var months = makeGetter('months');
+ var years = makeGetter('years');
- addUnitPriority('year', 1);
+ function weeks () {
+ return absFloor(this.days() / 7);
+ }
- // PARSING
+ var round = Math.round;
+ var thresholds = {
+ ss: 44, // a few seconds to seconds
+ s : 45, // seconds to minute
+ m : 45, // minutes to hour
+ h : 22, // hours to day
+ d : 26, // days to month
+ M : 11 // months to year
+ };
- addRegexToken('Y', matchSigned);
- addRegexToken('YY', match1to2, match2);
- addRegexToken('YYYY', match1to4, match4);
- addRegexToken('YYYYY', match1to6, match6);
- addRegexToken('YYYYYY', match1to6, match6);
+ // helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
+ function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
+ return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);
+ }
- addParseToken(['YYYYY', 'YYYYYY'], YEAR);
- addParseToken('YYYY', function (input, array) {
- array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);
- });
- addParseToken('YY', function (input, array) {
- array[YEAR] = hooks.parseTwoDigitYear(input);
- });
- addParseToken('Y', function (input, array) {
- array[YEAR] = parseInt(input, 10);
- });
+ function relativeTime$1 (posNegDuration, withoutSuffix, locale) {
+ var duration = createDuration(posNegDuration).abs();
+ var seconds = round(duration.as('s'));
+ var minutes = round(duration.as('m'));
+ var hours = round(duration.as('h'));
+ var days = round(duration.as('d'));
+ var months = round(duration.as('M'));
+ var years = round(duration.as('y'));
- // HELPERS
+ var a = seconds <= thresholds.ss && ['s', seconds] ||
+ seconds < thresholds.s && ['ss', seconds] ||
+ minutes <= 1 && ['m'] ||
+ minutes < thresholds.m && ['mm', minutes] ||
+ hours <= 1 && ['h'] ||
+ hours < thresholds.h && ['hh', hours] ||
+ days <= 1 && ['d'] ||
+ days < thresholds.d && ['dd', days] ||
+ months <= 1 && ['M'] ||
+ months < thresholds.M && ['MM', months] ||
+ years <= 1 && ['y'] || ['yy', years];
- function daysInYear(year) {
- return isLeapYear(year) ? 366 : 365;
+ a[2] = withoutSuffix;
+ a[3] = +posNegDuration > 0;
+ a[4] = locale;
+ return substituteTimeAgo.apply(null, a);
}
- function isLeapYear(year) {
- return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+ // This function allows you to set the rounding function for relative time strings
+ function getSetRelativeTimeRounding (roundingFunction) {
+ if (roundingFunction === undefined) {
+ return round;
+ }
+ if (typeof(roundingFunction) === 'function') {
+ round = roundingFunction;
+ return true;
+ }
+ return false;
}
- // HOOKS
-
- hooks.parseTwoDigitYear = function (input) {
- return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);
- };
+ // This function allows you to set a threshold for relative time strings
+ function getSetRelativeTimeThreshold (threshold, limit) {
+ if (thresholds[threshold] === undefined) {
+ return false;
+ }
+ if (limit === undefined) {
+ return thresholds[threshold];
+ }
+ thresholds[threshold] = limit;
+ if (threshold === 's') {
+ thresholds.ss = limit - 1;
+ }
+ return true;
+ }
- // MOMENTS
+ function humanize (withSuffix) {
+ if (!this.isValid()) {
+ return this.localeData().invalidDate();
+ }
- var getSetYear = makeGetSet('FullYear', true);
+ var locale = this.localeData();
+ var output = relativeTime$1(this, !withSuffix, locale);
- function getIsLeapYear () {
- return isLeapYear(this.year());
- }
+ if (withSuffix) {
+ output = locale.pastFuture(+this, output);
+ }
- function makeGetSet (unit, keepTime) {
- return function (value) {
- if (value != null) {
- set$1(this, unit, value);
- hooks.updateOffset(this, keepTime);
- return this;
- } else {
- return get(this, unit);
- }
- };
+ return locale.postformat(output);
}
- function get (mom, unit) {
- return mom.isValid() ?
- mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;
- }
+ var abs$1 = Math.abs;
- function set$1 (mom, unit, value) {
- if (mom.isValid() && !isNaN(value)) {
- if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {
- mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month()));
- }
- else {
- mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);
- }
- }
+ function sign(x) {
+ return ((x > 0) - (x < 0)) || +x;
}
- // MOMENTS
-
- function stringGet (units) {
- units = normalizeUnits(units);
- if (isFunction(this[units])) {
- return this[units]();
+ function toISOString$1() {
+ // for ISO strings we do not use the normal bubbling rules:
+ // * milliseconds bubble up until they become hours
+ // * days do not bubble at all
+ // * months bubble up until they become years
+ // This is because there is no context-free conversion between hours and days
+ // (think of clock changes)
+ // and also not between days and months (28-31 days per month)
+ if (!this.isValid()) {
+ return this.localeData().invalidDate();
}
- return this;
- }
+ var seconds = abs$1(this._milliseconds) / 1000;
+ var days = abs$1(this._days);
+ var months = abs$1(this._months);
+ var minutes, hours, years;
- function stringSet (units, value) {
- if (typeof units === 'object') {
- units = normalizeObjectUnits(units);
- var prioritized = getPrioritizedUnits(units);
- for (var i = 0; i < prioritized.length; i++) {
- this[prioritized[i].unit](units[prioritized[i].unit]);
- }
- } else {
- units = normalizeUnits(units);
- if (isFunction(this[units])) {
- return this[units](value);
- }
- }
- return this;
- }
+ // 3600 seconds -> 60 minutes -> 1 hour
+ minutes = absFloor(seconds / 60);
+ hours = absFloor(minutes / 60);
+ seconds %= 60;
+ minutes %= 60;
- function mod(n, x) {
- return ((n % x) + x) % x;
- }
+ // 12 months -> 1 year
+ years = absFloor(months / 12);
+ months %= 12;
- var indexOf;
- if (Array.prototype.indexOf) {
- indexOf = Array.prototype.indexOf;
- } else {
- indexOf = function (o) {
- // I know
- var i;
- for (i = 0; i < this.length; ++i) {
- if (this[i] === o) {
- return i;
- }
- }
- return -1;
- };
- }
+ // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
+ var Y = years;
+ var M = months;
+ var D = days;
+ var h = hours;
+ var m = minutes;
+ var s = seconds ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
+ var total = this.asSeconds();
- function daysInMonth(year, month) {
- if (isNaN(year) || isNaN(month)) {
- return NaN;
+ if (!total) {
+ // this is the same as C#'s (Noda) and python (isodate)...
+ // but not other JS (goog.date)
+ return 'P0D';
}
- var modMonth = mod(month, 12);
- year += (month - modMonth) / 12;
- return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2);
- }
- // FORMATTING
+ var totalSign = total < 0 ? '-' : '';
+ var ymSign = sign(this._months) !== sign(total) ? '-' : '';
+ var daysSign = sign(this._days) !== sign(total) ? '-' : '';
+ var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
- addFormatToken('M', ['MM', 2], 'Mo', function () {
- return this.month() + 1;
- });
+ return totalSign + 'P' +
+ (Y ? ymSign + Y + 'Y' : '') +
+ (M ? ymSign + M + 'M' : '') +
+ (D ? daysSign + D + 'D' : '') +
+ ((h || m || s) ? 'T' : '') +
+ (h ? hmsSign + h + 'H' : '') +
+ (m ? hmsSign + m + 'M' : '') +
+ (s ? hmsSign + s + 'S' : '');
+ }
- addFormatToken('MMM', 0, 0, function (format) {
- return this.localeData().monthsShort(this, format);
- });
+ var proto$2 = Duration.prototype;
- addFormatToken('MMMM', 0, 0, function (format) {
- return this.localeData().months(this, format);
- });
+ proto$2.isValid = isValid$1;
+ proto$2.abs = abs;
+ proto$2.add = add$1;
+ proto$2.subtract = subtract$1;
+ proto$2.as = as;
+ proto$2.asMilliseconds = asMilliseconds;
+ proto$2.asSeconds = asSeconds;
+ proto$2.asMinutes = asMinutes;
+ proto$2.asHours = asHours;
+ proto$2.asDays = asDays;
+ proto$2.asWeeks = asWeeks;
+ proto$2.asMonths = asMonths;
+ proto$2.asQuarters = asQuarters;
+ proto$2.asYears = asYears;
+ proto$2.valueOf = valueOf$1;
+ proto$2._bubble = bubble;
+ proto$2.clone = clone$1;
+ proto$2.get = get$2;
+ proto$2.milliseconds = milliseconds;
+ proto$2.seconds = seconds;
+ proto$2.minutes = minutes;
+ proto$2.hours = hours;
+ proto$2.days = days;
+ proto$2.weeks = weeks;
+ proto$2.months = months;
+ proto$2.years = years;
+ proto$2.humanize = humanize;
+ proto$2.toISOString = toISOString$1;
+ proto$2.toString = toISOString$1;
+ proto$2.toJSON = toISOString$1;
+ proto$2.locale = locale;
+ proto$2.localeData = localeData;
- // ALIASES
+ proto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);
+ proto$2.lang = lang;
- addUnitAlias('month', 'M');
+ // Side effect imports
- // PRIORITY
+ // FORMATTING
- addUnitPriority('month', 8);
+ addFormatToken('X', 0, 0, 'unix');
+ addFormatToken('x', 0, 0, 'valueOf');
// PARSING
- addRegexToken('M', match1to2);
- addRegexToken('MM', match1to2, match2);
- addRegexToken('MMM', function (isStrict, locale) {
- return locale.monthsShortRegex(isStrict);
- });
- addRegexToken('MMMM', function (isStrict, locale) {
- return locale.monthsRegex(isStrict);
+ addRegexToken('x', matchSigned);
+ addRegexToken('X', matchTimestamp);
+ addParseToken('X', function (input, array, config) {
+ config._d = new Date(parseFloat(input, 10) * 1000);
});
-
- addParseToken(['M', 'MM'], function (input, array) {
- array[MONTH] = toInt(input) - 1;
+ addParseToken('x', function (input, array, config) {
+ config._d = new Date(toInt(input));
});
- addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
- var month = config._locale.monthsParse(input, token, config._strict);
- // if we didn't find a month name, mark the date as invalid.
- if (month != null) {
- array[MONTH] = month;
- } else {
- getParsingFlags(config).invalidMonth = input;
- }
- });
+ // Side effect imports
- // LOCALES
- var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
- var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
- function localeMonths (m, format) {
- if (!m) {
- return isArray(this._months) ? this._months :
- this._months['standalone'];
- }
- return isArray(this._months) ? this._months[m.month()] :
- this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
- }
+ hooks.version = '2.24.0';
- var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
- function localeMonthsShort (m, format) {
- if (!m) {
- return isArray(this._monthsShort) ? this._monthsShort :
- this._monthsShort['standalone'];
- }
- return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
- this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
- }
+ setHookCallback(createLocal);
- function handleStrictParse(monthName, format, strict) {
- var i, ii, mom, llc = monthName.toLocaleLowerCase();
- if (!this._monthsParse) {
- // this is not used
- this._monthsParse = [];
- this._longMonthsParse = [];
- this._shortMonthsParse = [];
- for (i = 0; i < 12; ++i) {
- mom = createUTC([2000, i]);
- this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
- this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
- }
- }
+ hooks.fn = proto;
+ hooks.min = min;
+ hooks.max = max;
+ hooks.now = now;
+ hooks.utc = createUTC;
+ hooks.unix = createUnix;
+ hooks.months = listMonths;
+ hooks.isDate = isDate;
+ hooks.locale = getSetGlobalLocale;
+ hooks.invalid = createInvalid;
+ hooks.duration = createDuration;
+ hooks.isMoment = isMoment;
+ hooks.weekdays = listWeekdays;
+ hooks.parseZone = createInZone;
+ hooks.localeData = getLocale;
+ hooks.isDuration = isDuration;
+ hooks.monthsShort = listMonthsShort;
+ hooks.weekdaysMin = listWeekdaysMin;
+ hooks.defineLocale = defineLocale;
+ hooks.updateLocale = updateLocale;
+ hooks.locales = listLocales;
+ hooks.weekdaysShort = listWeekdaysShort;
+ hooks.normalizeUnits = normalizeUnits;
+ hooks.relativeTimeRounding = getSetRelativeTimeRounding;
+ hooks.relativeTimeThreshold = getSetRelativeTimeThreshold;
+ hooks.calendarFormat = getCalendarFormat;
+ hooks.prototype = proto;
- if (strict) {
- if (format === 'MMM') {
- ii = indexOf.call(this._shortMonthsParse, llc);
- return ii !== -1 ? ii : null;
- } else {
- ii = indexOf.call(this._longMonthsParse, llc);
- return ii !== -1 ? ii : null;
- }
- } else {
- if (format === 'MMM') {
- ii = indexOf.call(this._shortMonthsParse, llc);
- if (ii !== -1) {
- return ii;
- }
- ii = indexOf.call(this._longMonthsParse, llc);
- return ii !== -1 ? ii : null;
- } else {
- ii = indexOf.call(this._longMonthsParse, llc);
- if (ii !== -1) {
- return ii;
- }
- ii = indexOf.call(this._shortMonthsParse, llc);
- return ii !== -1 ? ii : null;
- }
- }
- }
+ // currently HTML5 input type only supports 24-hour formats
+ hooks.HTML5_FMT = {
+ DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm', // ';
-/***/ }),
-/* 359 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ const onetime = function (...args) {
+ calledFunctions.set(onetime, ++callCount);
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toArray", function() { return toArray; });
-/* harmony import */ var _reduce__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(314);
-/** PURE_IMPORTS_START _reduce PURE_IMPORTS_END */
+ if (isCalled) {
+ if (options.throw === true) {
+ throw new Error(`Function \`${functionName}\` can only be called once`);
+ }
-function toArrayReducer(arr, item, index) {
- if (index === 0) {
- return [item];
- }
- arr.push(item);
- return arr;
-}
-function toArray() {
- return Object(_reduce__WEBPACK_IMPORTED_MODULE_0__["reduce"])(toArrayReducer, []);
-}
-//# sourceMappingURL=toArray.js.map
+ return ret;
+ }
+ isCalled = true;
+ ret = fn.apply(this, args);
+ fn = null;
-/***/ }),
-/* 360 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ return ret;
+ };
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "window", function() { return window; });
-/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(36);
-/* harmony import */ var _Subject__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(187);
-/* harmony import */ var _OuterSubscriber__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(229);
-/* harmony import */ var _util_subscribeToResult__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(230);
-/** PURE_IMPORTS_START tslib,_Subject,_OuterSubscriber,_util_subscribeToResult PURE_IMPORTS_END */
+ mimicFn(onetime, fn);
+ calledFunctions.set(onetime, callCount);
+ return onetime;
+};
+module.exports = oneTime;
+// TODO: Remove this for the next major release
+module.exports.default = oneTime;
+module.exports.callCount = fn => {
+ if (!calledFunctions.has(fn)) {
+ throw new Error(`The given function \`${fn.name}\` is not wrapped by the \`onetime\` package`);
+ }
-function window(windowBoundaries) {
- return function windowOperatorFunction(source) {
- return source.lift(new WindowOperator(windowBoundaries));
- };
-}
-var WindowOperator = /*@__PURE__*/ (function () {
- function WindowOperator(windowBoundaries) {
- this.windowBoundaries = windowBoundaries;
- }
- WindowOperator.prototype.call = function (subscriber, source) {
- var windowSubscriber = new WindowSubscriber(subscriber);
- var sourceSubscription = source.subscribe(windowSubscriber);
- if (!sourceSubscription.closed) {
- windowSubscriber.add(Object(_util_subscribeToResult__WEBPACK_IMPORTED_MODULE_3__["subscribeToResult"])(windowSubscriber, this.windowBoundaries));
- }
- return sourceSubscription;
- };
- return WindowOperator;
-}());
-var WindowSubscriber = /*@__PURE__*/ (function (_super) {
- tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"](WindowSubscriber, _super);
- function WindowSubscriber(destination) {
- var _this = _super.call(this, destination) || this;
- _this.window = new _Subject__WEBPACK_IMPORTED_MODULE_1__["Subject"]();
- destination.next(_this.window);
- return _this;
- }
- WindowSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
- this.openWindow();
- };
- WindowSubscriber.prototype.notifyError = function (error, innerSub) {
- this._error(error);
- };
- WindowSubscriber.prototype.notifyComplete = function (innerSub) {
- this._complete();
- };
- WindowSubscriber.prototype._next = function (value) {
- this.window.next(value);
- };
- WindowSubscriber.prototype._error = function (err) {
- this.window.error(err);
- this.destination.error(err);
- };
- WindowSubscriber.prototype._complete = function () {
- this.window.complete();
- this.destination.complete();
- };
- WindowSubscriber.prototype._unsubscribe = function () {
- this.window = null;
- };
- WindowSubscriber.prototype.openWindow = function () {
- var prevWindow = this.window;
- if (prevWindow) {
- prevWindow.complete();
- }
- var destination = this.destination;
- var newWindow = this.window = new _Subject__WEBPACK_IMPORTED_MODULE_1__["Subject"]();
- destination.next(newWindow);
- };
- return WindowSubscriber;
-}(_OuterSubscriber__WEBPACK_IMPORTED_MODULE_2__["OuterSubscriber"]));
-//# sourceMappingURL=window.js.map
+ return calledFunctions.get(fn);
+};
/***/ }),
/* 361 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+/***/ (function(module, exports, __webpack_require__) {
"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "windowCount", function() { return windowCount; });
-/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(36);
-/* harmony import */ var _Subscriber__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(172);
-/* harmony import */ var _Subject__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(187);
-/** PURE_IMPORTS_START tslib,_Subscriber,_Subject PURE_IMPORTS_END */
+const mimicFn = (to, from) => {
+ for (const prop of Reflect.ownKeys(from)) {
+ Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+ }
+
+ return to;
+};
+
+module.exports = mimicFn;
+// TODO: Remove this for the next major release
+module.exports.default = mimicFn;
-function windowCount(windowSize, startWindowEvery) {
- if (startWindowEvery === void 0) {
- startWindowEvery = 0;
- }
- return function windowCountOperatorFunction(source) {
- return source.lift(new WindowCountOperator(windowSize, startWindowEvery));
- };
-}
-var WindowCountOperator = /*@__PURE__*/ (function () {
- function WindowCountOperator(windowSize, startWindowEvery) {
- this.windowSize = windowSize;
- this.startWindowEvery = startWindowEvery;
- }
- WindowCountOperator.prototype.call = function (subscriber, source) {
- return source.subscribe(new WindowCountSubscriber(subscriber, this.windowSize, this.startWindowEvery));
- };
- return WindowCountOperator;
-}());
-var WindowCountSubscriber = /*@__PURE__*/ (function (_super) {
- tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"](WindowCountSubscriber, _super);
- function WindowCountSubscriber(destination, windowSize, startWindowEvery) {
- var _this = _super.call(this, destination) || this;
- _this.destination = destination;
- _this.windowSize = windowSize;
- _this.startWindowEvery = startWindowEvery;
- _this.windows = [new _Subject__WEBPACK_IMPORTED_MODULE_2__["Subject"]()];
- _this.count = 0;
- destination.next(_this.windows[0]);
- return _this;
- }
- WindowCountSubscriber.prototype._next = function (value) {
- var startWindowEvery = (this.startWindowEvery > 0) ? this.startWindowEvery : this.windowSize;
- var destination = this.destination;
- var windowSize = this.windowSize;
- var windows = this.windows;
- var len = windows.length;
- for (var i = 0; i < len && !this.closed; i++) {
- windows[i].next(value);
- }
- var c = this.count - windowSize + 1;
- if (c >= 0 && c % startWindowEvery === 0 && !this.closed) {
- windows.shift().complete();
- }
- if (++this.count % startWindowEvery === 0 && !this.closed) {
- var window_1 = new _Subject__WEBPACK_IMPORTED_MODULE_2__["Subject"]();
- windows.push(window_1);
- destination.next(window_1);
- }
- };
- WindowCountSubscriber.prototype._error = function (err) {
- var windows = this.windows;
- if (windows) {
- while (windows.length > 0 && !this.closed) {
- windows.shift().error(err);
- }
- }
- this.destination.error(err);
- };
- WindowCountSubscriber.prototype._complete = function () {
- var windows = this.windows;
- if (windows) {
- while (windows.length > 0 && !this.closed) {
- windows.shift().complete();
- }
- }
- this.destination.complete();
- };
- WindowCountSubscriber.prototype._unsubscribe = function () {
- this.count = 0;
- this.windows = null;
- };
- return WindowCountSubscriber;
-}(_Subscriber__WEBPACK_IMPORTED_MODULE_1__["Subscriber"]));
-//# sourceMappingURL=windowCount.js.map
-
/***/ }),
/* 362 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+/***/ (function(module, exports, __webpack_require__) {
"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "windowTime", function() { return windowTime; });
-/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(36);
-/* harmony import */ var _Subject__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(187);
-/* harmony import */ var _scheduler_async__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(215);
-/* harmony import */ var _Subscriber__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(172);
-/* harmony import */ var _util_isNumeric__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(257);
-/* harmony import */ var _util_isScheduler__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(205);
-/** PURE_IMPORTS_START tslib,_Subject,_scheduler_async,_Subscriber,_util_isNumeric,_util_isScheduler PURE_IMPORTS_END */
+const {signalsByName} = __webpack_require__(363);
+const getErrorPrefix = ({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled}) => {
+ if (timedOut) {
+ return `timed out after ${timeout} milliseconds`;
+ }
+ if (isCanceled) {
+ return 'was canceled';
+ }
+ if (errorCode !== undefined) {
+ return `failed with ${errorCode}`;
+ }
+ if (signal !== undefined) {
+ return `was killed with ${signal} (${signalDescription})`;
+ }
-function windowTime(windowTimeSpan) {
- var scheduler = _scheduler_async__WEBPACK_IMPORTED_MODULE_2__["async"];
- var windowCreationInterval = null;
- var maxWindowSize = Number.POSITIVE_INFINITY;
- if (Object(_util_isScheduler__WEBPACK_IMPORTED_MODULE_5__["isScheduler"])(arguments[3])) {
- scheduler = arguments[3];
- }
- if (Object(_util_isScheduler__WEBPACK_IMPORTED_MODULE_5__["isScheduler"])(arguments[2])) {
- scheduler = arguments[2];
- }
- else if (Object(_util_isNumeric__WEBPACK_IMPORTED_MODULE_4__["isNumeric"])(arguments[2])) {
- maxWindowSize = arguments[2];
- }
- if (Object(_util_isScheduler__WEBPACK_IMPORTED_MODULE_5__["isScheduler"])(arguments[1])) {
- scheduler = arguments[1];
- }
- else if (Object(_util_isNumeric__WEBPACK_IMPORTED_MODULE_4__["isNumeric"])(arguments[1])) {
- windowCreationInterval = arguments[1];
- }
- return function windowTimeOperatorFunction(source) {
- return source.lift(new WindowTimeOperator(windowTimeSpan, windowCreationInterval, maxWindowSize, scheduler));
- };
-}
-var WindowTimeOperator = /*@__PURE__*/ (function () {
- function WindowTimeOperator(windowTimeSpan, windowCreationInterval, maxWindowSize, scheduler) {
- this.windowTimeSpan = windowTimeSpan;
- this.windowCreationInterval = windowCreationInterval;
- this.maxWindowSize = maxWindowSize;
- this.scheduler = scheduler;
- }
- WindowTimeOperator.prototype.call = function (subscriber, source) {
- return source.subscribe(new WindowTimeSubscriber(subscriber, this.windowTimeSpan, this.windowCreationInterval, this.maxWindowSize, this.scheduler));
- };
- return WindowTimeOperator;
-}());
-var CountedSubject = /*@__PURE__*/ (function (_super) {
- tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"](CountedSubject, _super);
- function CountedSubject() {
- var _this = _super !== null && _super.apply(this, arguments) || this;
- _this._numberOfNextedValues = 0;
- return _this;
- }
- CountedSubject.prototype.next = function (value) {
- this._numberOfNextedValues++;
- _super.prototype.next.call(this, value);
- };
- Object.defineProperty(CountedSubject.prototype, "numberOfNextedValues", {
- get: function () {
- return this._numberOfNextedValues;
- },
- enumerable: true,
- configurable: true
- });
- return CountedSubject;
-}(_Subject__WEBPACK_IMPORTED_MODULE_1__["Subject"]));
-var WindowTimeSubscriber = /*@__PURE__*/ (function (_super) {
- tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"](WindowTimeSubscriber, _super);
- function WindowTimeSubscriber(destination, windowTimeSpan, windowCreationInterval, maxWindowSize, scheduler) {
- var _this = _super.call(this, destination) || this;
- _this.destination = destination;
- _this.windowTimeSpan = windowTimeSpan;
- _this.windowCreationInterval = windowCreationInterval;
- _this.maxWindowSize = maxWindowSize;
- _this.scheduler = scheduler;
- _this.windows = [];
- var window = _this.openWindow();
- if (windowCreationInterval !== null && windowCreationInterval >= 0) {
- var closeState = { subscriber: _this, window: window, context: null };
- var creationState = { windowTimeSpan: windowTimeSpan, windowCreationInterval: windowCreationInterval, subscriber: _this, scheduler: scheduler };
- _this.add(scheduler.schedule(dispatchWindowClose, windowTimeSpan, closeState));
- _this.add(scheduler.schedule(dispatchWindowCreation, windowCreationInterval, creationState));
- }
- else {
- var timeSpanOnlyState = { subscriber: _this, window: window, windowTimeSpan: windowTimeSpan };
- _this.add(scheduler.schedule(dispatchWindowTimeSpanOnly, windowTimeSpan, timeSpanOnlyState));
- }
- return _this;
- }
- WindowTimeSubscriber.prototype._next = function (value) {
- var windows = this.windows;
- var len = windows.length;
- for (var i = 0; i < len; i++) {
- var window_1 = windows[i];
- if (!window_1.closed) {
- window_1.next(value);
- if (window_1.numberOfNextedValues >= this.maxWindowSize) {
- this.closeWindow(window_1);
- }
- }
- }
- };
- WindowTimeSubscriber.prototype._error = function (err) {
- var windows = this.windows;
- while (windows.length > 0) {
- windows.shift().error(err);
- }
- this.destination.error(err);
- };
- WindowTimeSubscriber.prototype._complete = function () {
- var windows = this.windows;
- while (windows.length > 0) {
- var window_2 = windows.shift();
- if (!window_2.closed) {
- window_2.complete();
- }
- }
- this.destination.complete();
- };
- WindowTimeSubscriber.prototype.openWindow = function () {
- var window = new CountedSubject();
- this.windows.push(window);
- var destination = this.destination;
- destination.next(window);
- return window;
- };
- WindowTimeSubscriber.prototype.closeWindow = function (window) {
- window.complete();
- var windows = this.windows;
- windows.splice(windows.indexOf(window), 1);
- };
- return WindowTimeSubscriber;
-}(_Subscriber__WEBPACK_IMPORTED_MODULE_3__["Subscriber"]));
-function dispatchWindowTimeSpanOnly(state) {
- var subscriber = state.subscriber, windowTimeSpan = state.windowTimeSpan, window = state.window;
- if (window) {
- subscriber.closeWindow(window);
- }
- state.window = subscriber.openWindow();
- this.schedule(state, windowTimeSpan);
-}
-function dispatchWindowCreation(state) {
- var windowTimeSpan = state.windowTimeSpan, subscriber = state.subscriber, scheduler = state.scheduler, windowCreationInterval = state.windowCreationInterval;
- var window = subscriber.openWindow();
- var action = this;
- var context = { action: action, subscription: null };
- var timeSpanState = { subscriber: subscriber, window: window, context: context };
- context.subscription = scheduler.schedule(dispatchWindowClose, windowTimeSpan, timeSpanState);
- action.add(context.subscription);
- action.schedule(state, windowCreationInterval);
-}
-function dispatchWindowClose(state) {
- var subscriber = state.subscriber, window = state.window, context = state.context;
- if (context && context.action && context.subscription) {
- context.action.remove(context.subscription);
- }
- subscriber.closeWindow(window);
-}
-//# sourceMappingURL=windowTime.js.map
+ if (exitCode !== undefined) {
+ return `failed with exit code ${exitCode}`;
+ }
+
+ return 'failed';
+};
+
+const makeError = ({
+ stdout,
+ stderr,
+ all,
+ error,
+ signal,
+ exitCode,
+ command,
+ timedOut,
+ isCanceled,
+ killed,
+ parsed: {options: {timeout}}
+}) => {
+ // `signal` and `exitCode` emitted on `spawned.on('exit')` event can be `null`.
+ // We normalize them to `undefined`
+ exitCode = exitCode === null ? undefined : exitCode;
+ signal = signal === null ? undefined : signal;
+ const signalDescription = signal === undefined ? undefined : signalsByName[signal].description;
+
+ const errorCode = error && error.code;
+
+ const prefix = getErrorPrefix({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled});
+ const execaMessage = `Command ${prefix}: ${command}`;
+ const isError = Object.prototype.toString.call(error) === '[object Error]';
+ const shortMessage = isError ? `${execaMessage}\n${error.message}` : execaMessage;
+ const message = [shortMessage, stderr, stdout].filter(Boolean).join('\n');
+
+ if (isError) {
+ error.originalMessage = error.message;
+ error.message = message;
+ } else {
+ error = new Error(message);
+ }
+
+ error.shortMessage = shortMessage;
+ error.command = command;
+ error.exitCode = exitCode;
+ error.signal = signal;
+ error.signalDescription = signalDescription;
+ error.stdout = stdout;
+ error.stderr = stderr;
+
+ if (all !== undefined) {
+ error.all = all;
+ }
+
+ if ('bufferedData' in error) {
+ delete error.bufferedData;
+ }
+
+ error.failed = true;
+ error.timedOut = Boolean(timedOut);
+ error.isCanceled = isCanceled;
+ error.killed = killed && !timedOut;
+
+ return error;
+};
+
+module.exports = makeError;
/***/ }),
/* 363 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+/***/ (function(module, exports, __webpack_require__) {
"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "windowToggle", function() { return windowToggle; });
-/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(36);
-/* harmony import */ var _Subject__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(187);
-/* harmony import */ var _Subscription__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(177);
-/* harmony import */ var _OuterSubscriber__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(229);
-/* harmony import */ var _util_subscribeToResult__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(230);
-/** PURE_IMPORTS_START tslib,_Subject,_Subscription,_OuterSubscriber,_util_subscribeToResult PURE_IMPORTS_END */
+Object.defineProperty(exports,"__esModule",{value:true});exports.signalsByNumber=exports.signalsByName=void 0;var _os=__webpack_require__(364);
+var _signals=__webpack_require__(365);
+var _realtime=__webpack_require__(367);
+const getSignalsByName=function(){
+const signals=(0,_signals.getSignals)();
+return signals.reduce(getSignalByName,{});
+};
-function windowToggle(openings, closingSelector) {
- return function (source) { return source.lift(new WindowToggleOperator(openings, closingSelector)); };
+const getSignalByName=function(
+signalByNameMemo,
+{name,number,description,supported,action,forced,standard})
+{
+return{
+...signalByNameMemo,
+[name]:{name,number,description,supported,action,forced,standard}};
+
+};
+
+const signalsByName=getSignalsByName();exports.signalsByName=signalsByName;
+
+
+
+
+const getSignalsByNumber=function(){
+const signals=(0,_signals.getSignals)();
+const length=_realtime.SIGRTMAX+1;
+const signalsA=Array.from({length},(value,number)=>
+getSignalByNumber(number,signals));
+
+return Object.assign({},...signalsA);
+};
+
+const getSignalByNumber=function(number,signals){
+const signal=findSignalByNumber(number,signals);
+
+if(signal===undefined){
+return{};
}
-var WindowToggleOperator = /*@__PURE__*/ (function () {
- function WindowToggleOperator(openings, closingSelector) {
- this.openings = openings;
- this.closingSelector = closingSelector;
- }
- WindowToggleOperator.prototype.call = function (subscriber, source) {
- return source.subscribe(new WindowToggleSubscriber(subscriber, this.openings, this.closingSelector));
- };
- return WindowToggleOperator;
-}());
-var WindowToggleSubscriber = /*@__PURE__*/ (function (_super) {
- tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"](WindowToggleSubscriber, _super);
- function WindowToggleSubscriber(destination, openings, closingSelector) {
- var _this = _super.call(this, destination) || this;
- _this.openings = openings;
- _this.closingSelector = closingSelector;
- _this.contexts = [];
- _this.add(_this.openSubscription = Object(_util_subscribeToResult__WEBPACK_IMPORTED_MODULE_4__["subscribeToResult"])(_this, openings, openings));
- return _this;
- }
- WindowToggleSubscriber.prototype._next = function (value) {
- var contexts = this.contexts;
- if (contexts) {
- var len = contexts.length;
- for (var i = 0; i < len; i++) {
- contexts[i].window.next(value);
- }
- }
- };
- WindowToggleSubscriber.prototype._error = function (err) {
- var contexts = this.contexts;
- this.contexts = null;
- if (contexts) {
- var len = contexts.length;
- var index = -1;
- while (++index < len) {
- var context_1 = contexts[index];
- context_1.window.error(err);
- context_1.subscription.unsubscribe();
- }
- }
- _super.prototype._error.call(this, err);
- };
- WindowToggleSubscriber.prototype._complete = function () {
- var contexts = this.contexts;
- this.contexts = null;
- if (contexts) {
- var len = contexts.length;
- var index = -1;
- while (++index < len) {
- var context_2 = contexts[index];
- context_2.window.complete();
- context_2.subscription.unsubscribe();
- }
- }
- _super.prototype._complete.call(this);
- };
- WindowToggleSubscriber.prototype._unsubscribe = function () {
- var contexts = this.contexts;
- this.contexts = null;
- if (contexts) {
- var len = contexts.length;
- var index = -1;
- while (++index < len) {
- var context_3 = contexts[index];
- context_3.window.unsubscribe();
- context_3.subscription.unsubscribe();
- }
- }
- };
- WindowToggleSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
- if (outerValue === this.openings) {
- var closingNotifier = void 0;
- try {
- var closingSelector = this.closingSelector;
- closingNotifier = closingSelector(innerValue);
- }
- catch (e) {
- return this.error(e);
- }
- var window_1 = new _Subject__WEBPACK_IMPORTED_MODULE_1__["Subject"]();
- var subscription = new _Subscription__WEBPACK_IMPORTED_MODULE_2__["Subscription"]();
- var context_4 = { window: window_1, subscription: subscription };
- this.contexts.push(context_4);
- var innerSubscription = Object(_util_subscribeToResult__WEBPACK_IMPORTED_MODULE_4__["subscribeToResult"])(this, closingNotifier, context_4);
- if (innerSubscription.closed) {
- this.closeWindow(this.contexts.length - 1);
- }
- else {
- innerSubscription.context = context_4;
- subscription.add(innerSubscription);
- }
- this.destination.next(window_1);
- }
- else {
- this.closeWindow(this.contexts.indexOf(outerValue));
- }
- };
- WindowToggleSubscriber.prototype.notifyError = function (err) {
- this.error(err);
- };
- WindowToggleSubscriber.prototype.notifyComplete = function (inner) {
- if (inner !== this.openSubscription) {
- this.closeWindow(this.contexts.indexOf(inner.context));
- }
- };
- WindowToggleSubscriber.prototype.closeWindow = function (index) {
- if (index === -1) {
- return;
- }
- var contexts = this.contexts;
- var context = contexts[index];
- var window = context.window, subscription = context.subscription;
- contexts.splice(index, 1);
- window.complete();
- subscription.unsubscribe();
- };
- return WindowToggleSubscriber;
-}(_OuterSubscriber__WEBPACK_IMPORTED_MODULE_3__["OuterSubscriber"]));
-//# sourceMappingURL=windowToggle.js.map
+const{name,description,supported,action,forced,standard}=signal;
+return{
+[number]:{
+name,
+number,
+description,
+supported,
+action,
+forced,
+standard}};
-/***/ }),
-/* 364 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "windowWhen", function() { return windowWhen; });
-/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(36);
-/* harmony import */ var _Subject__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(187);
-/* harmony import */ var _OuterSubscriber__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(229);
-/* harmony import */ var _util_subscribeToResult__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(230);
-/** PURE_IMPORTS_START tslib,_Subject,_OuterSubscriber,_util_subscribeToResult PURE_IMPORTS_END */
+};
+const findSignalByNumber=function(number,signals){
+const signal=signals.find(({name})=>_os.constants.signals[name]===number);
-function windowWhen(closingSelector) {
- return function windowWhenOperatorFunction(source) {
- return source.lift(new WindowOperator(closingSelector));
- };
+if(signal!==undefined){
+return signal;
}
-var WindowOperator = /*@__PURE__*/ (function () {
- function WindowOperator(closingSelector) {
- this.closingSelector = closingSelector;
- }
- WindowOperator.prototype.call = function (subscriber, source) {
- return source.subscribe(new WindowSubscriber(subscriber, this.closingSelector));
- };
- return WindowOperator;
-}());
-var WindowSubscriber = /*@__PURE__*/ (function (_super) {
- tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"](WindowSubscriber, _super);
- function WindowSubscriber(destination, closingSelector) {
- var _this = _super.call(this, destination) || this;
- _this.destination = destination;
- _this.closingSelector = closingSelector;
- _this.openWindow();
- return _this;
- }
- WindowSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
- this.openWindow(innerSub);
- };
- WindowSubscriber.prototype.notifyError = function (error, innerSub) {
- this._error(error);
- };
- WindowSubscriber.prototype.notifyComplete = function (innerSub) {
- this.openWindow(innerSub);
- };
- WindowSubscriber.prototype._next = function (value) {
- this.window.next(value);
- };
- WindowSubscriber.prototype._error = function (err) {
- this.window.error(err);
- this.destination.error(err);
- this.unsubscribeClosingNotification();
- };
- WindowSubscriber.prototype._complete = function () {
- this.window.complete();
- this.destination.complete();
- this.unsubscribeClosingNotification();
- };
- WindowSubscriber.prototype.unsubscribeClosingNotification = function () {
- if (this.closingNotification) {
- this.closingNotification.unsubscribe();
- }
- };
- WindowSubscriber.prototype.openWindow = function (innerSub) {
- if (innerSub === void 0) {
- innerSub = null;
- }
- if (innerSub) {
- this.remove(innerSub);
- innerSub.unsubscribe();
- }
- var prevWindow = this.window;
- if (prevWindow) {
- prevWindow.complete();
- }
- var window = this.window = new _Subject__WEBPACK_IMPORTED_MODULE_1__["Subject"]();
- this.destination.next(window);
- var closingNotifier;
- try {
- var closingSelector = this.closingSelector;
- closingNotifier = closingSelector();
- }
- catch (e) {
- this.destination.error(e);
- this.window.error(e);
- return;
- }
- this.add(this.closingNotification = Object(_util_subscribeToResult__WEBPACK_IMPORTED_MODULE_3__["subscribeToResult"])(this, closingNotifier));
- };
- return WindowSubscriber;
-}(_OuterSubscriber__WEBPACK_IMPORTED_MODULE_2__["OuterSubscriber"]));
-//# sourceMappingURL=windowWhen.js.map
-
-
-/***/ }),
-/* 365 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "withLatestFrom", function() { return withLatestFrom; });
-/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(36);
-/* harmony import */ var _OuterSubscriber__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(229);
-/* harmony import */ var _util_subscribeToResult__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(230);
-/** PURE_IMPORTS_START tslib,_OuterSubscriber,_util_subscribeToResult PURE_IMPORTS_END */
-
-
-
-function withLatestFrom() {
- var args = [];
- for (var _i = 0; _i < arguments.length; _i++) {
- args[_i] = arguments[_i];
- }
- return function (source) {
- var project;
- if (typeof args[args.length - 1] === 'function') {
- project = args.pop();
- }
- var observables = args;
- return source.lift(new WithLatestFromOperator(observables, project));
- };
-}
-var WithLatestFromOperator = /*@__PURE__*/ (function () {
- function WithLatestFromOperator(observables, project) {
- this.observables = observables;
- this.project = project;
- }
- WithLatestFromOperator.prototype.call = function (subscriber, source) {
- return source.subscribe(new WithLatestFromSubscriber(subscriber, this.observables, this.project));
- };
- return WithLatestFromOperator;
-}());
-var WithLatestFromSubscriber = /*@__PURE__*/ (function (_super) {
- tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"](WithLatestFromSubscriber, _super);
- function WithLatestFromSubscriber(destination, observables, project) {
- var _this = _super.call(this, destination) || this;
- _this.observables = observables;
- _this.project = project;
- _this.toRespond = [];
- var len = observables.length;
- _this.values = new Array(len);
- for (var i = 0; i < len; i++) {
- _this.toRespond.push(i);
- }
- for (var i = 0; i < len; i++) {
- var observable = observables[i];
- _this.add(Object(_util_subscribeToResult__WEBPACK_IMPORTED_MODULE_2__["subscribeToResult"])(_this, observable, observable, i));
- }
- return _this;
- }
- WithLatestFromSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {
- this.values[outerIndex] = innerValue;
- var toRespond = this.toRespond;
- if (toRespond.length > 0) {
- var found = toRespond.indexOf(outerIndex);
- if (found !== -1) {
- toRespond.splice(found, 1);
- }
- }
- };
- WithLatestFromSubscriber.prototype.notifyComplete = function () {
- };
- WithLatestFromSubscriber.prototype._next = function (value) {
- if (this.toRespond.length === 0) {
- var args = [value].concat(this.values);
- if (this.project) {
- this._tryProject(args);
- }
- else {
- this.destination.next(args);
- }
- }
- };
- WithLatestFromSubscriber.prototype._tryProject = function (args) {
- var result;
- try {
- result = this.project.apply(this, args);
- }
- catch (err) {
- this.destination.error(err);
- return;
- }
- this.destination.next(result);
- };
- return WithLatestFromSubscriber;
-}(_OuterSubscriber__WEBPACK_IMPORTED_MODULE_1__["OuterSubscriber"]));
-//# sourceMappingURL=withLatestFrom.js.map
-
-
-/***/ }),
-/* 366 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "zip", function() { return zip; });
-/* harmony import */ var _observable_zip__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(269);
-/** PURE_IMPORTS_START _observable_zip PURE_IMPORTS_END */
-function zip() {
- var observables = [];
- for (var _i = 0; _i < arguments.length; _i++) {
- observables[_i] = arguments[_i];
- }
- return function zipOperatorFunction(source) {
- return source.lift.call(_observable_zip__WEBPACK_IMPORTED_MODULE_0__["zip"].apply(void 0, [source].concat(observables)));
- };
-}
-//# sourceMappingURL=zip.js.map
+return signals.find(signalA=>signalA.number===number);
+};
+const signalsByNumber=getSignalsByNumber();exports.signalsByNumber=signalsByNumber;
+//# sourceMappingURL=main.js.map
/***/ }),
-/* 367 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "zipAll", function() { return zipAll; });
-/* harmony import */ var _observable_zip__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(269);
-/** PURE_IMPORTS_START _observable_zip PURE_IMPORTS_END */
-
-function zipAll(project) {
- return function (source) { return source.lift(new _observable_zip__WEBPACK_IMPORTED_MODULE_0__["ZipOperator"](project)); };
-}
-//# sourceMappingURL=zipAll.js.map
+/* 364 */
+/***/ (function(module, exports) {
+module.exports = require("os");
/***/ }),
-/* 368 */
+/* 365 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+Object.defineProperty(exports,"__esModule",{value:true});exports.getSignals=void 0;var _os=__webpack_require__(364);
+var _core=__webpack_require__(366);
+var _realtime=__webpack_require__(367);
-const callbacks = new Set();
-let called = false;
-function exit(exit, signal) {
- if (called) {
- return;
- }
- called = true;
+const getSignals=function(){
+const realtimeSignals=(0,_realtime.getRealtimeSignals)();
+const signals=[..._core.SIGNALS,...realtimeSignals].map(normalizeSignal);
+return signals;
+};exports.getSignals=getSignals;
- for (const callback of callbacks) {
- callback();
- }
- if (exit === true) {
- process.exit(128 + signal); // eslint-disable-line unicorn/no-process-exit
- }
-}
-module.exports = callback => {
- callbacks.add(callback);
- if (callbacks.size === 1) {
- process.once('exit', exit);
- process.once('SIGINT', exit.bind(null, true, 2));
- process.once('SIGTERM', exit.bind(null, true, 15));
- // PM2 Cluster shutdown message. Caught to support async handlers with pm2, needed because
- // explicitly calling process.exit() doesn't trigger the beforeExit event, and the exit
- // event cannot support async handlers, since the event loop is never called after it.
- process.on('message', message => {
- if (message === 'shutdown') {
- exit(true, -128);
- }
- });
- }
- return () => {
- callbacks.delete(callback);
- };
-};
+const normalizeSignal=function({
+name,
+number:defaultNumber,
+description,
+action,
+forced=false,
+standard})
+{
+const{
+signals:{[name]:constantSignal}}=
+_os.constants;
+const supported=constantSignal!==undefined;
+const number=supported?constantSignal:defaultNumber;
+return{name,number,description,supported,action,forced,standard};
+};
+//# sourceMappingURL=signals.js.map
/***/ }),
-/* 369 */
+/* 366 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+Object.defineProperty(exports,"__esModule",{value:true});exports.SIGNALS=void 0;
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const $isCliError = Symbol('isCliError');
-function createCliError(message) {
- const error = new Error(message);
- error[$isCliError] = true;
- return error;
-}
-exports.createCliError = createCliError;
-function isCliError(error) {
- return error && !!error[$isCliError];
-}
-exports.isCliError = isCliError;
+const SIGNALS=[
+{
+name:"SIGHUP",
+number:1,
+action:"terminate",
+description:"Terminal closed",
+standard:"posix"},
+{
+name:"SIGINT",
+number:2,
+action:"terminate",
+description:"User interruption with CTRL-C",
+standard:"ansi"},
-/***/ }),
-/* 370 */
-/***/ (function(module, exports, __webpack_require__) {
+{
+name:"SIGQUIT",
+number:3,
+action:"core",
+description:"User interruption with CTRL-\\",
+standard:"posix"},
-"use strict";
+{
+name:"SIGILL",
+number:4,
+action:"core",
+description:"Invalid machine instruction",
+standard:"ansi"},
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const execa_1 = tslib_1.__importDefault(__webpack_require__(371));
-const fs_1 = __webpack_require__(23);
-const Rx = tslib_1.__importStar(__webpack_require__(169));
-const operators_1 = __webpack_require__(270);
-const chalk_1 = tslib_1.__importDefault(__webpack_require__(2));
-const tree_kill_1 = tslib_1.__importDefault(__webpack_require__(411));
-const util_1 = __webpack_require__(29);
-const treeKillAsync = util_1.promisify((...args) => tree_kill_1.default(...args));
-const observe_lines_1 = __webpack_require__(412);
-const errors_1 = __webpack_require__(369);
-const SECOND = 1000;
-const STOP_TIMEOUT = 30 * SECOND;
-async function withTimeout(attempt, ms, onTimeout) {
- const TIMEOUT = Symbol('timeout');
- try {
- await Promise.race([
- attempt(),
- new Promise((_, reject) => setTimeout(() => reject(TIMEOUT), ms)),
- ]);
- }
- catch (error) {
- if (error === TIMEOUT) {
- await onTimeout();
- }
- else {
- throw error;
- }
- }
-}
-function startProc(name, options, log) {
- const { cmd, args, cwd, env, stdin } = options;
- log.info('[%s] > %s', name, cmd, args.join(' '));
- // spawn fails with ENOENT when either the
- // cmd or cwd don't exist, so we check for the cwd
- // ahead of time so that the error is less ambiguous
- try {
- if (!fs_1.statSync(cwd).isDirectory()) {
- throw new Error(`cwd "${cwd}" exists but is not a directory`);
- }
- }
- catch (err) {
- if (err.code === 'ENOENT') {
- throw new Error(`cwd "${cwd}" does not exist`);
- }
- }
- const childProcess = execa_1.default(cmd, args, {
- cwd,
- env,
- stdio: ['pipe', 'pipe', 'pipe'],
- preferLocal: true,
- });
- if (stdin) {
- childProcess.stdin.end(stdin, 'utf8');
- }
- else {
- childProcess.stdin.end();
- }
- let stopCalled = false;
- const outcome$ = Rx.race(
- // observe first exit event
- Rx.fromEvent(childProcess, 'exit').pipe(operators_1.take(1), operators_1.map(([code]) => {
- if (stopCalled) {
- return null;
- }
- // JVM exits with 143 on SIGTERM and 130 on SIGINT, dont' treat then as errors
- if (code > 0 && !(code === 143 || code === 130)) {
- throw errors_1.createCliError(`[${name}] exited with code ${code}`);
- }
- return code;
- })),
- // observe first error event
- Rx.fromEvent(childProcess, 'error').pipe(operators_1.take(1), operators_1.mergeMap((err) => Rx.throwError(err)))).pipe(operators_1.share());
- const lines$ = Rx.merge(observe_lines_1.observeLines(childProcess.stdout), observe_lines_1.observeLines(childProcess.stderr)).pipe(operators_1.tap((line) => log.write(` ${chalk_1.default.gray('proc')} [${chalk_1.default.gray(name)}] ${line}`)), operators_1.share());
- const outcomePromise = Rx.merge(lines$.pipe(operators_1.ignoreElements()), outcome$).toPromise();
- async function stop(signal) {
- if (stopCalled) {
- return;
- }
- stopCalled = true;
- await withTimeout(async () => {
- log.debug(`Sending "${signal}" to proc "${name}"`);
- await treeKillAsync(childProcess.pid, signal);
- await outcomePromise;
- }, STOP_TIMEOUT, async () => {
- log.warning(`Proc "${name}" was sent "${signal}" didn't emit the "exit" or "error" events after ${STOP_TIMEOUT} ms, sending SIGKILL`);
- await treeKillAsync(childProcess.pid, 'SIGKILL');
- });
- await withTimeout(async () => {
- try {
- await outcomePromise;
- }
- catch (error) {
- // ignore
- }
- }, STOP_TIMEOUT, async () => {
- throw new Error(`Proc "${name}" was stopped but never emitted either the "exit" or "error" event after ${STOP_TIMEOUT} ms`);
- });
- }
- return {
- name,
- lines$,
- outcome$,
- outcomePromise,
- stop,
- };
-}
-exports.startProc = startProc;
+{
+name:"SIGTRAP",
+number:5,
+action:"core",
+description:"Debugger breakpoint",
+standard:"posix"},
+{
+name:"SIGABRT",
+number:6,
+action:"core",
+description:"Aborted",
+standard:"ansi"},
-/***/ }),
-/* 371 */
-/***/ (function(module, exports, __webpack_require__) {
+{
+name:"SIGIOT",
+number:6,
+action:"core",
+description:"Aborted",
+standard:"bsd"},
-"use strict";
+{
+name:"SIGBUS",
+number:7,
+action:"core",
+description:
+"Bus error due to misaligned, non-existing address or paging error",
+standard:"bsd"},
-const path = __webpack_require__(16);
-const childProcess = __webpack_require__(372);
-const crossSpawn = __webpack_require__(373);
-const stripFinalNewline = __webpack_require__(386);
-const npmRunPath = __webpack_require__(387);
-const onetime = __webpack_require__(388);
-const makeError = __webpack_require__(390);
-const normalizeStdio = __webpack_require__(395);
-const {spawnedKill, spawnedCancel, setupTimeout, setExitHandler} = __webpack_require__(396);
-const {handleInput, getSpawnedResult, makeAllStream, validateInputSync} = __webpack_require__(400);
-const {mergePromise, getSpawnedPromise} = __webpack_require__(409);
-const {joinCommand, parseCommand} = __webpack_require__(410);
+{
+name:"SIGEMT",
+number:7,
+action:"terminate",
+description:"Command should be emulated but is not implemented",
+standard:"other"},
-const DEFAULT_MAX_BUFFER = 1000 * 1000 * 100;
+{
+name:"SIGFPE",
+number:8,
+action:"core",
+description:"Floating point arithmetic error",
+standard:"ansi"},
-const getEnv = ({env: envOption, extendEnv, preferLocal, localDir, execPath}) => {
- const env = extendEnv ? {...process.env, ...envOption} : envOption;
+{
+name:"SIGKILL",
+number:9,
+action:"terminate",
+description:"Forced termination",
+standard:"posix",
+forced:true},
- if (preferLocal) {
- return npmRunPath.env({env, cwd: localDir, execPath});
- }
+{
+name:"SIGUSR1",
+number:10,
+action:"terminate",
+description:"Application-specific signal",
+standard:"posix"},
- return env;
-};
+{
+name:"SIGSEGV",
+number:11,
+action:"core",
+description:"Segmentation fault",
+standard:"ansi"},
-const handleArgs = (file, args, options = {}) => {
- const parsed = crossSpawn._parse(file, args, options);
- file = parsed.command;
- args = parsed.args;
- options = parsed.options;
+{
+name:"SIGUSR2",
+number:12,
+action:"terminate",
+description:"Application-specific signal",
+standard:"posix"},
- options = {
- maxBuffer: DEFAULT_MAX_BUFFER,
- buffer: true,
- stripFinalNewline: true,
- extendEnv: true,
- preferLocal: false,
- localDir: options.cwd || process.cwd(),
- execPath: process.execPath,
- encoding: 'utf8',
- reject: true,
- cleanup: true,
- all: false,
- windowsHide: true,
- ...options
- };
+{
+name:"SIGPIPE",
+number:13,
+action:"terminate",
+description:"Broken pipe or socket",
+standard:"posix"},
- options.env = getEnv(options);
+{
+name:"SIGALRM",
+number:14,
+action:"terminate",
+description:"Timeout or timer",
+standard:"posix"},
- options.stdio = normalizeStdio(options);
+{
+name:"SIGTERM",
+number:15,
+action:"terminate",
+description:"Termination",
+standard:"ansi"},
- if (process.platform === 'win32' && path.basename(file, '.exe') === 'cmd') {
- // #116
- args.unshift('/q');
- }
+{
+name:"SIGSTKFLT",
+number:16,
+action:"terminate",
+description:"Stack is empty or overflowed",
+standard:"other"},
- return {file, args, options, parsed};
-};
+{
+name:"SIGCHLD",
+number:17,
+action:"ignore",
+description:"Child process terminated, paused or unpaused",
+standard:"posix"},
-const handleOutput = (options, value, error) => {
- if (typeof value !== 'string' && !Buffer.isBuffer(value)) {
- // When `execa.sync()` errors, we normalize it to '' to mimic `execa()`
- return error === undefined ? undefined : '';
- }
+{
+name:"SIGCLD",
+number:17,
+action:"ignore",
+description:"Child process terminated, paused or unpaused",
+standard:"other"},
- if (options.stripFinalNewline) {
- return stripFinalNewline(value);
- }
+{
+name:"SIGCONT",
+number:18,
+action:"unpause",
+description:"Unpaused",
+standard:"posix",
+forced:true},
- return value;
-};
+{
+name:"SIGSTOP",
+number:19,
+action:"pause",
+description:"Paused",
+standard:"posix",
+forced:true},
-const execa = (file, args, options) => {
- const parsed = handleArgs(file, args, options);
- const command = joinCommand(file, args);
+{
+name:"SIGTSTP",
+number:20,
+action:"pause",
+description:"Paused using CTRL-Z or \"suspend\"",
+standard:"posix"},
- let spawned;
- try {
- spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
- } catch (error) {
- // Ensure the returned error is always both a promise and a child process
- const dummySpawned = new childProcess.ChildProcess();
- const errorPromise = Promise.reject(makeError({
- error,
- stdout: '',
- stderr: '',
- all: '',
- command,
- parsed,
- timedOut: false,
- isCanceled: false,
- killed: false
- }));
- return mergePromise(dummySpawned, errorPromise);
- }
+{
+name:"SIGTTIN",
+number:21,
+action:"pause",
+description:"Background process cannot read terminal input",
+standard:"posix"},
- const spawnedPromise = getSpawnedPromise(spawned);
- const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
- const processDone = setExitHandler(spawned, parsed.options, timedPromise);
+{
+name:"SIGBREAK",
+number:21,
+action:"terminate",
+description:"User interruption with CTRL-BREAK",
+standard:"other"},
- const context = {isCanceled: false};
+{
+name:"SIGTTOU",
+number:22,
+action:"pause",
+description:"Background process cannot write to terminal output",
+standard:"posix"},
- spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
- spawned.cancel = spawnedCancel.bind(null, spawned, context);
+{
+name:"SIGURG",
+number:23,
+action:"ignore",
+description:"Socket received out-of-band data",
+standard:"bsd"},
- const handlePromise = async () => {
- const [{error, exitCode, signal, timedOut}, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
- const stdout = handleOutput(parsed.options, stdoutResult);
- const stderr = handleOutput(parsed.options, stderrResult);
- const all = handleOutput(parsed.options, allResult);
+{
+name:"SIGXCPU",
+number:24,
+action:"core",
+description:"Process timed out",
+standard:"bsd"},
- if (error || exitCode !== 0 || signal !== null) {
- const returnedError = makeError({
- error,
- exitCode,
- signal,
- stdout,
- stderr,
- all,
- command,
- parsed,
- timedOut,
- isCanceled: context.isCanceled,
- killed: spawned.killed
- });
+{
+name:"SIGXFSZ",
+number:25,
+action:"core",
+description:"File too big",
+standard:"bsd"},
- if (!parsed.options.reject) {
- return returnedError;
- }
+{
+name:"SIGVTALRM",
+number:26,
+action:"terminate",
+description:"Timeout or timer",
+standard:"bsd"},
- throw returnedError;
- }
+{
+name:"SIGPROF",
+number:27,
+action:"terminate",
+description:"Timeout or timer",
+standard:"bsd"},
- return {
- command,
- exitCode: 0,
- stdout,
- stderr,
- all,
- failed: false,
- timedOut: false,
- isCanceled: false,
- killed: false
- };
- };
+{
+name:"SIGWINCH",
+number:28,
+action:"ignore",
+description:"Terminal window size changed",
+standard:"bsd"},
- const handlePromiseOnce = onetime(handlePromise);
+{
+name:"SIGIO",
+number:29,
+action:"terminate",
+description:"I/O is available",
+standard:"other"},
- crossSpawn._enoent.hookChildProcess(spawned, parsed.parsed);
+{
+name:"SIGPOLL",
+number:29,
+action:"terminate",
+description:"Watched event",
+standard:"other"},
- handleInput(spawned, parsed.options.input);
+{
+name:"SIGINFO",
+number:29,
+action:"ignore",
+description:"Request for process information",
+standard:"other"},
- spawned.all = makeAllStream(spawned, parsed.options);
+{
+name:"SIGPWR",
+number:30,
+action:"terminate",
+description:"Device running out of power",
+standard:"systemv"},
+
+{
+name:"SIGSYS",
+number:31,
+action:"core",
+description:"Invalid system call",
+standard:"other"},
+
+{
+name:"SIGUNUSED",
+number:31,
+action:"terminate",
+description:"Invalid system call",
+standard:"other"}];exports.SIGNALS=SIGNALS;
+//# sourceMappingURL=core.js.map
+
+/***/ }),
+/* 367 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(exports,"__esModule",{value:true});exports.SIGRTMAX=exports.getRealtimeSignals=void 0;
+const getRealtimeSignals=function(){
+const length=SIGRTMAX-SIGRTMIN+1;
+return Array.from({length},getRealtimeSignal);
+};exports.getRealtimeSignals=getRealtimeSignals;
+
+const getRealtimeSignal=function(value,index){
+return{
+name:`SIGRT${index+1}`,
+number:SIGRTMIN+index,
+action:"terminate",
+description:"Application-specific signal (realtime)",
+standard:"posix"};
- return mergePromise(spawned, handlePromiseOnce);
};
-module.exports = execa;
+const SIGRTMIN=34;
+const SIGRTMAX=64;exports.SIGRTMAX=SIGRTMAX;
+//# sourceMappingURL=realtime.js.map
-module.exports.sync = (file, args, options) => {
- const parsed = handleArgs(file, args, options);
- const command = joinCommand(file, args);
+/***/ }),
+/* 368 */
+/***/ (function(module, exports, __webpack_require__) {
- validateInputSync(parsed.options);
+"use strict";
- let result;
- try {
- result = childProcess.spawnSync(parsed.file, parsed.args, parsed.options);
- } catch (error) {
- throw makeError({
- error,
- stdout: '',
- stderr: '',
- all: '',
- command,
- parsed,
- timedOut: false,
- isCanceled: false,
- killed: false
- });
+const aliases = ['stdin', 'stdout', 'stderr'];
+
+const hasAlias = opts => aliases.some(alias => opts[alias] !== undefined);
+
+const normalizeStdio = opts => {
+ if (!opts) {
+ return;
}
- const stdout = handleOutput(parsed.options, result.stdout, result.error);
- const stderr = handleOutput(parsed.options, result.stderr, result.error);
+ const {stdio} = opts;
- if (result.error || result.status !== 0 || result.signal !== null) {
- const error = makeError({
- stdout,
- stderr,
- error: result.error,
- signal: result.signal,
- exitCode: result.status,
- command,
- parsed,
- timedOut: result.error && result.error.code === 'ETIMEDOUT',
- isCanceled: false,
- killed: result.signal !== null
- });
+ if (stdio === undefined) {
+ return aliases.map(alias => opts[alias]);
+ }
- if (!parsed.options.reject) {
- return error;
- }
+ if (hasAlias(opts)) {
+ throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map(alias => `\`${alias}\``).join(', ')}`);
+ }
- throw error;
+ if (typeof stdio === 'string') {
+ return stdio;
}
- return {
- command,
- exitCode: 0,
- stdout,
- stderr,
- failed: false,
- timedOut: false,
- isCanceled: false,
- killed: false
- };
-};
+ if (!Array.isArray(stdio)) {
+ throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+ }
-module.exports.command = (command, options) => {
- const [file, ...args] = parseCommand(command);
- return execa(file, args, options);
+ const length = Math.max(stdio.length, aliases.length);
+ return Array.from({length}, (value, index) => stdio[index]);
};
-module.exports.commandSync = (command, options) => {
- const [file, ...args] = parseCommand(command);
- return execa.sync(file, args, options);
-};
+module.exports = normalizeStdio;
-module.exports.node = (scriptPath, args, options = {}) => {
- if (args && !Array.isArray(args) && typeof args === 'object') {
- options = args;
- args = [];
+// `ipc` is pushed unless it is already present
+module.exports.node = opts => {
+ const stdio = normalizeStdio(opts);
+
+ if (stdio === 'ipc') {
+ return 'ipc';
}
- const stdio = normalizeStdio.node(options);
+ if (stdio === undefined || typeof stdio === 'string') {
+ return [stdio, stdio, stdio, 'ipc'];
+ }
- const {nodePath = process.execPath, nodeOptions = process.execArgv} = options;
+ if (stdio.includes('ipc')) {
+ return stdio;
+ }
- return execa(
- nodePath,
- [
- ...nodeOptions,
- scriptPath,
- ...(Array.isArray(args) ? args : [])
- ],
- {
- ...options,
- stdin: undefined,
- stdout: undefined,
- stderr: undefined,
- stdio,
- shell: false
- }
- );
+ return [...stdio, 'ipc'];
};
/***/ }),
-/* 372 */
-/***/ (function(module, exports) {
-
-module.exports = require("child_process");
-
-/***/ }),
-/* 373 */
+/* 369 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+const os = __webpack_require__(364);
+const onExit = __webpack_require__(370);
-const cp = __webpack_require__(372);
-const parse = __webpack_require__(374);
-const enoent = __webpack_require__(385);
+const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
-function spawn(command, args, options) {
- // Parse the arguments
- const parsed = parse(command, args, options);
+// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
+const spawnedKill = (kill, signal = 'SIGTERM', options = {}) => {
+ const killResult = kill(signal);
+ setKillTimeout(kill, signal, options, killResult);
+ return killResult;
+};
- // Spawn the child process
- const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+const setKillTimeout = (kill, signal, options, killResult) => {
+ if (!shouldForceKill(signal, options, killResult)) {
+ return;
+ }
- // Hook into child process "exit" event to emit an error if the command
- // does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
- enoent.hookChildProcess(spawned, parsed);
+ const timeout = getForceKillAfterTimeout(options);
+ const t = setTimeout(() => {
+ kill('SIGKILL');
+ }, timeout);
- return spawned;
-}
+ // Guarded because there's no `.unref()` when `execa` is used in the renderer
+ // process in Electron. This cannot be tested since we don't run tests in
+ // Electron.
+ // istanbul ignore else
+ if (t.unref) {
+ t.unref();
+ }
+};
-function spawnSync(command, args, options) {
- // Parse the arguments
- const parsed = parse(command, args, options);
+const shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => {
+ return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
+};
- // Spawn the child process
- const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+const isSigterm = signal => {
+ return signal === os.constants.signals.SIGTERM ||
+ (typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');
+};
- // Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
- result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+const getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {
+ if (forceKillAfterTimeout === true) {
+ return DEFAULT_FORCE_KILL_TIMEOUT;
+ }
- return result;
-}
+ if (!Number.isInteger(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
+ throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
+ }
-module.exports = spawn;
-module.exports.spawn = spawn;
-module.exports.sync = spawnSync;
+ return forceKillAfterTimeout;
+};
-module.exports._parse = parse;
-module.exports._enoent = enoent;
+// `childProcess.cancel()`
+const spawnedCancel = (spawned, context) => {
+ const killResult = spawned.kill();
+ if (killResult) {
+ context.isCanceled = true;
+ }
+};
-/***/ }),
-/* 374 */
-/***/ (function(module, exports, __webpack_require__) {
+const timeoutKill = (spawned, signal, reject) => {
+ spawned.kill(signal);
+ reject(Object.assign(new Error('Timed out'), {timedOut: true, signal}));
+};
-"use strict";
+// `timeout` option handling
+const setupTimeout = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {
+ if (timeout === 0 || timeout === undefined) {
+ return spawnedPromise;
+ }
+ if (!Number.isInteger(timeout) || timeout < 0) {
+ throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+ }
-const path = __webpack_require__(16);
-const resolveCommand = __webpack_require__(375);
-const escape = __webpack_require__(381);
-const readShebang = __webpack_require__(382);
+ let timeoutId;
+ const timeoutPromise = new Promise((resolve, reject) => {
+ timeoutId = setTimeout(() => {
+ timeoutKill(spawned, killSignal, reject);
+ }, timeout);
+ });
-const isWin = process.platform === 'win32';
-const isExecutableRegExp = /\.(?:com|exe)$/i;
-const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+ const safeSpawnedPromise = spawnedPromise.finally(() => {
+ clearTimeout(timeoutId);
+ });
-function detectShebang(parsed) {
- parsed.file = resolveCommand(parsed);
+ return Promise.race([timeoutPromise, safeSpawnedPromise]);
+};
- const shebang = parsed.file && readShebang(parsed.file);
+// `cleanup` option handling
+const setExitHandler = async (spawned, {cleanup, detached}, timedPromise) => {
+ if (!cleanup || detached) {
+ return timedPromise;
+ }
- if (shebang) {
- parsed.args.unshift(parsed.file);
- parsed.command = shebang;
+ const removeExitHandler = onExit(() => {
+ spawned.kill();
+ });
- return resolveCommand(parsed);
- }
+ return timedPromise.finally(() => {
+ removeExitHandler();
+ });
+};
- return parsed.file;
-}
+module.exports = {
+ spawnedKill,
+ spawnedCancel,
+ setupTimeout,
+ setExitHandler
+};
-function parseNonShell(parsed) {
- if (!isWin) {
- return parsed;
- }
- // Detect & add support for shebangs
- const commandFile = detectShebang(parsed);
+/***/ }),
+/* 370 */
+/***/ (function(module, exports, __webpack_require__) {
- // We don't need a shell if the command filename is an executable
- const needsShell = !isExecutableRegExp.test(commandFile);
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+var assert = __webpack_require__(371)
+var signals = __webpack_require__(372)
- // If a shell is required, use cmd.exe and take care of escaping everything correctly
- // Note that `forceShell` is an hidden option used only in tests
- if (parsed.options.forceShell || needsShell) {
- // Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`
- // The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument
- // Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,
- // we need to double escape them
- const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+var EE = __webpack_require__(373)
+/* istanbul ignore if */
+if (typeof EE !== 'function') {
+ EE = EE.EventEmitter
+}
- // Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
- // This is necessary otherwise it will always fail with ENOENT in those cases
- parsed.command = path.normalize(parsed.command);
+var emitter
+if (process.__signal_exit_emitter__) {
+ emitter = process.__signal_exit_emitter__
+} else {
+ emitter = process.__signal_exit_emitter__ = new EE()
+ emitter.count = 0
+ emitter.emitted = {}
+}
- // Escape command & arguments
- parsed.command = escape.command(parsed.command);
- parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+// Because this emitter is a global, we have to check to see if a
+// previous version of this library failed to enable infinite listeners.
+// I know what you're about to say. But literally everything about
+// signal-exit is a compromise with evil. Get used to it.
+if (!emitter.infinite) {
+ emitter.setMaxListeners(Infinity)
+ emitter.infinite = true
+}
- const shellCommand = [parsed.command].concat(parsed.args).join(' ');
+module.exports = function (cb, opts) {
+ assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler')
- parsed.args = ['/d', '/s', '/c', `"${shellCommand}"`];
- parsed.command = process.env.comspec || 'cmd.exe';
- parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
- }
+ if (loaded === false) {
+ load()
+ }
- return parsed;
-}
+ var ev = 'exit'
+ if (opts && opts.alwaysLast) {
+ ev = 'afterexit'
+ }
-function parse(command, args, options) {
- // Normalize arguments, similar to nodejs
- if (args && !Array.isArray(args)) {
- options = args;
- args = null;
+ var remove = function () {
+ emitter.removeListener(ev, cb)
+ if (emitter.listeners('exit').length === 0 &&
+ emitter.listeners('afterexit').length === 0) {
+ unload()
}
+ }
+ emitter.on(ev, cb)
- args = args ? args.slice(0) : []; // Clone array to avoid changing the original
- options = Object.assign({}, options); // Clone object to avoid changing the original
-
- // Build our parsed object
- const parsed = {
- command,
- args,
- options,
- file: undefined,
- original: {
- command,
- args,
- },
- };
-
- // Delegate further parsing to shell or non-shell
- return options.shell ? parsed : parseNonShell(parsed);
+ return remove
}
-module.exports = parse;
+module.exports.unload = unload
+function unload () {
+ if (!loaded) {
+ return
+ }
+ loaded = false
+ signals.forEach(function (sig) {
+ try {
+ process.removeListener(sig, sigListeners[sig])
+ } catch (er) {}
+ })
+ process.emit = originalProcessEmit
+ process.reallyExit = originalProcessReallyExit
+ emitter.count -= 1
+}
-/***/ }),
-/* 375 */
-/***/ (function(module, exports, __webpack_require__) {
+function emit (event, code, signal) {
+ if (emitter.emitted[event]) {
+ return
+ }
+ emitter.emitted[event] = true
+ emitter.emit(event, code, signal)
+}
-"use strict";
+// { : , ... }
+var sigListeners = {}
+signals.forEach(function (sig) {
+ sigListeners[sig] = function listener () {
+ // If there are no other listeners, an exit is coming!
+ // Simplest way: remove us and then re-send the signal.
+ // We know that this will kill the process, so we can
+ // safely emit now.
+ var listeners = process.listeners(sig)
+ if (listeners.length === emitter.count) {
+ unload()
+ emit('exit', null, sig)
+ /* istanbul ignore next */
+ emit('afterexit', null, sig)
+ /* istanbul ignore next */
+ process.kill(process.pid, sig)
+ }
+ }
+})
+module.exports.signals = function () {
+ return signals
+}
-const path = __webpack_require__(16);
-const which = __webpack_require__(376);
-const pathKey = __webpack_require__(380)();
+module.exports.load = load
-function resolveCommandAttempt(parsed, withoutPathExt) {
- const cwd = process.cwd();
- const hasCustomCwd = parsed.options.cwd != null;
- // Worker threads do not have process.chdir()
- const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined;
+var loaded = false
- // If a custom `cwd` was specified, we need to change the process cwd
- // because `which` will do stat calls but does not support a custom cwd
- if (shouldSwitchCwd) {
- try {
- process.chdir(parsed.options.cwd);
- } catch (err) {
- /* Empty */
- }
- }
+function load () {
+ if (loaded) {
+ return
+ }
+ loaded = true
- let resolved;
+ // This is the number of onSignalExit's that are in play.
+ // It's important so that we can count the correct number of
+ // listeners on signals, and don't wait for the other one to
+ // handle it instead of us.
+ emitter.count += 1
+ signals = signals.filter(function (sig) {
try {
- resolved = which.sync(parsed.command, {
- path: (parsed.options.env || process.env)[pathKey],
- pathExt: withoutPathExt ? path.delimiter : undefined,
- });
- } catch (e) {
- /* Empty */
- } finally {
- if (shouldSwitchCwd) {
- process.chdir(cwd);
- }
+ process.on(sig, sigListeners[sig])
+ return true
+ } catch (er) {
+ return false
}
+ })
- // If we successfully resolved, ensure that an absolute path is returned
- // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
- if (resolved) {
- resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
- }
+ process.emit = processEmit
+ process.reallyExit = processReallyExit
+}
- return resolved;
+var originalProcessReallyExit = process.reallyExit
+function processReallyExit (code) {
+ process.exitCode = code || 0
+ emit('exit', process.exitCode, null)
+ /* istanbul ignore next */
+ emit('afterexit', process.exitCode, null)
+ /* istanbul ignore next */
+ originalProcessReallyExit.call(process, process.exitCode)
}
-function resolveCommand(parsed) {
- return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+var originalProcessEmit = process.emit
+function processEmit (ev, arg) {
+ if (ev === 'exit') {
+ if (arg !== undefined) {
+ process.exitCode = arg
+ }
+ var ret = originalProcessEmit.apply(this, arguments)
+ emit('exit', process.exitCode, null)
+ /* istanbul ignore next */
+ emit('afterexit', process.exitCode, null)
+ return ret
+ } else {
+ return originalProcessEmit.apply(this, arguments)
+ }
}
-module.exports = resolveCommand;
+/***/ }),
+/* 371 */
+/***/ (function(module, exports) {
+
+module.exports = require("assert");
/***/ }),
-/* 376 */
-/***/ (function(module, exports, __webpack_require__) {
+/* 372 */
+/***/ (function(module, exports) {
-const isWindows = process.platform === 'win32' ||
- process.env.OSTYPE === 'cygwin' ||
- process.env.OSTYPE === 'msys'
+// This is not the set of all possible signals.
+//
+// It IS, however, the set of all signals that trigger
+// an exit on either Linux or BSD systems. Linux is a
+// superset of the signal names supported on BSD, and
+// the unknown signals just fail to register, so we can
+// catch that easily enough.
+//
+// Don't bother with SIGKILL. It's uncatchable, which
+// means that we can't fire any callbacks anyway.
+//
+// If a user does happen to register a handler on a non-
+// fatal signal like SIGWINCH or something, and then
+// exit, it'll end up firing `process.emit('exit')`, so
+// the handler will be fired anyway.
+//
+// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+// artificially, inherently leave the process in a
+// state from which it is not safe to try and enter JS
+// listeners.
+module.exports = [
+ 'SIGABRT',
+ 'SIGALRM',
+ 'SIGHUP',
+ 'SIGINT',
+ 'SIGTERM'
+]
-const path = __webpack_require__(16)
-const COLON = isWindows ? ';' : ':'
-const isexe = __webpack_require__(377)
+if (process.platform !== 'win32') {
+ module.exports.push(
+ 'SIGVTALRM',
+ 'SIGXCPU',
+ 'SIGXFSZ',
+ 'SIGUSR2',
+ 'SIGTRAP',
+ 'SIGSYS',
+ 'SIGQUIT',
+ 'SIGIOT'
+ // should detect profiler and enable/disable accordingly.
+ // see #21
+ // 'SIGPROF'
+ )
+}
-const getNotFoundError = (cmd) =>
- Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' })
+if (process.platform === 'linux') {
+ module.exports.push(
+ 'SIGIO',
+ 'SIGPOLL',
+ 'SIGPWR',
+ 'SIGSTKFLT',
+ 'SIGUNUSED'
+ )
+}
-const getPathInfo = (cmd, opt) => {
- const colon = opt.colon || COLON
- // If it has a slash, then we don't bother searching the pathenv.
- // just check the file itself, and that's it.
- const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
- : (
- [
- // windows always checks the cwd first
- ...(isWindows ? [process.cwd()] : []),
- ...(opt.path || process.env.PATH ||
- /* istanbul ignore next: very unusual */ '').split(colon),
- ]
- )
- const pathExtExe = isWindows
- ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
- : ''
- const pathExt = isWindows ? pathExtExe.split(colon) : ['']
+/***/ }),
+/* 373 */
+/***/ (function(module, exports) {
- if (isWindows) {
- if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
- pathExt.unshift('')
- }
+module.exports = require("events");
- return {
- pathEnv,
- pathExt,
- pathExtExe,
- }
-}
+/***/ }),
+/* 374 */
+/***/ (function(module, exports, __webpack_require__) {
-const which = (cmd, opt, cb) => {
- if (typeof opt === 'function') {
- cb = opt
- opt = {}
- }
- if (!opt)
- opt = {}
+"use strict";
- const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt)
- const found = []
+const isStream = __webpack_require__(375);
+const getStream = __webpack_require__(376);
+const mergeStream = __webpack_require__(383);
- const step = i => new Promise((resolve, reject) => {
- if (i === pathEnv.length)
- return opt.all && found.length ? resolve(found)
- : reject(getNotFoundError(cmd))
+// `input` option
+const handleInput = (spawned, input) => {
+ // Checking for stdin is workaround for https://github.com/nodejs/node/issues/26852
+ // TODO: Remove `|| spawned.stdin === undefined` once we drop support for Node.js <=12.2.0
+ if (input === undefined || spawned.stdin === undefined) {
+ return;
+ }
- const ppRaw = pathEnv[i]
- const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw
+ if (isStream(input)) {
+ input.pipe(spawned.stdin);
+ } else {
+ spawned.stdin.end(input);
+ }
+};
- const pCmd = path.join(pathPart, cmd)
- const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
- : pCmd
+// `all` interleaves `stdout` and `stderr`
+const makeAllStream = (spawned, {all}) => {
+ if (!all || (!spawned.stdout && !spawned.stderr)) {
+ return;
+ }
- resolve(subStep(p, i, 0))
- })
+ const mixed = mergeStream();
- const subStep = (p, i, ii) => new Promise((resolve, reject) => {
- if (ii === pathExt.length)
- return resolve(step(i + 1))
- const ext = pathExt[ii]
- isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
- if (!er && is) {
- if (opt.all)
- found.push(p + ext)
- else
- return resolve(p + ext)
- }
- return resolve(subStep(p, i, ii + 1))
- })
- })
+ if (spawned.stdout) {
+ mixed.add(spawned.stdout);
+ }
- return cb ? step(0).then(res => cb(null, res), cb) : step(0)
-}
+ if (spawned.stderr) {
+ mixed.add(spawned.stderr);
+ }
-const whichSync = (cmd, opt) => {
- opt = opt || {}
+ return mixed;
+};
- const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt)
- const found = []
+// On failure, `result.stdout|stderr|all` should contain the currently buffered stream
+const getBufferedData = async (stream, streamPromise) => {
+ if (!stream) {
+ return;
+ }
- for (let i = 0; i < pathEnv.length; i ++) {
- const ppRaw = pathEnv[i]
- const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw
+ stream.destroy();
- const pCmd = path.join(pathPart, cmd)
- const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
- : pCmd
+ try {
+ return await streamPromise;
+ } catch (error) {
+ return error.bufferedData;
+ }
+};
- for (let j = 0; j < pathExt.length; j ++) {
- const cur = p + pathExt[j]
- try {
- const is = isexe.sync(cur, { pathExt: pathExtExe })
- if (is) {
- if (opt.all)
- found.push(cur)
- else
- return cur
- }
- } catch (ex) {}
- }
- }
+const getStreamPromise = (stream, {encoding, buffer, maxBuffer}) => {
+ if (!stream || !buffer) {
+ return;
+ }
- if (opt.all && found.length)
- return found
+ if (encoding) {
+ return getStream(stream, {encoding, maxBuffer});
+ }
- if (opt.nothrow)
- return null
+ return getStream.buffer(stream, {maxBuffer});
+};
- throw getNotFoundError(cmd)
-}
+// Retrieve result of child process: exit code, signal, error, streams (stdout/stderr/all)
+const getSpawnedResult = async ({stdout, stderr, all}, {encoding, buffer, maxBuffer}, processDone) => {
+ const stdoutPromise = getStreamPromise(stdout, {encoding, buffer, maxBuffer});
+ const stderrPromise = getStreamPromise(stderr, {encoding, buffer, maxBuffer});
+ const allPromise = getStreamPromise(all, {encoding, buffer, maxBuffer: maxBuffer * 2});
+
+ try {
+ return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
+ } catch (error) {
+ return Promise.all([
+ {error, signal: error.signal, timedOut: error.timedOut},
+ getBufferedData(stdout, stdoutPromise),
+ getBufferedData(stderr, stderrPromise),
+ getBufferedData(all, allPromise)
+ ]);
+ }
+};
+
+const validateInputSync = ({input}) => {
+ if (isStream(input)) {
+ throw new TypeError('The `input` option cannot be a stream in sync mode');
+ }
+};
+
+module.exports = {
+ handleInput,
+ makeAllStream,
+ getSpawnedResult,
+ validateInputSync
+};
-module.exports = which
-which.sync = whichSync
/***/ }),
-/* 377 */
+/* 375 */
/***/ (function(module, exports, __webpack_require__) {
-var fs = __webpack_require__(23)
-var core
-if (process.platform === 'win32' || global.TESTING_WINDOWS) {
- core = __webpack_require__(378)
-} else {
- core = __webpack_require__(379)
-}
+"use strict";
-module.exports = isexe
-isexe.sync = sync
-function isexe (path, options, cb) {
- if (typeof options === 'function') {
- cb = options
- options = {}
- }
+const isStream = stream =>
+ stream !== null &&
+ typeof stream === 'object' &&
+ typeof stream.pipe === 'function';
- if (!cb) {
- if (typeof Promise !== 'function') {
- throw new TypeError('callback not provided')
- }
+isStream.writable = stream =>
+ isStream(stream) &&
+ stream.writable !== false &&
+ typeof stream._write === 'function' &&
+ typeof stream._writableState === 'object';
- return new Promise(function (resolve, reject) {
- isexe(path, options || {}, function (er, is) {
- if (er) {
- reject(er)
- } else {
- resolve(is)
- }
- })
- })
- }
+isStream.readable = stream =>
+ isStream(stream) &&
+ stream.readable !== false &&
+ typeof stream._read === 'function' &&
+ typeof stream._readableState === 'object';
- core(path, options || {}, function (er, is) {
- // ignore EACCES because that just means we aren't allowed to run it
- if (er) {
- if (er.code === 'EACCES' || options && options.ignoreErrors) {
- er = null
- is = false
- }
- }
- cb(er, is)
- })
-}
+isStream.duplex = stream =>
+ isStream.writable(stream) &&
+ isStream.readable(stream);
-function sync (path, options) {
- // my kingdom for a filtered catch
- try {
- return core.sync(path, options || {})
- } catch (er) {
- if (options && options.ignoreErrors || er.code === 'EACCES') {
- return false
- } else {
- throw er
- }
- }
-}
+isStream.transform = stream =>
+ isStream.duplex(stream) &&
+ typeof stream._transform === 'function' &&
+ typeof stream._transformState === 'object';
+
+module.exports = isStream;
/***/ }),
-/* 378 */
+/* 376 */
/***/ (function(module, exports, __webpack_require__) {
-module.exports = isexe
-isexe.sync = sync
+"use strict";
-var fs = __webpack_require__(23)
+const pump = __webpack_require__(377);
+const bufferStream = __webpack_require__(381);
-function checkPathExt (path, options) {
- var pathext = options.pathExt !== undefined ?
- options.pathExt : process.env.PATHEXT
+class MaxBufferError extends Error {
+ constructor() {
+ super('maxBuffer exceeded');
+ this.name = 'MaxBufferError';
+ }
+}
- if (!pathext) {
- return true
- }
+async function getStream(inputStream, options) {
+ if (!inputStream) {
+ return Promise.reject(new Error('Expected a stream'));
+ }
- pathext = pathext.split(';')
- if (pathext.indexOf('') !== -1) {
- return true
- }
- for (var i = 0; i < pathext.length; i++) {
- var p = pathext[i].toLowerCase()
- if (p && path.substr(-p.length).toLowerCase() === p) {
- return true
- }
- }
- return false
-}
+ options = {
+ maxBuffer: Infinity,
+ ...options
+ };
-function checkStat (stat, path, options) {
- if (!stat.isSymbolicLink() && !stat.isFile()) {
- return false
- }
- return checkPathExt(path, options)
-}
+ const {maxBuffer} = options;
-function isexe (path, options, cb) {
- fs.stat(path, function (er, stat) {
- cb(er, er ? false : checkStat(stat, path, options))
- })
-}
+ let stream;
+ await new Promise((resolve, reject) => {
+ const rejectPromise = error => {
+ if (error) { // A null check
+ error.bufferedData = stream.getBufferedValue();
+ }
-function sync (path, options) {
- return checkStat(fs.statSync(path), path, options)
+ reject(error);
+ };
+
+ stream = pump(inputStream, bufferStream(options), error => {
+ if (error) {
+ rejectPromise(error);
+ return;
+ }
+
+ resolve();
+ });
+
+ stream.on('data', () => {
+ if (stream.getBufferedLength() > maxBuffer) {
+ rejectPromise(new MaxBufferError());
+ }
+ });
+ });
+
+ return stream.getBufferedValue();
}
+module.exports = getStream;
+// TODO: Remove this for the next major release
+module.exports.default = getStream;
+module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
+module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
+module.exports.MaxBufferError = MaxBufferError;
+
/***/ }),
-/* 379 */
+/* 377 */
/***/ (function(module, exports, __webpack_require__) {
-module.exports = isexe
-isexe.sync = sync
+var once = __webpack_require__(378)
+var eos = __webpack_require__(380)
+var fs = __webpack_require__(349) // we only need fs to get the ReadStream and WriteStream prototypes
-var fs = __webpack_require__(23)
+var noop = function () {}
+var ancient = /^v?\.0/.test(process.version)
-function isexe (path, options, cb) {
- fs.stat(path, function (er, stat) {
- cb(er, er ? false : checkStat(stat, options))
- })
+var isFn = function (fn) {
+ return typeof fn === 'function'
}
-function sync (path, options) {
- return checkStat(fs.statSync(path), options)
+var isFS = function (stream) {
+ if (!ancient) return false // newer node version do not need to care about fs is a special way
+ if (!fs) return false // browser
+ return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)
}
-function checkStat (stat, options) {
- return stat.isFile() && checkMode(stat, options)
+var isRequest = function (stream) {
+ return stream.setHeader && isFn(stream.abort)
}
-function checkMode (stat, options) {
- var mod = stat.mode
- var uid = stat.uid
- var gid = stat.gid
+var destroyer = function (stream, reading, writing, callback) {
+ callback = once(callback)
- var myUid = options.uid !== undefined ?
- options.uid : process.getuid && process.getuid()
- var myGid = options.gid !== undefined ?
- options.gid : process.getgid && process.getgid()
+ var closed = false
+ stream.on('close', function () {
+ closed = true
+ })
- var u = parseInt('100', 8)
- var g = parseInt('010', 8)
- var o = parseInt('001', 8)
- var ug = u | g
+ eos(stream, {readable: reading, writable: writing}, function (err) {
+ if (err) return callback(err)
+ closed = true
+ callback()
+ })
- var ret = (mod & o) ||
- (mod & g) && gid === myGid ||
- (mod & u) && uid === myUid ||
- (mod & ug) && myUid === 0
+ var destroyed = false
+ return function (err) {
+ if (closed) return
+ if (destroyed) return
+ destroyed = true
- return ret
-}
+ if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks
+ if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want
+ if (isFn(stream.destroy)) return stream.destroy()
-/***/ }),
-/* 380 */
-/***/ (function(module, exports, __webpack_require__) {
+ callback(err || new Error('stream was destroyed'))
+ }
+}
-"use strict";
+var call = function (fn) {
+ fn()
+}
+var pipe = function (from, to) {
+ return from.pipe(to)
+}
-const pathKey = (options = {}) => {
- const environment = options.env || process.env;
- const platform = options.platform || process.platform;
+var pump = function () {
+ var streams = Array.prototype.slice.call(arguments)
+ var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop
- if (platform !== 'win32') {
- return 'PATH';
- }
+ if (Array.isArray(streams[0])) streams = streams[0]
+ if (streams.length < 2) throw new Error('pump requires two streams per minimum')
- return Object.keys(environment).find(key => key.toUpperCase() === 'PATH') || 'Path';
-};
+ var error
+ var destroys = streams.map(function (stream, i) {
+ var reading = i < streams.length - 1
+ var writing = i > 0
+ return destroyer(stream, reading, writing, function (err) {
+ if (!error) error = err
+ if (err) destroys.forEach(call)
+ if (reading) return
+ destroys.forEach(call)
+ callback(error)
+ })
+ })
-module.exports = pathKey;
-// TODO: Remove this for the next major release
-module.exports.default = pathKey;
+ return streams.reduce(pipe)
+}
+
+module.exports = pump
/***/ }),
-/* 381 */
+/* 378 */
/***/ (function(module, exports, __webpack_require__) {
-"use strict";
-
+var wrappy = __webpack_require__(379)
+module.exports = wrappy(once)
+module.exports.strict = wrappy(onceStrict)
-// See http://www.robvanderwoude.com/escapechars.php
-const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+once.proto = once(function () {
+ Object.defineProperty(Function.prototype, 'once', {
+ value: function () {
+ return once(this)
+ },
+ configurable: true
+ })
-function escapeCommand(arg) {
- // Escape meta chars
- arg = arg.replace(metaCharsRegExp, '^$1');
+ Object.defineProperty(Function.prototype, 'onceStrict', {
+ value: function () {
+ return onceStrict(this)
+ },
+ configurable: true
+ })
+})
- return arg;
+function once (fn) {
+ var f = function () {
+ if (f.called) return f.value
+ f.called = true
+ return f.value = fn.apply(this, arguments)
+ }
+ f.called = false
+ return f
}
-function escapeArgument(arg, doubleEscapeMetaChars) {
- // Convert to string
- arg = `${arg}`;
+function onceStrict (fn) {
+ var f = function () {
+ if (f.called)
+ throw new Error(f.onceError)
+ f.called = true
+ return f.value = fn.apply(this, arguments)
+ }
+ var name = fn.name || 'Function wrapped with `once`'
+ f.onceError = name + " shouldn't be called more than once"
+ f.called = false
+ return f
+}
- // Algorithm below is based on https://qntm.org/cmd
- // Sequence of backslashes followed by a double quote:
- // double up all the backslashes and escape the double quote
- arg = arg.replace(/(\\*)"/g, '$1$1\\"');
+/***/ }),
+/* 379 */
+/***/ (function(module, exports) {
- // Sequence of backslashes followed by the end of the string
- // (which will become a double quote later):
- // double up all the backslashes
- arg = arg.replace(/(\\*)$/, '$1$1');
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+module.exports = wrappy
+function wrappy (fn, cb) {
+ if (fn && cb) return wrappy(fn)(cb)
- // All other backslashes occur literally
+ if (typeof fn !== 'function')
+ throw new TypeError('need wrapper function')
- // Quote the whole thing:
- arg = `"${arg}"`;
+ Object.keys(fn).forEach(function (k) {
+ wrapper[k] = fn[k]
+ })
- // Escape meta chars
- arg = arg.replace(metaCharsRegExp, '^$1');
+ return wrapper
- // Double escape meta chars if necessary
- if (doubleEscapeMetaChars) {
- arg = arg.replace(metaCharsRegExp, '^$1');
+ function wrapper() {
+ var args = new Array(arguments.length)
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i]
}
-
- return arg;
+ var ret = fn.apply(this, args)
+ var cb = args[args.length-1]
+ if (typeof ret === 'function' && ret !== cb) {
+ Object.keys(cb).forEach(function (k) {
+ ret[k] = cb[k]
+ })
+ }
+ return ret
+ }
}
-module.exports.command = escapeCommand;
-module.exports.argument = escapeArgument;
-
/***/ }),
-/* 382 */
+/* 380 */
/***/ (function(module, exports, __webpack_require__) {
-"use strict";
+var once = __webpack_require__(378);
+var noop = function() {};
-const fs = __webpack_require__(23);
-const shebangCommand = __webpack_require__(383);
+var isRequest = function(stream) {
+ return stream.setHeader && typeof stream.abort === 'function';
+};
-function readShebang(command) {
- // Read the first 150 bytes from the file
- const size = 150;
- const buffer = Buffer.alloc(size);
+var isChildProcess = function(stream) {
+ return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
+};
- let fd;
+var eos = function(stream, opts, callback) {
+ if (typeof opts === 'function') return eos(stream, null, opts);
+ if (!opts) opts = {};
- try {
- fd = fs.openSync(command, 'r');
- fs.readSync(fd, buffer, 0, size, 0);
- fs.closeSync(fd);
- } catch (e) { /* Empty */ }
+ callback = once(callback || noop);
- // Attempt to extract shebang (null is returned if not a shebang)
- return shebangCommand(buffer.toString());
-}
+ var ws = stream._writableState;
+ var rs = stream._readableState;
+ var readable = opts.readable || (opts.readable !== false && stream.readable);
+ var writable = opts.writable || (opts.writable !== false && stream.writable);
-module.exports = readShebang;
+ var onlegacyfinish = function() {
+ if (!stream.writable) onfinish();
+ };
+ var onfinish = function() {
+ writable = false;
+ if (!readable) callback.call(stream);
+ };
-/***/ }),
-/* 383 */
-/***/ (function(module, exports, __webpack_require__) {
+ var onend = function() {
+ readable = false;
+ if (!writable) callback.call(stream);
+ };
-"use strict";
+ var onexit = function(exitCode) {
+ callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
+ };
-const shebangRegex = __webpack_require__(384);
+ var onerror = function(err) {
+ callback.call(stream, err);
+ };
-module.exports = (string = '') => {
- const match = string.match(shebangRegex);
+ var onclose = function() {
+ if (readable && !(rs && rs.ended)) return callback.call(stream, new Error('premature close'));
+ if (writable && !(ws && ws.ended)) return callback.call(stream, new Error('premature close'));
+ };
- if (!match) {
- return null;
+ var onrequest = function() {
+ stream.req.on('finish', onfinish);
+ };
+
+ if (isRequest(stream)) {
+ stream.on('complete', onfinish);
+ stream.on('abort', onclose);
+ if (stream.req) onrequest();
+ else stream.on('request', onrequest);
+ } else if (writable && !ws) { // legacy streams
+ stream.on('end', onlegacyfinish);
+ stream.on('close', onlegacyfinish);
}
- const [path, argument] = match[0].replace(/#! ?/, '').split(' ');
- const binary = path.split('/').pop();
+ if (isChildProcess(stream)) stream.on('exit', onexit);
- if (binary === 'env') {
- return argument;
- }
+ stream.on('end', onend);
+ stream.on('finish', onfinish);
+ if (opts.error !== false) stream.on('error', onerror);
+ stream.on('close', onclose);
- return argument ? `${binary} ${argument}` : binary;
+ return function() {
+ stream.removeListener('complete', onfinish);
+ stream.removeListener('abort', onclose);
+ stream.removeListener('request', onrequest);
+ if (stream.req) stream.req.removeListener('finish', onfinish);
+ stream.removeListener('end', onlegacyfinish);
+ stream.removeListener('close', onlegacyfinish);
+ stream.removeListener('finish', onfinish);
+ stream.removeListener('exit', onexit);
+ stream.removeListener('end', onend);
+ stream.removeListener('error', onerror);
+ stream.removeListener('close', onclose);
+ };
};
+module.exports = eos;
+
/***/ }),
-/* 384 */
+/* 381 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-module.exports = /^#!(.*)/;
-
+const {PassThrough: PassThroughStream} = __webpack_require__(382);
-/***/ }),
-/* 385 */
-/***/ (function(module, exports, __webpack_require__) {
+module.exports = options => {
+ options = {...options};
-"use strict";
+ const {array} = options;
+ let {encoding} = options;
+ const isBuffer = encoding === 'buffer';
+ let objectMode = false;
+ if (array) {
+ objectMode = !(encoding || isBuffer);
+ } else {
+ encoding = encoding || 'utf8';
+ }
-const isWin = process.platform === 'win32';
+ if (isBuffer) {
+ encoding = null;
+ }
-function notFoundError(original, syscall) {
- return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
- code: 'ENOENT',
- errno: 'ENOENT',
- syscall: `${syscall} ${original.command}`,
- path: original.command,
- spawnargs: original.args,
- });
-}
+ const stream = new PassThroughStream({objectMode});
-function hookChildProcess(cp, parsed) {
- if (!isWin) {
- return;
- }
+ if (encoding) {
+ stream.setEncoding(encoding);
+ }
- const originalEmit = cp.emit;
+ let length = 0;
+ const chunks = [];
- cp.emit = function (name, arg1) {
- // If emitting "exit" event and exit code is 1, we need to check if
- // the command exists and emit an "error" instead
- // See https://github.com/IndigoUnited/node-cross-spawn/issues/16
- if (name === 'exit') {
- const err = verifyENOENT(arg1, parsed, 'spawn');
+ stream.on('data', chunk => {
+ chunks.push(chunk);
- if (err) {
- return originalEmit.call(cp, 'error', err);
- }
- }
+ if (objectMode) {
+ length = chunks.length;
+ } else {
+ length += chunk.length;
+ }
+ });
- return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params
- };
-}
+ stream.getBufferedValue = () => {
+ if (array) {
+ return chunks;
+ }
-function verifyENOENT(status, parsed) {
- if (isWin && status === 1 && !parsed.file) {
- return notFoundError(parsed.original, 'spawn');
- }
+ return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
+ };
- return null;
-}
+ stream.getBufferedLength = () => length;
-function verifyENOENTSync(status, parsed) {
- if (isWin && status === 1 && !parsed.file) {
- return notFoundError(parsed.original, 'spawnSync');
- }
+ return stream;
+};
- return null;
-}
-module.exports = {
- hookChildProcess,
- verifyENOENT,
- verifyENOENTSync,
- notFoundError,
-};
+/***/ }),
+/* 382 */
+/***/ (function(module, exports) {
+module.exports = require("stream");
/***/ }),
-/* 386 */
+/* 383 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-module.exports = input => {
- const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
- const CR = typeof input === 'string' ? '\r' : '\r'.charCodeAt();
+const { PassThrough } = __webpack_require__(382);
- if (input[input.length - 1] === LF) {
- input = input.slice(0, input.length - 1);
- }
+module.exports = function (/*streams...*/) {
+ var sources = []
+ var output = new PassThrough({objectMode: true})
- if (input[input.length - 1] === CR) {
- input = input.slice(0, input.length - 1);
- }
+ output.setMaxListeners(0)
- return input;
-};
+ output.add = add
+ output.isEmpty = isEmpty
+
+ output.on('unpipe', remove)
+
+ Array.prototype.slice.call(arguments).forEach(add)
+
+ return output
+
+ function add (source) {
+ if (Array.isArray(source)) {
+ source.forEach(add)
+ return this
+ }
+
+ sources.push(source);
+ source.once('end', remove.bind(null, source))
+ source.once('error', output.emit.bind(output, 'error'))
+ source.pipe(output, {end: false})
+ return this
+ }
+
+ function isEmpty () {
+ return sources.length == 0;
+ }
+
+ function remove (source) {
+ sources = sources.filter(function (it) { return it !== source })
+ if (!sources.length && output.readable) { output.end() }
+ }
+}
/***/ }),
-/* 387 */
+/* 384 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const path = __webpack_require__(16);
-const pathKey = __webpack_require__(380);
-const npmRunPath = options => {
- options = {
- cwd: process.cwd(),
- path: process.env[pathKey()],
- execPath: process.execPath,
- ...options
- };
+const nativePromisePrototype = (async () => {})().constructor.prototype;
+const descriptors = ['then', 'catch', 'finally'].map(property => [
+ property,
+ Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
+]);
- let previous;
- let cwdPath = path.resolve(options.cwd);
- const result = [];
+// The return value is a mixin of `childProcess` and `Promise`
+const mergePromise = (spawned, promise) => {
+ for (const [property, descriptor] of descriptors) {
+ // Starting the main `promise` is deferred to avoid consuming streams
+ const value = typeof promise === 'function' ?
+ (...args) => Reflect.apply(descriptor.value, promise(), args) :
+ descriptor.value.bind(promise);
- while (previous !== cwdPath) {
- result.push(path.join(cwdPath, 'node_modules/.bin'));
- previous = cwdPath;
- cwdPath = path.resolve(cwdPath, '..');
+ Reflect.defineProperty(spawned, property, {...descriptor, value});
}
- // Ensure the running `node` binary is used
- const execPathDir = path.resolve(options.cwd, options.execPath, '..');
- result.unshift(execPathDir);
-
- return result.concat(options.path).join(path.delimiter);
+ return spawned;
};
-module.exports = npmRunPath;
-// TODO: Remove this for the next major release
-module.exports.default = npmRunPath;
-
-module.exports.env = options => {
- options = {
- env: process.env,
- ...options
- };
+// Use promises instead of `child_process` events
+const getSpawnedPromise = spawned => {
+ return new Promise((resolve, reject) => {
+ spawned.on('exit', (exitCode, signal) => {
+ resolve({exitCode, signal});
+ });
- const env = {...options.env};
- const path = pathKey({env});
+ spawned.on('error', error => {
+ reject(error);
+ });
- options.path = env[path];
- env[path] = module.exports(options);
+ if (spawned.stdin) {
+ spawned.stdin.on('error', error => {
+ reject(error);
+ });
+ }
+ });
+};
- return env;
+module.exports = {
+ mergePromise,
+ getSpawnedPromise
};
+
/***/ }),
-/* 388 */
+/* 385 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const mimicFn = __webpack_require__(389);
-
-const calledFunctions = new WeakMap();
+const SPACES_REGEXP = / +/g;
-const oneTime = (fn, options = {}) => {
- if (typeof fn !== 'function') {
- throw new TypeError('Expected a function');
+const joinCommand = (file, args = []) => {
+ if (!Array.isArray(args)) {
+ return file;
}
- let ret;
- let isCalled = false;
- let callCount = 0;
- const functionName = fn.displayName || fn.name || '';
-
- const onetime = function (...args) {
- calledFunctions.set(onetime, ++callCount);
-
- if (isCalled) {
- if (options.throw === true) {
- throw new Error(`Function \`${functionName}\` can only be called once`);
- }
-
- return ret;
- }
+ return [file, ...args].join(' ');
+};
- isCalled = true;
- ret = fn.apply(this, args);
- fn = null;
+// Allow spaces to be escaped by a backslash if not meant as a delimiter
+const handleEscaping = (tokens, token, index) => {
+ if (index === 0) {
+ return [token];
+ }
- return ret;
- };
+ const previousToken = tokens[tokens.length - 1];
- mimicFn(onetime, fn);
- calledFunctions.set(onetime, callCount);
+ if (previousToken.endsWith('\\')) {
+ return [...tokens.slice(0, -1), `${previousToken.slice(0, -1)} ${token}`];
+ }
- return onetime;
+ return [...tokens, token];
};
-module.exports = oneTime;
-// TODO: Remove this for the next major release
-module.exports.default = oneTime;
-
-module.exports.callCount = fn => {
- if (!calledFunctions.has(fn)) {
- throw new Error(`The given function \`${fn.name}\` is not wrapped by the \`onetime\` package`);
- }
+// Handle `execa.command()`
+const parseCommand = command => {
+ return command
+ .trim()
+ .split(SPACES_REGEXP)
+ .reduce(handleEscaping, []);
+};
- return calledFunctions.get(fn);
+module.exports = {
+ joinCommand,
+ parseCommand
};
/***/ }),
-/* 389 */
+/* 386 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+const escapeStringRegexp = __webpack_require__(387);
+const ansiStyles = __webpack_require__(388);
+const stdoutColor = __webpack_require__(393).stdout;
-const mimicFn = (to, from) => {
- for (const prop of Reflect.ownKeys(from)) {
- Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
- }
+const template = __webpack_require__(395);
- return to;
-};
+const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
-module.exports = mimicFn;
-// TODO: Remove this for the next major release
-module.exports.default = mimicFn;
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
+// `color-convert` models to exclude from the Chalk API due to conflicts and such
+const skipModels = new Set(['gray']);
-/***/ }),
-/* 390 */
-/***/ (function(module, exports, __webpack_require__) {
+const styles = Object.create(null);
-"use strict";
+function applyOptions(obj, options) {
+ options = options || {};
-const {signalsByName} = __webpack_require__(391);
+ // Detect level if not set manually
+ const scLevel = stdoutColor ? stdoutColor.level : 0;
+ obj.level = options.level === undefined ? scLevel : options.level;
+ obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
+}
-const getErrorPrefix = ({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled}) => {
- if (timedOut) {
- return `timed out after ${timeout} milliseconds`;
- }
+function Chalk(options) {
+ // We check for this.template here since calling `chalk.constructor()`
+ // by itself will have a `this` of a previously constructed chalk object
+ if (!this || !(this instanceof Chalk) || this.template) {
+ const chalk = {};
+ applyOptions(chalk, options);
- if (isCanceled) {
- return 'was canceled';
- }
+ chalk.template = function () {
+ const args = [].slice.call(arguments);
+ return chalkTag.apply(null, [chalk.template].concat(args));
+ };
- if (errorCode !== undefined) {
- return `failed with ${errorCode}`;
- }
+ Object.setPrototypeOf(chalk, Chalk.prototype);
+ Object.setPrototypeOf(chalk.template, chalk);
- if (signal !== undefined) {
- return `was killed with ${signal} (${signalDescription})`;
- }
+ chalk.template.constructor = Chalk;
- if (exitCode !== undefined) {
- return `failed with exit code ${exitCode}`;
+ return chalk.template;
}
- return 'failed';
-};
+ applyOptions(this, options);
+}
-const makeError = ({
- stdout,
- stderr,
- all,
- error,
- signal,
- exitCode,
- command,
- timedOut,
- isCanceled,
- killed,
- parsed: {options: {timeout}}
-}) => {
- // `signal` and `exitCode` emitted on `spawned.on('exit')` event can be `null`.
- // We normalize them to `undefined`
- exitCode = exitCode === null ? undefined : exitCode;
- signal = signal === null ? undefined : signal;
- const signalDescription = signal === undefined ? undefined : signalsByName[signal].description;
+// Use bright blue on Windows as the normal blue color is illegible
+if (isSimpleWindowsTerm) {
+ ansiStyles.blue.open = '\u001B[94m';
+}
- const errorCode = error && error.code;
+for (const key of Object.keys(ansiStyles)) {
+ ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
- const prefix = getErrorPrefix({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled});
- const execaMessage = `Command ${prefix}: ${command}`;
- const isError = Object.prototype.toString.call(error) === '[object Error]';
- const shortMessage = isError ? `${execaMessage}\n${error.message}` : execaMessage;
- const message = [shortMessage, stderr, stdout].filter(Boolean).join('\n');
+ styles[key] = {
+ get() {
+ const codes = ansiStyles[key];
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+ }
+ };
+}
- if (isError) {
- error.originalMessage = error.message;
- error.message = message;
- } else {
- error = new Error(message);
+styles.visible = {
+ get() {
+ return build.call(this, this._styles || [], true, 'visible');
}
+};
- error.shortMessage = shortMessage;
- error.command = command;
- error.exitCode = exitCode;
- error.signal = signal;
- error.signalDescription = signalDescription;
- error.stdout = stdout;
- error.stderr = stderr;
-
- if (all !== undefined) {
- error.all = all;
+ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
+for (const model of Object.keys(ansiStyles.color.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
}
- if ('bufferedData' in error) {
- delete error.bufferedData;
- }
+ styles[model] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles.color.close,
+ closeRe: ansiStyles.color.closeRe
+ };
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
+}
- error.failed = true;
- error.timedOut = Boolean(timedOut);
- error.isCanceled = isCanceled;
- error.killed = killed && !timedOut;
+ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
+for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
- return error;
-};
+ const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+ styles[bgModel] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles.bgColor.close,
+ closeRe: ansiStyles.bgColor.closeRe
+ };
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
+}
-module.exports = makeError;
+const proto = Object.defineProperties(() => {}, styles);
+function build(_styles, _empty, key) {
+ const builder = function () {
+ return applyStyle.apply(builder, arguments);
+ };
-/***/ }),
-/* 391 */
-/***/ (function(module, exports, __webpack_require__) {
+ builder._styles = _styles;
+ builder._empty = _empty;
-"use strict";
-Object.defineProperty(exports,"__esModule",{value:true});exports.signalsByNumber=exports.signalsByName=void 0;var _os=__webpack_require__(11);
+ const self = this;
-var _signals=__webpack_require__(392);
-var _realtime=__webpack_require__(394);
+ Object.defineProperty(builder, 'level', {
+ enumerable: true,
+ get() {
+ return self.level;
+ },
+ set(level) {
+ self.level = level;
+ }
+ });
+ Object.defineProperty(builder, 'enabled', {
+ enumerable: true,
+ get() {
+ return self.enabled;
+ },
+ set(enabled) {
+ self.enabled = enabled;
+ }
+ });
+ // See below for fix regarding invisible grey/dim combination on Windows
+ builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
-const getSignalsByName=function(){
-const signals=(0,_signals.getSignals)();
-return signals.reduce(getSignalByName,{});
-};
+ // `__proto__` is used because we must return a function, but there is
+ // no way to create a function with a different prototype
+ builder.__proto__ = proto; // eslint-disable-line no-proto
-const getSignalByName=function(
-signalByNameMemo,
-{name,number,description,supported,action,forced,standard})
-{
-return{
-...signalByNameMemo,
-[name]:{name,number,description,supported,action,forced,standard}};
+ return builder;
+}
-};
+function applyStyle() {
+ // Support varags, but simply cast to string in case there's only one arg
+ const args = arguments;
+ const argsLen = args.length;
+ let str = String(arguments[0]);
-const signalsByName=getSignalsByName();exports.signalsByName=signalsByName;
+ if (argsLen === 0) {
+ return '';
+ }
+ if (argsLen > 1) {
+ // Don't slice `arguments`, it prevents V8 optimizations
+ for (let a = 1; a < argsLen; a++) {
+ str += ' ' + args[a];
+ }
+ }
+ if (!this.enabled || this.level <= 0 || !str) {
+ return this._empty ? '' : str;
+ }
+ // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
+ // see https://github.com/chalk/chalk/issues/58
+ // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
+ const originalDim = ansiStyles.dim.open;
+ if (isSimpleWindowsTerm && this.hasGrey) {
+ ansiStyles.dim.open = '';
+ }
-const getSignalsByNumber=function(){
-const signals=(0,_signals.getSignals)();
-const length=_realtime.SIGRTMAX+1;
-const signalsA=Array.from({length},(value,number)=>
-getSignalByNumber(number,signals));
+ for (const code of this._styles.slice().reverse()) {
+ // Replace any instances already present with a re-opening code
+ // otherwise only the part of the string until said closing code
+ // will be colored, and the rest will simply be 'plain'.
+ str = code.open + str.replace(code.closeRe, code.open) + code.close;
-return Object.assign({},...signalsA);
-};
+ // Close the styling before a linebreak and reopen
+ // after next line to fix a bleed issue on macOS
+ // https://github.com/chalk/chalk/pull/92
+ str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+ }
-const getSignalByNumber=function(number,signals){
-const signal=findSignalByNumber(number,signals);
+ // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
+ ansiStyles.dim.open = originalDim;
-if(signal===undefined){
-return{};
+ return str;
}
-const{name,description,supported,action,forced,standard}=signal;
-return{
-[number]:{
-name,
-number,
-description,
-supported,
-action,
-forced,
-standard}};
-
-
-};
-
+function chalkTag(chalk, strings) {
+ if (!Array.isArray(strings)) {
+ // If chalk() was called by itself or with a string,
+ // return the string itself as a string.
+ return [].slice.call(arguments, 1).join(' ');
+ }
+ const args = [].slice.call(arguments, 2);
+ const parts = [strings.raw[0]];
-const findSignalByNumber=function(number,signals){
-const signal=signals.find(({name})=>_os.constants.signals[name]===number);
+ for (let i = 1; i < strings.length; i++) {
+ parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
+ parts.push(String(strings.raw[i]));
+ }
-if(signal!==undefined){
-return signal;
+ return template(chalk, parts.join(''));
}
-return signals.find(signalA=>signalA.number===number);
-};
+Object.defineProperties(Chalk.prototype, styles);
+
+module.exports = Chalk(); // eslint-disable-line new-cap
+module.exports.supportsColor = stdoutColor;
+module.exports.default = module.exports; // For TypeScript
-const signalsByNumber=getSignalsByNumber();exports.signalsByNumber=signalsByNumber;
-//# sourceMappingURL=main.js.map
/***/ }),
-/* 392 */
+/* 387 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-Object.defineProperty(exports,"__esModule",{value:true});exports.getSignals=void 0;var _os=__webpack_require__(11);
-
-var _core=__webpack_require__(393);
-var _realtime=__webpack_require__(394);
-
-const getSignals=function(){
-const realtimeSignals=(0,_realtime.getRealtimeSignals)();
-const signals=[..._core.SIGNALS,...realtimeSignals].map(normalizeSignal);
-return signals;
-};exports.getSignals=getSignals;
+var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+module.exports = function (str) {
+ if (typeof str !== 'string') {
+ throw new TypeError('Expected a string');
+ }
+ return str.replace(matchOperatorsRe, '\\$&');
+};
-
-
-
-const normalizeSignal=function({
-name,
-number:defaultNumber,
-description,
-action,
-forced=false,
-standard})
-{
-const{
-signals:{[name]:constantSignal}}=
-_os.constants;
-const supported=constantSignal!==undefined;
-const number=supported?constantSignal:defaultNumber;
-return{name,number,description,supported,action,forced,standard};
-};
-//# sourceMappingURL=signals.js.map
-
/***/ }),
-/* 393 */
+/* 388 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-Object.defineProperty(exports,"__esModule",{value:true});exports.SIGNALS=void 0;
+/* WEBPACK VAR INJECTION */(function(module) {
+const colorConvert = __webpack_require__(389);
-const SIGNALS=[
-{
-name:"SIGHUP",
-number:1,
-action:"terminate",
-description:"Terminal closed",
-standard:"posix"},
+const wrapAnsi16 = (fn, offset) => function () {
+ const code = fn.apply(colorConvert, arguments);
+ return `\u001B[${code + offset}m`;
+};
-{
-name:"SIGINT",
-number:2,
-action:"terminate",
-description:"User interruption with CTRL-C",
-standard:"ansi"},
+const wrapAnsi256 = (fn, offset) => function () {
+ const code = fn.apply(colorConvert, arguments);
+ return `\u001B[${38 + offset};5;${code}m`;
+};
-{
-name:"SIGQUIT",
-number:3,
-action:"core",
-description:"User interruption with CTRL-\\",
-standard:"posix"},
+const wrapAnsi16m = (fn, offset) => function () {
+ const rgb = fn.apply(colorConvert, arguments);
+ return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+};
-{
-name:"SIGILL",
-number:4,
-action:"core",
-description:"Invalid machine instruction",
-standard:"ansi"},
+function assembleStyles() {
+ const codes = new Map();
+ const styles = {
+ modifier: {
+ reset: [0, 0],
+ // 21 isn't widely supported and 22 does the same thing
+ bold: [1, 22],
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29]
+ },
+ color: {
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+ gray: [90, 39],
-{
-name:"SIGTRAP",
-number:5,
-action:"core",
-description:"Debugger breakpoint",
-standard:"posix"},
+ // Bright color
+ redBright: [91, 39],
+ greenBright: [92, 39],
+ yellowBright: [93, 39],
+ blueBright: [94, 39],
+ magentaBright: [95, 39],
+ cyanBright: [96, 39],
+ whiteBright: [97, 39]
+ },
+ bgColor: {
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49],
-{
-name:"SIGABRT",
-number:6,
-action:"core",
-description:"Aborted",
-standard:"ansi"},
+ // Bright color
+ bgBlackBright: [100, 49],
+ bgRedBright: [101, 49],
+ bgGreenBright: [102, 49],
+ bgYellowBright: [103, 49],
+ bgBlueBright: [104, 49],
+ bgMagentaBright: [105, 49],
+ bgCyanBright: [106, 49],
+ bgWhiteBright: [107, 49]
+ }
+ };
-{
-name:"SIGIOT",
-number:6,
-action:"core",
-description:"Aborted",
-standard:"bsd"},
+ // Fix humans
+ styles.color.grey = styles.color.gray;
-{
-name:"SIGBUS",
-number:7,
-action:"core",
-description:
-"Bus error due to misaligned, non-existing address or paging error",
-standard:"bsd"},
+ for (const groupName of Object.keys(styles)) {
+ const group = styles[groupName];
-{
-name:"SIGEMT",
-number:7,
-action:"terminate",
-description:"Command should be emulated but is not implemented",
-standard:"other"},
+ for (const styleName of Object.keys(group)) {
+ const style = group[styleName];
-{
-name:"SIGFPE",
-number:8,
-action:"core",
-description:"Floating point arithmetic error",
-standard:"ansi"},
+ styles[styleName] = {
+ open: `\u001B[${style[0]}m`,
+ close: `\u001B[${style[1]}m`
+ };
-{
-name:"SIGKILL",
-number:9,
-action:"terminate",
-description:"Forced termination",
-standard:"posix",
-forced:true},
+ group[styleName] = styles[styleName];
-{
-name:"SIGUSR1",
-number:10,
-action:"terminate",
-description:"Application-specific signal",
-standard:"posix"},
+ codes.set(style[0], style[1]);
+ }
-{
-name:"SIGSEGV",
-number:11,
-action:"core",
-description:"Segmentation fault",
-standard:"ansi"},
+ Object.defineProperty(styles, groupName, {
+ value: group,
+ enumerable: false
+ });
-{
-name:"SIGUSR2",
-number:12,
-action:"terminate",
-description:"Application-specific signal",
-standard:"posix"},
+ Object.defineProperty(styles, 'codes', {
+ value: codes,
+ enumerable: false
+ });
+ }
-{
-name:"SIGPIPE",
-number:13,
-action:"terminate",
-description:"Broken pipe or socket",
-standard:"posix"},
+ const ansi2ansi = n => n;
+ const rgb2rgb = (r, g, b) => [r, g, b];
-{
-name:"SIGALRM",
-number:14,
-action:"terminate",
-description:"Timeout or timer",
-standard:"posix"},
+ styles.color.close = '\u001B[39m';
+ styles.bgColor.close = '\u001B[49m';
-{
-name:"SIGTERM",
-number:15,
-action:"terminate",
-description:"Termination",
-standard:"ansi"},
+ styles.color.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 0)
+ };
+ styles.color.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 0)
+ };
+ styles.color.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 0)
+ };
-{
-name:"SIGSTKFLT",
-number:16,
-action:"terminate",
-description:"Stack is empty or overflowed",
-standard:"other"},
+ styles.bgColor.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 10)
+ };
-{
-name:"SIGCHLD",
-number:17,
-action:"ignore",
-description:"Child process terminated, paused or unpaused",
-standard:"posix"},
+ for (let key of Object.keys(colorConvert)) {
+ if (typeof colorConvert[key] !== 'object') {
+ continue;
+ }
-{
-name:"SIGCLD",
-number:17,
-action:"ignore",
-description:"Child process terminated, paused or unpaused",
-standard:"other"},
+ const suite = colorConvert[key];
-{
-name:"SIGCONT",
-number:18,
-action:"unpause",
-description:"Unpaused",
-standard:"posix",
-forced:true},
+ if (key === 'ansi16') {
+ key = 'ansi';
+ }
-{
-name:"SIGSTOP",
-number:19,
-action:"pause",
-description:"Paused",
-standard:"posix",
-forced:true},
+ if ('ansi16' in suite) {
+ styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+ styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+ }
-{
-name:"SIGTSTP",
-number:20,
-action:"pause",
-description:"Paused using CTRL-Z or \"suspend\"",
-standard:"posix"},
+ if ('ansi256' in suite) {
+ styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+ styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+ }
-{
-name:"SIGTTIN",
-number:21,
-action:"pause",
-description:"Background process cannot read terminal input",
-standard:"posix"},
+ if ('rgb' in suite) {
+ styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+ styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+ }
+ }
-{
-name:"SIGBREAK",
-number:21,
-action:"terminate",
-description:"User interruption with CTRL-BREAK",
-standard:"other"},
+ return styles;
+}
-{
-name:"SIGTTOU",
-number:22,
-action:"pause",
-description:"Background process cannot write to terminal output",
-standard:"posix"},
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+ enumerable: true,
+ get: assembleStyles
+});
-{
-name:"SIGURG",
-number:23,
-action:"ignore",
-description:"Socket received out-of-band data",
-standard:"bsd"},
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(11)(module)))
-{
-name:"SIGXCPU",
-number:24,
-action:"core",
-description:"Process timed out",
-standard:"bsd"},
+/***/ }),
+/* 389 */
+/***/ (function(module, exports, __webpack_require__) {
-{
-name:"SIGXFSZ",
-number:25,
-action:"core",
-description:"File too big",
-standard:"bsd"},
+var conversions = __webpack_require__(390);
+var route = __webpack_require__(392);
-{
-name:"SIGVTALRM",
-number:26,
-action:"terminate",
-description:"Timeout or timer",
-standard:"bsd"},
+var convert = {};
-{
-name:"SIGPROF",
-number:27,
-action:"terminate",
-description:"Timeout or timer",
-standard:"bsd"},
+var models = Object.keys(conversions);
-{
-name:"SIGWINCH",
-number:28,
-action:"ignore",
-description:"Terminal window size changed",
-standard:"bsd"},
+function wrapRaw(fn) {
+ var wrappedFn = function (args) {
+ if (args === undefined || args === null) {
+ return args;
+ }
-{
-name:"SIGIO",
-number:29,
-action:"terminate",
-description:"I/O is available",
-standard:"other"},
+ if (arguments.length > 1) {
+ args = Array.prototype.slice.call(arguments);
+ }
-{
-name:"SIGPOLL",
-number:29,
-action:"terminate",
-description:"Watched event",
-standard:"other"},
+ return fn(args);
+ };
-{
-name:"SIGINFO",
-number:29,
-action:"ignore",
-description:"Request for process information",
-standard:"other"},
+ // preserve .conversion property if there is one
+ if ('conversion' in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
-{
-name:"SIGPWR",
-number:30,
-action:"terminate",
-description:"Device running out of power",
-standard:"systemv"},
+ return wrappedFn;
+}
-{
-name:"SIGSYS",
-number:31,
-action:"core",
-description:"Invalid system call",
-standard:"other"},
+function wrapRounded(fn) {
+ var wrappedFn = function (args) {
+ if (args === undefined || args === null) {
+ return args;
+ }
-{
-name:"SIGUNUSED",
-number:31,
-action:"terminate",
-description:"Invalid system call",
-standard:"other"}];exports.SIGNALS=SIGNALS;
-//# sourceMappingURL=core.js.map
+ if (arguments.length > 1) {
+ args = Array.prototype.slice.call(arguments);
+ }
-/***/ }),
-/* 394 */
-/***/ (function(module, exports, __webpack_require__) {
+ var result = fn(args);
-"use strict";
-Object.defineProperty(exports,"__esModule",{value:true});exports.SIGRTMAX=exports.getRealtimeSignals=void 0;
-const getRealtimeSignals=function(){
-const length=SIGRTMAX-SIGRTMIN+1;
-return Array.from({length},getRealtimeSignal);
-};exports.getRealtimeSignals=getRealtimeSignals;
+ // we're assuming the result is an array here.
+ // see notice in conversions.js; don't use box types
+ // in conversion functions.
+ if (typeof result === 'object') {
+ for (var len = result.length, i = 0; i < len; i++) {
+ result[i] = Math.round(result[i]);
+ }
+ }
-const getRealtimeSignal=function(value,index){
-return{
-name:`SIGRT${index+1}`,
-number:SIGRTMIN+index,
-action:"terminate",
-description:"Application-specific signal (realtime)",
-standard:"posix"};
+ return result;
+ };
-};
+ // preserve .conversion property if there is one
+ if ('conversion' in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
-const SIGRTMIN=34;
-const SIGRTMAX=64;exports.SIGRTMAX=SIGRTMAX;
-//# sourceMappingURL=realtime.js.map
+ return wrappedFn;
+}
-/***/ }),
-/* 395 */
-/***/ (function(module, exports, __webpack_require__) {
+models.forEach(function (fromModel) {
+ convert[fromModel] = {};
-"use strict";
+ Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
+ Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
-const aliases = ['stdin', 'stdout', 'stderr'];
+ var routes = route(fromModel);
+ var routeModels = Object.keys(routes);
-const hasAlias = opts => aliases.some(alias => opts[alias] !== undefined);
+ routeModels.forEach(function (toModel) {
+ var fn = routes[toModel];
-const normalizeStdio = opts => {
- if (!opts) {
- return;
- }
+ convert[fromModel][toModel] = wrapRounded(fn);
+ convert[fromModel][toModel].raw = wrapRaw(fn);
+ });
+});
- const {stdio} = opts;
+module.exports = convert;
- if (stdio === undefined) {
- return aliases.map(alias => opts[alias]);
- }
- if (hasAlias(opts)) {
- throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map(alias => `\`${alias}\``).join(', ')}`);
- }
+/***/ }),
+/* 390 */
+/***/ (function(module, exports, __webpack_require__) {
- if (typeof stdio === 'string') {
- return stdio;
- }
+/* MIT license */
+var cssKeywords = __webpack_require__(391);
- if (!Array.isArray(stdio)) {
- throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+// NOTE: conversions should only return primitive values (i.e. arrays, or
+// values that give correct `typeof` results).
+// do not use box values types (i.e. Number(), String(), etc.)
+
+var reverseKeywords = {};
+for (var key in cssKeywords) {
+ if (cssKeywords.hasOwnProperty(key)) {
+ reverseKeywords[cssKeywords[key]] = key;
}
+}
- const length = Math.max(stdio.length, aliases.length);
- return Array.from({length}, (value, index) => stdio[index]);
-};
+var convert = module.exports = {
+ rgb: {channels: 3, labels: 'rgb'},
+ hsl: {channels: 3, labels: 'hsl'},
+ hsv: {channels: 3, labels: 'hsv'},
+ hwb: {channels: 3, labels: 'hwb'},
+ cmyk: {channels: 4, labels: 'cmyk'},
+ xyz: {channels: 3, labels: 'xyz'},
+ lab: {channels: 3, labels: 'lab'},
+ lch: {channels: 3, labels: 'lch'},
+ hex: {channels: 1, labels: ['hex']},
+ keyword: {channels: 1, labels: ['keyword']},
+ ansi16: {channels: 1, labels: ['ansi16']},
+ ansi256: {channels: 1, labels: ['ansi256']},
+ hcg: {channels: 3, labels: ['h', 'c', 'g']},
+ apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
+ gray: {channels: 1, labels: ['gray']}
+};
-module.exports = normalizeStdio;
+// hide .channels and .labels properties
+for (var model in convert) {
+ if (convert.hasOwnProperty(model)) {
+ if (!('channels' in convert[model])) {
+ throw new Error('missing channels property: ' + model);
+ }
-// `ipc` is pushed unless it is already present
-module.exports.node = opts => {
- const stdio = normalizeStdio(opts);
+ if (!('labels' in convert[model])) {
+ throw new Error('missing channel labels property: ' + model);
+ }
- if (stdio === 'ipc') {
- return 'ipc';
- }
+ if (convert[model].labels.length !== convert[model].channels) {
+ throw new Error('channel and label counts mismatch: ' + model);
+ }
- if (stdio === undefined || typeof stdio === 'string') {
- return [stdio, stdio, stdio, 'ipc'];
+ var channels = convert[model].channels;
+ var labels = convert[model].labels;
+ delete convert[model].channels;
+ delete convert[model].labels;
+ Object.defineProperty(convert[model], 'channels', {value: channels});
+ Object.defineProperty(convert[model], 'labels', {value: labels});
}
+}
- if (stdio.includes('ipc')) {
- return stdio;
+convert.rgb.hsl = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var min = Math.min(r, g, b);
+ var max = Math.max(r, g, b);
+ var delta = max - min;
+ var h;
+ var s;
+ var l;
+
+ if (max === min) {
+ h = 0;
+ } else if (r === max) {
+ h = (g - b) / delta;
+ } else if (g === max) {
+ h = 2 + (b - r) / delta;
+ } else if (b === max) {
+ h = 4 + (r - g) / delta;
}
- return [...stdio, 'ipc'];
-};
+ h = Math.min(h * 60, 360);
+ if (h < 0) {
+ h += 360;
+ }
-/***/ }),
-/* 396 */
-/***/ (function(module, exports, __webpack_require__) {
+ l = (min + max) / 2;
-"use strict";
+ if (max === min) {
+ s = 0;
+ } else if (l <= 0.5) {
+ s = delta / (max + min);
+ } else {
+ s = delta / (2 - max - min);
+ }
-const os = __webpack_require__(11);
-const onExit = __webpack_require__(397);
+ return [h, s * 100, l * 100];
+};
-const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
+convert.rgb.hsv = function (rgb) {
+ var r = rgb[0];
+ var g = rgb[1];
+ var b = rgb[2];
+ var min = Math.min(r, g, b);
+ var max = Math.max(r, g, b);
+ var delta = max - min;
+ var h;
+ var s;
+ var v;
-// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
-const spawnedKill = (kill, signal = 'SIGTERM', options = {}) => {
- const killResult = kill(signal);
- setKillTimeout(kill, signal, options, killResult);
- return killResult;
-};
+ if (max === 0) {
+ s = 0;
+ } else {
+ s = (delta / max * 1000) / 10;
+ }
-const setKillTimeout = (kill, signal, options, killResult) => {
- if (!shouldForceKill(signal, options, killResult)) {
- return;
+ if (max === min) {
+ h = 0;
+ } else if (r === max) {
+ h = (g - b) / delta;
+ } else if (g === max) {
+ h = 2 + (b - r) / delta;
+ } else if (b === max) {
+ h = 4 + (r - g) / delta;
}
- const timeout = getForceKillAfterTimeout(options);
- const t = setTimeout(() => {
- kill('SIGKILL');
- }, timeout);
+ h = Math.min(h * 60, 360);
- // Guarded because there's no `.unref()` when `execa` is used in the renderer
- // process in Electron. This cannot be tested since we don't run tests in
- // Electron.
- // istanbul ignore else
- if (t.unref) {
- t.unref();
+ if (h < 0) {
+ h += 360;
}
-};
-const shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => {
- return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
-};
+ v = ((max / 255) * 1000) / 10;
-const isSigterm = signal => {
- return signal === os.constants.signals.SIGTERM ||
- (typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');
+ return [h, s, v];
};
-const getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {
- if (forceKillAfterTimeout === true) {
- return DEFAULT_FORCE_KILL_TIMEOUT;
- }
+convert.rgb.hwb = function (rgb) {
+ var r = rgb[0];
+ var g = rgb[1];
+ var b = rgb[2];
+ var h = convert.rgb.hsl(rgb)[0];
+ var w = 1 / 255 * Math.min(r, Math.min(g, b));
- if (!Number.isInteger(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
- throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
- }
+ b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
- return forceKillAfterTimeout;
+ return [h, w * 100, b * 100];
};
-// `childProcess.cancel()`
-const spawnedCancel = (spawned, context) => {
- const killResult = spawned.kill();
+convert.rgb.cmyk = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var c;
+ var m;
+ var y;
+ var k;
- if (killResult) {
- context.isCanceled = true;
- }
-};
+ k = Math.min(1 - r, 1 - g, 1 - b);
+ c = (1 - r - k) / (1 - k) || 0;
+ m = (1 - g - k) / (1 - k) || 0;
+ y = (1 - b - k) / (1 - k) || 0;
-const timeoutKill = (spawned, signal, reject) => {
- spawned.kill(signal);
- reject(Object.assign(new Error('Timed out'), {timedOut: true, signal}));
+ return [c * 100, m * 100, y * 100, k * 100];
};
-// `timeout` option handling
-const setupTimeout = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {
- if (timeout === 0 || timeout === undefined) {
- return spawnedPromise;
- }
+/**
+ * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
+ * */
+function comparativeDistance(x, y) {
+ return (
+ Math.pow(x[0] - y[0], 2) +
+ Math.pow(x[1] - y[1], 2) +
+ Math.pow(x[2] - y[2], 2)
+ );
+}
- if (!Number.isInteger(timeout) || timeout < 0) {
- throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+convert.rgb.keyword = function (rgb) {
+ var reversed = reverseKeywords[rgb];
+ if (reversed) {
+ return reversed;
}
- let timeoutId;
- const timeoutPromise = new Promise((resolve, reject) => {
- timeoutId = setTimeout(() => {
- timeoutKill(spawned, killSignal, reject);
- }, timeout);
- });
+ var currentClosestDistance = Infinity;
+ var currentClosestKeyword;
- const safeSpawnedPromise = spawnedPromise.finally(() => {
- clearTimeout(timeoutId);
- });
+ for (var keyword in cssKeywords) {
+ if (cssKeywords.hasOwnProperty(keyword)) {
+ var value = cssKeywords[keyword];
- return Promise.race([timeoutPromise, safeSpawnedPromise]);
-};
+ // Compute comparative distance
+ var distance = comparativeDistance(rgb, value);
-// `cleanup` option handling
-const setExitHandler = async (spawned, {cleanup, detached}, timedPromise) => {
- if (!cleanup || detached) {
- return timedPromise;
+ // Check if its less, if so set as closest
+ if (distance < currentClosestDistance) {
+ currentClosestDistance = distance;
+ currentClosestKeyword = keyword;
+ }
+ }
}
- const removeExitHandler = onExit(() => {
- spawned.kill();
- });
-
- return timedPromise.finally(() => {
- removeExitHandler();
- });
+ return currentClosestKeyword;
};
-module.exports = {
- spawnedKill,
- spawnedCancel,
- setupTimeout,
- setExitHandler
+convert.keyword.rgb = function (keyword) {
+ return cssKeywords[keyword];
};
+convert.rgb.xyz = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
-/***/ }),
-/* 397 */
-/***/ (function(module, exports, __webpack_require__) {
+ // assume sRGB
+ r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
+ g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
+ b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);
-// Note: since nyc uses this module to output coverage, any lines
-// that are in the direct sync flow of nyc's outputCoverage are
-// ignored, since we can never get coverage for them.
-var assert = __webpack_require__(30)
-var signals = __webpack_require__(398)
+ var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
+ var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
+ var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
-var EE = __webpack_require__(399)
-/* istanbul ignore if */
-if (typeof EE !== 'function') {
- EE = EE.EventEmitter
-}
+ return [x * 100, y * 100, z * 100];
+};
-var emitter
-if (process.__signal_exit_emitter__) {
- emitter = process.__signal_exit_emitter__
-} else {
- emitter = process.__signal_exit_emitter__ = new EE()
- emitter.count = 0
- emitter.emitted = {}
-}
+convert.rgb.lab = function (rgb) {
+ var xyz = convert.rgb.xyz(rgb);
+ var x = xyz[0];
+ var y = xyz[1];
+ var z = xyz[2];
+ var l;
+ var a;
+ var b;
-// Because this emitter is a global, we have to check to see if a
-// previous version of this library failed to enable infinite listeners.
-// I know what you're about to say. But literally everything about
-// signal-exit is a compromise with evil. Get used to it.
-if (!emitter.infinite) {
- emitter.setMaxListeners(Infinity)
- emitter.infinite = true
-}
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
-module.exports = function (cb, opts) {
- assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler')
+ x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
+ y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
+ z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
- if (loaded === false) {
- load()
- }
+ l = (116 * y) - 16;
+ a = 500 * (x - y);
+ b = 200 * (y - z);
- var ev = 'exit'
- if (opts && opts.alwaysLast) {
- ev = 'afterexit'
- }
+ return [l, a, b];
+};
- var remove = function () {
- emitter.removeListener(ev, cb)
- if (emitter.listeners('exit').length === 0 &&
- emitter.listeners('afterexit').length === 0) {
- unload()
- }
- }
- emitter.on(ev, cb)
+convert.hsl.rgb = function (hsl) {
+ var h = hsl[0] / 360;
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var t1;
+ var t2;
+ var t3;
+ var rgb;
+ var val;
- return remove
-}
+ if (s === 0) {
+ val = l * 255;
+ return [val, val, val];
+ }
-module.exports.unload = unload
-function unload () {
- if (!loaded) {
- return
- }
- loaded = false
+ if (l < 0.5) {
+ t2 = l * (1 + s);
+ } else {
+ t2 = l + s - l * s;
+ }
- signals.forEach(function (sig) {
- try {
- process.removeListener(sig, sigListeners[sig])
- } catch (er) {}
- })
- process.emit = originalProcessEmit
- process.reallyExit = originalProcessReallyExit
- emitter.count -= 1
-}
+ t1 = 2 * l - t2;
-function emit (event, code, signal) {
- if (emitter.emitted[event]) {
- return
- }
- emitter.emitted[event] = true
- emitter.emit(event, code, signal)
-}
+ rgb = [0, 0, 0];
+ for (var i = 0; i < 3; i++) {
+ t3 = h + 1 / 3 * -(i - 1);
+ if (t3 < 0) {
+ t3++;
+ }
+ if (t3 > 1) {
+ t3--;
+ }
-// { : , ... }
-var sigListeners = {}
-signals.forEach(function (sig) {
- sigListeners[sig] = function listener () {
- // If there are no other listeners, an exit is coming!
- // Simplest way: remove us and then re-send the signal.
- // We know that this will kill the process, so we can
- // safely emit now.
- var listeners = process.listeners(sig)
- if (listeners.length === emitter.count) {
- unload()
- emit('exit', null, sig)
- /* istanbul ignore next */
- emit('afterexit', null, sig)
- /* istanbul ignore next */
- process.kill(process.pid, sig)
- }
- }
-})
+ if (6 * t3 < 1) {
+ val = t1 + (t2 - t1) * 6 * t3;
+ } else if (2 * t3 < 1) {
+ val = t2;
+ } else if (3 * t3 < 2) {
+ val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+ } else {
+ val = t1;
+ }
-module.exports.signals = function () {
- return signals
-}
+ rgb[i] = val * 255;
+ }
-module.exports.load = load
+ return rgb;
+};
-var loaded = false
+convert.hsl.hsv = function (hsl) {
+ var h = hsl[0];
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var smin = s;
+ var lmin = Math.max(l, 0.01);
+ var sv;
+ var v;
-function load () {
- if (loaded) {
- return
- }
- loaded = true
+ l *= 2;
+ s *= (l <= 1) ? l : 2 - l;
+ smin *= lmin <= 1 ? lmin : 2 - lmin;
+ v = (l + s) / 2;
+ sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
- // This is the number of onSignalExit's that are in play.
- // It's important so that we can count the correct number of
- // listeners on signals, and don't wait for the other one to
- // handle it instead of us.
- emitter.count += 1
+ return [h, sv * 100, v * 100];
+};
- signals = signals.filter(function (sig) {
- try {
- process.on(sig, sigListeners[sig])
- return true
- } catch (er) {
- return false
- }
- })
+convert.hsv.rgb = function (hsv) {
+ var h = hsv[0] / 60;
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var hi = Math.floor(h) % 6;
- process.emit = processEmit
- process.reallyExit = processReallyExit
-}
+ var f = h - Math.floor(h);
+ var p = 255 * v * (1 - s);
+ var q = 255 * v * (1 - (s * f));
+ var t = 255 * v * (1 - (s * (1 - f)));
+ v *= 255;
-var originalProcessReallyExit = process.reallyExit
-function processReallyExit (code) {
- process.exitCode = code || 0
- emit('exit', process.exitCode, null)
- /* istanbul ignore next */
- emit('afterexit', process.exitCode, null)
- /* istanbul ignore next */
- originalProcessReallyExit.call(process, process.exitCode)
-}
+ switch (hi) {
+ case 0:
+ return [v, t, p];
+ case 1:
+ return [q, v, p];
+ case 2:
+ return [p, v, t];
+ case 3:
+ return [p, q, v];
+ case 4:
+ return [t, p, v];
+ case 5:
+ return [v, p, q];
+ }
+};
-var originalProcessEmit = process.emit
-function processEmit (ev, arg) {
- if (ev === 'exit') {
- if (arg !== undefined) {
- process.exitCode = arg
- }
- var ret = originalProcessEmit.apply(this, arguments)
- emit('exit', process.exitCode, null)
- /* istanbul ignore next */
- emit('afterexit', process.exitCode, null)
- return ret
- } else {
- return originalProcessEmit.apply(this, arguments)
- }
-}
+convert.hsv.hsl = function (hsv) {
+ var h = hsv[0];
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var vmin = Math.max(v, 0.01);
+ var lmin;
+ var sl;
+ var l;
+ l = (2 - s) * v;
+ lmin = (2 - s) * vmin;
+ sl = s * vmin;
+ sl /= (lmin <= 1) ? lmin : 2 - lmin;
+ sl = sl || 0;
+ l /= 2;
-/***/ }),
-/* 398 */
-/***/ (function(module, exports) {
+ return [h, sl * 100, l * 100];
+};
-// This is not the set of all possible signals.
-//
-// It IS, however, the set of all signals that trigger
-// an exit on either Linux or BSD systems. Linux is a
-// superset of the signal names supported on BSD, and
-// the unknown signals just fail to register, so we can
-// catch that easily enough.
-//
-// Don't bother with SIGKILL. It's uncatchable, which
-// means that we can't fire any callbacks anyway.
-//
-// If a user does happen to register a handler on a non-
-// fatal signal like SIGWINCH or something, and then
-// exit, it'll end up firing `process.emit('exit')`, so
-// the handler will be fired anyway.
-//
-// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
-// artificially, inherently leave the process in a
-// state from which it is not safe to try and enter JS
-// listeners.
-module.exports = [
- 'SIGABRT',
- 'SIGALRM',
- 'SIGHUP',
- 'SIGINT',
- 'SIGTERM'
-]
-
-if (process.platform !== 'win32') {
- module.exports.push(
- 'SIGVTALRM',
- 'SIGXCPU',
- 'SIGXFSZ',
- 'SIGUSR2',
- 'SIGTRAP',
- 'SIGSYS',
- 'SIGQUIT',
- 'SIGIOT'
- // should detect profiler and enable/disable accordingly.
- // see #21
- // 'SIGPROF'
- )
-}
-
-if (process.platform === 'linux') {
- module.exports.push(
- 'SIGIO',
- 'SIGPOLL',
- 'SIGPWR',
- 'SIGSTKFLT',
- 'SIGUNUSED'
- )
-}
-
-
-/***/ }),
-/* 399 */
-/***/ (function(module, exports) {
-
-module.exports = require("events");
-
-/***/ }),
-/* 400 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-const isStream = __webpack_require__(401);
-const getStream = __webpack_require__(402);
-const mergeStream = __webpack_require__(408);
+// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+convert.hwb.rgb = function (hwb) {
+ var h = hwb[0] / 360;
+ var wh = hwb[1] / 100;
+ var bl = hwb[2] / 100;
+ var ratio = wh + bl;
+ var i;
+ var v;
+ var f;
+ var n;
-// `input` option
-const handleInput = (spawned, input) => {
- // Checking for stdin is workaround for https://github.com/nodejs/node/issues/26852
- // TODO: Remove `|| spawned.stdin === undefined` once we drop support for Node.js <=12.2.0
- if (input === undefined || spawned.stdin === undefined) {
- return;
+ // wh + bl cant be > 1
+ if (ratio > 1) {
+ wh /= ratio;
+ bl /= ratio;
}
- if (isStream(input)) {
- input.pipe(spawned.stdin);
- } else {
- spawned.stdin.end(input);
- }
-};
+ i = Math.floor(6 * h);
+ v = 1 - bl;
+ f = 6 * h - i;
-// `all` interleaves `stdout` and `stderr`
-const makeAllStream = (spawned, {all}) => {
- if (!all || (!spawned.stdout && !spawned.stderr)) {
- return;
+ if ((i & 0x01) !== 0) {
+ f = 1 - f;
}
- const mixed = mergeStream();
-
- if (spawned.stdout) {
- mixed.add(spawned.stdout);
- }
+ n = wh + f * (v - wh); // linear interpolation
- if (spawned.stderr) {
- mixed.add(spawned.stderr);
+ var r;
+ var g;
+ var b;
+ switch (i) {
+ default:
+ case 6:
+ case 0: r = v; g = n; b = wh; break;
+ case 1: r = n; g = v; b = wh; break;
+ case 2: r = wh; g = v; b = n; break;
+ case 3: r = wh; g = n; b = v; break;
+ case 4: r = n; g = wh; b = v; break;
+ case 5: r = v; g = wh; b = n; break;
}
- return mixed;
+ return [r * 255, g * 255, b * 255];
};
-// On failure, `result.stdout|stderr|all` should contain the currently buffered stream
-const getBufferedData = async (stream, streamPromise) => {
- if (!stream) {
- return;
- }
+convert.cmyk.rgb = function (cmyk) {
+ var c = cmyk[0] / 100;
+ var m = cmyk[1] / 100;
+ var y = cmyk[2] / 100;
+ var k = cmyk[3] / 100;
+ var r;
+ var g;
+ var b;
- stream.destroy();
+ r = 1 - Math.min(1, c * (1 - k) + k);
+ g = 1 - Math.min(1, m * (1 - k) + k);
+ b = 1 - Math.min(1, y * (1 - k) + k);
- try {
- return await streamPromise;
- } catch (error) {
- return error.bufferedData;
- }
+ return [r * 255, g * 255, b * 255];
};
-const getStreamPromise = (stream, {encoding, buffer, maxBuffer}) => {
- if (!stream || !buffer) {
- return;
- }
+convert.xyz.rgb = function (xyz) {
+ var x = xyz[0] / 100;
+ var y = xyz[1] / 100;
+ var z = xyz[2] / 100;
+ var r;
+ var g;
+ var b;
- if (encoding) {
- return getStream(stream, {encoding, maxBuffer});
- }
+ r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
+ g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
+ b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
- return getStream.buffer(stream, {maxBuffer});
-};
+ // assume sRGB
+ r = r > 0.0031308
+ ? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
+ : r * 12.92;
-// Retrieve result of child process: exit code, signal, error, streams (stdout/stderr/all)
-const getSpawnedResult = async ({stdout, stderr, all}, {encoding, buffer, maxBuffer}, processDone) => {
- const stdoutPromise = getStreamPromise(stdout, {encoding, buffer, maxBuffer});
- const stderrPromise = getStreamPromise(stderr, {encoding, buffer, maxBuffer});
- const allPromise = getStreamPromise(all, {encoding, buffer, maxBuffer: maxBuffer * 2});
+ g = g > 0.0031308
+ ? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
+ : g * 12.92;
- try {
- return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
- } catch (error) {
- return Promise.all([
- {error, signal: error.signal, timedOut: error.timedOut},
- getBufferedData(stdout, stdoutPromise),
- getBufferedData(stderr, stderrPromise),
- getBufferedData(all, allPromise)
- ]);
- }
-};
+ b = b > 0.0031308
+ ? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
+ : b * 12.92;
-const validateInputSync = ({input}) => {
- if (isStream(input)) {
- throw new TypeError('The `input` option cannot be a stream in sync mode');
- }
-};
+ r = Math.min(Math.max(0, r), 1);
+ g = Math.min(Math.max(0, g), 1);
+ b = Math.min(Math.max(0, b), 1);
-module.exports = {
- handleInput,
- makeAllStream,
- getSpawnedResult,
- validateInputSync
+ return [r * 255, g * 255, b * 255];
};
+convert.xyz.lab = function (xyz) {
+ var x = xyz[0];
+ var y = xyz[1];
+ var z = xyz[2];
+ var l;
+ var a;
+ var b;
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
-/***/ }),
-/* 401 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-
-const isStream = stream =>
- stream !== null &&
- typeof stream === 'object' &&
- typeof stream.pipe === 'function';
+ x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
+ y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
+ z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);
-isStream.writable = stream =>
- isStream(stream) &&
- stream.writable !== false &&
- typeof stream._write === 'function' &&
- typeof stream._writableState === 'object';
+ l = (116 * y) - 16;
+ a = 500 * (x - y);
+ b = 200 * (y - z);
-isStream.readable = stream =>
- isStream(stream) &&
- stream.readable !== false &&
- typeof stream._read === 'function' &&
- typeof stream._readableState === 'object';
+ return [l, a, b];
+};
-isStream.duplex = stream =>
- isStream.writable(stream) &&
- isStream.readable(stream);
+convert.lab.xyz = function (lab) {
+ var l = lab[0];
+ var a = lab[1];
+ var b = lab[2];
+ var x;
+ var y;
+ var z;
-isStream.transform = stream =>
- isStream.duplex(stream) &&
- typeof stream._transform === 'function' &&
- typeof stream._transformState === 'object';
+ y = (l + 16) / 116;
+ x = a / 500 + y;
+ z = y - b / 200;
-module.exports = isStream;
+ var y2 = Math.pow(y, 3);
+ var x2 = Math.pow(x, 3);
+ var z2 = Math.pow(z, 3);
+ y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+ x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+ z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+ x *= 95.047;
+ y *= 100;
+ z *= 108.883;
-/***/ }),
-/* 402 */
-/***/ (function(module, exports, __webpack_require__) {
+ return [x, y, z];
+};
-"use strict";
+convert.lab.lch = function (lab) {
+ var l = lab[0];
+ var a = lab[1];
+ var b = lab[2];
+ var hr;
+ var h;
+ var c;
-const pump = __webpack_require__(403);
-const bufferStream = __webpack_require__(407);
+ hr = Math.atan2(b, a);
+ h = hr * 360 / 2 / Math.PI;
-class MaxBufferError extends Error {
- constructor() {
- super('maxBuffer exceeded');
- this.name = 'MaxBufferError';
+ if (h < 0) {
+ h += 360;
}
-}
-async function getStream(inputStream, options) {
- if (!inputStream) {
- return Promise.reject(new Error('Expected a stream'));
- }
+ c = Math.sqrt(a * a + b * b);
- options = {
- maxBuffer: Infinity,
- ...options
- };
+ return [l, c, h];
+};
- const {maxBuffer} = options;
+convert.lch.lab = function (lch) {
+ var l = lch[0];
+ var c = lch[1];
+ var h = lch[2];
+ var a;
+ var b;
+ var hr;
- let stream;
- await new Promise((resolve, reject) => {
- const rejectPromise = error => {
- if (error) { // A null check
- error.bufferedData = stream.getBufferedValue();
- }
+ hr = h / 360 * 2 * Math.PI;
+ a = c * Math.cos(hr);
+ b = c * Math.sin(hr);
- reject(error);
- };
+ return [l, a, b];
+};
- stream = pump(inputStream, bufferStream(options), error => {
- if (error) {
- rejectPromise(error);
- return;
- }
+convert.rgb.ansi16 = function (args) {
+ var r = args[0];
+ var g = args[1];
+ var b = args[2];
+ var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2]; // hsv -> ansi16 optimization
- resolve();
- });
+ value = Math.round(value / 50);
- stream.on('data', () => {
- if (stream.getBufferedLength() > maxBuffer) {
- rejectPromise(new MaxBufferError());
- }
- });
- });
+ if (value === 0) {
+ return 30;
+ }
- return stream.getBufferedValue();
-}
+ var ansi = 30
+ + ((Math.round(b / 255) << 2)
+ | (Math.round(g / 255) << 1)
+ | Math.round(r / 255));
-module.exports = getStream;
-// TODO: Remove this for the next major release
-module.exports.default = getStream;
-module.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
-module.exports.array = (stream, options) => getStream(stream, {...options, array: true});
-module.exports.MaxBufferError = MaxBufferError;
+ if (value === 2) {
+ ansi += 60;
+ }
+ return ansi;
+};
-/***/ }),
-/* 403 */
-/***/ (function(module, exports, __webpack_require__) {
+convert.hsv.ansi16 = function (args) {
+ // optimization here; we already know the value and don't need to get
+ // it converted for us.
+ return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+};
-var once = __webpack_require__(404)
-var eos = __webpack_require__(406)
-var fs = __webpack_require__(23) // we only need fs to get the ReadStream and WriteStream prototypes
+convert.rgb.ansi256 = function (args) {
+ var r = args[0];
+ var g = args[1];
+ var b = args[2];
-var noop = function () {}
-var ancient = /^v?\.0/.test(process.version)
+ // we use the extended greyscale palette here, with the exception of
+ // black and white. normal palette only has 4 greyscale shades.
+ if (r === g && g === b) {
+ if (r < 8) {
+ return 16;
+ }
-var isFn = function (fn) {
- return typeof fn === 'function'
-}
+ if (r > 248) {
+ return 231;
+ }
-var isFS = function (stream) {
- if (!ancient) return false // newer node version do not need to care about fs is a special way
- if (!fs) return false // browser
- return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)
-}
+ return Math.round(((r - 8) / 247) * 24) + 232;
+ }
-var isRequest = function (stream) {
- return stream.setHeader && isFn(stream.abort)
-}
+ var ansi = 16
+ + (36 * Math.round(r / 255 * 5))
+ + (6 * Math.round(g / 255 * 5))
+ + Math.round(b / 255 * 5);
-var destroyer = function (stream, reading, writing, callback) {
- callback = once(callback)
+ return ansi;
+};
- var closed = false
- stream.on('close', function () {
- closed = true
- })
+convert.ansi16.rgb = function (args) {
+ var color = args % 10;
- eos(stream, {readable: reading, writable: writing}, function (err) {
- if (err) return callback(err)
- closed = true
- callback()
- })
+ // handle greyscale
+ if (color === 0 || color === 7) {
+ if (args > 50) {
+ color += 3.5;
+ }
- var destroyed = false
- return function (err) {
- if (closed) return
- if (destroyed) return
- destroyed = true
+ color = color / 10.5 * 255;
- if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks
- if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want
+ return [color, color, color];
+ }
- if (isFn(stream.destroy)) return stream.destroy()
+ var mult = (~~(args > 50) + 1) * 0.5;
+ var r = ((color & 1) * mult) * 255;
+ var g = (((color >> 1) & 1) * mult) * 255;
+ var b = (((color >> 2) & 1) * mult) * 255;
- callback(err || new Error('stream was destroyed'))
- }
-}
+ return [r, g, b];
+};
-var call = function (fn) {
- fn()
-}
+convert.ansi256.rgb = function (args) {
+ // handle greyscale
+ if (args >= 232) {
+ var c = (args - 232) * 10 + 8;
+ return [c, c, c];
+ }
-var pipe = function (from, to) {
- return from.pipe(to)
-}
+ args -= 16;
-var pump = function () {
- var streams = Array.prototype.slice.call(arguments)
- var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop
+ var rem;
+ var r = Math.floor(args / 36) / 5 * 255;
+ var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+ var b = (rem % 6) / 5 * 255;
- if (Array.isArray(streams[0])) streams = streams[0]
- if (streams.length < 2) throw new Error('pump requires two streams per minimum')
+ return [r, g, b];
+};
- var error
- var destroys = streams.map(function (stream, i) {
- var reading = i < streams.length - 1
- var writing = i > 0
- return destroyer(stream, reading, writing, function (err) {
- if (!error) error = err
- if (err) destroys.forEach(call)
- if (reading) return
- destroys.forEach(call)
- callback(error)
- })
- })
+convert.rgb.hex = function (args) {
+ var integer = ((Math.round(args[0]) & 0xFF) << 16)
+ + ((Math.round(args[1]) & 0xFF) << 8)
+ + (Math.round(args[2]) & 0xFF);
- return streams.reduce(pipe)
-}
+ var string = integer.toString(16).toUpperCase();
+ return '000000'.substring(string.length) + string;
+};
-module.exports = pump
+convert.hex.rgb = function (args) {
+ var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+ if (!match) {
+ return [0, 0, 0];
+ }
+ var colorString = match[0];
-/***/ }),
-/* 404 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (match[0].length === 3) {
+ colorString = colorString.split('').map(function (char) {
+ return char + char;
+ }).join('');
+ }
-var wrappy = __webpack_require__(405)
-module.exports = wrappy(once)
-module.exports.strict = wrappy(onceStrict)
+ var integer = parseInt(colorString, 16);
+ var r = (integer >> 16) & 0xFF;
+ var g = (integer >> 8) & 0xFF;
+ var b = integer & 0xFF;
-once.proto = once(function () {
- Object.defineProperty(Function.prototype, 'once', {
- value: function () {
- return once(this)
- },
- configurable: true
- })
-
- Object.defineProperty(Function.prototype, 'onceStrict', {
- value: function () {
- return onceStrict(this)
- },
- configurable: true
- })
-})
-
-function once (fn) {
- var f = function () {
- if (f.called) return f.value
- f.called = true
- return f.value = fn.apply(this, arguments)
- }
- f.called = false
- return f
-}
-
-function onceStrict (fn) {
- var f = function () {
- if (f.called)
- throw new Error(f.onceError)
- f.called = true
- return f.value = fn.apply(this, arguments)
- }
- var name = fn.name || 'Function wrapped with `once`'
- f.onceError = name + " shouldn't be called more than once"
- f.called = false
- return f
-}
-
-
-/***/ }),
-/* 405 */
-/***/ (function(module, exports) {
-
-// Returns a wrapper function that returns a wrapped callback
-// The wrapper function should do some stuff, and return a
-// presumably different callback function.
-// This makes sure that own properties are retained, so that
-// decorations and such are not lost along the way.
-module.exports = wrappy
-function wrappy (fn, cb) {
- if (fn && cb) return wrappy(fn)(cb)
-
- if (typeof fn !== 'function')
- throw new TypeError('need wrapper function')
-
- Object.keys(fn).forEach(function (k) {
- wrapper[k] = fn[k]
- })
-
- return wrapper
-
- function wrapper() {
- var args = new Array(arguments.length)
- for (var i = 0; i < args.length; i++) {
- args[i] = arguments[i]
- }
- var ret = fn.apply(this, args)
- var cb = args[args.length-1]
- if (typeof ret === 'function' && ret !== cb) {
- Object.keys(cb).forEach(function (k) {
- ret[k] = cb[k]
- })
- }
- return ret
- }
-}
-
-
-/***/ }),
-/* 406 */
-/***/ (function(module, exports, __webpack_require__) {
-
-var once = __webpack_require__(404);
-
-var noop = function() {};
-
-var isRequest = function(stream) {
- return stream.setHeader && typeof stream.abort === 'function';
-};
-
-var isChildProcess = function(stream) {
- return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
+ return [r, g, b];
};
-var eos = function(stream, opts, callback) {
- if (typeof opts === 'function') return eos(stream, null, opts);
- if (!opts) opts = {};
-
- callback = once(callback || noop);
-
- var ws = stream._writableState;
- var rs = stream._readableState;
- var readable = opts.readable || (opts.readable !== false && stream.readable);
- var writable = opts.writable || (opts.writable !== false && stream.writable);
-
- var onlegacyfinish = function() {
- if (!stream.writable) onfinish();
- };
-
- var onfinish = function() {
- writable = false;
- if (!readable) callback.call(stream);
- };
-
- var onend = function() {
- readable = false;
- if (!writable) callback.call(stream);
- };
-
- var onexit = function(exitCode) {
- callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
- };
-
- var onerror = function(err) {
- callback.call(stream, err);
- };
-
- var onclose = function() {
- if (readable && !(rs && rs.ended)) return callback.call(stream, new Error('premature close'));
- if (writable && !(ws && ws.ended)) return callback.call(stream, new Error('premature close'));
- };
-
- var onrequest = function() {
- stream.req.on('finish', onfinish);
- };
+convert.rgb.hcg = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var max = Math.max(Math.max(r, g), b);
+ var min = Math.min(Math.min(r, g), b);
+ var chroma = (max - min);
+ var grayscale;
+ var hue;
- if (isRequest(stream)) {
- stream.on('complete', onfinish);
- stream.on('abort', onclose);
- if (stream.req) onrequest();
- else stream.on('request', onrequest);
- } else if (writable && !ws) { // legacy streams
- stream.on('end', onlegacyfinish);
- stream.on('close', onlegacyfinish);
+ if (chroma < 1) {
+ grayscale = min / (1 - chroma);
+ } else {
+ grayscale = 0;
}
- if (isChildProcess(stream)) stream.on('exit', onexit);
+ if (chroma <= 0) {
+ hue = 0;
+ } else
+ if (max === r) {
+ hue = ((g - b) / chroma) % 6;
+ } else
+ if (max === g) {
+ hue = 2 + (b - r) / chroma;
+ } else {
+ hue = 4 + (r - g) / chroma + 4;
+ }
- stream.on('end', onend);
- stream.on('finish', onfinish);
- if (opts.error !== false) stream.on('error', onerror);
- stream.on('close', onclose);
+ hue /= 6;
+ hue %= 1;
- return function() {
- stream.removeListener('complete', onfinish);
- stream.removeListener('abort', onclose);
- stream.removeListener('request', onrequest);
- if (stream.req) stream.req.removeListener('finish', onfinish);
- stream.removeListener('end', onlegacyfinish);
- stream.removeListener('close', onlegacyfinish);
- stream.removeListener('finish', onfinish);
- stream.removeListener('exit', onexit);
- stream.removeListener('end', onend);
- stream.removeListener('error', onerror);
- stream.removeListener('close', onclose);
- };
+ return [hue * 360, chroma * 100, grayscale * 100];
};
-module.exports = eos;
-
-
-/***/ }),
-/* 407 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-const {PassThrough: PassThroughStream} = __webpack_require__(27);
-
-module.exports = options => {
- options = {...options};
-
- const {array} = options;
- let {encoding} = options;
- const isBuffer = encoding === 'buffer';
- let objectMode = false;
+convert.hsl.hcg = function (hsl) {
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var c = 1;
+ var f = 0;
- if (array) {
- objectMode = !(encoding || isBuffer);
+ if (l < 0.5) {
+ c = 2.0 * s * l;
} else {
- encoding = encoding || 'utf8';
- }
-
- if (isBuffer) {
- encoding = null;
+ c = 2.0 * s * (1.0 - l);
}
- const stream = new PassThroughStream({objectMode});
-
- if (encoding) {
- stream.setEncoding(encoding);
+ if (c < 1.0) {
+ f = (l - 0.5 * c) / (1.0 - c);
}
- let length = 0;
- const chunks = [];
-
- stream.on('data', chunk => {
- chunks.push(chunk);
-
- if (objectMode) {
- length = chunks.length;
- } else {
- length += chunk.length;
- }
- });
-
- stream.getBufferedValue = () => {
- if (array) {
- return chunks;
- }
-
- return isBuffer ? Buffer.concat(chunks, length) : chunks.join('');
- };
-
- stream.getBufferedLength = () => length;
-
- return stream;
+ return [hsl[0], c * 100, f * 100];
};
+convert.hsv.hcg = function (hsv) {
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
-/***/ }),
-/* 408 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
+ var c = s * v;
+ var f = 0;
+ if (c < 1.0) {
+ f = (v - c) / (1 - c);
+ }
-const { PassThrough } = __webpack_require__(27);
+ return [hsv[0], c * 100, f * 100];
+};
-module.exports = function (/*streams...*/) {
- var sources = []
- var output = new PassThrough({objectMode: true})
+convert.hcg.rgb = function (hcg) {
+ var h = hcg[0] / 360;
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
- output.setMaxListeners(0)
+ if (c === 0.0) {
+ return [g * 255, g * 255, g * 255];
+ }
- output.add = add
- output.isEmpty = isEmpty
+ var pure = [0, 0, 0];
+ var hi = (h % 1) * 6;
+ var v = hi % 1;
+ var w = 1 - v;
+ var mg = 0;
- output.on('unpipe', remove)
+ switch (Math.floor(hi)) {
+ case 0:
+ pure[0] = 1; pure[1] = v; pure[2] = 0; break;
+ case 1:
+ pure[0] = w; pure[1] = 1; pure[2] = 0; break;
+ case 2:
+ pure[0] = 0; pure[1] = 1; pure[2] = v; break;
+ case 3:
+ pure[0] = 0; pure[1] = w; pure[2] = 1; break;
+ case 4:
+ pure[0] = v; pure[1] = 0; pure[2] = 1; break;
+ default:
+ pure[0] = 1; pure[1] = 0; pure[2] = w;
+ }
- Array.prototype.slice.call(arguments).forEach(add)
+ mg = (1.0 - c) * g;
- return output
+ return [
+ (c * pure[0] + mg) * 255,
+ (c * pure[1] + mg) * 255,
+ (c * pure[2] + mg) * 255
+ ];
+};
- function add (source) {
- if (Array.isArray(source)) {
- source.forEach(add)
- return this
- }
+convert.hcg.hsv = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
- sources.push(source);
- source.once('end', remove.bind(null, source))
- source.once('error', output.emit.bind(output, 'error'))
- source.pipe(output, {end: false})
- return this
- }
+ var v = c + g * (1.0 - c);
+ var f = 0;
- function isEmpty () {
- return sources.length == 0;
- }
+ if (v > 0.0) {
+ f = c / v;
+ }
- function remove (source) {
- sources = sources.filter(function (it) { return it !== source })
- if (!sources.length && output.readable) { output.end() }
- }
-}
+ return [hcg[0], f * 100, v * 100];
+};
+convert.hcg.hsl = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
-/***/ }),
-/* 409 */
-/***/ (function(module, exports, __webpack_require__) {
+ var l = g * (1.0 - c) + 0.5 * c;
+ var s = 0;
-"use strict";
+ if (l > 0.0 && l < 0.5) {
+ s = c / (2 * l);
+ } else
+ if (l >= 0.5 && l < 1.0) {
+ s = c / (2 * (1 - l));
+ }
+ return [hcg[0], s * 100, l * 100];
+};
-const nativePromisePrototype = (async () => {})().constructor.prototype;
-const descriptors = ['then', 'catch', 'finally'].map(property => [
- property,
- Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)
-]);
+convert.hcg.hwb = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var v = c + g * (1.0 - c);
+ return [hcg[0], (v - c) * 100, (1 - v) * 100];
+};
-// The return value is a mixin of `childProcess` and `Promise`
-const mergePromise = (spawned, promise) => {
- for (const [property, descriptor] of descriptors) {
- // Starting the main `promise` is deferred to avoid consuming streams
- const value = typeof promise === 'function' ?
- (...args) => Reflect.apply(descriptor.value, promise(), args) :
- descriptor.value.bind(promise);
+convert.hwb.hcg = function (hwb) {
+ var w = hwb[1] / 100;
+ var b = hwb[2] / 100;
+ var v = 1 - b;
+ var c = v - w;
+ var g = 0;
- Reflect.defineProperty(spawned, property, {...descriptor, value});
+ if (c < 1) {
+ g = (v - c) / (1 - c);
}
- return spawned;
+ return [hwb[0], c * 100, g * 100];
};
-// Use promises instead of `child_process` events
-const getSpawnedPromise = spawned => {
- return new Promise((resolve, reject) => {
- spawned.on('exit', (exitCode, signal) => {
- resolve({exitCode, signal});
- });
-
- spawned.on('error', error => {
- reject(error);
- });
-
- if (spawned.stdin) {
- spawned.stdin.on('error', error => {
- reject(error);
- });
- }
- });
+convert.apple.rgb = function (apple) {
+ return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
};
-module.exports = {
- mergePromise,
- getSpawnedPromise
+convert.rgb.apple = function (rgb) {
+ return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
};
-
-
-/***/ }),
-/* 410 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-const SPACES_REGEXP = / +/g;
-
-const joinCommand = (file, args = []) => {
- if (!Array.isArray(args)) {
- return file;
- }
-
- return [file, ...args].join(' ');
+convert.gray.rgb = function (args) {
+ return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
};
-// Allow spaces to be escaped by a backslash if not meant as a delimiter
-const handleEscaping = (tokens, token, index) => {
- if (index === 0) {
- return [token];
- }
+convert.gray.hsl = convert.gray.hsv = function (args) {
+ return [0, 0, args[0]];
+};
- const previousToken = tokens[tokens.length - 1];
+convert.gray.hwb = function (gray) {
+ return [0, 100, gray[0]];
+};
- if (previousToken.endsWith('\\')) {
- return [...tokens.slice(0, -1), `${previousToken.slice(0, -1)} ${token}`];
- }
+convert.gray.cmyk = function (gray) {
+ return [0, 0, 0, gray[0]];
+};
- return [...tokens, token];
+convert.gray.lab = function (gray) {
+ return [gray[0], 0, 0];
};
-// Handle `execa.command()`
-const parseCommand = command => {
- return command
- .trim()
- .split(SPACES_REGEXP)
- .reduce(handleEscaping, []);
+convert.gray.hex = function (gray) {
+ var val = Math.round(gray[0] / 100 * 255) & 0xFF;
+ var integer = (val << 16) + (val << 8) + val;
+
+ var string = integer.toString(16).toUpperCase();
+ return '000000'.substring(string.length) + string;
};
-module.exports = {
- joinCommand,
- parseCommand
+convert.rgb.gray = function (rgb) {
+ var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+ return [val / 255 * 100];
};
/***/ }),
-/* 411 */
+/* 391 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+
+
+module.exports = {
+ "aliceblue": [240, 248, 255],
+ "antiquewhite": [250, 235, 215],
+ "aqua": [0, 255, 255],
+ "aquamarine": [127, 255, 212],
+ "azure": [240, 255, 255],
+ "beige": [245, 245, 220],
+ "bisque": [255, 228, 196],
+ "black": [0, 0, 0],
+ "blanchedalmond": [255, 235, 205],
+ "blue": [0, 0, 255],
+ "blueviolet": [138, 43, 226],
+ "brown": [165, 42, 42],
+ "burlywood": [222, 184, 135],
+ "cadetblue": [95, 158, 160],
+ "chartreuse": [127, 255, 0],
+ "chocolate": [210, 105, 30],
+ "coral": [255, 127, 80],
+ "cornflowerblue": [100, 149, 237],
+ "cornsilk": [255, 248, 220],
+ "crimson": [220, 20, 60],
+ "cyan": [0, 255, 255],
+ "darkblue": [0, 0, 139],
+ "darkcyan": [0, 139, 139],
+ "darkgoldenrod": [184, 134, 11],
+ "darkgray": [169, 169, 169],
+ "darkgreen": [0, 100, 0],
+ "darkgrey": [169, 169, 169],
+ "darkkhaki": [189, 183, 107],
+ "darkmagenta": [139, 0, 139],
+ "darkolivegreen": [85, 107, 47],
+ "darkorange": [255, 140, 0],
+ "darkorchid": [153, 50, 204],
+ "darkred": [139, 0, 0],
+ "darksalmon": [233, 150, 122],
+ "darkseagreen": [143, 188, 143],
+ "darkslateblue": [72, 61, 139],
+ "darkslategray": [47, 79, 79],
+ "darkslategrey": [47, 79, 79],
+ "darkturquoise": [0, 206, 209],
+ "darkviolet": [148, 0, 211],
+ "deeppink": [255, 20, 147],
+ "deepskyblue": [0, 191, 255],
+ "dimgray": [105, 105, 105],
+ "dimgrey": [105, 105, 105],
+ "dodgerblue": [30, 144, 255],
+ "firebrick": [178, 34, 34],
+ "floralwhite": [255, 250, 240],
+ "forestgreen": [34, 139, 34],
+ "fuchsia": [255, 0, 255],
+ "gainsboro": [220, 220, 220],
+ "ghostwhite": [248, 248, 255],
+ "gold": [255, 215, 0],
+ "goldenrod": [218, 165, 32],
+ "gray": [128, 128, 128],
+ "green": [0, 128, 0],
+ "greenyellow": [173, 255, 47],
+ "grey": [128, 128, 128],
+ "honeydew": [240, 255, 240],
+ "hotpink": [255, 105, 180],
+ "indianred": [205, 92, 92],
+ "indigo": [75, 0, 130],
+ "ivory": [255, 255, 240],
+ "khaki": [240, 230, 140],
+ "lavender": [230, 230, 250],
+ "lavenderblush": [255, 240, 245],
+ "lawngreen": [124, 252, 0],
+ "lemonchiffon": [255, 250, 205],
+ "lightblue": [173, 216, 230],
+ "lightcoral": [240, 128, 128],
+ "lightcyan": [224, 255, 255],
+ "lightgoldenrodyellow": [250, 250, 210],
+ "lightgray": [211, 211, 211],
+ "lightgreen": [144, 238, 144],
+ "lightgrey": [211, 211, 211],
+ "lightpink": [255, 182, 193],
+ "lightsalmon": [255, 160, 122],
+ "lightseagreen": [32, 178, 170],
+ "lightskyblue": [135, 206, 250],
+ "lightslategray": [119, 136, 153],
+ "lightslategrey": [119, 136, 153],
+ "lightsteelblue": [176, 196, 222],
+ "lightyellow": [255, 255, 224],
+ "lime": [0, 255, 0],
+ "limegreen": [50, 205, 50],
+ "linen": [250, 240, 230],
+ "magenta": [255, 0, 255],
+ "maroon": [128, 0, 0],
+ "mediumaquamarine": [102, 205, 170],
+ "mediumblue": [0, 0, 205],
+ "mediumorchid": [186, 85, 211],
+ "mediumpurple": [147, 112, 219],
+ "mediumseagreen": [60, 179, 113],
+ "mediumslateblue": [123, 104, 238],
+ "mediumspringgreen": [0, 250, 154],
+ "mediumturquoise": [72, 209, 204],
+ "mediumvioletred": [199, 21, 133],
+ "midnightblue": [25, 25, 112],
+ "mintcream": [245, 255, 250],
+ "mistyrose": [255, 228, 225],
+ "moccasin": [255, 228, 181],
+ "navajowhite": [255, 222, 173],
+ "navy": [0, 0, 128],
+ "oldlace": [253, 245, 230],
+ "olive": [128, 128, 0],
+ "olivedrab": [107, 142, 35],
+ "orange": [255, 165, 0],
+ "orangered": [255, 69, 0],
+ "orchid": [218, 112, 214],
+ "palegoldenrod": [238, 232, 170],
+ "palegreen": [152, 251, 152],
+ "paleturquoise": [175, 238, 238],
+ "palevioletred": [219, 112, 147],
+ "papayawhip": [255, 239, 213],
+ "peachpuff": [255, 218, 185],
+ "peru": [205, 133, 63],
+ "pink": [255, 192, 203],
+ "plum": [221, 160, 221],
+ "powderblue": [176, 224, 230],
+ "purple": [128, 0, 128],
+ "rebeccapurple": [102, 51, 153],
+ "red": [255, 0, 0],
+ "rosybrown": [188, 143, 143],
+ "royalblue": [65, 105, 225],
+ "saddlebrown": [139, 69, 19],
+ "salmon": [250, 128, 114],
+ "sandybrown": [244, 164, 96],
+ "seagreen": [46, 139, 87],
+ "seashell": [255, 245, 238],
+ "sienna": [160, 82, 45],
+ "silver": [192, 192, 192],
+ "skyblue": [135, 206, 235],
+ "slateblue": [106, 90, 205],
+ "slategray": [112, 128, 144],
+ "slategrey": [112, 128, 144],
+ "snow": [255, 250, 250],
+ "springgreen": [0, 255, 127],
+ "steelblue": [70, 130, 180],
+ "tan": [210, 180, 140],
+ "teal": [0, 128, 128],
+ "thistle": [216, 191, 216],
+ "tomato": [255, 99, 71],
+ "turquoise": [64, 224, 208],
+ "violet": [238, 130, 238],
+ "wheat": [245, 222, 179],
+ "white": [255, 255, 255],
+ "whitesmoke": [245, 245, 245],
+ "yellow": [255, 255, 0],
+ "yellowgreen": [154, 205, 50]
+};
-var childProcess = __webpack_require__(372);
-var spawn = childProcess.spawn;
-var exec = childProcess.exec;
-
-module.exports = function (pid, signal, callback) {
- if (typeof signal === 'function' && callback === undefined) {
- callback = signal;
- signal = undefined;
- }
-
- pid = parseInt(pid);
- if (Number.isNaN(pid)) {
- if (callback) {
- return callback(new Error("pid must be a number"));
- } else {
- throw new Error("pid must be a number");
- }
- }
-
- var tree = {};
- var pidsToProcess = {};
- tree[pid] = [];
- pidsToProcess[pid] = 1;
-
- switch (process.platform) {
- case 'win32':
- exec('taskkill /pid ' + pid + ' /T /F', callback);
- break;
- case 'darwin':
- buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
- return spawn('pgrep', ['-P', parentPid]);
- }, function () {
- killAll(tree, signal, callback);
- });
- break;
- // case 'sunos':
- // buildProcessTreeSunOS(pid, tree, pidsToProcess, function () {
- // killAll(tree, signal, callback);
- // });
- // break;
- default: // Linux
- buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
- return spawn('ps', ['-o', 'pid', '--no-headers', '--ppid', parentPid]);
- }, function () {
- killAll(tree, signal, callback);
- });
- break;
- }
-};
-
-function killAll (tree, signal, callback) {
- var killed = {};
- try {
- Object.keys(tree).forEach(function (pid) {
- tree[pid].forEach(function (pidpid) {
- if (!killed[pidpid]) {
- killPid(pidpid, signal);
- killed[pidpid] = 1;
- }
- });
- if (!killed[pid]) {
- killPid(pid, signal);
- killed[pid] = 1;
- }
- });
- } catch (err) {
- if (callback) {
- return callback(err);
- } else {
- throw err;
- }
- }
- if (callback) {
- return callback();
- }
-}
-
-function killPid(pid, signal) {
- try {
- process.kill(parseInt(pid, 10), signal);
- }
- catch (err) {
- if (err.code !== 'ESRCH') throw err;
- }
-}
+/***/ }),
+/* 392 */
+/***/ (function(module, exports, __webpack_require__) {
-function buildProcessTree (parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
- var ps = spawnChildProcessesList(parentPid);
- var allData = '';
- ps.stdout.on('data', function (data) {
- var data = data.toString('ascii');
- allData += data;
- });
+var conversions = __webpack_require__(390);
- var onClose = function (code) {
- delete pidsToProcess[parentPid];
+/*
+ this function routes a model to all other models.
- if (code != 0) {
- // no more parent processes
- if (Object.keys(pidsToProcess).length == 0) {
- cb();
- }
- return;
- }
+ all functions that are routed have a property `.conversion` attached
+ to the returned synthetic function. This property is an array
+ of strings, each with the steps in between the 'from' and 'to'
+ color models (inclusive).
- allData.match(/\d+/g).forEach(function (pid) {
- pid = parseInt(pid, 10);
- tree[parentPid].push(pid);
- tree[pid] = [];
- pidsToProcess[pid] = 1;
- buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
- });
- };
+ conversions that are not possible simply are not included.
+*/
- ps.on('close', onClose);
+function buildGraph() {
+ var graph = {};
+ // https://jsperf.com/object-keys-vs-for-in-with-closure/3
+ var models = Object.keys(conversions);
+
+ for (var len = models.length, i = 0; i < len; i++) {
+ graph[models[i]] = {
+ // http://jsperf.com/1-vs-infinity
+ // micro-opt, but this is simple.
+ distance: -1,
+ parent: null
+ };
+ }
+
+ return graph;
}
+// https://en.wikipedia.org/wiki/Breadth-first_search
+function deriveBFS(fromModel) {
+ var graph = buildGraph();
+ var queue = [fromModel]; // unshift -> queue -> pop
-/***/ }),
-/* 412 */
-/***/ (function(module, exports, __webpack_require__) {
+ graph[fromModel].distance = 0;
-"use strict";
+ while (queue.length) {
+ var current = queue.pop();
+ var adjacents = Object.keys(conversions[current]);
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const Rx = tslib_1.__importStar(__webpack_require__(169));
-const operators_1 = __webpack_require__(270);
-const SEP = /\r?\n/;
-const observe_readable_1 = __webpack_require__(413);
-/**
- * Creates an Observable from a Readable Stream that:
- * - splits data from `readable` into lines
- * - completes when `readable` emits "end"
- * - fails if `readable` emits "errors"
- *
- * @param {ReadableStream} readable
- * @return {Rx.Observable}
- */
-function observeLines(readable) {
- const done$ = observe_readable_1.observeReadable(readable).pipe(operators_1.share());
- const scan$ = Rx.fromEvent(readable, 'data').pipe(operators_1.scan(({ buffer }, chunk) => {
- buffer += chunk;
- const lines = [];
- while (true) {
- const match = buffer.match(SEP);
- if (!match || match.index === undefined) {
- break;
- }
- lines.push(buffer.slice(0, match.index));
- buffer = buffer.slice(match.index + match[0].length);
- }
- return { buffer, lines };
- }, { buffer: '' }),
- // stop if done completes or errors
- operators_1.takeUntil(done$.pipe(operators_1.materialize())), operators_1.share());
- return Rx.merge(
- // use done$ to provide completion/errors
- done$,
- // merge in the "lines" from each step
- scan$.pipe(operators_1.mergeMap(({ lines }) => lines || [])),
- // inject the "unsplit" data at the end
- scan$.pipe(operators_1.last(), operators_1.mergeMap(({ buffer }) => (buffer ? [buffer] : [])),
- // if there were no lines, last() will error, so catch and complete
- operators_1.catchError(() => Rx.empty())));
+ for (var len = adjacents.length, i = 0; i < len; i++) {
+ var adjacent = adjacents[i];
+ var node = graph[adjacent];
+
+ if (node.distance === -1) {
+ node.distance = graph[current].distance + 1;
+ node.parent = current;
+ queue.unshift(adjacent);
+ }
+ }
+ }
+
+ return graph;
}
-exports.observeLines = observeLines;
+function link(from, to) {
+ return function (args) {
+ return to(from(args));
+ };
+}
-/***/ }),
-/* 413 */
-/***/ (function(module, exports, __webpack_require__) {
+function wrapConversion(toModel, graph) {
+ var path = [graph[toModel].parent, toModel];
+ var fn = conversions[graph[toModel].parent][toModel];
-"use strict";
+ var cur = graph[toModel].parent;
+ while (graph[cur].parent) {
+ path.unshift(graph[cur].parent);
+ fn = link(conversions[graph[cur].parent][cur], fn);
+ cur = graph[cur].parent;
+ }
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const Rx = tslib_1.__importStar(__webpack_require__(169));
-const operators_1 = __webpack_require__(270);
-/**
- * Produces an Observable from a ReadableSteam that:
- * - completes on the first "end" event
- * - fails on the first "error" event
- */
-function observeReadable(readable) {
- return Rx.race(Rx.fromEvent(readable, 'end').pipe(operators_1.first(), operators_1.ignoreElements()), Rx.fromEvent(readable, 'error').pipe(operators_1.first(), operators_1.mergeMap((err) => Rx.throwError(err))));
+ fn.conversion = path;
+ return fn;
}
-exports.observeReadable = observeReadable;
+module.exports = function (fromModel) {
+ var graph = deriveBFS(fromModel);
+ var conversion = {};
-/***/ }),
-/* 414 */
-/***/ (function(module, exports, __webpack_require__) {
+ var models = Object.keys(graph);
+ for (var len = models.length, i = 0; i < len; i++) {
+ var toModel = models[i];
+ var node = graph[toModel];
-"use strict";
+ if (node.parent === null) {
+ // no possible conversion, or this node is the source model.
+ continue;
+ }
+
+ conversion[toModel] = wrapConversion(toModel, graph);
+ }
+
+ return conversion;
+};
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-var tooling_log_1 = __webpack_require__(415);
-exports.ToolingLog = tooling_log_1.ToolingLog;
-var tooling_log_text_writer_1 = __webpack_require__(416);
-exports.ToolingLogTextWriter = tooling_log_text_writer_1.ToolingLogTextWriter;
-var log_levels_1 = __webpack_require__(417);
-exports.pickLevelFromFlags = log_levels_1.pickLevelFromFlags;
-exports.parseLogLevel = log_levels_1.parseLogLevel;
-var tooling_log_collecting_writer_1 = __webpack_require__(418);
-exports.ToolingLogCollectingWriter = tooling_log_collecting_writer_1.ToolingLogCollectingWriter;
/***/ }),
-/* 415 */
+/* 393 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const Rx = tslib_1.__importStar(__webpack_require__(169));
-const tooling_log_text_writer_1 = __webpack_require__(416);
-class ToolingLog {
- constructor(writerConfig) {
- this.identWidth = 0;
- this.writers = writerConfig ? [new tooling_log_text_writer_1.ToolingLogTextWriter(writerConfig)] : [];
- this.written$ = new Rx.Subject();
- }
- indent(delta = 0) {
- this.identWidth = Math.max(this.identWidth + delta, 0);
- return this.identWidth;
- }
- verbose(...args) {
- this.sendToWriters('verbose', args);
- }
- debug(...args) {
- this.sendToWriters('debug', args);
- }
- info(...args) {
- this.sendToWriters('info', args);
- }
- success(...args) {
- this.sendToWriters('success', args);
- }
- warning(...args) {
- this.sendToWriters('warning', args);
- }
- error(error) {
- this.sendToWriters('error', [error]);
- }
- write(...args) {
- this.sendToWriters('write', args);
- }
- getWriters() {
- return this.writers.slice(0);
- }
- setWriters(writers) {
- this.writers = [...writers];
- }
- getWritten$() {
- return this.written$.asObservable();
- }
- sendToWriters(type, args) {
- const msg = {
- type,
- indent: this.identWidth,
- args,
- };
- let written = false;
- for (const writer of this.writers) {
- if (writer.write(msg)) {
- written = true;
- }
- }
- if (written) {
- this.written$.next(msg);
- }
- }
-}
-exports.ToolingLog = ToolingLog;
-
+const os = __webpack_require__(364);
+const hasFlag = __webpack_require__(394);
-/***/ }),
-/* 416 */
-/***/ (function(module, exports, __webpack_require__) {
+const env = process.env;
-"use strict";
+let forceColor;
+if (hasFlag('no-color') ||
+ hasFlag('no-colors') ||
+ hasFlag('color=false')) {
+ forceColor = false;
+} else if (hasFlag('color') ||
+ hasFlag('colors') ||
+ hasFlag('color=true') ||
+ hasFlag('color=always')) {
+ forceColor = true;
+}
+if ('FORCE_COLOR' in env) {
+ forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
+}
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const util_1 = __webpack_require__(29);
-const chalk_1 = tslib_1.__importDefault(__webpack_require__(2));
-const log_levels_1 = __webpack_require__(417);
-const { magentaBright, yellow, red, blue, green, dim } = chalk_1.default;
-const PREFIX_INDENT = ' '.repeat(6);
-const MSG_PREFIXES = {
- verbose: ` ${magentaBright('sill')} `,
- debug: ` ${dim('debg')} `,
- info: ` ${blue('info')} `,
- success: ` ${green('succ')} `,
- warning: ` ${yellow('warn')} `,
- error: `${red('ERROR')} `,
-};
-const has = (obj, key) => obj.hasOwnProperty(key);
-function shouldWriteType(level, type) {
- if (type === 'write') {
- return true;
- }
- return Boolean(level.flags[type === 'success' ? 'info' : type]);
-}
-function stringifyError(error) {
- if (typeof error !== 'string' && !(error instanceof Error)) {
- error = new Error(`"${error}" thrown`);
- }
- if (typeof error === 'string') {
- return error;
- }
- return error.stack || error.message || error;
-}
-class ToolingLogTextWriter {
- constructor(config) {
- this.level = log_levels_1.parseLogLevel(config.level);
- this.writeTo = config.writeTo;
- if (!this.writeTo || typeof this.writeTo.write !== 'function') {
- throw new Error('ToolingLogTextWriter requires the `writeTo` option be set to a stream (like process.stdout)');
- }
- }
- write(msg) {
- if (!shouldWriteType(this.level, msg.type)) {
- return false;
- }
- const prefix = has(MSG_PREFIXES, msg.type) ? MSG_PREFIXES[msg.type] : '';
- ToolingLogTextWriter.write(this.writeTo, prefix, msg);
- return true;
- }
- static write(writeTo, prefix, msg) {
- const txt = msg.type === 'error'
- ? stringifyError(msg.args[0])
- : util_1.format(msg.args[0], ...msg.args.slice(1));
- (prefix + txt).split('\n').forEach((line, i) => {
- let lineIndent = '';
- if (msg.indent > 0) {
- // if we are indenting write some spaces followed by a symbol
- lineIndent += ' '.repeat(msg.indent - 1);
- lineIndent += line.startsWith('-') ? '└' : '│';
- }
- if (line && prefix && i > 0) {
- // apply additional indentation to lines after
- // the first if this message gets a prefix
- lineIndent += PREFIX_INDENT;
- }
- writeTo.write(`${lineIndent}${line}\n`);
- });
- }
+function translateLevel(level) {
+ if (level === 0) {
+ return false;
+ }
+
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
}
-exports.ToolingLogTextWriter = ToolingLogTextWriter;
+function supportsColor(stream) {
+ if (forceColor === false) {
+ return 0;
+ }
-/***/ }),
-/* 417 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (hasFlag('color=16m') ||
+ hasFlag('color=full') ||
+ hasFlag('color=truecolor')) {
+ return 3;
+ }
-"use strict";
+ if (hasFlag('color=256')) {
+ return 2;
+ }
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const LEVELS = ['silent', 'error', 'warning', 'info', 'debug', 'verbose'];
-function pickLevelFromFlags(flags, options = {}) {
- if (flags.verbose)
- return 'verbose';
- if (flags.debug)
- return 'debug';
- if (flags.quiet)
- return 'error';
- if (flags.silent)
- return 'silent';
- return options.default || 'info';
-}
-exports.pickLevelFromFlags = pickLevelFromFlags;
-function parseLogLevel(name) {
- const i = LEVELS.indexOf(name);
- if (i === -1) {
- const msg = `Invalid log level "${name}" ` + `(expected one of ${LEVELS.join(',')})`;
- throw new Error(msg);
- }
- const flags = {};
- LEVELS.forEach((level, levelI) => {
- flags[level] = levelI <= i;
- });
- return {
- name,
- flags: flags,
- };
-}
-exports.parseLogLevel = parseLogLevel;
+ if (stream && !stream.isTTY && forceColor !== true) {
+ // VS code debugger doesn't have isTTY set
+ if (env.VSCODE_PID) {
+ return 1;
+ }
+ return 0;
+ }
+ const min = forceColor ? 1 : 0;
-/***/ }),
-/* 418 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (process.platform === 'win32') {
+ // Node.js 7.5.0 is the first version of Node.js to include a patch to
+ // libuv that enables 256 color output on Windows. Anything earlier and it
+ // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+ // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+ // release that supports 256 colors. Windows 10 build 14931 is the first release
+ // that supports 16m/TrueColor.
+ const osRelease = os.release().split('.');
+ if (
+ Number(process.versions.node.split('.')[0]) >= 8 &&
+ Number(osRelease[0]) >= 10 &&
+ Number(osRelease[2]) >= 10586
+ ) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
-"use strict";
+ return 1;
+ }
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tooling_log_text_writer_1 = __webpack_require__(416);
-class ToolingLogCollectingWriter extends tooling_log_text_writer_1.ToolingLogTextWriter {
- constructor() {
- super({
- level: 'verbose',
- writeTo: {
- write: (msg) => {
- // trim trailing new line
- this.messages.push(msg.slice(0, -1));
- },
- },
- });
- this.messages = [];
- }
-}
-exports.ToolingLogCollectingWriter = ToolingLogCollectingWriter;
+ if ('CI' in env) {
+ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+ return 1;
+ }
+ return min;
+ }
-/***/ }),
-/* 419 */
-/***/ (function(module, exports, __webpack_require__) {
+ if ('TEAMCITY_VERSION' in env) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+ }
-"use strict";
+ if (env.COLORTERM === 'truecolor') {
+ return 3;
+ }
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-var absolute_path_serializer_1 = __webpack_require__(420);
-exports.createAbsolutePathSerializer = absolute_path_serializer_1.createAbsolutePathSerializer;
+ if ('TERM_PROGRAM' in env) {
+ const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+ switch (env.TERM_PROGRAM) {
+ case 'iTerm.app':
+ return version >= 3 ? 3 : 2;
+ case 'Apple_Terminal':
+ return 2;
+ // No default
+ }
+ }
+ if (/-256(color)?$/i.test(env.TERM)) {
+ return 2;
+ }
-/***/ }),
-/* 420 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+ return 1;
+ }
-"use strict";
+ if ('COLORTERM' in env) {
+ return 1;
+ }
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const repo_root_1 = __webpack_require__(421);
-function createAbsolutePathSerializer(rootPath = repo_root_1.REPO_ROOT) {
- return {
- print: (value) => value.replace(rootPath, '').replace(/\\/g, '/'),
- test: (value) => typeof value === 'string' && value.startsWith(rootPath),
- };
+ if (env.TERM === 'dumb') {
+ return min;
+ }
+
+ return min;
}
-exports.createAbsolutePathSerializer = createAbsolutePathSerializer;
+
+function getSupportLevel(stream) {
+ const level = supportsColor(stream);
+ return translateLevel(level);
+}
+
+module.exports = {
+ supportsColor: getSupportLevel,
+ stdout: getSupportLevel(process.stdout),
+ stderr: getSupportLevel(process.stderr)
+};
/***/ }),
-/* 421 */
+/* 394 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const path_1 = tslib_1.__importDefault(__webpack_require__(16));
-const fs_1 = tslib_1.__importDefault(__webpack_require__(23));
-const load_json_file_1 = tslib_1.__importDefault(__webpack_require__(422));
-const isKibanaDir = (dir) => {
- try {
- const path = path_1.default.resolve(dir, 'package.json');
- const json = load_json_file_1.default.sync(path);
- if (json && typeof json === 'object' && 'name' in json && json.name === 'kibana') {
- return true;
- }
- }
- catch (error) {
- if (error && error.code === 'ENOENT') {
- return false;
- }
- throw error;
- }
+module.exports = (flag, argv) => {
+ argv = argv || process.argv;
+ const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+ const pos = argv.indexOf(prefix + flag);
+ const terminatorPos = argv.indexOf('--');
+ return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
};
-// search for the kibana directory, since this file is moved around it might
-// not be where we think but should always be a relatively close parent
-// of this directory
-const startDir = fs_1.default.realpathSync(__dirname);
-const { root: rootDir } = path_1.default.parse(startDir);
-let cursor = startDir;
-while (true) {
- if (isKibanaDir(cursor)) {
- break;
- }
- const parent = path_1.default.dirname(cursor);
- if (parent === rootDir) {
- throw new Error(`unable to find kibana directory from ${startDir}`);
- }
- cursor = parent;
-}
-exports.REPO_ROOT = cursor;
/***/ }),
-/* 422 */
+/* 395 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const path = __webpack_require__(16);
-const {promisify} = __webpack_require__(29);
-const fs = __webpack_require__(423);
-const stripBom = __webpack_require__(427);
-const parseJson = __webpack_require__(428);
+const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
-const parse = (data, filePath, options = {}) => {
- data = stripBom(data);
+const ESCAPES = new Map([
+ ['n', '\n'],
+ ['r', '\r'],
+ ['t', '\t'],
+ ['b', '\b'],
+ ['f', '\f'],
+ ['v', '\v'],
+ ['0', '\0'],
+ ['\\', '\\'],
+ ['e', '\u001B'],
+ ['a', '\u0007']
+]);
- if (typeof options.beforeParse === 'function') {
- data = options.beforeParse(data);
+function unescape(c) {
+ if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+ return String.fromCharCode(parseInt(c.slice(1), 16));
}
- return parseJson(data, options.reviver, path.relative(process.cwd(), filePath));
-};
-
-module.exports = async (filePath, options) => parse(await promisify(fs.readFile)(filePath, 'utf8'), filePath, options);
-module.exports.sync = (filePath, options) => parse(fs.readFileSync(filePath, 'utf8'), filePath, options);
+ return ESCAPES.get(c) || c;
+}
+function parseArguments(name, args) {
+ const results = [];
+ const chunks = args.trim().split(/\s*,\s*/g);
+ let matches;
-/***/ }),
-/* 423 */
-/***/ (function(module, exports, __webpack_require__) {
+ for (const chunk of chunks) {
+ if (!isNaN(chunk)) {
+ results.push(Number(chunk));
+ } else if ((matches = chunk.match(STRING_REGEX))) {
+ results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
+ } else {
+ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+ }
+ }
-var fs = __webpack_require__(23)
-var polyfills = __webpack_require__(424)
-var legacy = __webpack_require__(425)
-var clone = __webpack_require__(426)
+ return results;
+}
-var queue = []
+function parseStyle(style) {
+ STYLE_REGEX.lastIndex = 0;
-var util = __webpack_require__(29)
+ const results = [];
+ let matches;
-function noop () {}
+ while ((matches = STYLE_REGEX.exec(style)) !== null) {
+ const name = matches[1];
-var debug = noop
-if (util.debuglog)
- debug = util.debuglog('gfs4')
-else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
- debug = function() {
- var m = util.format.apply(util, arguments)
- m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
- console.error(m)
- }
+ if (matches[2]) {
+ const args = parseArguments(name, matches[2]);
+ results.push([name].concat(args));
+ } else {
+ results.push([name]);
+ }
+ }
-if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
- process.on('exit', function() {
- debug(queue)
- __webpack_require__(30).equal(queue.length, 0)
- })
+ return results;
}
-module.exports = patch(clone(fs))
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
- module.exports = patch(fs)
- fs.__patched = true;
-}
+function buildStyle(chalk, styles) {
+ const enabled = {};
-// Always patch fs.close/closeSync, because we want to
-// retry() whenever a close happens *anywhere* in the program.
-// This is essential when multiple graceful-fs instances are
-// in play at the same time.
-module.exports.close = (function (fs$close) { return function (fd, cb) {
- return fs$close.call(fs, fd, function (err) {
- if (!err)
- retry()
+ for (const layer of styles) {
+ for (const style of layer.styles) {
+ enabled[style[0]] = layer.inverse ? null : style.slice(1);
+ }
+ }
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- })
-}})(fs.close)
+ let current = chalk;
+ for (const styleName of Object.keys(enabled)) {
+ if (Array.isArray(enabled[styleName])) {
+ if (!(styleName in current)) {
+ throw new Error(`Unknown Chalk style: ${styleName}`);
+ }
-module.exports.closeSync = (function (fs$closeSync) { return function (fd) {
- // Note that graceful-fs also retries when fs.closeSync() fails.
- // Looks like a bug to me, although it's probably a harmless one.
- var rval = fs$closeSync.apply(fs, arguments)
- retry()
- return rval
-}})(fs.closeSync)
+ if (enabled[styleName].length > 0) {
+ current = current[styleName].apply(current, enabled[styleName]);
+ } else {
+ current = current[styleName];
+ }
+ }
+ }
-// Only patch fs once, otherwise we'll run into a memory leak if
-// graceful-fs is loaded multiple times, such as in test environments that
-// reset the loaded modules between tests.
-// We look for the string `graceful-fs` from the comment above. This
-// way we are not adding any extra properties and it will detect if older
-// versions of graceful-fs are installed.
-if (!/\bgraceful-fs\b/.test(fs.closeSync.toString())) {
- fs.closeSync = module.exports.closeSync;
- fs.close = module.exports.close;
+ return current;
}
-function patch (fs) {
- // Everything that references the open() function needs to be in here
- polyfills(fs)
- fs.gracefulify = patch
- fs.FileReadStream = ReadStream; // Legacy name.
- fs.FileWriteStream = WriteStream; // Legacy name.
- fs.createReadStream = createReadStream
- fs.createWriteStream = createWriteStream
- var fs$readFile = fs.readFile
- fs.readFile = readFile
- function readFile (path, options, cb) {
- if (typeof options === 'function')
- cb = options, options = null
-
- return go$readFile(path, options, cb)
+module.exports = (chalk, tmp) => {
+ const styles = [];
+ const chunks = [];
+ let chunk = [];
- function go$readFile (path, options, cb) {
- return fs$readFile(path, options, function (err) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$readFile, [path, options, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
- }
- })
- }
- }
+ // eslint-disable-next-line max-params
+ tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
+ if (escapeChar) {
+ chunk.push(unescape(escapeChar));
+ } else if (style) {
+ const str = chunk.join('');
+ chunk = [];
+ chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+ styles.push({inverse, styles: parseStyle(style)});
+ } else if (close) {
+ if (styles.length === 0) {
+ throw new Error('Found extraneous } in Chalk template literal');
+ }
- var fs$writeFile = fs.writeFile
- fs.writeFile = writeFile
- function writeFile (path, data, options, cb) {
- if (typeof options === 'function')
- cb = options, options = null
+ chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+ chunk = [];
+ styles.pop();
+ } else {
+ chunk.push(chr);
+ }
+ });
- return go$writeFile(path, data, options, cb)
+ chunks.push(chunk.join(''));
- function go$writeFile (path, data, options, cb) {
- return fs$writeFile(path, data, options, function (err) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$writeFile, [path, data, options, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
- }
- })
- }
- }
+ if (styles.length > 0) {
+ const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+ throw new Error(errMsg);
+ }
- var fs$appendFile = fs.appendFile
- if (fs$appendFile)
- fs.appendFile = appendFile
- function appendFile (path, data, options, cb) {
- if (typeof options === 'function')
- cb = options, options = null
+ return chunks.join('');
+};
- return go$appendFile(path, data, options, cb)
- function go$appendFile (path, data, options, cb) {
- return fs$appendFile(path, data, options, function (err) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$appendFile, [path, data, options, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
- }
- })
- }
- }
+/***/ }),
+/* 396 */
+/***/ (function(module, exports, __webpack_require__) {
- var fs$readdir = fs.readdir
- fs.readdir = readdir
- function readdir (path, options, cb) {
- var args = [path]
- if (typeof options !== 'function') {
- args.push(options)
- } else {
- cb = options
- }
- args.push(go$readdir$cb)
+"use strict";
- return go$readdir(args)
- function go$readdir$cb (err, files) {
- if (files && files.sort)
- files.sort()
+var childProcess = __webpack_require__(343);
+var spawn = childProcess.spawn;
+var exec = childProcess.exec;
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$readdir, [args]])
+module.exports = function (pid, signal, callback) {
+ if (typeof signal === 'function' && callback === undefined) {
+ callback = signal;
+ signal = undefined;
+ }
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
- }
+ pid = parseInt(pid);
+ if (Number.isNaN(pid)) {
+ if (callback) {
+ return callback(new Error("pid must be a number"));
+ } else {
+ throw new Error("pid must be a number");
+ }
}
- }
- function go$readdir (args) {
- return fs$readdir.apply(fs, args)
- }
+ var tree = {};
+ var pidsToProcess = {};
+ tree[pid] = [];
+ pidsToProcess[pid] = 1;
- if (process.version.substr(0, 4) === 'v0.8') {
- var legStreams = legacy(fs)
- ReadStream = legStreams.ReadStream
- WriteStream = legStreams.WriteStream
- }
+ switch (process.platform) {
+ case 'win32':
+ exec('taskkill /pid ' + pid + ' /T /F', callback);
+ break;
+ case 'darwin':
+ buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
+ return spawn('pgrep', ['-P', parentPid]);
+ }, function () {
+ killAll(tree, signal, callback);
+ });
+ break;
+ // case 'sunos':
+ // buildProcessTreeSunOS(pid, tree, pidsToProcess, function () {
+ // killAll(tree, signal, callback);
+ // });
+ // break;
+ default: // Linux
+ buildProcessTree(pid, tree, pidsToProcess, function (parentPid) {
+ return spawn('ps', ['-o', 'pid', '--no-headers', '--ppid', parentPid]);
+ }, function () {
+ killAll(tree, signal, callback);
+ });
+ break;
+ }
+};
- var fs$ReadStream = fs.ReadStream
- if (fs$ReadStream) {
- ReadStream.prototype = Object.create(fs$ReadStream.prototype)
- ReadStream.prototype.open = ReadStream$open
- }
+function killAll (tree, signal, callback) {
+ var killed = {};
+ try {
+ Object.keys(tree).forEach(function (pid) {
+ tree[pid].forEach(function (pidpid) {
+ if (!killed[pidpid]) {
+ killPid(pidpid, signal);
+ killed[pidpid] = 1;
+ }
+ });
+ if (!killed[pid]) {
+ killPid(pid, signal);
+ killed[pid] = 1;
+ }
+ });
+ } catch (err) {
+ if (callback) {
+ return callback(err);
+ } else {
+ throw err;
+ }
+ }
+ if (callback) {
+ return callback();
+ }
+}
- var fs$WriteStream = fs.WriteStream
- if (fs$WriteStream) {
- WriteStream.prototype = Object.create(fs$WriteStream.prototype)
- WriteStream.prototype.open = WriteStream$open
- }
+function killPid(pid, signal) {
+ try {
+ process.kill(parseInt(pid, 10), signal);
+ }
+ catch (err) {
+ if (err.code !== 'ESRCH') throw err;
+ }
+}
- fs.ReadStream = ReadStream
- fs.WriteStream = WriteStream
+function buildProcessTree (parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+ var ps = spawnChildProcessesList(parentPid);
+ var allData = '';
+ ps.stdout.on('data', function (data) {
+ var data = data.toString('ascii');
+ allData += data;
+ });
- function ReadStream (path, options) {
- if (this instanceof ReadStream)
- return fs$ReadStream.apply(this, arguments), this
- else
- return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
- }
+ var onClose = function (code) {
+ delete pidsToProcess[parentPid];
- function ReadStream$open () {
- var that = this
- open(that.path, that.flags, that.mode, function (err, fd) {
- if (err) {
- if (that.autoClose)
- that.destroy()
+ if (code != 0) {
+ // no more parent processes
+ if (Object.keys(pidsToProcess).length == 0) {
+ cb();
+ }
+ return;
+ }
- that.emit('error', err)
- } else {
- that.fd = fd
- that.emit('open', fd)
- that.read()
- }
- })
- }
+ allData.match(/\d+/g).forEach(function (pid) {
+ pid = parseInt(pid, 10);
+ tree[parentPid].push(pid);
+ tree[pid] = [];
+ pidsToProcess[pid] = 1;
+ buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
+ });
+ };
- function WriteStream (path, options) {
- if (this instanceof WriteStream)
- return fs$WriteStream.apply(this, arguments), this
- else
- return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
- }
+ ps.on('close', onClose);
+}
- function WriteStream$open () {
- var that = this
- open(that.path, that.flags, that.mode, function (err, fd) {
- if (err) {
- that.destroy()
- that.emit('error', err)
- } else {
- that.fd = fd
- that.emit('open', fd)
- }
- })
- }
- function createReadStream (path, options) {
- return new ReadStream(path, options)
- }
+/***/ }),
+/* 397 */
+/***/ (function(module, exports) {
- function createWriteStream (path, options) {
- return new WriteStream(path, options)
- }
+module.exports = require("util");
- var fs$open = fs.open
- fs.open = open
- function open (path, flags, mode, cb) {
- if (typeof mode === 'function')
- cb = mode, mode = null
+/***/ }),
+/* 398 */
+/***/ (function(module, exports, __webpack_require__) {
- return go$open(path, flags, mode, cb)
+"use strict";
- function go$open (path, flags, mode, cb) {
- return fs$open(path, flags, mode, function (err, fd) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$open, [path, flags, mode, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+const Rx = tslib_1.__importStar(__webpack_require__(140));
+const operators_1 = __webpack_require__(241);
+const SEP = /\r?\n/;
+const observe_readable_1 = __webpack_require__(399);
+/**
+ * Creates an Observable from a Readable Stream that:
+ * - splits data from `readable` into lines
+ * - completes when `readable` emits "end"
+ * - fails if `readable` emits "errors"
+ *
+ * @param {ReadableStream} readable
+ * @return {Rx.Observable}
+ */
+function observeLines(readable) {
+ const done$ = observe_readable_1.observeReadable(readable).pipe(operators_1.share());
+ const scan$ = Rx.fromEvent(readable, 'data').pipe(operators_1.scan(({ buffer }, chunk) => {
+ buffer += chunk;
+ const lines = [];
+ while (true) {
+ const match = buffer.match(SEP);
+ if (!match || match.index === undefined) {
+ break;
+ }
+ lines.push(buffer.slice(0, match.index));
+ buffer = buffer.slice(match.index + match[0].length);
}
- })
- }
- }
-
- return fs
-}
-
-function enqueue (elem) {
- debug('ENQUEUE', elem[0].name, elem[1])
- queue.push(elem)
-}
-
-function retry () {
- var elem = queue.shift()
- if (elem) {
- debug('RETRY', elem[0].name, elem[1])
- elem[0].apply(null, elem[1])
- }
+ return { buffer, lines };
+ }, { buffer: '' }),
+ // stop if done completes or errors
+ operators_1.takeUntil(done$.pipe(operators_1.materialize())), operators_1.share());
+ return Rx.merge(
+ // use done$ to provide completion/errors
+ done$,
+ // merge in the "lines" from each step
+ scan$.pipe(operators_1.mergeMap(({ lines }) => lines || [])),
+ // inject the "unsplit" data at the end
+ scan$.pipe(operators_1.last(), operators_1.mergeMap(({ buffer }) => (buffer ? [buffer] : [])),
+ // if there were no lines, last() will error, so catch and complete
+ operators_1.catchError(() => Rx.empty())));
}
+exports.observeLines = observeLines;
/***/ }),
-/* 424 */
+/* 399 */
/***/ (function(module, exports, __webpack_require__) {
-var constants = __webpack_require__(25)
-
-var origCwd = process.cwd
-var cwd = null
-
-var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
-
-process.cwd = function() {
- if (!cwd)
- cwd = origCwd.call(process)
- return cwd
-}
-try {
- process.cwd()
-} catch (er) {}
+"use strict";
-var chdir = process.chdir
-process.chdir = function(d) {
- cwd = null
- chdir.call(process, d)
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+const Rx = tslib_1.__importStar(__webpack_require__(140));
+const operators_1 = __webpack_require__(241);
+/**
+ * Produces an Observable from a ReadableSteam that:
+ * - completes on the first "end" event
+ * - fails on the first "error" event
+ */
+function observeReadable(readable) {
+ return Rx.race(Rx.fromEvent(readable, 'end').pipe(operators_1.first(), operators_1.ignoreElements()), Rx.fromEvent(readable, 'error').pipe(operators_1.first(), operators_1.mergeMap((err) => Rx.throwError(err))));
}
+exports.observeReadable = observeReadable;
-module.exports = patch
-
-function patch (fs) {
- // (re-)implement some things that are known busted or missing.
-
- // lchmod, broken prior to 0.6.2
- // back-port the fix here.
- if (constants.hasOwnProperty('O_SYMLINK') &&
- process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
- patchLchmod(fs)
- }
-
- // lutimes implementation, or no-op
- if (!fs.lutimes) {
- patchLutimes(fs)
- }
-
- // https://github.com/isaacs/node-graceful-fs/issues/4
- // Chown should not fail on einval or eperm if non-root.
- // It should not fail on enosys ever, as this just indicates
- // that a fs doesn't support the intended operation.
-
- fs.chown = chownFix(fs.chown)
- fs.fchown = chownFix(fs.fchown)
- fs.lchown = chownFix(fs.lchown)
- fs.chmod = chmodFix(fs.chmod)
- fs.fchmod = chmodFix(fs.fchmod)
- fs.lchmod = chmodFix(fs.lchmod)
+/***/ }),
+/* 400 */
+/***/ (function(module, exports, __webpack_require__) {
- fs.chownSync = chownFixSync(fs.chownSync)
- fs.fchownSync = chownFixSync(fs.fchownSync)
- fs.lchownSync = chownFixSync(fs.lchownSync)
+"use strict";
- fs.chmodSync = chmodFixSync(fs.chmodSync)
- fs.fchmodSync = chmodFixSync(fs.fchmodSync)
- fs.lchmodSync = chmodFixSync(fs.lchmodSync)
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var tooling_log_1 = __webpack_require__(401);
+exports.ToolingLog = tooling_log_1.ToolingLog;
+var tooling_log_text_writer_1 = __webpack_require__(402);
+exports.ToolingLogTextWriter = tooling_log_text_writer_1.ToolingLogTextWriter;
+var log_levels_1 = __webpack_require__(403);
+exports.pickLevelFromFlags = log_levels_1.pickLevelFromFlags;
+exports.parseLogLevel = log_levels_1.parseLogLevel;
+var tooling_log_collecting_writer_1 = __webpack_require__(404);
+exports.ToolingLogCollectingWriter = tooling_log_collecting_writer_1.ToolingLogCollectingWriter;
- fs.stat = statFix(fs.stat)
- fs.fstat = statFix(fs.fstat)
- fs.lstat = statFix(fs.lstat)
- fs.statSync = statFixSync(fs.statSync)
- fs.fstatSync = statFixSync(fs.fstatSync)
- fs.lstatSync = statFixSync(fs.lstatSync)
+/***/ }),
+/* 401 */
+/***/ (function(module, exports, __webpack_require__) {
- // if lchmod/lchown do not exist, then make them no-ops
- if (!fs.lchmod) {
- fs.lchmod = function (path, mode, cb) {
- if (cb) process.nextTick(cb)
- }
- fs.lchmodSync = function () {}
- }
- if (!fs.lchown) {
- fs.lchown = function (path, uid, gid, cb) {
- if (cb) process.nextTick(cb)
- }
- fs.lchownSync = function () {}
- }
+"use strict";
- // on Windows, A/V software can lock the directory, causing this
- // to fail with an EACCES or EPERM if the directory contains newly
- // created files. Try again on failure, for up to 60 seconds.
-
- // Set the timeout this long because some Windows Anti-Virus, such as Parity
- // bit9, may lock files for up to a minute, causing npm package install
- // failures. Also, take care to yield the scheduler. Windows scheduling gives
- // CPU to a busy looping process, which can cause the program causing the lock
- // contention to be starved of CPU by node, so the contention doesn't resolve.
- if (platform === "win32") {
- fs.rename = (function (fs$rename) { return function (from, to, cb) {
- var start = Date.now()
- var backoff = 0;
- fs$rename(from, to, function CB (er) {
- if (er
- && (er.code === "EACCES" || er.code === "EPERM")
- && Date.now() - start < 60000) {
- setTimeout(function() {
- fs.stat(to, function (stater, st) {
- if (stater && stater.code === "ENOENT")
- fs$rename(from, to, CB);
- else
- cb(er)
- })
- }, backoff)
- if (backoff < 100)
- backoff += 10;
- return;
- }
- if (cb) cb(er)
- })
- }})(fs.rename)
- }
-
- // if read() returns EAGAIN, then just try it again.
- fs.read = (function (fs$read) { return function (fd, buffer, offset, length, position, callback_) {
- var callback
- if (callback_ && typeof callback_ === 'function') {
- var eagCounter = 0
- callback = function (er, _, __) {
- if (er && er.code === 'EAGAIN' && eagCounter < 10) {
- eagCounter ++
- return fs$read.call(fs, fd, buffer, offset, length, position, callback)
- }
- callback_.apply(this, arguments)
- }
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+const Rx = tslib_1.__importStar(__webpack_require__(140));
+const tooling_log_text_writer_1 = __webpack_require__(402);
+class ToolingLog {
+ constructor(writerConfig) {
+ this.identWidth = 0;
+ this.writers = writerConfig ? [new tooling_log_text_writer_1.ToolingLogTextWriter(writerConfig)] : [];
+ this.written$ = new Rx.Subject();
}
- return fs$read.call(fs, fd, buffer, offset, length, position, callback)
- }})(fs.read)
-
- fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
- var eagCounter = 0
- while (true) {
- try {
- return fs$readSync.call(fs, fd, buffer, offset, length, position)
- } catch (er) {
- if (er.code === 'EAGAIN' && eagCounter < 10) {
- eagCounter ++
- continue
- }
- throw er
- }
+ indent(delta = 0) {
+ this.identWidth = Math.max(this.identWidth + delta, 0);
+ return this.identWidth;
}
- }})(fs.readSync)
-
- function patchLchmod (fs) {
- fs.lchmod = function (path, mode, callback) {
- fs.open( path
- , constants.O_WRONLY | constants.O_SYMLINK
- , mode
- , function (err, fd) {
- if (err) {
- if (callback) callback(err)
- return
- }
- // prefer to return the chmod error, if one occurs,
- // but still try to close, and report closing errors if they occur.
- fs.fchmod(fd, mode, function (err) {
- fs.close(fd, function(err2) {
- if (callback) callback(err || err2)
- })
- })
- })
+ verbose(...args) {
+ this.sendToWriters('verbose', args);
}
-
- fs.lchmodSync = function (path, mode) {
- var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
-
- // prefer to return the chmod error, if one occurs,
- // but still try to close, and report closing errors if they occur.
- var threw = true
- var ret
- try {
- ret = fs.fchmodSync(fd, mode)
- threw = false
- } finally {
- if (threw) {
- try {
- fs.closeSync(fd)
- } catch (er) {}
- } else {
- fs.closeSync(fd)
+ debug(...args) {
+ this.sendToWriters('debug', args);
+ }
+ info(...args) {
+ this.sendToWriters('info', args);
+ }
+ success(...args) {
+ this.sendToWriters('success', args);
+ }
+ warning(...args) {
+ this.sendToWriters('warning', args);
+ }
+ error(error) {
+ this.sendToWriters('error', [error]);
+ }
+ write(...args) {
+ this.sendToWriters('write', args);
+ }
+ getWriters() {
+ return this.writers.slice(0);
+ }
+ setWriters(writers) {
+ this.writers = [...writers];
+ }
+ getWritten$() {
+ return this.written$.asObservable();
+ }
+ sendToWriters(type, args) {
+ const msg = {
+ type,
+ indent: this.identWidth,
+ args,
+ };
+ let written = false;
+ for (const writer of this.writers) {
+ if (writer.write(msg)) {
+ written = true;
+ }
+ }
+ if (written) {
+ this.written$.next(msg);
}
- }
- return ret
}
- }
+}
+exports.ToolingLog = ToolingLog;
- function patchLutimes (fs) {
- if (constants.hasOwnProperty("O_SYMLINK")) {
- fs.lutimes = function (path, at, mt, cb) {
- fs.open(path, constants.O_SYMLINK, function (er, fd) {
- if (er) {
- if (cb) cb(er)
- return
- }
- fs.futimes(fd, at, mt, function (er) {
- fs.close(fd, function (er2) {
- if (cb) cb(er || er2)
- })
- })
- })
- }
- fs.lutimesSync = function (path, at, mt) {
- var fd = fs.openSync(path, constants.O_SYMLINK)
- var ret
- var threw = true
- try {
- ret = fs.futimesSync(fd, at, mt)
- threw = false
- } finally {
- if (threw) {
- try {
- fs.closeSync(fd)
- } catch (er) {}
- } else {
- fs.closeSync(fd)
- }
- }
- return ret
- }
+/***/ }),
+/* 402 */
+/***/ (function(module, exports, __webpack_require__) {
- } else {
- fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
- fs.lutimesSync = function () {}
- }
- }
+"use strict";
- function chmodFix (orig) {
- if (!orig) return orig
- return function (target, mode, cb) {
- return orig.call(fs, target, mode, function (er) {
- if (chownErOk(er)) er = null
- if (cb) cb.apply(this, arguments)
- })
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+const util_1 = __webpack_require__(397);
+const chalk_1 = tslib_1.__importDefault(__webpack_require__(386));
+const log_levels_1 = __webpack_require__(403);
+const { magentaBright, yellow, red, blue, green, dim } = chalk_1.default;
+const PREFIX_INDENT = ' '.repeat(6);
+const MSG_PREFIXES = {
+ verbose: ` ${magentaBright('sill')} `,
+ debug: ` ${dim('debg')} `,
+ info: ` ${blue('info')} `,
+ success: ` ${green('succ')} `,
+ warning: ` ${yellow('warn')} `,
+ error: `${red('ERROR')} `,
+};
+const has = (obj, key) => obj.hasOwnProperty(key);
+function shouldWriteType(level, type) {
+ if (type === 'write') {
+ return level.name !== 'silent';
}
- }
-
- function chmodFixSync (orig) {
- if (!orig) return orig
- return function (target, mode) {
- try {
- return orig.call(fs, target, mode)
- } catch (er) {
- if (!chownErOk(er)) throw er
- }
+ return Boolean(level.flags[type === 'success' ? 'info' : type]);
+}
+function stringifyError(error) {
+ if (typeof error !== 'string' && !(error instanceof Error)) {
+ error = new Error(`"${error}" thrown`);
}
- }
-
-
- function chownFix (orig) {
- if (!orig) return orig
- return function (target, uid, gid, cb) {
- return orig.call(fs, target, uid, gid, function (er) {
- if (chownErOk(er)) er = null
- if (cb) cb.apply(this, arguments)
- })
+ if (typeof error === 'string') {
+ return error;
}
- }
-
- function chownFixSync (orig) {
- if (!orig) return orig
- return function (target, uid, gid) {
- try {
- return orig.call(fs, target, uid, gid)
- } catch (er) {
- if (!chownErOk(er)) throw er
- }
+ return error.stack || error.message || error;
+}
+class ToolingLogTextWriter {
+ constructor(config) {
+ this.level = log_levels_1.parseLogLevel(config.level);
+ this.writeTo = config.writeTo;
+ if (!this.writeTo || typeof this.writeTo.write !== 'function') {
+ throw new Error('ToolingLogTextWriter requires the `writeTo` option be set to a stream (like process.stdout)');
+ }
}
- }
-
-
- function statFix (orig) {
- if (!orig) return orig
- // Older versions of Node erroneously returned signed integers for
- // uid + gid.
- return function (target, cb) {
- return orig.call(fs, target, function (er, stats) {
- if (!stats) return cb.apply(this, arguments)
- if (stats.uid < 0) stats.uid += 0x100000000
- if (stats.gid < 0) stats.gid += 0x100000000
- if (cb) cb.apply(this, arguments)
- })
+ write(msg) {
+ if (!shouldWriteType(this.level, msg.type)) {
+ return false;
+ }
+ const prefix = has(MSG_PREFIXES, msg.type) ? MSG_PREFIXES[msg.type] : '';
+ ToolingLogTextWriter.write(this.writeTo, prefix, msg);
+ return true;
}
- }
-
- function statFixSync (orig) {
- if (!orig) return orig
- // Older versions of Node erroneously returned signed integers for
- // uid + gid.
- return function (target) {
- var stats = orig.call(fs, target)
- if (stats.uid < 0) stats.uid += 0x100000000
- if (stats.gid < 0) stats.gid += 0x100000000
- return stats;
+ static write(writeTo, prefix, msg) {
+ const txt = msg.type === 'error'
+ ? stringifyError(msg.args[0])
+ : util_1.format(msg.args[0], ...msg.args.slice(1));
+ (prefix + txt).split('\n').forEach((line, i) => {
+ let lineIndent = '';
+ if (msg.indent > 0) {
+ // if we are indenting write some spaces followed by a symbol
+ lineIndent += ' '.repeat(msg.indent - 1);
+ lineIndent += line.startsWith('-') ? '└' : '│';
+ }
+ if (line && prefix && i > 0) {
+ // apply additional indentation to lines after
+ // the first if this message gets a prefix
+ lineIndent += PREFIX_INDENT;
+ }
+ writeTo.write(`${lineIndent}${line}\n`);
+ });
}
- }
+}
+exports.ToolingLogTextWriter = ToolingLogTextWriter;
- // ENOSYS means that the fs doesn't support the op. Just ignore
- // that, because it doesn't matter.
- //
- // if there's no getuid, or if getuid() is something other
- // than 0, and the error is EINVAL or EPERM, then just ignore
- // it.
- //
- // This specific case is a silent failure in cp, install, tar,
- // and most other unix tools that manage permissions.
- //
- // When running as root, or if other types of errors are
- // encountered, then it's strict.
- function chownErOk (er) {
- if (!er)
- return true
- if (er.code === "ENOSYS")
- return true
+/***/ }),
+/* 403 */
+/***/ (function(module, exports, __webpack_require__) {
- var nonroot = !process.getuid || process.getuid() !== 0
- if (nonroot) {
- if (er.code === "EINVAL" || er.code === "EPERM")
- return true
- }
+"use strict";
- return false
- }
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const LEVELS = ['silent', 'error', 'warning', 'info', 'debug', 'verbose'];
+function pickLevelFromFlags(flags, options = {}) {
+ if (flags.verbose)
+ return 'verbose';
+ if (flags.debug)
+ return 'debug';
+ if (flags.quiet)
+ return 'error';
+ if (flags.silent)
+ return 'silent';
+ return options.default || 'info';
+}
+exports.pickLevelFromFlags = pickLevelFromFlags;
+function parseLogLevel(name) {
+ const i = LEVELS.indexOf(name);
+ if (i === -1) {
+ const msg = `Invalid log level "${name}" ` + `(expected one of ${LEVELS.join(',')})`;
+ throw new Error(msg);
+ }
+ const flags = {};
+ LEVELS.forEach((level, levelI) => {
+ flags[level] = levelI <= i;
+ });
+ return {
+ name,
+ flags: flags,
+ };
}
+exports.parseLogLevel = parseLogLevel;
/***/ }),
-/* 425 */
+/* 404 */
/***/ (function(module, exports, __webpack_require__) {
-var Stream = __webpack_require__(27).Stream
+"use strict";
-module.exports = legacy
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tooling_log_text_writer_1 = __webpack_require__(402);
+class ToolingLogCollectingWriter extends tooling_log_text_writer_1.ToolingLogTextWriter {
+ constructor(level = 'verbose') {
+ super({
+ level,
+ writeTo: {
+ write: (msg) => {
+ // trim trailing new line
+ this.messages.push(msg.slice(0, -1));
+ },
+ },
+ });
+ this.messages = [];
+ }
+}
+exports.ToolingLogCollectingWriter = ToolingLogCollectingWriter;
-function legacy (fs) {
- return {
- ReadStream: ReadStream,
- WriteStream: WriteStream
- }
- function ReadStream (path, options) {
- if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+/***/ }),
+/* 405 */
+/***/ (function(module, exports, __webpack_require__) {
- Stream.call(this);
+"use strict";
- var self = this;
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var absolute_path_serializer_1 = __webpack_require__(406);
+exports.createAbsolutePathSerializer = absolute_path_serializer_1.createAbsolutePathSerializer;
- this.path = path;
- this.fd = null;
- this.readable = true;
- this.paused = false;
- this.flags = 'r';
- this.mode = 438; /*=0666*/
- this.bufferSize = 64 * 1024;
+/***/ }),
+/* 406 */
+/***/ (function(module, exports, __webpack_require__) {
- options = options || {};
+"use strict";
- // Mixin options into this
- var keys = Object.keys(options);
- for (var index = 0, length = keys.length; index < length; index++) {
- var key = keys[index];
- this[key] = options[key];
- }
-
- if (this.encoding) this.setEncoding(this.encoding);
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const repo_root_1 = __webpack_require__(407);
+function createAbsolutePathSerializer(rootPath = repo_root_1.REPO_ROOT) {
+ return {
+ print: (value) => value.replace(rootPath, '').replace(/\\/g, '/'),
+ test: (value) => typeof value === 'string' && value.startsWith(rootPath),
+ };
+}
+exports.createAbsolutePathSerializer = createAbsolutePathSerializer;
- if (this.start !== undefined) {
- if ('number' !== typeof this.start) {
- throw TypeError('start must be a Number');
- }
- if (this.end === undefined) {
- this.end = Infinity;
- } else if ('number' !== typeof this.end) {
- throw TypeError('end must be a Number');
- }
- if (this.start > this.end) {
- throw new Error('start must be <= end');
- }
+/***/ }),
+/* 407 */
+/***/ (function(module, exports, __webpack_require__) {
- this.pos = this.start;
- }
+"use strict";
- if (this.fd !== null) {
- process.nextTick(function() {
- self._read();
- });
- return;
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+const path_1 = tslib_1.__importDefault(__webpack_require__(4));
+const fs_1 = tslib_1.__importDefault(__webpack_require__(349));
+const load_json_file_1 = tslib_1.__importDefault(__webpack_require__(408));
+const isKibanaDir = (dir) => {
+ try {
+ const path = path_1.default.resolve(dir, 'package.json');
+ const json = load_json_file_1.default.sync(path);
+ if (json && typeof json === 'object' && 'name' in json && json.name === 'kibana') {
+ return true;
+ }
}
-
- fs.open(this.path, this.flags, this.mode, function (err, fd) {
- if (err) {
- self.emit('error', err);
- self.readable = false;
- return;
- }
-
- self.fd = fd;
- self.emit('open', fd);
- self._read();
- })
- }
-
- function WriteStream (path, options) {
- if (!(this instanceof WriteStream)) return new WriteStream(path, options);
-
- Stream.call(this);
-
- this.path = path;
- this.fd = null;
- this.writable = true;
-
- this.flags = 'w';
- this.encoding = 'binary';
- this.mode = 438; /*=0666*/
- this.bytesWritten = 0;
-
- options = options || {};
-
- // Mixin options into this
- var keys = Object.keys(options);
- for (var index = 0, length = keys.length; index < length; index++) {
- var key = keys[index];
- this[key] = options[key];
+ catch (error) {
+ if (error && error.code === 'ENOENT') {
+ return false;
+ }
+ throw error;
}
-
- if (this.start !== undefined) {
- if ('number' !== typeof this.start) {
- throw TypeError('start must be a Number');
- }
- if (this.start < 0) {
- throw new Error('start must be >= zero');
- }
-
- this.pos = this.start;
+};
+// search for the kibana directory, since this file is moved around it might
+// not be where we think but should always be a relatively close parent
+// of this directory
+const startDir = fs_1.default.realpathSync(__dirname);
+const { root: rootDir } = path_1.default.parse(startDir);
+let cursor = startDir;
+while (true) {
+ if (isKibanaDir(cursor)) {
+ break;
}
-
- this.busy = false;
- this._queue = [];
-
- if (this.fd === null) {
- this._open = fs.open;
- this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
- this.flush();
+ const parent = path_1.default.dirname(cursor);
+ if (parent === rootDir) {
+ throw new Error(`unable to find kibana directory from ${startDir}`);
}
- }
+ cursor = parent;
}
+exports.REPO_ROOT = cursor;
/***/ }),
-/* 426 */
+/* 408 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+const path = __webpack_require__(4);
+const {promisify} = __webpack_require__(397);
+const fs = __webpack_require__(409);
+const stripBom = __webpack_require__(414);
+const parseJson = __webpack_require__(415);
-module.exports = clone
-
-function clone (obj) {
- if (obj === null || typeof obj !== 'object')
- return obj
+const parse = (data, filePath, options = {}) => {
+ data = stripBom(data);
- if (obj instanceof Object)
- var copy = { __proto__: obj.__proto__ }
- else
- var copy = Object.create(null)
+ if (typeof options.beforeParse === 'function') {
+ data = options.beforeParse(data);
+ }
- Object.getOwnPropertyNames(obj).forEach(function (key) {
- Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
- })
+ return parseJson(data, options.reviver, path.relative(process.cwd(), filePath));
+};
- return copy
-}
+module.exports = async (filePath, options) => parse(await promisify(fs.readFile)(filePath, 'utf8'), filePath, options);
+module.exports.sync = (filePath, options) => parse(fs.readFileSync(filePath, 'utf8'), filePath, options);
/***/ }),
-/* 427 */
+/* 409 */
/***/ (function(module, exports, __webpack_require__) {
-"use strict";
+var fs = __webpack_require__(349)
+var polyfills = __webpack_require__(410)
+var legacy = __webpack_require__(412)
+var clone = __webpack_require__(413)
+var queue = []
-module.exports = string => {
- if (typeof string !== 'string') {
- throw new TypeError(`Expected a string, got ${typeof string}`);
- }
+var util = __webpack_require__(397)
- // Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
- // conversion translates it to FEFF (UTF-16 BOM)
- if (string.charCodeAt(0) === 0xFEFF) {
- return string.slice(1);
- }
+function noop () {}
- return string;
-};
+var debug = noop
+if (util.debuglog)
+ debug = util.debuglog('gfs4')
+else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+ debug = function() {
+ var m = util.format.apply(util, arguments)
+ m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
+ console.error(m)
+ }
+if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+ process.on('exit', function() {
+ debug(queue)
+ __webpack_require__(371).equal(queue.length, 0)
+ })
+}
-/***/ }),
-/* 428 */
-/***/ (function(module, exports, __webpack_require__) {
+module.exports = patch(clone(fs))
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+ module.exports = patch(fs)
+ fs.__patched = true;
+}
-"use strict";
+// Always patch fs.close/closeSync, because we want to
+// retry() whenever a close happens *anywhere* in the program.
+// This is essential when multiple graceful-fs instances are
+// in play at the same time.
+module.exports.close = (function (fs$close) { return function (fd, cb) {
+ return fs$close.call(fs, fd, function (err) {
+ if (!err)
+ retry()
-const errorEx = __webpack_require__(429);
-const fallback = __webpack_require__(431);
-const {default: LinesAndColumns} = __webpack_require__(432);
-const {codeFrameColumns} = __webpack_require__(433);
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ })
+}})(fs.close)
-const JSONError = errorEx('JSONError', {
- fileName: errorEx.append('in %s'),
- codeFrame: errorEx.append('\n\n%s\n')
-});
+module.exports.closeSync = (function (fs$closeSync) { return function (fd) {
+ // Note that graceful-fs also retries when fs.closeSync() fails.
+ // Looks like a bug to me, although it's probably a harmless one.
+ var rval = fs$closeSync.apply(fs, arguments)
+ retry()
+ return rval
+}})(fs.closeSync)
-module.exports = (string, reviver, filename) => {
- if (typeof reviver === 'string') {
- filename = reviver;
- reviver = null;
- }
+// Only patch fs once, otherwise we'll run into a memory leak if
+// graceful-fs is loaded multiple times, such as in test environments that
+// reset the loaded modules between tests.
+// We look for the string `graceful-fs` from the comment above. This
+// way we are not adding any extra properties and it will detect if older
+// versions of graceful-fs are installed.
+if (!/\bgraceful-fs\b/.test(fs.closeSync.toString())) {
+ fs.closeSync = module.exports.closeSync;
+ fs.close = module.exports.close;
+}
- try {
- try {
- return JSON.parse(string, reviver);
- } catch (error) {
- fallback(string, reviver);
- throw error;
- }
- } catch (error) {
- error.message = error.message.replace(/\n/g, '');
- const indexMatch = error.message.match(/in JSON at position (\d+) while parsing near/);
+function patch (fs) {
+ // Everything that references the open() function needs to be in here
+ polyfills(fs)
+ fs.gracefulify = patch
+ fs.FileReadStream = ReadStream; // Legacy name.
+ fs.FileWriteStream = WriteStream; // Legacy name.
+ fs.createReadStream = createReadStream
+ fs.createWriteStream = createWriteStream
+ var fs$readFile = fs.readFile
+ fs.readFile = readFile
+ function readFile (path, options, cb) {
+ if (typeof options === 'function')
+ cb = options, options = null
- const jsonError = new JSONError(error);
- if (filename) {
- jsonError.fileName = filename;
- }
+ return go$readFile(path, options, cb)
- if (indexMatch && indexMatch.length > 0) {
- const lines = new LinesAndColumns(string);
- const index = Number(indexMatch[1]);
- const location = lines.locationForIndex(index);
+ function go$readFile (path, options, cb) {
+ return fs$readFile(path, options, function (err) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$readFile, [path, options, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ })
+ }
+ }
- const codeFrame = codeFrameColumns(
- string,
- {start: {line: location.line + 1, column: location.column + 1}},
- {highlightCode: true}
- );
+ var fs$writeFile = fs.writeFile
+ fs.writeFile = writeFile
+ function writeFile (path, data, options, cb) {
+ if (typeof options === 'function')
+ cb = options, options = null
- jsonError.codeFrame = codeFrame;
- }
+ return go$writeFile(path, data, options, cb)
- throw jsonError;
- }
-};
+ function go$writeFile (path, data, options, cb) {
+ return fs$writeFile(path, data, options, function (err) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$writeFile, [path, data, options, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ })
+ }
+ }
+ var fs$appendFile = fs.appendFile
+ if (fs$appendFile)
+ fs.appendFile = appendFile
+ function appendFile (path, data, options, cb) {
+ if (typeof options === 'function')
+ cb = options, options = null
-/***/ }),
-/* 429 */
-/***/ (function(module, exports, __webpack_require__) {
+ return go$appendFile(path, data, options, cb)
-"use strict";
+ function go$appendFile (path, data, options, cb) {
+ return fs$appendFile(path, data, options, function (err) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$appendFile, [path, data, options, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ })
+ }
+ }
+ var fs$readdir = fs.readdir
+ fs.readdir = readdir
+ function readdir (path, options, cb) {
+ var args = [path]
+ if (typeof options !== 'function') {
+ args.push(options)
+ } else {
+ cb = options
+ }
+ args.push(go$readdir$cb)
-var util = __webpack_require__(29);
-var isArrayish = __webpack_require__(430);
+ return go$readdir(args)
-var errorEx = function errorEx(name, properties) {
- if (!name || name.constructor !== String) {
- properties = name || {};
- name = Error.name;
- }
+ function go$readdir$cb (err, files) {
+ if (files && files.sort)
+ files.sort()
- var errorExError = function ErrorEXError(message) {
- if (!this) {
- return new ErrorEXError(message);
- }
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$readdir, [args]])
- message = message instanceof Error
- ? message.message
- : (message || this.message);
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ }
+ }
- Error.call(this, message);
- Error.captureStackTrace(this, errorExError);
+ function go$readdir (args) {
+ return fs$readdir.apply(fs, args)
+ }
- this.name = name;
+ if (process.version.substr(0, 4) === 'v0.8') {
+ var legStreams = legacy(fs)
+ ReadStream = legStreams.ReadStream
+ WriteStream = legStreams.WriteStream
+ }
- Object.defineProperty(this, 'message', {
- configurable: true,
- enumerable: false,
- get: function () {
- var newMessage = message.split(/\r?\n/g);
+ var fs$ReadStream = fs.ReadStream
+ if (fs$ReadStream) {
+ ReadStream.prototype = Object.create(fs$ReadStream.prototype)
+ ReadStream.prototype.open = ReadStream$open
+ }
- for (var key in properties) {
- if (!properties.hasOwnProperty(key)) {
- continue;
- }
+ var fs$WriteStream = fs.WriteStream
+ if (fs$WriteStream) {
+ WriteStream.prototype = Object.create(fs$WriteStream.prototype)
+ WriteStream.prototype.open = WriteStream$open
+ }
- var modifier = properties[key];
+ fs.ReadStream = ReadStream
+ fs.WriteStream = WriteStream
- if ('message' in modifier) {
- newMessage = modifier.message(this[key], newMessage) || newMessage;
- if (!isArrayish(newMessage)) {
- newMessage = [newMessage];
- }
- }
- }
+ function ReadStream (path, options) {
+ if (this instanceof ReadStream)
+ return fs$ReadStream.apply(this, arguments), this
+ else
+ return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
+ }
- return newMessage.join('\n');
- },
- set: function (v) {
- message = v;
- }
- });
+ function ReadStream$open () {
+ var that = this
+ open(that.path, that.flags, that.mode, function (err, fd) {
+ if (err) {
+ if (that.autoClose)
+ that.destroy()
- var stackDescriptor = Object.getOwnPropertyDescriptor(this, 'stack');
- var stackGetter = stackDescriptor.get;
- var stackValue = stackDescriptor.value;
- delete stackDescriptor.value;
- delete stackDescriptor.writable;
+ that.emit('error', err)
+ } else {
+ that.fd = fd
+ that.emit('open', fd)
+ that.read()
+ }
+ })
+ }
- stackDescriptor.get = function () {
- var stack = (stackGetter)
- ? stackGetter.call(this).split(/\r?\n+/g)
- : stackValue.split(/\r?\n+/g);
+ function WriteStream (path, options) {
+ if (this instanceof WriteStream)
+ return fs$WriteStream.apply(this, arguments), this
+ else
+ return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
+ }
- // starting in Node 7, the stack builder caches the message.
- // just replace it.
- stack[0] = this.name + ': ' + this.message;
+ function WriteStream$open () {
+ var that = this
+ open(that.path, that.flags, that.mode, function (err, fd) {
+ if (err) {
+ that.destroy()
+ that.emit('error', err)
+ } else {
+ that.fd = fd
+ that.emit('open', fd)
+ }
+ })
+ }
- var lineCount = 1;
- for (var key in properties) {
- if (!properties.hasOwnProperty(key)) {
- continue;
- }
+ function createReadStream (path, options) {
+ return new ReadStream(path, options)
+ }
- var modifier = properties[key];
+ function createWriteStream (path, options) {
+ return new WriteStream(path, options)
+ }
- if ('line' in modifier) {
- var line = modifier.line(this[key]);
- if (line) {
- stack.splice(lineCount++, 0, ' ' + line);
- }
- }
+ var fs$open = fs.open
+ fs.open = open
+ function open (path, flags, mode, cb) {
+ if (typeof mode === 'function')
+ cb = mode, mode = null
- if ('stack' in modifier) {
- modifier.stack(this[key], stack);
- }
- }
+ return go$open(path, flags, mode, cb)
- return stack.join('\n');
- };
-
- Object.defineProperty(this, 'stack', stackDescriptor);
- };
-
- if (Object.setPrototypeOf) {
- Object.setPrototypeOf(errorExError.prototype, Error.prototype);
- Object.setPrototypeOf(errorExError, Error);
- } else {
- util.inherits(errorExError, Error);
- }
-
- return errorExError;
-};
-
-errorEx.append = function (str, def) {
- return {
- message: function (v, message) {
- v = v || def;
-
- if (v) {
- message[0] += ' ' + str.replace('%s', v.toString());
- }
-
- return message;
- }
- };
-};
-
-errorEx.line = function (str, def) {
- return {
- line: function (v) {
- v = v || def;
+ function go$open (path, flags, mode, cb) {
+ return fs$open(path, flags, mode, function (err, fd) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$open, [path, flags, mode, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ })
+ }
+ }
- if (v) {
- return str.replace('%s', v.toString());
- }
+ return fs
+}
- return null;
- }
- };
-};
+function enqueue (elem) {
+ debug('ENQUEUE', elem[0].name, elem[1])
+ queue.push(elem)
+}
-module.exports = errorEx;
+function retry () {
+ var elem = queue.shift()
+ if (elem) {
+ debug('RETRY', elem[0].name, elem[1])
+ elem[0].apply(null, elem[1])
+ }
+}
/***/ }),
-/* 430 */
+/* 410 */
/***/ (function(module, exports, __webpack_require__) {
-"use strict";
-
-
-module.exports = function isArrayish(obj) {
- if (!obj) {
- return false;
- }
-
- return obj instanceof Array || Array.isArray(obj) ||
- (obj.length >= 0 && obj.splice instanceof Function);
-};
-
+var constants = __webpack_require__(411)
-/***/ }),
-/* 431 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
+var origCwd = process.cwd
+var cwd = null
+var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
-module.exports = parseJson
-function parseJson (txt, reviver, context) {
- context = context || 20
- try {
- return JSON.parse(txt, reviver)
- } catch (e) {
- const syntaxErr = e.message.match(/^Unexpected token.*position\s+(\d+)/i)
- const errIdx = syntaxErr
- ? +syntaxErr[1]
- : e.message.match(/^Unexpected end of JSON.*/i)
- ? txt.length - 1
- : null
- if (errIdx != null) {
- const start = errIdx <= context
- ? 0
- : errIdx - context
- const end = errIdx + context >= txt.length
- ? txt.length
- : errIdx + context
- e.message += ` while parsing near '${
- start === 0 ? '' : '...'
- }${txt.slice(start, end)}${
- end === txt.length ? '' : '...'
- }'`
- } else {
- e.message += ` while parsing '${txt.slice(0, context * 2)}'`
- }
- throw e
- }
+process.cwd = function() {
+ if (!cwd)
+ cwd = origCwd.call(process)
+ return cwd
}
+try {
+ process.cwd()
+} catch (er) {}
+var chdir = process.chdir
+process.chdir = function(d) {
+ cwd = null
+ chdir.call(process, d)
+}
-/***/ }),
-/* 432 */
-/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-var LF = '\n';
-var CR = '\r';
-var LinesAndColumns = (function () {
- function LinesAndColumns(string) {
- this.string = string;
- var offsets = [0];
- for (var offset = 0; offset < string.length;) {
- switch (string[offset]) {
- case LF:
- offset += LF.length;
- offsets.push(offset);
- break;
- case CR:
- offset += CR.length;
- if (string[offset] === LF) {
- offset += LF.length;
- }
- offsets.push(offset);
- break;
- default:
- offset++;
- break;
- }
- }
- this.offsets = offsets;
- }
- LinesAndColumns.prototype.locationForIndex = function (index) {
- if (index < 0 || index > this.string.length) {
- return null;
- }
- var line = 0;
- var offsets = this.offsets;
- while (offsets[line + 1] <= index) {
- line++;
- }
- var column = index - offsets[line];
- return { line: line, column: column };
- };
- LinesAndColumns.prototype.indexForLocation = function (location) {
- var line = location.line, column = location.column;
- if (line < 0 || line >= this.offsets.length) {
- return null;
- }
- if (column < 0 || column > this.lengthOfLine(line)) {
- return null;
- }
- return this.offsets[line] + column;
- };
- LinesAndColumns.prototype.lengthOfLine = function (line) {
- var offset = this.offsets[line];
- var nextOffset = line === this.offsets.length - 1 ? this.string.length : this.offsets[line + 1];
- return nextOffset - offset;
- };
- return LinesAndColumns;
-}());
-/* harmony default export */ __webpack_exports__["default"] = (LinesAndColumns);
-
-
-/***/ }),
-/* 433 */
-/***/ (function(module, exports, __webpack_require__) {
+module.exports = patch
-"use strict";
+function patch (fs) {
+ // (re-)implement some things that are known busted or missing.
+ // lchmod, broken prior to 0.6.2
+ // back-port the fix here.
+ if (constants.hasOwnProperty('O_SYMLINK') &&
+ process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+ patchLchmod(fs)
+ }
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.codeFrameColumns = codeFrameColumns;
-exports.default = _default;
+ // lutimes implementation, or no-op
+ if (!fs.lutimes) {
+ patchLutimes(fs)
+ }
-var _highlight = _interopRequireWildcard(__webpack_require__(434));
+ // https://github.com/isaacs/node-graceful-fs/issues/4
+ // Chown should not fail on einval or eperm if non-root.
+ // It should not fail on enosys ever, as this just indicates
+ // that a fs doesn't support the intended operation.
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+ fs.chown = chownFix(fs.chown)
+ fs.fchown = chownFix(fs.fchown)
+ fs.lchown = chownFix(fs.lchown)
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+ fs.chmod = chmodFix(fs.chmod)
+ fs.fchmod = chmodFix(fs.fchmod)
+ fs.lchmod = chmodFix(fs.lchmod)
-let deprecationWarningShown = false;
+ fs.chownSync = chownFixSync(fs.chownSync)
+ fs.fchownSync = chownFixSync(fs.fchownSync)
+ fs.lchownSync = chownFixSync(fs.lchownSync)
-function getDefs(chalk) {
- return {
- gutter: chalk.grey,
- marker: chalk.red.bold,
- message: chalk.red.bold
- };
-}
+ fs.chmodSync = chmodFixSync(fs.chmodSync)
+ fs.fchmodSync = chmodFixSync(fs.fchmodSync)
+ fs.lchmodSync = chmodFixSync(fs.lchmodSync)
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+ fs.stat = statFix(fs.stat)
+ fs.fstat = statFix(fs.fstat)
+ fs.lstat = statFix(fs.lstat)
-function getMarkerLines(loc, source, opts) {
- const startLoc = Object.assign({
- column: 0,
- line: -1
- }, loc.start);
- const endLoc = Object.assign({}, startLoc, {}, loc.end);
- const {
- linesAbove = 2,
- linesBelow = 3
- } = opts || {};
- const startLine = startLoc.line;
- const startColumn = startLoc.column;
- const endLine = endLoc.line;
- const endColumn = endLoc.column;
- let start = Math.max(startLine - (linesAbove + 1), 0);
- let end = Math.min(source.length, endLine + linesBelow);
+ fs.statSync = statFixSync(fs.statSync)
+ fs.fstatSync = statFixSync(fs.fstatSync)
+ fs.lstatSync = statFixSync(fs.lstatSync)
- if (startLine === -1) {
- start = 0;
+ // if lchmod/lchown do not exist, then make them no-ops
+ if (!fs.lchmod) {
+ fs.lchmod = function (path, mode, cb) {
+ if (cb) process.nextTick(cb)
+ }
+ fs.lchmodSync = function () {}
}
-
- if (endLine === -1) {
- end = source.length;
+ if (!fs.lchown) {
+ fs.lchown = function (path, uid, gid, cb) {
+ if (cb) process.nextTick(cb)
+ }
+ fs.lchownSync = function () {}
}
- const lineDiff = endLine - startLine;
- const markerLines = {};
+ // on Windows, A/V software can lock the directory, causing this
+ // to fail with an EACCES or EPERM if the directory contains newly
+ // created files. Try again on failure, for up to 60 seconds.
- if (lineDiff) {
- for (let i = 0; i <= lineDiff; i++) {
- const lineNumber = i + startLine;
+ // Set the timeout this long because some Windows Anti-Virus, such as Parity
+ // bit9, may lock files for up to a minute, causing npm package install
+ // failures. Also, take care to yield the scheduler. Windows scheduling gives
+ // CPU to a busy looping process, which can cause the program causing the lock
+ // contention to be starved of CPU by node, so the contention doesn't resolve.
+ if (platform === "win32") {
+ fs.rename = (function (fs$rename) { return function (from, to, cb) {
+ var start = Date.now()
+ var backoff = 0;
+ fs$rename(from, to, function CB (er) {
+ if (er
+ && (er.code === "EACCES" || er.code === "EPERM")
+ && Date.now() - start < 60000) {
+ setTimeout(function() {
+ fs.stat(to, function (stater, st) {
+ if (stater && stater.code === "ENOENT")
+ fs$rename(from, to, CB);
+ else
+ cb(er)
+ })
+ }, backoff)
+ if (backoff < 100)
+ backoff += 10;
+ return;
+ }
+ if (cb) cb(er)
+ })
+ }})(fs.rename)
+ }
- if (!startColumn) {
- markerLines[lineNumber] = true;
- } else if (i === 0) {
- const sourceLength = source[lineNumber - 1].length;
- markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
- } else if (i === lineDiff) {
- markerLines[lineNumber] = [0, endColumn];
- } else {
- const sourceLength = source[lineNumber - i].length;
- markerLines[lineNumber] = [0, sourceLength];
+ // if read() returns EAGAIN, then just try it again.
+ fs.read = (function (fs$read) { return function (fd, buffer, offset, length, position, callback_) {
+ var callback
+ if (callback_ && typeof callback_ === 'function') {
+ var eagCounter = 0
+ callback = function (er, _, __) {
+ if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+ eagCounter ++
+ return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+ }
+ callback_.apply(this, arguments)
}
}
- } else {
- if (startColumn === endColumn) {
- if (startColumn) {
- markerLines[startLine] = [startColumn, 0];
- } else {
- markerLines[startLine] = true;
+ return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+ }})(fs.read)
+
+ fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+ var eagCounter = 0
+ while (true) {
+ try {
+ return fs$readSync.call(fs, fd, buffer, offset, length, position)
+ } catch (er) {
+ if (er.code === 'EAGAIN' && eagCounter < 10) {
+ eagCounter ++
+ continue
+ }
+ throw er
}
- } else {
- markerLines[startLine] = [startColumn, endColumn - startColumn];
}
- }
-
- return {
- start,
- end,
- markerLines
- };
-}
-
-function codeFrameColumns(rawLines, loc, opts = {}) {
- const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
- const chalk = (0, _highlight.getChalk)(opts);
- const defs = getDefs(chalk);
+ }})(fs.readSync)
- const maybeHighlight = (chalkFn, string) => {
- return highlighted ? chalkFn(string) : string;
- };
+ function patchLchmod (fs) {
+ fs.lchmod = function (path, mode, callback) {
+ fs.open( path
+ , constants.O_WRONLY | constants.O_SYMLINK
+ , mode
+ , function (err, fd) {
+ if (err) {
+ if (callback) callback(err)
+ return
+ }
+ // prefer to return the chmod error, if one occurs,
+ // but still try to close, and report closing errors if they occur.
+ fs.fchmod(fd, mode, function (err) {
+ fs.close(fd, function(err2) {
+ if (callback) callback(err || err2)
+ })
+ })
+ })
+ }
- const lines = rawLines.split(NEWLINE);
- const {
- start,
- end,
- markerLines
- } = getMarkerLines(loc, lines, opts);
- const hasColumns = loc.start && typeof loc.start.column === "number";
- const numberMaxWidth = String(end).length;
- const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
- let frame = highlightedLines.split(NEWLINE).slice(start, end).map((line, index) => {
- const number = start + 1 + index;
- const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
- const gutter = ` ${paddedNumber} | `;
- const hasMarker = markerLines[number];
- const lastMarkerLine = !markerLines[number + 1];
+ fs.lchmodSync = function (path, mode) {
+ var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
- if (hasMarker) {
- let markerLine = "";
+ // prefer to return the chmod error, if one occurs,
+ // but still try to close, and report closing errors if they occur.
+ var threw = true
+ var ret
+ try {
+ ret = fs.fchmodSync(fd, mode)
+ threw = false
+ } finally {
+ if (threw) {
+ try {
+ fs.closeSync(fd)
+ } catch (er) {}
+ } else {
+ fs.closeSync(fd)
+ }
+ }
+ return ret
+ }
+ }
- if (Array.isArray(hasMarker)) {
- const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
- const numberOfMarkers = hasMarker[1] || 1;
- markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
+ function patchLutimes (fs) {
+ if (constants.hasOwnProperty("O_SYMLINK")) {
+ fs.lutimes = function (path, at, mt, cb) {
+ fs.open(path, constants.O_SYMLINK, function (er, fd) {
+ if (er) {
+ if (cb) cb(er)
+ return
+ }
+ fs.futimes(fd, at, mt, function (er) {
+ fs.close(fd, function (er2) {
+ if (cb) cb(er || er2)
+ })
+ })
+ })
+ }
- if (lastMarkerLine && opts.message) {
- markerLine += " " + maybeHighlight(defs.message, opts.message);
+ fs.lutimesSync = function (path, at, mt) {
+ var fd = fs.openSync(path, constants.O_SYMLINK)
+ var ret
+ var threw = true
+ try {
+ ret = fs.futimesSync(fd, at, mt)
+ threw = false
+ } finally {
+ if (threw) {
+ try {
+ fs.closeSync(fd)
+ } catch (er) {}
+ } else {
+ fs.closeSync(fd)
+ }
}
+ return ret
}
- return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line, markerLine].join("");
} else {
- return ` ${maybeHighlight(defs.gutter, gutter)}${line}`;
+ fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
+ fs.lutimesSync = function () {}
}
- }).join("\n");
-
- if (opts.message && !hasColumns) {
- frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
}
- if (highlighted) {
- return chalk.reset(frame);
- } else {
- return frame;
+ function chmodFix (orig) {
+ if (!orig) return orig
+ return function (target, mode, cb) {
+ return orig.call(fs, target, mode, function (er) {
+ if (chownErOk(er)) er = null
+ if (cb) cb.apply(this, arguments)
+ })
+ }
}
-}
-
-function _default(rawLines, lineNumber, colNumber, opts = {}) {
- if (!deprecationWarningShown) {
- deprecationWarningShown = true;
- const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
- if (process.emitWarning) {
- process.emitWarning(message, "DeprecationWarning");
- } else {
- const deprecationError = new Error(message);
- deprecationError.name = "DeprecationWarning";
- console.warn(new Error(message));
+ function chmodFixSync (orig) {
+ if (!orig) return orig
+ return function (target, mode) {
+ try {
+ return orig.call(fs, target, mode)
+ } catch (er) {
+ if (!chownErOk(er)) throw er
+ }
}
}
- colNumber = Math.max(colNumber, 0);
- const location = {
- start: {
- column: colNumber,
- line: lineNumber
- }
- };
- return codeFrameColumns(rawLines, location, opts);
-}
-
-/***/ }),
-/* 434 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.shouldHighlight = shouldHighlight;
-exports.getChalk = getChalk;
-exports.default = highlight;
-
-var _jsTokens = _interopRequireWildcard(__webpack_require__(435));
-
-var _helperValidatorIdentifier = __webpack_require__(436);
-
-var _chalk = _interopRequireDefault(__webpack_require__(439));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-function getDefs(chalk) {
- return {
- keyword: chalk.cyan,
- capitalized: chalk.yellow,
- jsx_tag: chalk.yellow,
- punctuator: chalk.yellow,
- number: chalk.magenta,
- string: chalk.green,
- regex: chalk.magenta,
- comment: chalk.grey,
- invalid: chalk.white.bgRed.bold
- };
-}
-
-const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
-const JSX_TAG = /^[a-z][\w-]*$/i;
-const BRACKET = /^[()[\]{}]$/;
-
-function getTokenType(match) {
- const [offset, text] = match.slice(-2);
- const token = (0, _jsTokens.matchToToken)(match);
-
- if (token.type === "name") {
- if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isReservedWord)(token.value)) {
- return "keyword";
- }
- if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == " colorize(str)).join("\n");
- } else {
- return args[0];
+ var nonroot = !process.getuid || process.getuid() !== 0
+ if (nonroot) {
+ if (er.code === "EINVAL" || er.code === "EPERM")
+ return true
}
- });
-}
-
-function shouldHighlight(options) {
- return _chalk.default.supportsColor || options.forceColor;
-}
-
-function getChalk(options) {
- let chalk = _chalk.default;
- if (options.forceColor) {
- chalk = new _chalk.default.constructor({
- enabled: true,
- level: 1
- });
+ return false
}
-
- return chalk;
}
-function highlight(code, options = {}) {
- if (shouldHighlight(options)) {
- const chalk = getChalk(options);
- const defs = getDefs(chalk);
- return highlightTokens(defs, code);
- } else {
- return code;
- }
-}
/***/ }),
-/* 435 */
+/* 411 */
/***/ (function(module, exports) {
-// Copyright 2014, 2015, 2016, 2017, 2018 Simon Lydell
-// License: MIT. (See LICENSE.)
-
-Object.defineProperty(exports, "__esModule", {
- value: true
-})
-
-// This regex comes from regex.coffee, and is inserted here by generate-index.js
-// (run `npm run build`).
-exports.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g
-
-exports.matchToToken = function(match) {
- var token = {type: "invalid", value: match[0], closed: undefined}
- if (match[ 1]) token.type = "string" , token.closed = !!(match[3] || match[4])
- else if (match[ 5]) token.type = "comment"
- else if (match[ 6]) token.type = "comment", token.closed = !!match[7]
- else if (match[ 8]) token.type = "regex"
- else if (match[ 9]) token.type = "number"
- else if (match[10]) token.type = "name"
- else if (match[11]) token.type = "punctuator"
- else if (match[12]) token.type = "whitespace"
- return token
-}
-
+module.exports = require("constants");
/***/ }),
-/* 436 */
+/* 412 */
/***/ (function(module, exports, __webpack_require__) {
-"use strict";
+var Stream = __webpack_require__(382).Stream
+module.exports = legacy
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-Object.defineProperty(exports, "isIdentifierName", {
- enumerable: true,
- get: function () {
- return _identifier.isIdentifierName;
- }
-});
-Object.defineProperty(exports, "isIdentifierChar", {
- enumerable: true,
- get: function () {
- return _identifier.isIdentifierChar;
- }
-});
-Object.defineProperty(exports, "isIdentifierStart", {
- enumerable: true,
- get: function () {
- return _identifier.isIdentifierStart;
- }
-});
-Object.defineProperty(exports, "isReservedWord", {
- enumerable: true,
- get: function () {
- return _keyword.isReservedWord;
- }
-});
-Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
- enumerable: true,
- get: function () {
- return _keyword.isStrictBindOnlyReservedWord;
- }
-});
-Object.defineProperty(exports, "isStrictBindReservedWord", {
- enumerable: true,
- get: function () {
- return _keyword.isStrictBindReservedWord;
- }
-});
-Object.defineProperty(exports, "isStrictReservedWord", {
- enumerable: true,
- get: function () {
- return _keyword.isStrictReservedWord;
- }
-});
-Object.defineProperty(exports, "isKeyword", {
- enumerable: true,
- get: function () {
- return _keyword.isKeyword;
+function legacy (fs) {
+ return {
+ ReadStream: ReadStream,
+ WriteStream: WriteStream
}
-});
-var _identifier = __webpack_require__(437);
+ function ReadStream (path, options) {
+ if (!(this instanceof ReadStream)) return new ReadStream(path, options);
-var _keyword = __webpack_require__(438);
+ Stream.call(this);
-/***/ }),
-/* 437 */
-/***/ (function(module, exports, __webpack_require__) {
+ var self = this;
-"use strict";
+ this.path = path;
+ this.fd = null;
+ this.readable = true;
+ this.paused = false;
+ this.flags = 'r';
+ this.mode = 438; /*=0666*/
+ this.bufferSize = 64 * 1024;
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.isIdentifierStart = isIdentifierStart;
-exports.isIdentifierChar = isIdentifierChar;
-exports.isIdentifierName = isIdentifierName;
-let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08c7\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\u9ffc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7ca\ua7f5-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
-let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf\u1ac0\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
-const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
-const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
-nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
-const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 107, 20, 28, 22, 13, 52, 76, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 230, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 35, 56, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8952, 286, 50, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 2357, 44, 11, 6, 17, 0, 370, 43, 1301, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42717, 35, 4148, 12, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];
-const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 176, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 135, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 419, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+ options = options || {};
-function isInAstralSet(code, set) {
- let pos = 0x10000;
+ // Mixin options into this
+ var keys = Object.keys(options);
+ for (var index = 0, length = keys.length; index < length; index++) {
+ var key = keys[index];
+ this[key] = options[key];
+ }
- for (let i = 0, length = set.length; i < length; i += 2) {
- pos += set[i];
- if (pos > code) return false;
- pos += set[i + 1];
- if (pos >= code) return true;
- }
+ if (this.encoding) this.setEncoding(this.encoding);
- return false;
-}
+ if (this.start !== undefined) {
+ if ('number' !== typeof this.start) {
+ throw TypeError('start must be a Number');
+ }
+ if (this.end === undefined) {
+ this.end = Infinity;
+ } else if ('number' !== typeof this.end) {
+ throw TypeError('end must be a Number');
+ }
-function isIdentifierStart(code) {
- if (code < 65) return code === 36;
- if (code <= 90) return true;
- if (code < 97) return code === 95;
- if (code <= 122) return true;
+ if (this.start > this.end) {
+ throw new Error('start must be <= end');
+ }
- if (code <= 0xffff) {
- return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
- }
+ this.pos = this.start;
+ }
- return isInAstralSet(code, astralIdentifierStartCodes);
-}
+ if (this.fd !== null) {
+ process.nextTick(function() {
+ self._read();
+ });
+ return;
+ }
-function isIdentifierChar(code) {
- if (code < 48) return code === 36;
- if (code < 58) return true;
- if (code < 65) return false;
- if (code <= 90) return true;
- if (code < 97) return code === 95;
- if (code <= 122) return true;
+ fs.open(this.path, this.flags, this.mode, function (err, fd) {
+ if (err) {
+ self.emit('error', err);
+ self.readable = false;
+ return;
+ }
- if (code <= 0xffff) {
- return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+ self.fd = fd;
+ self.emit('open', fd);
+ self._read();
+ })
}
- return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
-}
+ function WriteStream (path, options) {
+ if (!(this instanceof WriteStream)) return new WriteStream(path, options);
-function isIdentifierName(name) {
- let isFirst = true;
+ Stream.call(this);
- for (let _i = 0, _Array$from = Array.from(name); _i < _Array$from.length; _i++) {
- const char = _Array$from[_i];
- const cp = char.codePointAt(0);
+ this.path = path;
+ this.fd = null;
+ this.writable = true;
- if (isFirst) {
- if (!isIdentifierStart(cp)) {
- return false;
+ this.flags = 'w';
+ this.encoding = 'binary';
+ this.mode = 438; /*=0666*/
+ this.bytesWritten = 0;
+
+ options = options || {};
+
+ // Mixin options into this
+ var keys = Object.keys(options);
+ for (var index = 0, length = keys.length; index < length; index++) {
+ var key = keys[index];
+ this[key] = options[key];
+ }
+
+ if (this.start !== undefined) {
+ if ('number' !== typeof this.start) {
+ throw TypeError('start must be a Number');
+ }
+ if (this.start < 0) {
+ throw new Error('start must be >= zero');
}
- isFirst = false;
- } else if (!isIdentifierChar(cp)) {
- return false;
+ this.pos = this.start;
}
- }
- return true;
+ this.busy = false;
+ this._queue = [];
+
+ if (this.fd === null) {
+ this._open = fs.open;
+ this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+ this.flush();
+ }
+ }
}
+
/***/ }),
-/* 438 */
+/* 413 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-Object.defineProperty(exports, "__esModule", {
- value: true
-});
-exports.isReservedWord = isReservedWord;
-exports.isStrictReservedWord = isStrictReservedWord;
-exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
-exports.isStrictBindReservedWord = isStrictBindReservedWord;
-exports.isKeyword = isKeyword;
-const reservedWords = {
- keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
- strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
- strictBind: ["eval", "arguments"]
-};
-const keywords = new Set(reservedWords.keyword);
-const reservedWordsStrictSet = new Set(reservedWords.strict);
-const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+module.exports = clone
-function isReservedWord(word, inModule) {
- return inModule && word === "await" || word === "enum";
-}
+function clone (obj) {
+ if (obj === null || typeof obj !== 'object')
+ return obj
-function isStrictReservedWord(word, inModule) {
- return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
-}
+ if (obj instanceof Object)
+ var copy = { __proto__: obj.__proto__ }
+ else
+ var copy = Object.create(null)
-function isStrictBindOnlyReservedWord(word) {
- return reservedWordsStrictBindSet.has(word);
-}
+ Object.getOwnPropertyNames(obj).forEach(function (key) {
+ Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
+ })
-function isStrictBindReservedWord(word, inModule) {
- return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+ return copy
}
-function isKeyword(word) {
- return keywords.has(word);
-}
/***/ }),
-/* 439 */
+/* 414 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const escapeStringRegexp = __webpack_require__(3);
-const ansiStyles = __webpack_require__(440);
-const stdoutColor = __webpack_require__(441).stdout;
-const template = __webpack_require__(442);
+module.exports = string => {
+ if (typeof string !== 'string') {
+ throw new TypeError(`Expected a string, got ${typeof string}`);
+ }
-const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
+ // Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
+ // conversion translates it to FEFF (UTF-16 BOM)
+ if (string.charCodeAt(0) === 0xFEFF) {
+ return string.slice(1);
+ }
-// `supportsColor.level` → `ansiStyles.color[name]` mapping
-const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
+ return string;
+};
-// `color-convert` models to exclude from the Chalk API due to conflicts and such
-const skipModels = new Set(['gray']);
-const styles = Object.create(null);
+/***/ }),
+/* 415 */
+/***/ (function(module, exports, __webpack_require__) {
-function applyOptions(obj, options) {
- options = options || {};
+"use strict";
- // Detect level if not set manually
- const scLevel = stdoutColor ? stdoutColor.level : 0;
- obj.level = options.level === undefined ? scLevel : options.level;
- obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
-}
+const errorEx = __webpack_require__(416);
+const fallback = __webpack_require__(418);
+const {default: LinesAndColumns} = __webpack_require__(419);
+const {codeFrameColumns} = __webpack_require__(420);
-function Chalk(options) {
- // We check for this.template here since calling `chalk.constructor()`
- // by itself will have a `this` of a previously constructed chalk object
- if (!this || !(this instanceof Chalk) || this.template) {
- const chalk = {};
- applyOptions(chalk, options);
+const JSONError = errorEx('JSONError', {
+ fileName: errorEx.append('in %s'),
+ codeFrame: errorEx.append('\n\n%s\n')
+});
- chalk.template = function () {
- const args = [].slice.call(arguments);
- return chalkTag.apply(null, [chalk.template].concat(args));
- };
+module.exports = (string, reviver, filename) => {
+ if (typeof reviver === 'string') {
+ filename = reviver;
+ reviver = null;
+ }
- Object.setPrototypeOf(chalk, Chalk.prototype);
- Object.setPrototypeOf(chalk.template, chalk);
+ try {
+ try {
+ return JSON.parse(string, reviver);
+ } catch (error) {
+ fallback(string, reviver);
+ throw error;
+ }
+ } catch (error) {
+ error.message = error.message.replace(/\n/g, '');
+ const indexMatch = error.message.match(/in JSON at position (\d+) while parsing near/);
- chalk.template.constructor = Chalk;
+ const jsonError = new JSONError(error);
+ if (filename) {
+ jsonError.fileName = filename;
+ }
- return chalk.template;
- }
+ if (indexMatch && indexMatch.length > 0) {
+ const lines = new LinesAndColumns(string);
+ const index = Number(indexMatch[1]);
+ const location = lines.locationForIndex(index);
- applyOptions(this, options);
-}
-
-// Use bright blue on Windows as the normal blue color is illegible
-if (isSimpleWindowsTerm) {
- ansiStyles.blue.open = '\u001B[94m';
-}
-
-for (const key of Object.keys(ansiStyles)) {
- ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+ const codeFrame = codeFrameColumns(
+ string,
+ {start: {line: location.line + 1, column: location.column + 1}},
+ {highlightCode: true}
+ );
- styles[key] = {
- get() {
- const codes = ansiStyles[key];
- return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+ jsonError.codeFrame = codeFrame;
}
- };
-}
-styles.visible = {
- get() {
- return build.call(this, this._styles || [], true, 'visible');
+ throw jsonError;
}
};
-ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
-for (const model of Object.keys(ansiStyles.color.ansi)) {
- if (skipModels.has(model)) {
- continue;
- }
- styles[model] = {
- get() {
- const level = this.level;
- return function () {
- const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
- const codes = {
- open,
- close: ansiStyles.color.close,
- closeRe: ansiStyles.color.closeRe
- };
- return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
- };
- }
- };
-}
+/***/ }),
+/* 416 */
+/***/ (function(module, exports, __webpack_require__) {
-ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
-for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
- if (skipModels.has(model)) {
- continue;
+"use strict";
+
+
+var util = __webpack_require__(397);
+var isArrayish = __webpack_require__(417);
+
+var errorEx = function errorEx(name, properties) {
+ if (!name || name.constructor !== String) {
+ properties = name || {};
+ name = Error.name;
}
- const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
- styles[bgModel] = {
- get() {
- const level = this.level;
- return function () {
- const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
- const codes = {
- open,
- close: ansiStyles.bgColor.close,
- closeRe: ansiStyles.bgColor.closeRe
- };
- return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
- };
+ var errorExError = function ErrorEXError(message) {
+ if (!this) {
+ return new ErrorEXError(message);
}
- };
-}
-const proto = Object.defineProperties(() => {}, styles);
+ message = message instanceof Error
+ ? message.message
+ : (message || this.message);
-function build(_styles, _empty, key) {
- const builder = function () {
- return applyStyle.apply(builder, arguments);
- };
+ Error.call(this, message);
+ Error.captureStackTrace(this, errorExError);
- builder._styles = _styles;
- builder._empty = _empty;
+ this.name = name;
- const self = this;
+ Object.defineProperty(this, 'message', {
+ configurable: true,
+ enumerable: false,
+ get: function () {
+ var newMessage = message.split(/\r?\n/g);
- Object.defineProperty(builder, 'level', {
- enumerable: true,
- get() {
- return self.level;
- },
- set(level) {
- self.level = level;
- }
- });
+ for (var key in properties) {
+ if (!properties.hasOwnProperty(key)) {
+ continue;
+ }
- Object.defineProperty(builder, 'enabled', {
- enumerable: true,
- get() {
- return self.enabled;
- },
- set(enabled) {
- self.enabled = enabled;
- }
- });
+ var modifier = properties[key];
- // See below for fix regarding invisible grey/dim combination on Windows
- builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
+ if ('message' in modifier) {
+ newMessage = modifier.message(this[key], newMessage) || newMessage;
+ if (!isArrayish(newMessage)) {
+ newMessage = [newMessage];
+ }
+ }
+ }
- // `__proto__` is used because we must return a function, but there is
- // no way to create a function with a different prototype
- builder.__proto__ = proto; // eslint-disable-line no-proto
+ return newMessage.join('\n');
+ },
+ set: function (v) {
+ message = v;
+ }
+ });
- return builder;
-}
+ var stackDescriptor = Object.getOwnPropertyDescriptor(this, 'stack');
+ var stackGetter = stackDescriptor.get;
+ var stackValue = stackDescriptor.value;
+ delete stackDescriptor.value;
+ delete stackDescriptor.writable;
-function applyStyle() {
- // Support varags, but simply cast to string in case there's only one arg
- const args = arguments;
- const argsLen = args.length;
- let str = String(arguments[0]);
+ stackDescriptor.get = function () {
+ var stack = (stackGetter)
+ ? stackGetter.call(this).split(/\r?\n+/g)
+ : stackValue.split(/\r?\n+/g);
- if (argsLen === 0) {
- return '';
- }
+ // starting in Node 7, the stack builder caches the message.
+ // just replace it.
+ stack[0] = this.name + ': ' + this.message;
- if (argsLen > 1) {
- // Don't slice `arguments`, it prevents V8 optimizations
- for (let a = 1; a < argsLen; a++) {
- str += ' ' + args[a];
- }
- }
+ var lineCount = 1;
+ for (var key in properties) {
+ if (!properties.hasOwnProperty(key)) {
+ continue;
+ }
- if (!this.enabled || this.level <= 0 || !str) {
- return this._empty ? '' : str;
- }
+ var modifier = properties[key];
- // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
- // see https://github.com/chalk/chalk/issues/58
- // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
- const originalDim = ansiStyles.dim.open;
- if (isSimpleWindowsTerm && this.hasGrey) {
- ansiStyles.dim.open = '';
- }
+ if ('line' in modifier) {
+ var line = modifier.line(this[key]);
+ if (line) {
+ stack.splice(lineCount++, 0, ' ' + line);
+ }
+ }
- for (const code of this._styles.slice().reverse()) {
- // Replace any instances already present with a re-opening code
- // otherwise only the part of the string until said closing code
- // will be colored, and the rest will simply be 'plain'.
- str = code.open + str.replace(code.closeRe, code.open) + code.close;
+ if ('stack' in modifier) {
+ modifier.stack(this[key], stack);
+ }
+ }
- // Close the styling before a linebreak and reopen
- // after next line to fix a bleed issue on macOS
- // https://github.com/chalk/chalk/pull/92
- str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+ return stack.join('\n');
+ };
+
+ Object.defineProperty(this, 'stack', stackDescriptor);
+ };
+
+ if (Object.setPrototypeOf) {
+ Object.setPrototypeOf(errorExError.prototype, Error.prototype);
+ Object.setPrototypeOf(errorExError, Error);
+ } else {
+ util.inherits(errorExError, Error);
}
- // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
- ansiStyles.dim.open = originalDim;
+ return errorExError;
+};
- return str;
-}
+errorEx.append = function (str, def) {
+ return {
+ message: function (v, message) {
+ v = v || def;
-function chalkTag(chalk, strings) {
- if (!Array.isArray(strings)) {
- // If chalk() was called by itself or with a string,
- // return the string itself as a string.
- return [].slice.call(arguments, 1).join(' ');
- }
+ if (v) {
+ message[0] += ' ' + str.replace('%s', v.toString());
+ }
- const args = [].slice.call(arguments, 2);
- const parts = [strings.raw[0]];
+ return message;
+ }
+ };
+};
- for (let i = 1; i < strings.length; i++) {
- parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
- parts.push(String(strings.raw[i]));
- }
+errorEx.line = function (str, def) {
+ return {
+ line: function (v) {
+ v = v || def;
- return template(chalk, parts.join(''));
-}
+ if (v) {
+ return str.replace('%s', v.toString());
+ }
-Object.defineProperties(Chalk.prototype, styles);
+ return null;
+ }
+ };
+};
-module.exports = Chalk(); // eslint-disable-line new-cap
-module.exports.supportsColor = stdoutColor;
-module.exports.default = module.exports; // For TypeScript
+module.exports = errorEx;
/***/ }),
-/* 440 */
+/* 417 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-/* WEBPACK VAR INJECTION */(function(module) {
-const colorConvert = __webpack_require__(6);
-const wrapAnsi16 = (fn, offset) => function () {
- const code = fn.apply(colorConvert, arguments);
- return `\u001B[${code + offset}m`;
-};
-const wrapAnsi256 = (fn, offset) => function () {
- const code = fn.apply(colorConvert, arguments);
- return `\u001B[${38 + offset};5;${code}m`;
-};
+module.exports = function isArrayish(obj) {
+ if (!obj) {
+ return false;
+ }
-const wrapAnsi16m = (fn, offset) => function () {
- const rgb = fn.apply(colorConvert, arguments);
- return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+ return obj instanceof Array || Array.isArray(obj) ||
+ (obj.length >= 0 && obj.splice instanceof Function);
};
-function assembleStyles() {
- const codes = new Map();
- const styles = {
- modifier: {
- reset: [0, 0],
- // 21 isn't widely supported and 22 does the same thing
- bold: [1, 22],
- dim: [2, 22],
- italic: [3, 23],
- underline: [4, 24],
- inverse: [7, 27],
- hidden: [8, 28],
- strikethrough: [9, 29]
- },
- color: {
- black: [30, 39],
- red: [31, 39],
- green: [32, 39],
- yellow: [33, 39],
- blue: [34, 39],
- magenta: [35, 39],
- cyan: [36, 39],
- white: [37, 39],
- gray: [90, 39],
-
- // Bright color
- redBright: [91, 39],
- greenBright: [92, 39],
- yellowBright: [93, 39],
- blueBright: [94, 39],
- magentaBright: [95, 39],
- cyanBright: [96, 39],
- whiteBright: [97, 39]
- },
- bgColor: {
- bgBlack: [40, 49],
- bgRed: [41, 49],
- bgGreen: [42, 49],
- bgYellow: [43, 49],
- bgBlue: [44, 49],
- bgMagenta: [45, 49],
- bgCyan: [46, 49],
- bgWhite: [47, 49],
- // Bright color
- bgBlackBright: [100, 49],
- bgRedBright: [101, 49],
- bgGreenBright: [102, 49],
- bgYellowBright: [103, 49],
- bgBlueBright: [104, 49],
- bgMagentaBright: [105, 49],
- bgCyanBright: [106, 49],
- bgWhiteBright: [107, 49]
- }
- };
+/***/ }),
+/* 418 */
+/***/ (function(module, exports, __webpack_require__) {
- // Fix humans
- styles.color.grey = styles.color.gray;
+"use strict";
- for (const groupName of Object.keys(styles)) {
- const group = styles[groupName];
- for (const styleName of Object.keys(group)) {
- const style = group[styleName];
+module.exports = parseJson
+function parseJson (txt, reviver, context) {
+ context = context || 20
+ try {
+ return JSON.parse(txt, reviver)
+ } catch (e) {
+ const syntaxErr = e.message.match(/^Unexpected token.*position\s+(\d+)/i)
+ const errIdx = syntaxErr
+ ? +syntaxErr[1]
+ : e.message.match(/^Unexpected end of JSON.*/i)
+ ? txt.length - 1
+ : null
+ if (errIdx != null) {
+ const start = errIdx <= context
+ ? 0
+ : errIdx - context
+ const end = errIdx + context >= txt.length
+ ? txt.length
+ : errIdx + context
+ e.message += ` while parsing near '${
+ start === 0 ? '' : '...'
+ }${txt.slice(start, end)}${
+ end === txt.length ? '' : '...'
+ }'`
+ } else {
+ e.message += ` while parsing '${txt.slice(0, context * 2)}'`
+ }
+ throw e
+ }
+}
- styles[styleName] = {
- open: `\u001B[${style[0]}m`,
- close: `\u001B[${style[1]}m`
- };
- group[styleName] = styles[styleName];
+/***/ }),
+/* 419 */
+/***/ (function(__webpack_module__, __webpack_exports__, __webpack_require__) {
- codes.set(style[0], style[1]);
- }
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+var LF = '\n';
+var CR = '\r';
+var LinesAndColumns = (function () {
+ function LinesAndColumns(string) {
+ this.string = string;
+ var offsets = [0];
+ for (var offset = 0; offset < string.length;) {
+ switch (string[offset]) {
+ case LF:
+ offset += LF.length;
+ offsets.push(offset);
+ break;
+ case CR:
+ offset += CR.length;
+ if (string[offset] === LF) {
+ offset += LF.length;
+ }
+ offsets.push(offset);
+ break;
+ default:
+ offset++;
+ break;
+ }
+ }
+ this.offsets = offsets;
+ }
+ LinesAndColumns.prototype.locationForIndex = function (index) {
+ if (index < 0 || index > this.string.length) {
+ return null;
+ }
+ var line = 0;
+ var offsets = this.offsets;
+ while (offsets[line + 1] <= index) {
+ line++;
+ }
+ var column = index - offsets[line];
+ return { line: line, column: column };
+ };
+ LinesAndColumns.prototype.indexForLocation = function (location) {
+ var line = location.line, column = location.column;
+ if (line < 0 || line >= this.offsets.length) {
+ return null;
+ }
+ if (column < 0 || column > this.lengthOfLine(line)) {
+ return null;
+ }
+ return this.offsets[line] + column;
+ };
+ LinesAndColumns.prototype.lengthOfLine = function (line) {
+ var offset = this.offsets[line];
+ var nextOffset = line === this.offsets.length - 1 ? this.string.length : this.offsets[line + 1];
+ return nextOffset - offset;
+ };
+ return LinesAndColumns;
+}());
+/* harmony default export */ __webpack_exports__["default"] = (LinesAndColumns);
- Object.defineProperty(styles, groupName, {
- value: group,
- enumerable: false
- });
- Object.defineProperty(styles, 'codes', {
- value: codes,
- enumerable: false
- });
- }
+/***/ }),
+/* 420 */
+/***/ (function(module, exports, __webpack_require__) {
- const ansi2ansi = n => n;
- const rgb2rgb = (r, g, b) => [r, g, b];
+"use strict";
- styles.color.close = '\u001B[39m';
- styles.bgColor.close = '\u001B[49m';
- styles.color.ansi = {
- ansi: wrapAnsi16(ansi2ansi, 0)
- };
- styles.color.ansi256 = {
- ansi256: wrapAnsi256(ansi2ansi, 0)
- };
- styles.color.ansi16m = {
- rgb: wrapAnsi16m(rgb2rgb, 0)
- };
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.codeFrameColumns = codeFrameColumns;
+exports.default = _default;
- styles.bgColor.ansi = {
- ansi: wrapAnsi16(ansi2ansi, 10)
- };
- styles.bgColor.ansi256 = {
- ansi256: wrapAnsi256(ansi2ansi, 10)
- };
- styles.bgColor.ansi16m = {
- rgb: wrapAnsi16m(rgb2rgb, 10)
- };
+var _highlight = _interopRequireWildcard(__webpack_require__(421));
- for (let key of Object.keys(colorConvert)) {
- if (typeof colorConvert[key] !== 'object') {
- continue;
- }
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
- const suite = colorConvert[key];
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
- if (key === 'ansi16') {
- key = 'ansi';
- }
+let deprecationWarningShown = false;
- if ('ansi16' in suite) {
- styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
- styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
- }
+function getDefs(chalk) {
+ return {
+ gutter: chalk.grey,
+ marker: chalk.red.bold,
+ message: chalk.red.bold
+ };
+}
- if ('ansi256' in suite) {
- styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
- styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
- }
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
- if ('rgb' in suite) {
- styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
- styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
- }
- }
+function getMarkerLines(loc, source, opts) {
+ const startLoc = Object.assign({
+ column: 0,
+ line: -1
+ }, loc.start);
+ const endLoc = Object.assign({}, startLoc, {}, loc.end);
+ const {
+ linesAbove = 2,
+ linesBelow = 3
+ } = opts || {};
+ const startLine = startLoc.line;
+ const startColumn = startLoc.column;
+ const endLine = endLoc.line;
+ const endColumn = endLoc.column;
+ let start = Math.max(startLine - (linesAbove + 1), 0);
+ let end = Math.min(source.length, endLine + linesBelow);
- return styles;
-}
+ if (startLine === -1) {
+ start = 0;
+ }
-// Make the export immutable
-Object.defineProperty(module, 'exports', {
- enumerable: true,
- get: assembleStyles
-});
+ if (endLine === -1) {
+ end = source.length;
+ }
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(5)(module)))
+ const lineDiff = endLine - startLine;
+ const markerLines = {};
-/***/ }),
-/* 441 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (lineDiff) {
+ for (let i = 0; i <= lineDiff; i++) {
+ const lineNumber = i + startLine;
-"use strict";
+ if (!startColumn) {
+ markerLines[lineNumber] = true;
+ } else if (i === 0) {
+ const sourceLength = source[lineNumber - 1].length;
+ markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+ } else if (i === lineDiff) {
+ markerLines[lineNumber] = [0, endColumn];
+ } else {
+ const sourceLength = source[lineNumber - i].length;
+ markerLines[lineNumber] = [0, sourceLength];
+ }
+ }
+ } else {
+ if (startColumn === endColumn) {
+ if (startColumn) {
+ markerLines[startLine] = [startColumn, 0];
+ } else {
+ markerLines[startLine] = true;
+ }
+ } else {
+ markerLines[startLine] = [startColumn, endColumn - startColumn];
+ }
+ }
-const os = __webpack_require__(11);
-const hasFlag = __webpack_require__(12);
+ return {
+ start,
+ end,
+ markerLines
+ };
+}
-const env = process.env;
+function codeFrameColumns(rawLines, loc, opts = {}) {
+ const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
+ const chalk = (0, _highlight.getChalk)(opts);
+ const defs = getDefs(chalk);
-let forceColor;
-if (hasFlag('no-color') ||
- hasFlag('no-colors') ||
- hasFlag('color=false')) {
- forceColor = false;
-} else if (hasFlag('color') ||
- hasFlag('colors') ||
- hasFlag('color=true') ||
- hasFlag('color=always')) {
- forceColor = true;
-}
-if ('FORCE_COLOR' in env) {
- forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
-}
+ const maybeHighlight = (chalkFn, string) => {
+ return highlighted ? chalkFn(string) : string;
+ };
-function translateLevel(level) {
- if (level === 0) {
- return false;
- }
+ const lines = rawLines.split(NEWLINE);
+ const {
+ start,
+ end,
+ markerLines
+ } = getMarkerLines(loc, lines, opts);
+ const hasColumns = loc.start && typeof loc.start.column === "number";
+ const numberMaxWidth = String(end).length;
+ const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
+ let frame = highlightedLines.split(NEWLINE).slice(start, end).map((line, index) => {
+ const number = start + 1 + index;
+ const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+ const gutter = ` ${paddedNumber} | `;
+ const hasMarker = markerLines[number];
+ const lastMarkerLine = !markerLines[number + 1];
- return {
- level,
- hasBasic: true,
- has256: level >= 2,
- has16m: level >= 3
- };
-}
+ if (hasMarker) {
+ let markerLine = "";
-function supportsColor(stream) {
- if (forceColor === false) {
- return 0;
- }
+ if (Array.isArray(hasMarker)) {
+ const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+ const numberOfMarkers = hasMarker[1] || 1;
+ markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
- if (hasFlag('color=16m') ||
- hasFlag('color=full') ||
- hasFlag('color=truecolor')) {
- return 3;
- }
+ if (lastMarkerLine && opts.message) {
+ markerLine += " " + maybeHighlight(defs.message, opts.message);
+ }
+ }
- if (hasFlag('color=256')) {
- return 2;
- }
+ return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line, markerLine].join("");
+ } else {
+ return ` ${maybeHighlight(defs.gutter, gutter)}${line}`;
+ }
+ }).join("\n");
- if (stream && !stream.isTTY && forceColor !== true) {
- // VS code debugger doesn't have isTTY set
- if (env.VSCODE_PID) {
- return 1;
- }
- return 0;
- }
+ if (opts.message && !hasColumns) {
+ frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+ }
- const min = forceColor ? 1 : 0;
+ if (highlighted) {
+ return chalk.reset(frame);
+ } else {
+ return frame;
+ }
+}
- if (process.platform === 'win32') {
- // Node.js 7.5.0 is the first version of Node.js to include a patch to
- // libuv that enables 256 color output on Windows. Anything earlier and it
- // won't work. However, here we target Node.js 8 at minimum as it is an LTS
- // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
- // release that supports 256 colors. Windows 10 build 14931 is the first release
- // that supports 16m/TrueColor.
- const osRelease = os.release().split('.');
- if (
- Number(process.versions.node.split('.')[0]) >= 8 &&
- Number(osRelease[0]) >= 10 &&
- Number(osRelease[2]) >= 10586
- ) {
- return Number(osRelease[2]) >= 14931 ? 3 : 2;
- }
+function _default(rawLines, lineNumber, colNumber, opts = {}) {
+ if (!deprecationWarningShown) {
+ deprecationWarningShown = true;
+ const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
- return 1;
- }
+ if (process.emitWarning) {
+ process.emitWarning(message, "DeprecationWarning");
+ } else {
+ const deprecationError = new Error(message);
+ deprecationError.name = "DeprecationWarning";
+ console.warn(new Error(message));
+ }
+ }
- if ('CI' in env) {
- if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
- return 1;
- }
+ colNumber = Math.max(colNumber, 0);
+ const location = {
+ start: {
+ column: colNumber,
+ line: lineNumber
+ }
+ };
+ return codeFrameColumns(rawLines, location, opts);
+}
- return min;
- }
+/***/ }),
+/* 421 */
+/***/ (function(module, exports, __webpack_require__) {
- if ('TEAMCITY_VERSION' in env) {
- return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
- }
+"use strict";
- if (env.COLORTERM === 'truecolor') {
- return 3;
- }
- if ('TERM_PROGRAM' in env) {
- const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.shouldHighlight = shouldHighlight;
+exports.getChalk = getChalk;
+exports.default = highlight;
- switch (env.TERM_PROGRAM) {
- case 'iTerm.app':
- return version >= 3 ? 3 : 2;
- case 'Apple_Terminal':
- return 2;
- // No default
- }
- }
+var _jsTokens = _interopRequireWildcard(__webpack_require__(422));
- if (/-256(color)?$/i.test(env.TERM)) {
- return 2;
- }
+var _helperValidatorIdentifier = __webpack_require__(423);
- if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
- return 1;
- }
+var _chalk = _interopRequireDefault(__webpack_require__(426));
- if ('COLORTERM' in env) {
- return 1;
- }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
- if (env.TERM === 'dumb') {
- return min;
- }
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
- return min;
-}
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-function getSupportLevel(stream) {
- const level = supportsColor(stream);
- return translateLevel(level);
+function getDefs(chalk) {
+ return {
+ keyword: chalk.cyan,
+ capitalized: chalk.yellow,
+ jsx_tag: chalk.yellow,
+ punctuator: chalk.yellow,
+ number: chalk.magenta,
+ string: chalk.green,
+ regex: chalk.magenta,
+ comment: chalk.grey,
+ invalid: chalk.white.bgRed.bold
+ };
}
-module.exports = {
- supportsColor: getSupportLevel,
- stdout: getSupportLevel(process.stdout),
- stderr: getSupportLevel(process.stderr)
-};
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+const JSX_TAG = /^[a-z][\w-]*$/i;
+const BRACKET = /^[()[\]{}]$/;
+function getTokenType(match) {
+ const [offset, text] = match.slice(-2);
+ const token = (0, _jsTokens.matchToToken)(match);
-/***/ }),
-/* 442 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (token.type === "name") {
+ if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isReservedWord)(token.value)) {
+ return "keyword";
+ }
-"use strict";
+ if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.substr(offset - 2, 2) == " escape ? unescape(escape) : chr));
- } else {
- throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
- }
- }
+function highlightTokens(defs, text) {
+ return text.replace(_jsTokens.default, function (...args) {
+ const type = getTokenType(args);
+ const colorize = defs[type];
- return results;
+ if (colorize) {
+ return args[0].split(NEWLINE).map(str => colorize(str)).join("\n");
+ } else {
+ return args[0];
+ }
+ });
}
-function parseStyle(style) {
- STYLE_REGEX.lastIndex = 0;
+function shouldHighlight(options) {
+ return _chalk.default.supportsColor || options.forceColor;
+}
- const results = [];
- let matches;
+function getChalk(options) {
+ let chalk = _chalk.default;
- while ((matches = STYLE_REGEX.exec(style)) !== null) {
- const name = matches[1];
+ if (options.forceColor) {
+ chalk = new _chalk.default.constructor({
+ enabled: true,
+ level: 1
+ });
+ }
- if (matches[2]) {
- const args = parseArguments(name, matches[2]);
- results.push([name].concat(args));
- } else {
- results.push([name]);
- }
- }
+ return chalk;
+}
- return results;
+function highlight(code, options = {}) {
+ if (shouldHighlight(options)) {
+ const chalk = getChalk(options);
+ const defs = getDefs(chalk);
+ return highlightTokens(defs, code);
+ } else {
+ return code;
+ }
}
-function buildStyle(chalk, styles) {
- const enabled = {};
+/***/ }),
+/* 422 */
+/***/ (function(module, exports) {
- for (const layer of styles) {
- for (const style of layer.styles) {
- enabled[style[0]] = layer.inverse ? null : style.slice(1);
- }
- }
+// Copyright 2014, 2015, 2016, 2017, 2018 Simon Lydell
+// License: MIT. (See LICENSE.)
- let current = chalk;
- for (const styleName of Object.keys(enabled)) {
- if (Array.isArray(enabled[styleName])) {
- if (!(styleName in current)) {
- throw new Error(`Unknown Chalk style: ${styleName}`);
- }
+Object.defineProperty(exports, "__esModule", {
+ value: true
+})
- if (enabled[styleName].length > 0) {
- current = current[styleName].apply(current, enabled[styleName]);
- } else {
- current = current[styleName];
- }
- }
- }
+// This regex comes from regex.coffee, and is inserted here by generate-index.js
+// (run `npm run build`).
+exports.default = /((['"])(?:(?!\2|\\).|\\(?:\r\n|[\s\S]))*(\2)?|`(?:[^`\\$]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{[^}]*\}?)*\}?)*(`)?)|(\/\/.*)|(\/\*(?:[^*]|\*(?!\/))*(\*\/)?)|(\/(?!\*)(?:\[(?:(?![\]\\]).|\\.)*\]|(?![\/\]\\]).|\\.)+\/(?:(?!\s*(?:\b|[\u0080-\uFFFF$\\'"~({]|[+\-!](?!=)|\.?\d))|[gmiyus]{1,6}\b(?![\u0080-\uFFFF$\\]|\s*(?:[+\-*%&|^<>!=?({]|\/(?![\/*])))))|(0[xX][\da-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d*\.\d+|\d+\.?)(?:[eE][+-]?\d+)?)|((?!\d)(?:(?!\s)[$\w\u0080-\uFFFF]|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+)|(--|\+\+|&&|\|\||=>|\.{3}|(?:[+\-\/%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2})=?|[?~.,:;[\](){}])|(\s+)|(^$|[\s\S])/g
- return current;
+exports.matchToToken = function(match) {
+ var token = {type: "invalid", value: match[0], closed: undefined}
+ if (match[ 1]) token.type = "string" , token.closed = !!(match[3] || match[4])
+ else if (match[ 5]) token.type = "comment"
+ else if (match[ 6]) token.type = "comment", token.closed = !!match[7]
+ else if (match[ 8]) token.type = "regex"
+ else if (match[ 9]) token.type = "number"
+ else if (match[10]) token.type = "name"
+ else if (match[11]) token.type = "punctuator"
+ else if (match[12]) token.type = "whitespace"
+ return token
}
-module.exports = (chalk, tmp) => {
- const styles = [];
- const chunks = [];
- let chunk = [];
- // eslint-disable-next-line max-params
- tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
- if (escapeChar) {
- chunk.push(unescape(escapeChar));
- } else if (style) {
- const str = chunk.join('');
- chunk = [];
- chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
- styles.push({inverse, styles: parseStyle(style)});
- } else if (close) {
- if (styles.length === 0) {
- throw new Error('Found extraneous } in Chalk template literal');
- }
+/***/ }),
+/* 423 */
+/***/ (function(module, exports, __webpack_require__) {
- chunks.push(buildStyle(chalk, styles)(chunk.join('')));
- chunk = [];
- styles.pop();
- } else {
- chunk.push(chr);
- }
- });
+"use strict";
- chunks.push(chunk.join(''));
- if (styles.length > 0) {
- const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
- throw new Error(errMsg);
- }
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+Object.defineProperty(exports, "isIdentifierName", {
+ enumerable: true,
+ get: function () {
+ return _identifier.isIdentifierName;
+ }
+});
+Object.defineProperty(exports, "isIdentifierChar", {
+ enumerable: true,
+ get: function () {
+ return _identifier.isIdentifierChar;
+ }
+});
+Object.defineProperty(exports, "isIdentifierStart", {
+ enumerable: true,
+ get: function () {
+ return _identifier.isIdentifierStart;
+ }
+});
+Object.defineProperty(exports, "isReservedWord", {
+ enumerable: true,
+ get: function () {
+ return _keyword.isReservedWord;
+ }
+});
+Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+ enumerable: true,
+ get: function () {
+ return _keyword.isStrictBindOnlyReservedWord;
+ }
+});
+Object.defineProperty(exports, "isStrictBindReservedWord", {
+ enumerable: true,
+ get: function () {
+ return _keyword.isStrictBindReservedWord;
+ }
+});
+Object.defineProperty(exports, "isStrictReservedWord", {
+ enumerable: true,
+ get: function () {
+ return _keyword.isStrictReservedWord;
+ }
+});
+Object.defineProperty(exports, "isKeyword", {
+ enumerable: true,
+ get: function () {
+ return _keyword.isKeyword;
+ }
+});
- return chunks.join('');
-};
+var _identifier = __webpack_require__(424);
+var _keyword = __webpack_require__(425);
/***/ }),
-/* 443 */
+/* 424 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __webpack_require__(16);
-exports.CA_CERT_PATH = path_1.resolve(__dirname, '../certs/ca.crt');
-exports.ES_KEY_PATH = path_1.resolve(__dirname, '../certs/elasticsearch.key');
-exports.ES_CERT_PATH = path_1.resolve(__dirname, '../certs/elasticsearch.crt');
-exports.ES_P12_PATH = path_1.resolve(__dirname, '../certs/elasticsearch.p12');
-exports.ES_P12_PASSWORD = 'storepass';
-exports.ES_EMPTYPASSWORD_P12_PATH = path_1.resolve(__dirname, '../certs/elasticsearch_emptypassword.p12');
-exports.ES_NOPASSWORD_P12_PATH = path_1.resolve(__dirname, '../certs/elasticsearch_nopassword.p12');
-exports.KBN_KEY_PATH = path_1.resolve(__dirname, '../certs/kibana.key');
-exports.KBN_CERT_PATH = path_1.resolve(__dirname, '../certs/kibana.crt');
-exports.KBN_P12_PATH = path_1.resolve(__dirname, '../certs/kibana.p12');
-exports.KBN_P12_PASSWORD = 'storepass';
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.isIdentifierStart = isIdentifierStart;
+exports.isIdentifierChar = isIdentifierChar;
+exports.isIdentifierName = isIdentifierName;
+let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u08a0-\u08b4\u08b6-\u08c7\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\u9ffc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7bf\ua7c2-\ua7ca\ua7f5-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08d3-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf\u1ac0\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1df9\u1dfb-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
+const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 107, 20, 28, 22, 13, 52, 76, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 230, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 35, 56, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8952, 286, 50, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 2357, 44, 11, 6, 17, 0, 370, 43, 1301, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42717, 35, 4148, 12, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];
+const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 176, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 135, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 419, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
-/***/ }),
-/* 444 */
-/***/ (function(module, exports, __webpack_require__) {
+function isInAstralSet(code, set) {
+ let pos = 0x10000;
-"use strict";
+ for (let i = 0, length = set.length; i < length; i += 2) {
+ pos += set[i];
+ if (pos > code) return false;
+ pos += set[i + 1];
+ if (pos >= code) return true;
+ }
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-var run_1 = __webpack_require__(445);
-exports.run = run_1.run;
-var fail_1 = __webpack_require__(446);
-exports.createFailError = fail_1.createFailError;
-exports.createFlagError = fail_1.createFlagError;
-exports.combineErrors = fail_1.combineErrors;
-exports.isFailError = fail_1.isFailError;
+ return false;
+}
+function isIdentifierStart(code) {
+ if (code < 65) return code === 36;
+ if (code <= 90) return true;
+ if (code < 97) return code === 95;
+ if (code <= 122) return true;
-/***/ }),
-/* 445 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (code <= 0xffff) {
+ return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+ }
-"use strict";
+ return isInAstralSet(code, astralIdentifierStartCodes);
+}
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const util_1 = __webpack_require__(29);
-// @ts-ignore @types are outdated and module is super simple
-const exit_hook_1 = tslib_1.__importDefault(__webpack_require__(368));
-const tooling_log_1 = __webpack_require__(414);
-const fail_1 = __webpack_require__(446);
-const flags_1 = __webpack_require__(447);
-const proc_runner_1 = __webpack_require__(37);
-async function run(fn, options = {}) {
- var _a;
- const flags = flags_1.getFlags(process.argv.slice(2), options);
- if (flags.help) {
- process.stderr.write(flags_1.getHelp(options));
- process.exit(1);
- }
- const log = new tooling_log_1.ToolingLog({
- level: tooling_log_1.pickLevelFromFlags(flags),
- writeTo: process.stdout,
- });
- process.on('unhandledRejection', (error) => {
- log.error('UNHANDLED PROMISE REJECTION');
- log.error(error instanceof Error
- ? error
- : new Error(`non-Error type rejection value: ${util_1.inspect(error)}`));
- process.exit(1);
- });
- const handleErrorWithoutExit = (error) => {
- if (fail_1.isFailError(error)) {
- log.error(error.message);
- if (error.showHelp) {
- log.write(flags_1.getHelp(options));
- }
- process.exitCode = error.exitCode;
- }
- else {
- log.error('UNHANDLED ERROR');
- log.error(error);
- process.exitCode = 1;
- }
- };
- const doCleanup = () => {
- const tasks = cleanupTasks.slice(0);
- cleanupTasks.length = 0;
- for (const task of tasks) {
- try {
- task();
- }
- catch (error) {
- handleErrorWithoutExit(error);
- }
- }
- };
- const unhookExit = exit_hook_1.default(doCleanup);
- const cleanupTasks = [unhookExit];
- try {
- if (!((_a = options.flags) === null || _a === void 0 ? void 0 : _a.allowUnexpected) && flags.unexpected.length) {
- throw fail_1.createFlagError(`Unknown flag(s) "${flags.unexpected.join('", "')}"`);
- }
- try {
- await proc_runner_1.withProcRunner(log, async (procRunner) => {
- await fn({
- log,
- flags,
- procRunner,
- addCleanupTask: (task) => cleanupTasks.push(task),
- });
- });
- }
- finally {
- doCleanup();
- }
- }
- catch (error) {
- handleErrorWithoutExit(error);
- process.exit();
- }
+function isIdentifierChar(code) {
+ if (code < 48) return code === 36;
+ if (code < 58) return true;
+ if (code < 65) return false;
+ if (code <= 90) return true;
+ if (code < 97) return code === 95;
+ if (code <= 122) return true;
+
+ if (code <= 0xffff) {
+ return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+ }
+
+ return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
}
-exports.run = run;
+function isIdentifierName(name) {
+ let isFirst = true;
-/***/ }),
-/* 446 */
-/***/ (function(module, exports, __webpack_require__) {
+ for (let _i = 0, _Array$from = Array.from(name); _i < _Array$from.length; _i++) {
+ const char = _Array$from[_i];
+ const cp = char.codePointAt(0);
-"use strict";
+ if (isFirst) {
+ if (!isIdentifierStart(cp)) {
+ return false;
+ }
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const util_1 = __webpack_require__(29);
-const FAIL_TAG = Symbol('fail error');
-function createFailError(reason, options = {}) {
- const { exitCode = 1, showHelp = false } = options;
- return Object.assign(new Error(reason), {
- exitCode,
- showHelp,
- [FAIL_TAG]: true,
- });
-}
-exports.createFailError = createFailError;
-function createFlagError(reason) {
- return createFailError(reason, {
- showHelp: true,
- });
-}
-exports.createFlagError = createFlagError;
-function isFailError(error) {
- return Boolean(error && error[FAIL_TAG]);
-}
-exports.isFailError = isFailError;
-function combineErrors(errors) {
- if (errors.length === 1) {
- return errors[0];
+ isFirst = false;
+ } else if (!isIdentifierChar(cp)) {
+ return false;
}
- const exitCode = errors
- .filter(isFailError)
- .reduce((acc, error) => Math.max(acc, error.exitCode), 1);
- const showHelp = errors.some((error) => isFailError(error) && error.showHelp);
- const message = errors.reduce((acc, error) => {
- if (isFailError(error)) {
- return acc + '\n' + error.message;
- }
- return acc + `\nUNHANDLED ERROR\n${util_1.inspect(error)}`;
- }, '');
- return createFailError(`${errors.length} errors:\n${message}`, {
- exitCode,
- showHelp,
- });
-}
-exports.combineErrors = combineErrors;
+ }
+ return true;
+}
/***/ }),
-/* 447 */
+/* 425 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const path_1 = __webpack_require__(16);
-const dedent_1 = tslib_1.__importDefault(__webpack_require__(14));
-const getopts_1 = tslib_1.__importDefault(__webpack_require__(448));
-function getFlags(argv, options) {
- const unexpectedNames = new Set();
- const flagOpts = options.flags || {};
- const { verbose, quiet, silent, debug, help, _, ...others } = getopts_1.default(argv, {
- string: flagOpts.string,
- boolean: [...(flagOpts.boolean || []), 'verbose', 'quiet', 'silent', 'debug', 'help'],
- alias: {
- ...(flagOpts.alias || {}),
- v: 'verbose',
- },
- default: flagOpts.default,
- unknown: (name) => {
- unexpectedNames.add(name);
- return flagOpts.guessTypesForUnexpectedFlags;
- },
- });
- const unexpected = [];
- for (const unexpectedName of unexpectedNames) {
- const matchingArgv = [];
- iterArgv: for (const [i, v] of argv.entries()) {
- for (const prefix of ['--', '-']) {
- if (v.startsWith(prefix)) {
- // -/--name=value
- if (v.startsWith(`${prefix}${unexpectedName}=`)) {
- matchingArgv.push(v);
- continue iterArgv;
- }
- // -/--name (value possibly follows)
- if (v === `${prefix}${unexpectedName}`) {
- matchingArgv.push(v);
- // value follows -/--name
- if (argv.length > i + 1 && !argv[i + 1].startsWith('-')) {
- matchingArgv.push(argv[i + 1]);
- }
- continue iterArgv;
- }
- }
- }
- // special case for `--no-{flag}` disabling of boolean flags
- if (v === `--no-${unexpectedName}`) {
- matchingArgv.push(v);
- continue iterArgv;
- }
- // special case for shortcut flags formatted as `-abc` where `a`, `b`,
- // and `c` will be three separate unexpected flags
- if (unexpectedName.length === 1 &&
- v[0] === '-' &&
- v[1] !== '-' &&
- !v.includes('=') &&
- v.includes(unexpectedName)) {
- matchingArgv.push(`-${unexpectedName}`);
- continue iterArgv;
- }
- }
- if (matchingArgv.length) {
- unexpected.push(...matchingArgv);
- }
- else {
- throw new Error(`unable to find unexpected flag named "${unexpectedName}"`);
- }
- }
- return {
- verbose,
- quiet,
- silent,
- debug,
- help,
- _,
- unexpected,
- ...others,
- };
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.isReservedWord = isReservedWord;
+exports.isStrictReservedWord = isStrictReservedWord;
+exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+exports.isStrictBindReservedWord = isStrictBindReservedWord;
+exports.isKeyword = isKeyword;
+const reservedWords = {
+ keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+ strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+ strictBind: ["eval", "arguments"]
+};
+const keywords = new Set(reservedWords.keyword);
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+
+function isReservedWord(word, inModule) {
+ return inModule && word === "await" || word === "enum";
}
-exports.getFlags = getFlags;
-function getHelp(options) {
- var _a, _b;
- const usage = options.usage || `node ${path_1.relative(process.cwd(), process.argv[1])}`;
- const optionHelp = (dedent_1.default(((_b = (_a = options) === null || _a === void 0 ? void 0 : _a.flags) === null || _b === void 0 ? void 0 : _b.help) || '') +
- '\n' +
- dedent_1.default `
- --verbose, -v Log verbosely
- --debug Log debug messages (less than verbose)
- --quiet Only log errors
- --silent Don't log anything
- --help Show this message
- `)
- .split('\n')
- .filter(Boolean)
- .join('\n ');
- return `
- ${usage}
- ${dedent_1.default(options.description || 'Runs a dev task')
- .split('\n')
- .join('\n ')}
+function isStrictReservedWord(word, inModule) {
+ return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+}
- Options:
- ${optionHelp + '\n\n'}`;
+function isStrictBindOnlyReservedWord(word) {
+ return reservedWordsStrictBindSet.has(word);
+}
+
+function isStrictBindReservedWord(word, inModule) {
+ return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
}
-exports.getHelp = getHelp;
+function isKeyword(word) {
+ return keywords.has(word);
+}
/***/ }),
-/* 448 */
+/* 426 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+const escapeStringRegexp = __webpack_require__(387);
+const ansiStyles = __webpack_require__(427);
+const stdoutColor = __webpack_require__(428).stdout;
-const EMPTYARR = []
-const SHORTSPLIT = /$|[!-@[-`{-~][\s\S]*/g
-const isArray = Array.isArray
+const template = __webpack_require__(429);
-const parseValue = function(any) {
- if (any === "") return ""
- if (any === "false") return false
- const maybe = Number(any)
- return maybe * 0 === 0 ? maybe : any
-}
+const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
-const parseAlias = function(aliases) {
- let out = {},
- key,
- alias,
- prev,
- len,
- any,
- i,
- k
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
- for (key in aliases) {
- any = aliases[key]
- alias = out[key] = isArray(any) ? any : [any]
+// `color-convert` models to exclude from the Chalk API due to conflicts and such
+const skipModels = new Set(['gray']);
- for (i = 0, len = alias.length; i < len; i++) {
- prev = out[alias[i]] = [key]
+const styles = Object.create(null);
- for (k = 0; k < len; k++) {
- if (i !== k) prev.push(alias[k])
- }
- }
- }
+function applyOptions(obj, options) {
+ options = options || {};
- return out
+ // Detect level if not set manually
+ const scLevel = stdoutColor ? stdoutColor.level : 0;
+ obj.level = options.level === undefined ? scLevel : options.level;
+ obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
}
-const parseDefault = function(aliases, defaults) {
- let out = {},
- key,
- alias,
- value,
- len,
- i
+function Chalk(options) {
+ // We check for this.template here since calling `chalk.constructor()`
+ // by itself will have a `this` of a previously constructed chalk object
+ if (!this || !(this instanceof Chalk) || this.template) {
+ const chalk = {};
+ applyOptions(chalk, options);
- for (key in defaults) {
- value = defaults[key]
- alias = aliases[key]
+ chalk.template = function () {
+ const args = [].slice.call(arguments);
+ return chalkTag.apply(null, [chalk.template].concat(args));
+ };
- out[key] = value
+ Object.setPrototypeOf(chalk, Chalk.prototype);
+ Object.setPrototypeOf(chalk.template, chalk);
- if (alias === undefined) {
- aliases[key] = EMPTYARR
- } else {
- for (i = 0, len = alias.length; i < len; i++) {
- out[alias[i]] = value
- }
- }
- }
+ chalk.template.constructor = Chalk;
- return out
+ return chalk.template;
+ }
+
+ applyOptions(this, options);
}
-const parseOptions = function(aliases, options, value) {
- let out = {},
- key,
- alias,
- len,
- end,
- i,
- k
+// Use bright blue on Windows as the normal blue color is illegible
+if (isSimpleWindowsTerm) {
+ ansiStyles.blue.open = '\u001B[94m';
+}
- if (options !== undefined) {
- for (i = 0, len = options.length; i < len; i++) {
- key = options[i]
- alias = aliases[key]
-
- out[key] = value
-
- if (alias === undefined) {
- aliases[key] = EMPTYARR
- } else {
- for (k = 0, end = alias.length; k < end; k++) {
- out[alias[k]] = value
- }
- }
- }
- }
+for (const key of Object.keys(ansiStyles)) {
+ ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
- return out
+ styles[key] = {
+ get() {
+ const codes = ansiStyles[key];
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+ }
+ };
}
-const write = function(out, key, value, aliases, unknown) {
- let i,
- prev,
- alias = aliases[key],
- len = alias === undefined ? -1 : alias.length
-
- if (len >= 0 || unknown === undefined || unknown(key)) {
- prev = out[key]
+styles.visible = {
+ get() {
+ return build.call(this, this._styles || [], true, 'visible');
+ }
+};
- if (prev === undefined) {
- out[key] = value
- } else {
- if (isArray(prev)) {
- prev.push(value)
- } else {
- out[key] = [prev, value]
- }
- }
+ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
+for (const model of Object.keys(ansiStyles.color.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
- for (i = 0; i < len; i++) {
- out[alias[i]] = out[key]
- }
- }
+ styles[model] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles.color.close,
+ closeRe: ansiStyles.color.closeRe
+ };
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
}
-const getopts = function(argv, opts) {
- let unknown = (opts = opts || {}).unknown,
- aliases = parseAlias(opts.alias),
- strings = parseOptions(aliases, opts.string, ""),
- values = parseDefault(aliases, opts.default),
- bools = parseOptions(aliases, opts.boolean, false),
- stopEarly = opts.stopEarly,
- _ = [],
- out = { _ },
- i = 0,
- k = 0,
- len = argv.length,
- key,
- arg,
- end,
- match,
- value
-
- for (; i < len; i++) {
- arg = argv[i]
-
- if (arg[0] !== "-" || arg === "-") {
- if (stopEarly) while (i < len) _.push(argv[i++])
- else _.push(arg)
- } else if (arg === "--") {
- while (++i < len) _.push(argv[i])
- } else if (arg[1] === "-") {
- end = arg.indexOf("=", 2)
- if (arg[2] === "n" && arg[3] === "o" && arg[4] === "-") {
- key = arg.slice(5, end >= 0 ? end : undefined)
- value = false
- } else if (end >= 0) {
- key = arg.slice(2, end)
- value =
- bools[key] !== undefined ||
- (strings[key] === undefined
- ? parseValue(arg.slice(end + 1))
- : arg.slice(end + 1))
- } else {
- key = arg.slice(2)
- value =
- bools[key] !== undefined ||
- (len === i + 1 || argv[i + 1][0] === "-"
- ? strings[key] === undefined
- ? true
- : ""
- : strings[key] === undefined
- ? parseValue(argv[++i])
- : argv[++i])
- }
- write(out, key, value, aliases, unknown)
- } else {
- SHORTSPLIT.lastIndex = 2
- match = SHORTSPLIT.exec(arg)
- end = match.index
- value = match[0]
-
- for (k = 1; k < end; k++) {
- write(
- out,
- (key = arg[k]),
- k + 1 < end
- ? strings[key] === undefined ||
- arg.substring(k + 1, (k = end)) + value
- : value === ""
- ? len === i + 1 || argv[i + 1][0] === "-"
- ? strings[key] === undefined || ""
- : bools[key] !== undefined ||
- (strings[key] === undefined ? parseValue(argv[++i]) : argv[++i])
- : bools[key] !== undefined ||
- (strings[key] === undefined ? parseValue(value) : value),
- aliases,
- unknown
- )
- }
- }
- }
-
- for (key in values) if (out[key] === undefined) out[key] = values[key]
- for (key in bools) if (out[key] === undefined) out[key] = false
- for (key in strings) if (out[key] === undefined) out[key] = ""
+ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
+for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
- return out
+ const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+ styles[bgModel] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles.bgColor.close,
+ closeRe: ansiStyles.bgColor.closeRe
+ };
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
}
-module.exports = getopts
-
-
-/***/ }),
-/* 449 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-var kbn_client_1 = __webpack_require__(450);
-exports.KbnClient = kbn_client_1.KbnClient;
-var kbn_client_requester_1 = __webpack_require__(451);
-exports.uriencode = kbn_client_requester_1.uriencode;
+const proto = Object.defineProperties(() => {}, styles);
+function build(_styles, _empty, key) {
+ const builder = function () {
+ return applyStyle.apply(builder, arguments);
+ };
-/***/ }),
-/* 450 */
-/***/ (function(module, exports, __webpack_require__) {
+ builder._styles = _styles;
+ builder._empty = _empty;
-"use strict";
+ const self = this;
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const kbn_client_requester_1 = __webpack_require__(451);
-const kbn_client_status_1 = __webpack_require__(494);
-const kbn_client_plugins_1 = __webpack_require__(495);
-const kbn_client_version_1 = __webpack_require__(496);
-const kbn_client_saved_objects_1 = __webpack_require__(497);
-const kbn_client_ui_settings_1 = __webpack_require__(498);
-class KbnClient {
- /**
- * Basic Kibana server client that implements common behaviors for talking
- * to the Kibana server from dev tooling.
- *
- * @param log ToolingLog
- * @param kibanaUrls Array of kibana server urls to send requests to
- * @param uiSettingDefaults Map of uiSetting values that will be merged with all uiSetting resets
- */
- constructor(log, kibanaUrls, uiSettingDefaults) {
- this.log = log;
- this.kibanaUrls = kibanaUrls;
- this.uiSettingDefaults = uiSettingDefaults;
- this.requester = new kbn_client_requester_1.KbnClientRequester(this.log, this.kibanaUrls);
- this.status = new kbn_client_status_1.KbnClientStatus(this.requester);
- this.plugins = new kbn_client_plugins_1.KbnClientPlugins(this.status);
- this.version = new kbn_client_version_1.KbnClientVersion(this.status);
- this.savedObjects = new kbn_client_saved_objects_1.KbnClientSavedObjects(this.log, this.requester);
- this.uiSettings = new kbn_client_ui_settings_1.KbnClientUiSettings(this.log, this.requester, this.uiSettingDefaults);
- if (!kibanaUrls.length) {
- throw new Error('missing Kibana urls');
- }
- }
- /**
- * Make a direct request to the Kibana server
- */
- async request(options) {
- return await this.requester.request(options);
- }
- resolveUrl(relativeUrl) {
- return this.requester.resolveUrl(relativeUrl);
- }
-}
-exports.KbnClient = KbnClient;
+ Object.defineProperty(builder, 'level', {
+ enumerable: true,
+ get() {
+ return self.level;
+ },
+ set(level) {
+ self.level = level;
+ }
+ });
+ Object.defineProperty(builder, 'enabled', {
+ enumerable: true,
+ get() {
+ return self.enabled;
+ },
+ set(enabled) {
+ self.enabled = enabled;
+ }
+ });
-/***/ }),
-/* 451 */
-/***/ (function(module, exports, __webpack_require__) {
+ // See below for fix regarding invisible grey/dim combination on Windows
+ builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
-"use strict";
+ // `__proto__` is used because we must return a function, but there is
+ // no way to create a function with a different prototype
+ builder.__proto__ = proto; // eslint-disable-line no-proto
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const url_1 = tslib_1.__importDefault(__webpack_require__(452));
-const axios_1 = tslib_1.__importDefault(__webpack_require__(453));
-const axios_2 = __webpack_require__(492);
-const isConcliftOnGetError = (error) => {
- return (axios_2.isAxiosResponseError(error) && error.config.method === 'GET' && error.response.status === 409);
-};
-exports.uriencode = (strings, ...values) => {
- const queue = strings.slice();
- if (queue.length === 0) {
- throw new Error('how could strings passed to `uriencode` template tag be empty?');
- }
- if (queue.length !== values.length + 1) {
- throw new Error('strings and values passed to `uriencode` template tag are unbalanced');
- }
- // pull the first string off the queue, there is one less item in `values`
- // since the values are always wrapped in strings, so we shift the extra string
- // off the queue to balance the queue and values array.
- const leadingString = queue.shift();
- return queue.reduce((acc, string, i) => `${acc}${encodeURIComponent(values[i])}${string}`, leadingString);
-};
-const DEFAULT_MAX_ATTEMPTS = 5;
-const delay = (ms) => new Promise((resolve) => {
- setTimeout(resolve, ms);
-});
-class KbnClientRequester {
- constructor(log, kibanaUrls) {
- this.log = log;
- this.kibanaUrls = kibanaUrls;
- }
- pickUrl() {
- const url = this.kibanaUrls.shift();
- this.kibanaUrls.push(url);
- return url;
- }
- resolveUrl(relativeUrl = '/') {
- return url_1.default.resolve(this.pickUrl(), relativeUrl);
- }
- async request(options) {
- var _a;
- const url = url_1.default.resolve(this.pickUrl(), options.path);
- const description = options.description || `${options.method} ${url}`;
- let attempt = 0;
- const maxAttempts = (_a = options.retries, (_a !== null && _a !== void 0 ? _a : DEFAULT_MAX_ATTEMPTS));
- while (true) {
- attempt += 1;
- try {
- const response = await axios_1.default.request({
- method: options.method,
- url,
- data: options.body,
- params: options.query,
- headers: {
- 'kbn-xsrf': 'kbn-client',
- },
- });
- return response.data;
- }
- catch (error) {
- const conflictOnGet = isConcliftOnGetError(error);
- const requestedRetries = options.retries !== undefined;
- const failedToGetResponse = axios_2.isAxiosRequestError(error);
- let errorMessage;
- if (conflictOnGet) {
- errorMessage = `Conflict on GET (path=${options.path}, attempt=${attempt}/${maxAttempts})`;
- this.log.error(errorMessage);
- }
- else if (requestedRetries || failedToGetResponse) {
- errorMessage = `[${description}] request failed (attempt=${attempt}/${maxAttempts})`;
- this.log.error(errorMessage);
- }
- else {
- throw error;
- }
- if (attempt < maxAttempts) {
- await delay(1000 * attempt);
- continue;
- }
- throw new Error(`${errorMessage} -- and ran out of retries`);
- }
- }
- }
+ return builder;
}
-exports.KbnClientRequester = KbnClientRequester;
-
-
-/***/ }),
-/* 452 */
-/***/ (function(module, exports) {
-
-module.exports = require("url");
-
-/***/ }),
-/* 453 */
-/***/ (function(module, exports, __webpack_require__) {
-module.exports = __webpack_require__(454);
+function applyStyle() {
+ // Support varags, but simply cast to string in case there's only one arg
+ const args = arguments;
+ const argsLen = args.length;
+ let str = String(arguments[0]);
-/***/ }),
-/* 454 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (argsLen === 0) {
+ return '';
+ }
-"use strict";
+ if (argsLen > 1) {
+ // Don't slice `arguments`, it prevents V8 optimizations
+ for (let a = 1; a < argsLen; a++) {
+ str += ' ' + args[a];
+ }
+ }
+ if (!this.enabled || this.level <= 0 || !str) {
+ return this._empty ? '' : str;
+ }
-var utils = __webpack_require__(455);
-var bind = __webpack_require__(456);
-var Axios = __webpack_require__(457);
-var mergeConfig = __webpack_require__(488);
-var defaults = __webpack_require__(463);
+ // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
+ // see https://github.com/chalk/chalk/issues/58
+ // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
+ const originalDim = ansiStyles.dim.open;
+ if (isSimpleWindowsTerm && this.hasGrey) {
+ ansiStyles.dim.open = '';
+ }
-/**
- * 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);
+ for (const code of this._styles.slice().reverse()) {
+ // Replace any instances already present with a re-opening code
+ // otherwise only the part of the string until said closing code
+ // will be colored, and the rest will simply be 'plain'.
+ str = code.open + str.replace(code.closeRe, code.open) + code.close;
- // Copy axios.prototype to instance
- utils.extend(instance, Axios.prototype, context);
+ // Close the styling before a linebreak and reopen
+ // after next line to fix a bleed issue on macOS
+ // https://github.com/chalk/chalk/pull/92
+ str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+ }
- // Copy context to instance
- utils.extend(instance, context);
+ // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
+ ansiStyles.dim.open = originalDim;
- return instance;
+ return str;
}
-// Create the default instance to be exported
-var axios = createInstance(defaults);
-
-// Expose Axios class to allow class inheritance
-axios.Axios = Axios;
+function chalkTag(chalk, strings) {
+ if (!Array.isArray(strings)) {
+ // If chalk() was called by itself or with a string,
+ // return the string itself as a string.
+ return [].slice.call(arguments, 1).join(' ');
+ }
-// Factory for creating new instances
-axios.create = function create(instanceConfig) {
- return createInstance(mergeConfig(axios.defaults, instanceConfig));
-};
+ const args = [].slice.call(arguments, 2);
+ const parts = [strings.raw[0]];
-// Expose Cancel & CancelToken
-axios.Cancel = __webpack_require__(489);
-axios.CancelToken = __webpack_require__(490);
-axios.isCancel = __webpack_require__(462);
+ for (let i = 1; i < strings.length; i++) {
+ parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
+ parts.push(String(strings.raw[i]));
+ }
-// Expose all/spread
-axios.all = function all(promises) {
- return Promise.all(promises);
-};
-axios.spread = __webpack_require__(491);
+ return template(chalk, parts.join(''));
+}
-module.exports = axios;
+Object.defineProperties(Chalk.prototype, styles);
-// Allow use of default import syntax in TypeScript
-module.exports.default = axios;
+module.exports = Chalk(); // eslint-disable-line new-cap
+module.exports.supportsColor = stdoutColor;
+module.exports.default = module.exports; // For TypeScript
/***/ }),
-/* 455 */
+/* 427 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+/* WEBPACK VAR INJECTION */(function(module) {
+const colorConvert = __webpack_require__(389);
+const wrapAnsi16 = (fn, offset) => function () {
+ const code = fn.apply(colorConvert, arguments);
+ return `\u001B[${code + offset}m`;
+};
-var bind = __webpack_require__(456);
-
-/*global toString:true*/
-
-// utils is a library of generic helper functions non-specific to axios
+const wrapAnsi256 = (fn, offset) => function () {
+ const code = fn.apply(colorConvert, arguments);
+ return `\u001B[${38 + offset};5;${code}m`;
+};
-var toString = Object.prototype.toString;
+const wrapAnsi16m = (fn, offset) => function () {
+ const rgb = fn.apply(colorConvert, arguments);
+ return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+};
-/**
- * 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]';
-}
+function assembleStyles() {
+ const codes = new Map();
+ const styles = {
+ modifier: {
+ reset: [0, 0],
+ // 21 isn't widely supported and 22 does the same thing
+ bold: [1, 22],
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29]
+ },
+ color: {
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+ gray: [90, 39],
-/**
- * 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);
-}
+ // Bright color
+ redBright: [91, 39],
+ greenBright: [92, 39],
+ yellowBright: [93, 39],
+ blueBright: [94, 39],
+ magentaBright: [95, 39],
+ cyanBright: [96, 39],
+ whiteBright: [97, 39]
+ },
+ bgColor: {
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49],
-/**
- * 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;
-}
+ // Bright color
+ bgBlackBright: [100, 49],
+ bgRedBright: [101, 49],
+ bgGreenBright: [102, 49],
+ bgYellowBright: [103, 49],
+ bgBlueBright: [104, 49],
+ bgMagentaBright: [105, 49],
+ bgCyanBright: [106, 49],
+ bgWhiteBright: [107, 49]
+ }
+ };
-/**
- * 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';
-}
+ // Fix humans
+ styles.color.grey = styles.color.gray;
-/**
- * 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';
-}
+ for (const groupName of Object.keys(styles)) {
+ const group = styles[groupName];
-/**
- * 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';
-}
+ for (const styleName of Object.keys(group)) {
+ const style = group[styleName];
-/**
- * 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]';
-}
+ styles[styleName] = {
+ open: `\u001B[${style[0]}m`,
+ close: `\u001B[${style[1]}m`
+ };
-/**
- * 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]';
-}
+ group[styleName] = styles[styleName];
-/**
- * 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]';
-}
+ codes.set(style[0], style[1]);
+ }
-/**
- * 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]';
-}
+ Object.defineProperty(styles, groupName, {
+ value: group,
+ enumerable: false
+ });
-/**
- * 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);
-}
+ Object.defineProperty(styles, 'codes', {
+ value: codes,
+ enumerable: false
+ });
+ }
-/**
- * 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;
-}
+ const ansi2ansi = n => n;
+ const rgb2rgb = (r, g, b) => [r, g, b];
-/**
- * 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*$/, '');
-}
+ styles.color.close = '\u001B[39m';
+ styles.bgColor.close = '\u001B[49m';
-/**
- * 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'
- );
-}
+ styles.color.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 0)
+ };
+ styles.color.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 0)
+ };
+ styles.color.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 0)
+ };
-/**
- * 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;
- }
+ styles.bgColor.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 10)
+ };
- // Force an array if not already something iterable
- if (typeof obj !== 'object') {
- /*eslint no-param-reassign:0*/
- obj = [obj];
- }
+ for (let key of Object.keys(colorConvert)) {
+ if (typeof colorConvert[key] !== 'object') {
+ continue;
+ }
- 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);
- }
- }
- }
-}
+ const suite = colorConvert[key];
-/**
- * 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 (typeof result[key] === 'object' && typeof val === 'object') {
- result[key] = merge(result[key], val);
- } else {
- result[key] = val;
- }
- }
+ if (key === 'ansi16') {
+ key = 'ansi';
+ }
- for (var i = 0, l = arguments.length; i < l; i++) {
- forEach(arguments[i], assignValue);
- }
- return result;
-}
+ if ('ansi16' in suite) {
+ styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+ styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+ }
-/**
- * Function equal to merge with the difference being that no reference
- * to original objects is kept.
- *
- * @see merge
- * @param {Object} obj1 Object to merge
- * @returns {Object} Result of all merge properties
- */
-function deepMerge(/* obj1, obj2, obj3, ... */) {
- var result = {};
- function assignValue(val, key) {
- if (typeof result[key] === 'object' && typeof val === 'object') {
- result[key] = deepMerge(result[key], val);
- } else if (typeof val === 'object') {
- result[key] = deepMerge({}, val);
- } else {
- result[key] = val;
- }
- }
+ if ('ansi256' in suite) {
+ styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+ styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+ }
- for (var i = 0, l = arguments.length; i < l; i++) {
- forEach(arguments[i], assignValue);
- }
- return result;
-}
+ if ('rgb' in suite) {
+ styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+ styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+ }
+ }
-/**
- * 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;
+ return styles;
}
-module.exports = {
- isArray: isArray,
- isArrayBuffer: isArrayBuffer,
- isBuffer: isBuffer,
- isFormData: isFormData,
- isArrayBufferView: isArrayBufferView,
- isString: isString,
- isNumber: isNumber,
- isObject: isObject,
- isUndefined: isUndefined,
- isDate: isDate,
- isFile: isFile,
- isBlob: isBlob,
- isFunction: isFunction,
- isStream: isStream,
- isURLSearchParams: isURLSearchParams,
- isStandardBrowserEnv: isStandardBrowserEnv,
- forEach: forEach,
- merge: merge,
- deepMerge: deepMerge,
- extend: extend,
- trim: trim
-};
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+ enumerable: true,
+ get: assembleStyles
+});
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(11)(module)))
/***/ }),
-/* 456 */
+/* 428 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+const os = __webpack_require__(364);
+const hasFlag = __webpack_require__(394);
-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);
- };
-};
-
-
-/***/ }),
-/* 457 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
+const env = process.env;
+let forceColor;
+if (hasFlag('no-color') ||
+ hasFlag('no-colors') ||
+ hasFlag('color=false')) {
+ forceColor = false;
+} else if (hasFlag('color') ||
+ hasFlag('colors') ||
+ hasFlag('color=true') ||
+ hasFlag('color=always')) {
+ forceColor = true;
+}
+if ('FORCE_COLOR' in env) {
+ forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
+}
-var utils = __webpack_require__(455);
-var buildURL = __webpack_require__(458);
-var InterceptorManager = __webpack_require__(459);
-var dispatchRequest = __webpack_require__(460);
-var mergeConfig = __webpack_require__(488);
+function translateLevel(level) {
+ if (level === 0) {
+ return false;
+ }
-/**
- * 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()
- };
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
}
-/**
- * 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 || {};
- }
+function supportsColor(stream) {
+ if (forceColor === false) {
+ return 0;
+ }
- config = mergeConfig(this.defaults, config);
+ if (hasFlag('color=16m') ||
+ hasFlag('color=full') ||
+ hasFlag('color=truecolor')) {
+ return 3;
+ }
- // 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';
- }
+ if (hasFlag('color=256')) {
+ return 2;
+ }
- // Hook up interceptors middleware
- var chain = [dispatchRequest, undefined];
- var promise = Promise.resolve(config);
+ if (stream && !stream.isTTY && forceColor !== true) {
+ // VS code debugger doesn't have isTTY set
+ if (env.VSCODE_PID) {
+ return 1;
+ }
+ return 0;
+ }
- this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
- chain.unshift(interceptor.fulfilled, interceptor.rejected);
- });
+ const min = forceColor ? 1 : 0;
- this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
- chain.push(interceptor.fulfilled, interceptor.rejected);
- });
+ if (process.platform === 'win32') {
+ // Node.js 7.5.0 is the first version of Node.js to include a patch to
+ // libuv that enables 256 color output on Windows. Anything earlier and it
+ // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+ // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+ // release that supports 256 colors. Windows 10 build 14931 is the first release
+ // that supports 16m/TrueColor.
+ const osRelease = os.release().split('.');
+ if (
+ Number(process.versions.node.split('.')[0]) >= 8 &&
+ Number(osRelease[0]) >= 10 &&
+ Number(osRelease[2]) >= 10586
+ ) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
- while (chain.length) {
- promise = promise.then(chain.shift(), chain.shift());
- }
+ return 1;
+ }
- return promise;
-};
+ if ('CI' in env) {
+ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+ return 1;
+ }
-Axios.prototype.getUri = function getUri(config) {
- config = mergeConfig(this.defaults, config);
- return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
-};
+ return min;
+ }
-// 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(utils.merge(config || {}, {
- method: method,
- url: url
- }));
- };
-});
+ if ('TEAMCITY_VERSION' in env) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+ }
-utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
- /*eslint func-names:0*/
- Axios.prototype[method] = function(url, data, config) {
- return this.request(utils.merge(config || {}, {
- method: method,
- url: url,
- data: data
- }));
- };
-});
+ if (env.COLORTERM === 'truecolor') {
+ return 3;
+ }
-module.exports = Axios;
+ if ('TERM_PROGRAM' in env) {
+ const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+ switch (env.TERM_PROGRAM) {
+ case 'iTerm.app':
+ return version >= 3 ? 3 : 2;
+ case 'Apple_Terminal':
+ return 2;
+ // No default
+ }
+ }
-/***/ }),
-/* 458 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (/-256(color)?$/i.test(env.TERM)) {
+ return 2;
+ }
-"use strict";
+ if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+ return 1;
+ }
+ if ('COLORTERM' in env) {
+ return 1;
+ }
-var utils = __webpack_require__(455);
+ if (env.TERM === 'dumb') {
+ return min;
+ }
-function encode(val) {
- return encodeURIComponent(val).
- replace(/%40/gi, '@').
- replace(/%3A/gi, ':').
- replace(/%24/g, '$').
- replace(/%2C/gi, ',').
- replace(/%20/g, '+').
- replace(/%5B/gi, '[').
- replace(/%5D/gi, ']');
+ return min;
}
-/**
- * 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;
- }
+function getSupportLevel(stream) {
+ const level = supportsColor(stream);
+ return translateLevel(level);
+}
- return url;
+module.exports = {
+ supportsColor: getSupportLevel,
+ stdout: getSupportLevel(process.stdout),
+ stderr: getSupportLevel(process.stderr)
};
/***/ }),
-/* 459 */
+/* 429 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
-var utils = __webpack_require__(455);
-
-function InterceptorManager() {
- this.handlers = [];
-}
+const ESCAPES = new Map([
+ ['n', '\n'],
+ ['r', '\r'],
+ ['t', '\t'],
+ ['b', '\b'],
+ ['f', '\f'],
+ ['v', '\v'],
+ ['0', '\0'],
+ ['\\', '\\'],
+ ['e', '\u001B'],
+ ['a', '\u0007']
+]);
-/**
- * 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;
-};
+function unescape(c) {
+ if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+ return String.fromCharCode(parseInt(c.slice(1), 16));
+ }
-/**
- * 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;
- }
-};
+ return ESCAPES.get(c) || c;
+}
-/**
- * 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);
- }
- });
-};
+function parseArguments(name, args) {
+ const results = [];
+ const chunks = args.trim().split(/\s*,\s*/g);
+ let matches;
-module.exports = InterceptorManager;
+ for (const chunk of chunks) {
+ if (!isNaN(chunk)) {
+ results.push(Number(chunk));
+ } else if ((matches = chunk.match(STRING_REGEX))) {
+ results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
+ } else {
+ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+ }
+ }
+ return results;
+}
-/***/ }),
-/* 460 */
-/***/ (function(module, exports, __webpack_require__) {
+function parseStyle(style) {
+ STYLE_REGEX.lastIndex = 0;
-"use strict";
+ const results = [];
+ let matches;
+ while ((matches = STYLE_REGEX.exec(style)) !== null) {
+ const name = matches[1];
-var utils = __webpack_require__(455);
-var transformData = __webpack_require__(461);
-var isCancel = __webpack_require__(462);
-var defaults = __webpack_require__(463);
+ if (matches[2]) {
+ const args = parseArguments(name, matches[2]);
+ results.push([name].concat(args));
+ } else {
+ results.push([name]);
+ }
+ }
-/**
- * Throws a `Cancel` if cancellation has been requested.
- */
-function throwIfCancellationRequested(config) {
- if (config.cancelToken) {
- config.cancelToken.throwIfRequested();
- }
+ return results;
}
-/**
- * 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);
+function buildStyle(chalk, styles) {
+ const enabled = {};
- // Ensure headers exist
- config.headers = config.headers || {};
+ for (const layer of styles) {
+ for (const style of layer.styles) {
+ enabled[style[0]] = layer.inverse ? null : style.slice(1);
+ }
+ }
- // Transform request data
- config.data = transformData(
- config.data,
- config.headers,
- config.transformRequest
- );
+ let current = chalk;
+ for (const styleName of Object.keys(enabled)) {
+ if (Array.isArray(enabled[styleName])) {
+ if (!(styleName in current)) {
+ throw new Error(`Unknown Chalk style: ${styleName}`);
+ }
- // Flatten headers
- config.headers = utils.merge(
- config.headers.common || {},
- config.headers[config.method] || {},
- config.headers
- );
+ if (enabled[styleName].length > 0) {
+ current = current[styleName].apply(current, enabled[styleName]);
+ } else {
+ current = current[styleName];
+ }
+ }
+ }
- utils.forEach(
- ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
- function cleanHeaderConfig(method) {
- delete config.headers[method];
- }
- );
+ return current;
+}
- var adapter = config.adapter || defaults.adapter;
+module.exports = (chalk, tmp) => {
+ const styles = [];
+ const chunks = [];
+ let chunk = [];
- return adapter(config).then(function onAdapterResolution(response) {
- throwIfCancellationRequested(config);
+ // eslint-disable-next-line max-params
+ tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
+ if (escapeChar) {
+ chunk.push(unescape(escapeChar));
+ } else if (style) {
+ const str = chunk.join('');
+ chunk = [];
+ chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+ styles.push({inverse, styles: parseStyle(style)});
+ } else if (close) {
+ if (styles.length === 0) {
+ throw new Error('Found extraneous } in Chalk template literal');
+ }
- // Transform response data
- response.data = transformData(
- response.data,
- response.headers,
- config.transformResponse
- );
+ chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+ chunk = [];
+ styles.pop();
+ } else {
+ chunk.push(chr);
+ }
+ });
- return response;
- }, function onAdapterRejection(reason) {
- if (!isCancel(reason)) {
- throwIfCancellationRequested(config);
+ chunks.push(chunk.join(''));
- // Transform response data
- if (reason && reason.response) {
- reason.response.data = transformData(
- reason.response.data,
- reason.response.headers,
- config.transformResponse
- );
- }
- }
+ if (styles.length > 0) {
+ const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+ throw new Error(errMsg);
+ }
- return Promise.reject(reason);
- });
+ return chunks.join('');
};
/***/ }),
-/* 461 */
+/* 430 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-var utils = __webpack_require__(455);
-
-/**
- * Transform the data for a request or a response
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
*
- * @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
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
*/
-module.exports = function transformData(data, headers, fns) {
- /*eslint no-param-reassign:0*/
- utils.forEach(fns, function transform(fn) {
- data = fn(data, headers);
- });
-
- return data;
-};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __webpack_require__(4);
+exports.CA_CERT_PATH = path_1.resolve(__dirname, '../certs/ca.crt');
+exports.ES_KEY_PATH = path_1.resolve(__dirname, '../certs/elasticsearch.key');
+exports.ES_CERT_PATH = path_1.resolve(__dirname, '../certs/elasticsearch.crt');
+exports.ES_P12_PATH = path_1.resolve(__dirname, '../certs/elasticsearch.p12');
+exports.ES_P12_PASSWORD = 'storepass';
+exports.ES_EMPTYPASSWORD_P12_PATH = path_1.resolve(__dirname, '../certs/elasticsearch_emptypassword.p12');
+exports.ES_NOPASSWORD_P12_PATH = path_1.resolve(__dirname, '../certs/elasticsearch_nopassword.p12');
+exports.KBN_KEY_PATH = path_1.resolve(__dirname, '../certs/kibana.key');
+exports.KBN_CERT_PATH = path_1.resolve(__dirname, '../certs/kibana.crt');
+exports.KBN_P12_PATH = path_1.resolve(__dirname, '../certs/kibana.p12');
+exports.KBN_P12_PASSWORD = 'storepass';
/***/ }),
-/* 462 */
+/* 431 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-module.exports = function isCancel(value) {
- return !!(value && value.__CANCEL__);
-};
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var run_1 = __webpack_require__(432);
+exports.run = run_1.run;
+var fail_1 = __webpack_require__(433);
+exports.createFailError = fail_1.createFailError;
+exports.createFlagError = fail_1.createFlagError;
+exports.combineErrors = fail_1.combineErrors;
+exports.isFailError = fail_1.isFailError;
/***/ }),
-/* 463 */
+/* 432 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-var utils = __webpack_require__(455);
-var normalizeHeaderName = __webpack_require__(464);
-
-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__(465);
- } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
- // For node use HTTP adapter
- adapter = __webpack_require__(475);
- }
- 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();
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+const util_1 = __webpack_require__(397);
+// @ts-ignore @types are outdated and module is super simple
+const exit_hook_1 = tslib_1.__importDefault(__webpack_require__(339));
+const tooling_log_1 = __webpack_require__(400);
+const fail_1 = __webpack_require__(433);
+const flags_1 = __webpack_require__(434);
+const proc_runner_1 = __webpack_require__(7);
+async function run(fn, options = {}) {
+ var _a;
+ const flags = flags_1.getFlags(process.argv.slice(2), options);
+ if (flags.help) {
+ process.stderr.write(flags_1.getHelp(options));
+ process.exit(1);
}
- if (utils.isObject(data)) {
- setContentTypeIfUnset(headers, 'application/json;charset=utf-8');
- return JSON.stringify(data);
+ const log = new tooling_log_1.ToolingLog({
+ level: tooling_log_1.pickLevelFromFlags(flags),
+ writeTo: process.stdout,
+ });
+ process.on('unhandledRejection', (error) => {
+ log.error('UNHANDLED PROMISE REJECTION');
+ log.error(error instanceof Error
+ ? error
+ : new Error(`non-Error type rejection value: ${util_1.inspect(error)}`));
+ process.exit(1);
+ });
+ const handleErrorWithoutExit = (error) => {
+ if (fail_1.isFailError(error)) {
+ log.error(error.message);
+ if (error.showHelp) {
+ log.write(flags_1.getHelp(options));
+ }
+ process.exitCode = error.exitCode;
+ }
+ else {
+ log.error('UNHANDLED ERROR');
+ log.error(error);
+ process.exitCode = 1;
+ }
+ };
+ const doCleanup = () => {
+ const tasks = cleanupTasks.slice(0);
+ cleanupTasks.length = 0;
+ for (const task of tasks) {
+ try {
+ task();
+ }
+ catch (error) {
+ handleErrorWithoutExit(error);
+ }
+ }
+ };
+ const unhookExit = exit_hook_1.default(doCleanup);
+ const cleanupTasks = [unhookExit];
+ try {
+ if (!((_a = options.flags) === null || _a === void 0 ? void 0 : _a.allowUnexpected) && flags.unexpected.length) {
+ throw fail_1.createFlagError(`Unknown flag(s) "${flags.unexpected.join('", "')}"`);
+ }
+ try {
+ await proc_runner_1.withProcRunner(log, async (procRunner) => {
+ await fn({
+ log,
+ flags,
+ procRunner,
+ addCleanupTask: (task) => cleanupTasks.push(task),
+ });
+ });
+ }
+ finally {
+ doCleanup();
+ }
}
- return data;
- }],
-
- transformResponse: [function transformResponse(data) {
- /*eslint no-param-reassign:0*/
- if (typeof data === 'string') {
- try {
- data = JSON.parse(data);
- } catch (e) { /* Ignore */ }
+ catch (error) {
+ handleErrorWithoutExit(error);
+ process.exit();
}
- 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,
-
- validateStatus: function validateStatus(status) {
- return status >= 200 && status < 300;
- }
-};
+}
+exports.run = run;
-defaults.headers = {
- common: {
- 'Accept': 'application/json, text/plain, */*'
- }
-};
-utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
- defaults.headers[method] = {};
-});
+/***/ }),
+/* 433 */
+/***/ (function(module, exports, __webpack_require__) {
-utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
- defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
-});
+"use strict";
-module.exports = defaults;
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __webpack_require__(397);
+const FAIL_TAG = Symbol('fail error');
+function createFailError(reason, options = {}) {
+ const { exitCode = 1, showHelp = false } = options;
+ return Object.assign(new Error(reason), {
+ exitCode,
+ showHelp,
+ [FAIL_TAG]: true,
+ });
+}
+exports.createFailError = createFailError;
+function createFlagError(reason) {
+ return createFailError(reason, {
+ showHelp: true,
+ });
+}
+exports.createFlagError = createFlagError;
+function isFailError(error) {
+ return Boolean(error && error[FAIL_TAG]);
+}
+exports.isFailError = isFailError;
+function combineErrors(errors) {
+ if (errors.length === 1) {
+ return errors[0];
+ }
+ const exitCode = errors
+ .filter(isFailError)
+ .reduce((acc, error) => Math.max(acc, error.exitCode), 1);
+ const showHelp = errors.some((error) => isFailError(error) && error.showHelp);
+ const message = errors.reduce((acc, error) => {
+ if (isFailError(error)) {
+ return acc + '\n' + error.message;
+ }
+ return acc + `\nUNHANDLED ERROR\n${util_1.inspect(error)}`;
+ }, '');
+ return createFailError(`${errors.length} errors:\n${message}`, {
+ exitCode,
+ showHelp,
+ });
+}
+exports.combineErrors = combineErrors;
/***/ }),
-/* 464 */
+/* 434 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+const path_1 = __webpack_require__(4);
+const dedent_1 = tslib_1.__importDefault(__webpack_require__(2));
+const getopts_1 = tslib_1.__importDefault(__webpack_require__(435));
+function getFlags(argv, options) {
+ const unexpectedNames = new Set();
+ const flagOpts = options.flags || {};
+ const { verbose, quiet, silent, debug, help, _, ...others } = getopts_1.default(argv, {
+ string: flagOpts.string,
+ boolean: [...(flagOpts.boolean || []), 'verbose', 'quiet', 'silent', 'debug', 'help'],
+ alias: {
+ ...(flagOpts.alias || {}),
+ v: 'verbose',
+ },
+ default: flagOpts.default,
+ unknown: (name) => {
+ unexpectedNames.add(name);
+ return flagOpts.guessTypesForUnexpectedFlags;
+ },
+ });
+ const unexpected = [];
+ for (const unexpectedName of unexpectedNames) {
+ const matchingArgv = [];
+ iterArgv: for (const [i, v] of argv.entries()) {
+ for (const prefix of ['--', '-']) {
+ if (v.startsWith(prefix)) {
+ // -/--name=value
+ if (v.startsWith(`${prefix}${unexpectedName}=`)) {
+ matchingArgv.push(v);
+ continue iterArgv;
+ }
+ // -/--name (value possibly follows)
+ if (v === `${prefix}${unexpectedName}`) {
+ matchingArgv.push(v);
+ // value follows -/--name
+ if (argv.length > i + 1 && !argv[i + 1].startsWith('-')) {
+ matchingArgv.push(argv[i + 1]);
+ }
+ continue iterArgv;
+ }
+ }
+ }
+ // special case for `--no-{flag}` disabling of boolean flags
+ if (v === `--no-${unexpectedName}`) {
+ matchingArgv.push(v);
+ continue iterArgv;
+ }
+ // special case for shortcut flags formatted as `-abc` where `a`, `b`,
+ // and `c` will be three separate unexpected flags
+ if (unexpectedName.length === 1 &&
+ v[0] === '-' &&
+ v[1] !== '-' &&
+ !v.includes('=') &&
+ v.includes(unexpectedName)) {
+ matchingArgv.push(`-${unexpectedName}`);
+ continue iterArgv;
+ }
+ }
+ if (matchingArgv.length) {
+ unexpected.push(...matchingArgv);
+ }
+ else {
+ throw new Error(`unable to find unexpected flag named "${unexpectedName}"`);
+ }
+ }
+ return {
+ verbose,
+ quiet,
+ silent,
+ debug,
+ help,
+ _,
+ unexpected,
+ ...others,
+ };
+}
+exports.getFlags = getFlags;
+function getHelp(options) {
+ var _a, _b;
+ const usage = options.usage || `node ${path_1.relative(process.cwd(), process.argv[1])}`;
+ const optionHelp = (dedent_1.default(((_b = (_a = options) === null || _a === void 0 ? void 0 : _a.flags) === null || _b === void 0 ? void 0 : _b.help) || '') +
+ '\n' +
+ dedent_1.default `
+ --verbose, -v Log verbosely
+ --debug Log debug messages (less than verbose)
+ --quiet Only log errors
+ --silent Don't log anything
+ --help Show this message
+ `)
+ .split('\n')
+ .filter(Boolean)
+ .join('\n ');
+ return `
+ ${usage}
-var utils = __webpack_require__(455);
+ ${dedent_1.default(options.description || 'Runs a dev task')
+ .split('\n')
+ .join('\n ')}
-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];
- }
- });
-};
+ Options:
+ ${optionHelp + '\n\n'}`;
+}
+exports.getHelp = getHelp;
/***/ }),
-/* 465 */
+/* 435 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var utils = __webpack_require__(455);
-var settle = __webpack_require__(466);
-var buildURL = __webpack_require__(458);
-var buildFullPath = __webpack_require__(469);
-var parseHeaders = __webpack_require__(472);
-var isURLSameOrigin = __webpack_require__(473);
-var createError = __webpack_require__(467);
-
-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
- }
+const EMPTYARR = []
+const SHORTSPLIT = /$|[!-@[-`{-~][\s\S]*/g
+const isArray = Array.isArray
- var request = new XMLHttpRequest();
+const parseValue = function(any) {
+ if (any === "") return ""
+ if (any === "false") return false
+ const maybe = Number(any)
+ return maybe * 0 === 0 ? maybe : any
+}
- // HTTP basic authentication
- if (config.auth) {
- var username = config.auth.username || '';
- var password = config.auth.password || '';
- requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
- }
+const parseAlias = function(aliases) {
+ let out = {},
+ key,
+ alias,
+ prev,
+ len,
+ any,
+ i,
+ k
- var fullPath = buildFullPath(config.baseURL, config.url);
- request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
+ for (key in aliases) {
+ any = aliases[key]
+ alias = out[key] = isArray(any) ? any : [any]
- // Set the request timeout in MS
- request.timeout = config.timeout;
+ for (i = 0, len = alias.length; i < len; i++) {
+ prev = out[alias[i]] = [key]
- // Listen for ready state
- request.onreadystatechange = function handleLoad() {
- if (!request || request.readyState !== 4) {
- return;
+ for (k = 0; k < len; k++) {
+ if (i !== k) prev.push(alias[k])
}
+ }
+ }
- // 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;
- }
+ return out
+}
- // 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
- };
+const parseDefault = function(aliases, defaults) {
+ let out = {},
+ key,
+ alias,
+ value,
+ len,
+ i
- settle(resolve, reject, response);
+ for (key in defaults) {
+ value = defaults[key]
+ alias = aliases[key]
- // Clean up request
- request = null;
- };
+ out[key] = value
- // Handle browser request cancellation (as opposed to a manual cancellation)
- request.onabort = function handleAbort() {
- if (!request) {
- return;
+ if (alias === undefined) {
+ aliases[key] = EMPTYARR
+ } else {
+ for (i = 0, len = alias.length; i < len; i++) {
+ out[alias[i]] = value
}
+ }
+ }
- reject(createError('Request aborted', config, 'ECONNABORTED', request));
+ return out
+}
- // Clean up request
- request = null;
- };
+const parseOptions = function(aliases, options, value) {
+ let out = {},
+ key,
+ alias,
+ len,
+ end,
+ i,
+ k
- // 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));
+ if (options !== undefined) {
+ for (i = 0, len = options.length; i < len; i++) {
+ key = options[i]
+ alias = aliases[key]
- // Clean up request
- request = null;
- };
+ out[key] = value
- // Handle timeout
- request.ontimeout = function handleTimeout() {
- var timeoutErrorMessage = 'timeout of ' + config.timeout + 'ms exceeded';
- if (config.timeoutErrorMessage) {
- timeoutErrorMessage = config.timeoutErrorMessage;
+ if (alias === undefined) {
+ aliases[key] = EMPTYARR
+ } else {
+ for (k = 0, end = alias.length; k < end; k++) {
+ out[alias[k]] = value
+ }
}
- reject(createError(timeoutErrorMessage, config, 'ECONNABORTED',
- request));
+ }
+ }
- // Clean up request
- request = null;
- };
+ return out
+}
- // 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()) {
- var cookies = __webpack_require__(474);
+const write = function(out, key, value, aliases, unknown) {
+ let i,
+ prev,
+ alias = aliases[key],
+ len = alias === undefined ? -1 : alias.length
- // Add xsrf header
- var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?
- cookies.read(config.xsrfCookieName) :
- undefined;
+ if (len >= 0 || unknown === undefined || unknown(key)) {
+ prev = out[key]
- if (xsrfValue) {
- requestHeaders[config.xsrfHeaderName] = xsrfValue;
+ if (prev === undefined) {
+ out[key] = value
+ } else {
+ if (isArray(prev)) {
+ prev.push(value)
+ } else {
+ out[key] = [prev, value]
}
}
- // 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);
- }
- });
+ for (i = 0; i < len; i++) {
+ out[alias[i]] = out[key]
}
+ }
+}
- // Add withCredentials to request if needed
- if (!utils.isUndefined(config.withCredentials)) {
- request.withCredentials = !!config.withCredentials;
- }
+const getopts = function(argv, opts) {
+ let unknown = (opts = opts || {}).unknown,
+ aliases = parseAlias(opts.alias),
+ strings = parseOptions(aliases, opts.string, ""),
+ values = parseDefault(aliases, opts.default),
+ bools = parseOptions(aliases, opts.boolean, false),
+ stopEarly = opts.stopEarly,
+ _ = [],
+ out = { _ },
+ i = 0,
+ k = 0,
+ len = argv.length,
+ key,
+ arg,
+ end,
+ match,
+ value
- // 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;
- }
- }
- }
+ for (; i < len; i++) {
+ arg = argv[i]
- // Handle progress if needed
- if (typeof config.onDownloadProgress === 'function') {
- request.addEventListener('progress', config.onDownloadProgress);
- }
+ if (arg[0] !== "-" || arg === "-") {
+ if (stopEarly) while (i < len) _.push(argv[i++])
+ else _.push(arg)
+ } else if (arg === "--") {
+ while (++i < len) _.push(argv[i])
+ } else if (arg[1] === "-") {
+ end = arg.indexOf("=", 2)
+ if (arg[2] === "n" && arg[3] === "o" && arg[4] === "-") {
+ key = arg.slice(5, end >= 0 ? end : undefined)
+ value = false
+ } else if (end >= 0) {
+ key = arg.slice(2, end)
+ value =
+ bools[key] !== undefined ||
+ (strings[key] === undefined
+ ? parseValue(arg.slice(end + 1))
+ : arg.slice(end + 1))
+ } else {
+ key = arg.slice(2)
+ value =
+ bools[key] !== undefined ||
+ (len === i + 1 || argv[i + 1][0] === "-"
+ ? strings[key] === undefined
+ ? true
+ : ""
+ : strings[key] === undefined
+ ? parseValue(argv[++i])
+ : argv[++i])
+ }
+ write(out, key, value, aliases, unknown)
+ } else {
+ SHORTSPLIT.lastIndex = 2
+ match = SHORTSPLIT.exec(arg)
+ end = match.index
+ value = match[0]
- // Not all browsers support upload events
- if (typeof config.onUploadProgress === 'function' && request.upload) {
- request.upload.addEventListener('progress', config.onUploadProgress);
+ for (k = 1; k < end; k++) {
+ write(
+ out,
+ (key = arg[k]),
+ k + 1 < end
+ ? strings[key] === undefined ||
+ arg.substring(k + 1, (k = end)) + value
+ : value === ""
+ ? len === i + 1 || argv[i + 1][0] === "-"
+ ? strings[key] === undefined || ""
+ : bools[key] !== undefined ||
+ (strings[key] === undefined ? parseValue(argv[++i]) : argv[++i])
+ : bools[key] !== undefined ||
+ (strings[key] === undefined ? parseValue(value) : value),
+ aliases,
+ unknown
+ )
+ }
}
+ }
- if (config.cancelToken) {
- // Handle cancellation
- config.cancelToken.promise.then(function onCanceled(cancel) {
- if (!request) {
- return;
- }
-
- request.abort();
- reject(cancel);
- // Clean up request
- request = null;
- });
- }
+ for (key in values) if (out[key] === undefined) out[key] = values[key]
+ for (key in bools) if (out[key] === undefined) out[key] = false
+ for (key in strings) if (out[key] === undefined) out[key] = ""
- if (requestData === undefined) {
- requestData = null;
- }
+ return out
+}
- // Send the request
- request.send(requestData);
- });
-};
+module.exports = getopts
/***/ }),
-/* 466 */
+/* 436 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-var createError = __webpack_require__(467);
-
-/**
- * Resolve or reject a Promise based on response status.
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
*
- * @param {Function} resolve A function that resolves the promise.
- * @param {Function} reject A function that rejects the promise.
- * @param {object} response The response.
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
*/
-module.exports = function settle(resolve, reject, response) {
- var validateStatus = response.config.validateStatus;
- if (!validateStatus || validateStatus(response.status)) {
- resolve(response);
- } else {
- reject(createError(
- 'Request failed with status code ' + response.status,
- response.config,
- null,
- response.request,
- response
- ));
- }
-};
+Object.defineProperty(exports, "__esModule", { value: true });
+var kbn_client_1 = __webpack_require__(437);
+exports.KbnClient = kbn_client_1.KbnClient;
+var kbn_client_requester_1 = __webpack_require__(438);
+exports.uriencode = kbn_client_requester_1.uriencode;
/***/ }),
-/* 467 */
+/* 437 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-var enhanceError = __webpack_require__(468);
-
-/**
- * Create an Error with the specified message, config, error code, request and response.
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
*
- * @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.
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
*/
-module.exports = function createError(message, config, code, request, response) {
- var error = new Error(message);
- return enhanceError(error, config, code, request, response);
-};
+Object.defineProperty(exports, "__esModule", { value: true });
+const kbn_client_requester_1 = __webpack_require__(438);
+const kbn_client_status_1 = __webpack_require__(481);
+const kbn_client_plugins_1 = __webpack_require__(482);
+const kbn_client_version_1 = __webpack_require__(483);
+const kbn_client_saved_objects_1 = __webpack_require__(484);
+const kbn_client_ui_settings_1 = __webpack_require__(485);
+class KbnClient {
+ /**
+ * Basic Kibana server client that implements common behaviors for talking
+ * to the Kibana server from dev tooling.
+ *
+ * @param log ToolingLog
+ * @param kibanaUrls Array of kibana server urls to send requests to
+ * @param uiSettingDefaults Map of uiSetting values that will be merged with all uiSetting resets
+ */
+ constructor(log, kibanaUrls, uiSettingDefaults) {
+ this.log = log;
+ this.kibanaUrls = kibanaUrls;
+ this.uiSettingDefaults = uiSettingDefaults;
+ this.requester = new kbn_client_requester_1.KbnClientRequester(this.log, this.kibanaUrls);
+ this.status = new kbn_client_status_1.KbnClientStatus(this.requester);
+ this.plugins = new kbn_client_plugins_1.KbnClientPlugins(this.status);
+ this.version = new kbn_client_version_1.KbnClientVersion(this.status);
+ this.savedObjects = new kbn_client_saved_objects_1.KbnClientSavedObjects(this.log, this.requester);
+ this.uiSettings = new kbn_client_ui_settings_1.KbnClientUiSettings(this.log, this.requester, this.uiSettingDefaults);
+ if (!kibanaUrls.length) {
+ throw new Error('missing Kibana urls');
+ }
+ }
+ /**
+ * Make a direct request to the Kibana server
+ */
+ async request(options) {
+ return await this.requester.request(options);
+ }
+ resolveUrl(relativeUrl) {
+ return this.requester.resolveUrl(relativeUrl);
+ }
+}
+exports.KbnClient = KbnClient;
/***/ }),
-/* 468 */
+/* 438 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-/**
- * Update an Error with the specified config, error code, and response.
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
*
- * @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.
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
*/
-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() {
- 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;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+const url_1 = tslib_1.__importDefault(__webpack_require__(439));
+const axios_1 = tslib_1.__importDefault(__webpack_require__(440));
+const axios_2 = __webpack_require__(479);
+const isConcliftOnGetError = (error) => {
+ return (axios_2.isAxiosResponseError(error) && error.config.method === 'GET' && error.response.status === 409);
+};
+exports.uriencode = (strings, ...values) => {
+ const queue = strings.slice();
+ if (queue.length === 0) {
+ throw new Error('how could strings passed to `uriencode` template tag be empty?');
+ }
+ if (queue.length !== values.length + 1) {
+ throw new Error('strings and values passed to `uriencode` template tag are unbalanced');
+ }
+ // pull the first string off the queue, there is one less item in `values`
+ // since the values are always wrapped in strings, so we shift the extra string
+ // off the queue to balance the queue and values array.
+ const leadingString = queue.shift();
+ return queue.reduce((acc, string, i) => `${acc}${encodeURIComponent(values[i])}${string}`, leadingString);
};
+const DEFAULT_MAX_ATTEMPTS = 5;
+const delay = (ms) => new Promise((resolve) => {
+ setTimeout(resolve, ms);
+});
+class KbnClientRequester {
+ constructor(log, kibanaUrls) {
+ this.log = log;
+ this.kibanaUrls = kibanaUrls;
+ }
+ pickUrl() {
+ const url = this.kibanaUrls.shift();
+ this.kibanaUrls.push(url);
+ return url;
+ }
+ resolveUrl(relativeUrl = '/') {
+ return url_1.default.resolve(this.pickUrl(), relativeUrl);
+ }
+ async request(options) {
+ var _a;
+ const url = url_1.default.resolve(this.pickUrl(), options.path);
+ const description = options.description || `${options.method} ${url}`;
+ let attempt = 0;
+ const maxAttempts = (_a = options.retries, (_a !== null && _a !== void 0 ? _a : DEFAULT_MAX_ATTEMPTS));
+ while (true) {
+ attempt += 1;
+ try {
+ const response = await axios_1.default.request({
+ method: options.method,
+ url,
+ data: options.body,
+ params: options.query,
+ headers: {
+ 'kbn-xsrf': 'kbn-client',
+ },
+ });
+ return response.data;
+ }
+ catch (error) {
+ const conflictOnGet = isConcliftOnGetError(error);
+ const requestedRetries = options.retries !== undefined;
+ const failedToGetResponse = axios_2.isAxiosRequestError(error);
+ let errorMessage;
+ if (conflictOnGet) {
+ errorMessage = `Conflict on GET (path=${options.path}, attempt=${attempt}/${maxAttempts})`;
+ this.log.error(errorMessage);
+ }
+ else if (requestedRetries || failedToGetResponse) {
+ errorMessage = `[${description}] request failed (attempt=${attempt}/${maxAttempts})`;
+ this.log.error(errorMessage);
+ }
+ else {
+ throw error;
+ }
+ if (attempt < maxAttempts) {
+ await delay(1000 * attempt);
+ continue;
+ }
+ throw new Error(`${errorMessage} -- and ran out of retries`);
+ }
+ }
+ }
+}
+exports.KbnClientRequester = KbnClientRequester;
/***/ }),
-/* 469 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-
-var isAbsoluteURL = __webpack_require__(470);
-var combineURLs = __webpack_require__(471);
-
-/**
- * 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;
-};
+/* 439 */
+/***/ (function(module, exports) {
+module.exports = require("url");
/***/ }),
-/* 470 */
+/* 440 */
/***/ (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);
-};
-
+module.exports = __webpack_require__(441);
/***/ }),
-/* 471 */
+/* 441 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+var utils = __webpack_require__(442);
+var bind = __webpack_require__(443);
+var Axios = __webpack_require__(444);
+var mergeConfig = __webpack_require__(475);
+var defaults = __webpack_require__(450);
+
/**
- * Creates a new URL by combining the specified URLs
+ * Create an instance of Axios
*
- * @param {string} baseURL The base URL
- * @param {string} relativeURL The relative URL
- * @returns {string} The combined URL
+ * @param {Object} defaultConfig The default config for the instance
+ * @return {Axios} A new instance of Axios
*/
-module.exports = function combineURLs(baseURL, relativeURL) {
- return relativeURL
- ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
- : baseURL;
-};
-
+function createInstance(defaultConfig) {
+ var context = new Axios(defaultConfig);
+ var instance = bind(Axios.prototype.request, context);
-/***/ }),
-/* 472 */
-/***/ (function(module, exports, __webpack_require__) {
+ // Copy axios.prototype to instance
+ utils.extend(instance, Axios.prototype, context);
-"use strict";
+ // Copy context to instance
+ utils.extend(instance, context);
+ return instance;
+}
-var utils = __webpack_require__(455);
+// Create the default instance to be exported
+var axios = createInstance(defaults);
-// 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'
-];
+// Expose Axios class to allow class inheritance
+axios.Axios = Axios;
-/**
- * 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;
+// Factory for creating new instances
+axios.create = function create(instanceConfig) {
+ return createInstance(mergeConfig(axios.defaults, instanceConfig));
+};
- if (!headers) { return parsed; }
+// Expose Cancel & CancelToken
+axios.Cancel = __webpack_require__(476);
+axios.CancelToken = __webpack_require__(477);
+axios.isCancel = __webpack_require__(449);
- 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));
+// Expose all/spread
+axios.all = function all(promises) {
+ return Promise.all(promises);
+};
+axios.spread = __webpack_require__(478);
- 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;
- }
- }
- });
+module.exports = axios;
- return parsed;
-};
+// Allow use of default import syntax in TypeScript
+module.exports.default = axios;
/***/ }),
-/* 473 */
+/* 442 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var utils = __webpack_require__(455);
+var bind = __webpack_require__(443);
-module.exports = (
- utils.isStandardBrowserEnv() ?
+/*global toString:true*/
- // 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;
+// utils is a library of generic helper functions non-specific to axios
- /**
- * Parse a URL to discover it's components
- *
- * @param {String} url The URL to be parsed
- * @returns {Object}
- */
- function resolveURL(url) {
- var href = url;
+var toString = Object.prototype.toString;
- if (msie) {
- // IE needs attribute set twice to normalize properties
- urlParsingNode.setAttribute('href', href);
- href = urlParsingNode.href;
- }
+/**
+ * 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]';
+}
- urlParsingNode.setAttribute('href', href);
+/**
+ * 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';
+}
- // 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
- };
- }
+/**
+ * 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);
+}
- originURL = resolveURL(window.location.href);
+/**
+ * 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 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);
- };
- })() :
+/**
+ * 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);
+}
- // Non standard browser envs (web workers, react-native) lack needed support.
- (function nonStandardBrowserEnv() {
- return function isURLSameOrigin() {
- return true;
- };
- })()
-);
+/**
+ * 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';
+}
-/***/ }),
-/* 474 */
-/***/ (function(module, exports, __webpack_require__) {
+/**
+ * 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';
+}
-"use strict";
+/**
+ * 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 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]';
+}
-var utils = __webpack_require__(455);
+/**
+ * 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]';
+}
-module.exports = (
- utils.isStandardBrowserEnv() ?
+/**
+ * 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]';
+}
- // 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));
+/**
+ * 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]';
+}
- if (utils.isNumber(expires)) {
- cookie.push('expires=' + new Date(expires).toGMTString());
- }
+/**
+ * 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);
+}
- if (utils.isString(path)) {
- cookie.push('path=' + path);
- }
+/**
+ * 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;
+}
- if (utils.isString(domain)) {
- cookie.push('domain=' + domain);
- }
+/**
+ * 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*$/, '');
+}
- if (secure === true) {
- cookie.push('secure');
- }
+/**
+ * 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'
+ );
+}
- document.cookie = cookie.join('; ');
- },
+/**
+ * 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;
+ }
- read: function read(name) {
- var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
- return (match ? decodeURIComponent(match[3]) : null);
- },
+ // Force an array if not already something iterable
+ if (typeof obj !== 'object') {
+ /*eslint no-param-reassign:0*/
+ obj = [obj];
+ }
- remove: function remove(name) {
- this.write(name, '', Date.now() - 86400000);
- }
- };
- })() :
+ 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);
+ }
+ }
+ }
+}
- // 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() {}
- };
- })()
-);
+/**
+ * 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 (typeof result[key] === 'object' && typeof val === 'object') {
+ result[key] = merge(result[key], val);
+ } else {
+ result[key] = val;
+ }
+ }
+
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ forEach(arguments[i], assignValue);
+ }
+ return result;
+}
+
+/**
+ * Function equal to merge with the difference being that no reference
+ * to original objects is kept.
+ *
+ * @see merge
+ * @param {Object} obj1 Object to merge
+ * @returns {Object} Result of all merge properties
+ */
+function deepMerge(/* obj1, obj2, obj3, ... */) {
+ var result = {};
+ function assignValue(val, key) {
+ if (typeof result[key] === 'object' && typeof val === 'object') {
+ result[key] = deepMerge(result[key], val);
+ } else if (typeof val === 'object') {
+ result[key] = deepMerge({}, val);
+ } 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;
+}
+
+module.exports = {
+ isArray: isArray,
+ isArrayBuffer: isArrayBuffer,
+ isBuffer: isBuffer,
+ isFormData: isFormData,
+ isArrayBufferView: isArrayBufferView,
+ isString: isString,
+ isNumber: isNumber,
+ isObject: isObject,
+ isUndefined: isUndefined,
+ isDate: isDate,
+ isFile: isFile,
+ isBlob: isBlob,
+ isFunction: isFunction,
+ isStream: isStream,
+ isURLSearchParams: isURLSearchParams,
+ isStandardBrowserEnv: isStandardBrowserEnv,
+ forEach: forEach,
+ merge: merge,
+ deepMerge: deepMerge,
+ extend: extend,
+ trim: trim
+};
/***/ }),
-/* 475 */
+/* 443 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var utils = __webpack_require__(455);
-var settle = __webpack_require__(466);
-var buildFullPath = __webpack_require__(469);
-var buildURL = __webpack_require__(458);
-var http = __webpack_require__(476);
-var https = __webpack_require__(477);
-var httpFollow = __webpack_require__(478).http;
-var httpsFollow = __webpack_require__(478).https;
-var url = __webpack_require__(452);
-var zlib = __webpack_require__(486);
-var pkg = __webpack_require__(487);
-var createError = __webpack_require__(467);
-var enhanceError = __webpack_require__(468);
+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);
+ };
+};
-var isHttps = /https:?/;
-/*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;
+/***/ }),
+/* 444 */
+/***/ (function(module, exports, __webpack_require__) {
- // 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;
- }
+"use strict";
- 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;
- }
+var utils = __webpack_require__(442);
+var buildURL = __webpack_require__(445);
+var InterceptorManager = __webpack_require__(446);
+var dispatchRequest = __webpack_require__(447);
+var mergeConfig = __webpack_require__(475);
- // HTTP basic authentication
- var auth = undefined;
- if (config.auth) {
- var username = config.auth.username || '';
- var password = config.auth.password || '';
- auth = username + ':' + password;
- }
+/**
+ * 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()
+ };
+}
- // Parse url
- var fullPath = buildFullPath(config.baseURL, config.url);
- var parsed = url.parse(fullPath);
- var protocol = parsed.protocol || 'http:';
+/**
+ * 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 || {};
+ }
- if (!auth && parsed.auth) {
- var urlAuth = parsed.auth.split(':');
- var urlUsername = urlAuth[0] || '';
- var urlPassword = urlAuth[1] || '';
- auth = urlUsername + ':' + urlPassword;
- }
+ config = mergeConfig(this.defaults, config);
- if (auth) {
- delete headers.Authorization;
- }
+ // 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';
+ }
- var isHttpsRequest = isHttps.test(protocol);
- var agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
+ // Hook up interceptors middleware
+ var chain = [dispatchRequest, undefined];
+ var promise = Promise.resolve(config);
- 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
- };
+ this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+ chain.unshift(interceptor.fulfilled, interceptor.rejected);
+ });
- if (config.socketPath) {
- options.socketPath = config.socketPath;
- } else {
- options.hostname = parsed.hostname;
- options.port = parsed.port;
- }
+ this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+ chain.push(interceptor.fulfilled, interceptor.rejected);
+ });
- 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;
+ while (chain.length) {
+ promise = promise.then(chain.shift(), chain.shift());
+ }
- if (noProxyEnv) {
- var noProxy = noProxyEnv.split(',').map(function trim(s) {
- return s.trim();
- });
+ return promise;
+};
- 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;
- }
+Axios.prototype.getUri = function getUri(config) {
+ config = mergeConfig(this.defaults, config);
+ return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
+};
- return parsed.hostname === proxyElement;
- });
- }
+// 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(utils.merge(config || {}, {
+ method: method,
+ url: url
+ }));
+ };
+});
+utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+ /*eslint func-names:0*/
+ Axios.prototype[method] = function(url, data, config) {
+ return this.request(utils.merge(config || {}, {
+ method: method,
+ url: url,
+ data: data
+ }));
+ };
+});
- if (shouldProxy) {
- proxy = {
- host: parsedProxyUrl.hostname,
- port: parsedProxyUrl.port
- };
+module.exports = Axios;
- if (parsedProxyUrl.auth) {
- var proxyUrlAuth = parsedProxyUrl.auth.split(':');
- proxy.auth = {
- username: proxyUrlAuth[0],
- password: proxyUrlAuth[1]
- };
- }
- }
- }
- }
- if (proxy) {
- options.hostname = proxy.host;
- options.host = proxy.host;
- options.headers.host = parsed.hostname + (parsed.port ? ':' + parsed.port : '');
- options.port = proxy.port;
- options.path = protocol + '//' + parsed.hostname + (parsed.port ? ':' + parsed.port : '') + options.path;
+/***/ }),
+/* 445 */
+/***/ (function(module, exports, __webpack_require__) {
- // 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;
- }
- }
+"use strict";
- 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.maxContentLength && config.maxContentLength > -1) {
- options.maxBodyLength = config.maxContentLength;
- }
+var utils = __webpack_require__(442);
- // Create the request
- var req = transport.request(options, function handleResponse(res) {
- if (req.aborted) return;
+function encode(val) {
+ return encodeURIComponent(val).
+ replace(/%40/gi, '@').
+ replace(/%3A/gi, ':').
+ replace(/%24/g, '$').
+ replace(/%2C/gi, ',').
+ replace(/%20/g, '+').
+ replace(/%5B/gi, '[').
+ replace(/%5D/gi, ']');
+}
- // uncompress the response body transparently if required
- var stream = res;
- 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 = (res.statusCode === 204) ? stream : stream.pipe(zlib.createUnzip());
+/**
+ * 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;
+ }
- // remove the content-encoding in order to not confuse downstream operations
- delete res.headers['content-encoding'];
- break;
+ 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;
}
- // return the last request in case of redirects
- var lastRequest = res.req || req;
+ if (utils.isArray(val)) {
+ key = key + '[]';
+ } else {
+ val = [val];
+ }
- var response = {
- status: res.statusCode,
- statusText: res.statusMessage,
- headers: res.headers,
- config: config,
- request: lastRequest
- };
+ 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));
+ });
+ });
- if (config.responseType === 'stream') {
- response.data = stream;
- settle(resolve, reject, response);
- } else {
- var responseBuffer = [];
- stream.on('data', function handleStreamData(chunk) {
- responseBuffer.push(chunk);
+ serializedParams = parts.join('&');
+ }
- // 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));
- }
- });
+ if (serializedParams) {
+ var hashmarkIndex = url.indexOf('#');
+ if (hashmarkIndex !== -1) {
+ url = url.slice(0, hashmarkIndex);
+ }
- stream.on('error', function handleStreamError(err) {
- if (req.aborted) return;
- reject(enhanceError(err, config, null, lastRequest));
- });
+ url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
+ }
- stream.on('end', function handleStreamEnd() {
- var responseData = Buffer.concat(responseBuffer);
- if (config.responseType !== 'arraybuffer') {
- responseData = responseData.toString(config.responseEncoding);
- }
+ return url;
+};
- response.data = responseData;
- settle(resolve, reject, response);
- });
- }
- });
- // Handle errors
- req.on('error', function handleRequestError(err) {
- if (req.aborted) return;
- reject(enhanceError(err, config, null, req));
- });
+/***/ }),
+/* 446 */
+/***/ (function(module, exports, __webpack_require__) {
- // 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));
- });
- }
+"use strict";
- if (config.cancelToken) {
- // Handle cancellation
- config.cancelToken.promise.then(function onCanceled(cancel) {
- if (req.aborted) return;
- req.abort();
- reject(cancel);
- });
- }
+var utils = __webpack_require__(442);
- // 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);
- }
+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;
+ }
+};
-/***/ }),
-/* 476 */
-/***/ (function(module, exports) {
-
-module.exports = require("http");
+/**
+ * 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);
+ }
+ });
+};
-/***/ }),
-/* 477 */
-/***/ (function(module, exports) {
+module.exports = InterceptorManager;
-module.exports = require("https");
/***/ }),
-/* 478 */
+/* 447 */
/***/ (function(module, exports, __webpack_require__) {
-var url = __webpack_require__(452);
-var http = __webpack_require__(476);
-var https = __webpack_require__(477);
-var assert = __webpack_require__(30);
-var Writable = __webpack_require__(27).Writable;
-var debug = __webpack_require__(479)("follow-redirects");
-
-// RFC7231§4.2.1: Of the request methods defined by this specification,
-// the GET, HEAD, OPTIONS, and TRACE methods are defined to be safe.
-var SAFE_METHODS = { GET: true, HEAD: true, OPTIONS: true, TRACE: true };
+"use strict";
-// Create handlers that pass events from native requests
-var eventHandlers = Object.create(null);
-["abort", "aborted", "error", "socket", "timeout"].forEach(function (event) {
- eventHandlers[event] = function (arg) {
- this._redirectable.emit(event, arg);
- };
-});
-// An HTTP(S) request that can be redirected
-function RedirectableRequest(options, responseCallback) {
- // Initialize the request
- Writable.call(this);
- options.headers = options.headers || {};
- this._options = options;
- this._redirectCount = 0;
- this._redirects = [];
- this._requestBodyLength = 0;
- this._requestBodyBuffers = [];
+var utils = __webpack_require__(442);
+var transformData = __webpack_require__(448);
+var isCancel = __webpack_require__(449);
+var defaults = __webpack_require__(450);
- // 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;
+/**
+ * Throws a `Cancel` if cancellation has been requested.
+ */
+function throwIfCancellationRequested(config) {
+ if (config.cancelToken) {
+ config.cancelToken.throwIfRequested();
}
+}
- // Attach a callback if passed
- if (responseCallback) {
- this.on("response", responseCallback);
- }
+/**
+ * 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);
- // React to responses of native requests
- var self = this;
- this._onNativeResponse = function (response) {
- self._processResponse(response);
- };
+ // Ensure headers exist
+ config.headers = config.headers || {};
- // 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);
+ // 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];
}
- }
+ );
- // Perform the first request
- this._performRequest();
-}
-RedirectableRequest.prototype = Object.create(Writable.prototype);
+ var adapter = config.adapter || defaults.adapter;
-// Writes buffered data to the current native request
-RedirectableRequest.prototype.write = function (data, encoding, callback) {
- // Validate input and shift parameters if necessary
- if (!(typeof data === "string" || typeof data === "object" && ("length" in data))) {
- throw new Error("data should be a string, Buffer or Uint8Array");
- }
- if (typeof encoding === "function") {
- callback = encoding;
- encoding = null;
- }
+ return adapter(config).then(function onAdapterResolution(response) {
+ throwIfCancellationRequested(config);
- // 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 Error("Request body larger than maxBodyLength limit"));
- this.abort();
- }
-};
+ // Transform response data
+ response.data = transformData(
+ response.data,
+ response.headers,
+ config.transformResponse
+ );
-// 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;
- }
+ return response;
+ }, function onAdapterRejection(reason) {
+ if (!isCancel(reason)) {
+ throwIfCancellationRequested(config);
- // Write data and end
- var currentRequest = this._currentRequest;
- this.write(data || "", encoding, function () {
- currentRequest.end(null, null, callback);
+ // Transform response data
+ if (reason && reason.response) {
+ reason.response.data = transformData(
+ reason.response.data,
+ reason.response.headers,
+ config.transformResponse
+ );
+ }
+ }
+
+ return Promise.reject(reason);
});
};
-// 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);
-};
+/***/ }),
+/* 448 */
+/***/ (function(module, exports, __webpack_require__) {
-// Proxy all other public ClientRequest methods
-[
- "abort", "flushHeaders", "getHeader",
- "setNoDelay", "setSocketKeepAlive", "setTimeout",
-].forEach(function (method) {
- RedirectableRequest.prototype[method] = function (a, b) {
- return this._currentRequest[method](a, b);
- };
-});
+"use strict";
-// Proxy all public ClientRequest properties
-["aborted", "connection", "socket"].forEach(function (property) {
- Object.defineProperty(RedirectableRequest.prototype, property, {
- get: function () { return this._currentRequest[property]; },
- });
-});
-// 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 Error("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);
+var utils = __webpack_require__(442);
- // Set up event handlers
- request._redirectable = this;
- for (var event in eventHandlers) {
- /* istanbul ignore else */
- if (event) {
- request.on(event, eventHandlers[event]);
- }
- }
+/**
+ * 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);
+ });
- // 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 buffers = this._requestBodyBuffers;
- (function writeNext() {
- if (i < buffers.length) {
- var buffer = buffers[i++];
- request.write(buffer.data, buffer.encoding, writeNext);
- }
- else {
- request.end();
- }
- }());
- }
+ return data;
};
-// Processes a response from the current native request
-RedirectableRequest.prototype._processResponse = function (response) {
- // Store the redirected response
- if (this._options.trackRedirects) {
- this._redirects.push({
- url: this._currentUrl,
- headers: response.headers,
- statusCode: response.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 &&
- response.statusCode >= 300 && response.statusCode < 400) {
- // 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 Error("Max redirects exceeded."));
- return;
- }
-
- // RFC7231§6.4: Automatic redirection needs to done with
- // care for methods not known to be safe […],
- // since the user might not wish to redirect an unsafe request.
- // RFC7231§6.4.7: The 307 (Temporary Redirect) status code indicates
- // that the target resource resides temporarily under a different URI
- // and the user agent MUST NOT change the request method
- // if it performs an automatic redirection to that URI.
- var header;
- var headers = this._options.headers;
- if (response.statusCode !== 307 && !(this._options.method in SAFE_METHODS)) {
- this._options.method = "GET";
- // Drop a possible entity and headers related to it
- this._requestBodyBuffers = [];
- for (header in headers) {
- if (/^content-/i.test(header)) {
- delete headers[header];
- }
- }
- }
- // Drop the Host header, as the redirect might lead to a different host
- if (!this._isRedirect) {
- for (header in headers) {
- if (/^host$/i.test(header)) {
- delete headers[header];
- }
- }
- }
+/***/ }),
+/* 449 */
+/***/ (function(module, exports, __webpack_require__) {
- // Perform the redirected request
- var redirectUrl = url.resolve(this._currentUrl, location);
- debug("redirecting to", redirectUrl);
- Object.assign(this._options, url.parse(redirectUrl));
- this._isRedirect = true;
- this._performRequest();
+"use strict";
- // Discard the remainder of the response to avoid waiting for data
- response.destroy();
- }
- 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 = [];
- }
+module.exports = function isCancel(value) {
+ return !!(value && value.__CANCEL__);
};
-// 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 (options, callback) {
- if (typeof options === "string") {
- options = url.parse(options);
- options.maxRedirects = exports.maxRedirects;
- }
- else {
- options = Object.assign({
- protocol: protocol,
- maxRedirects: exports.maxRedirects,
- maxBodyLength: exports.maxBodyLength,
- }, 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 (options, callback) {
- var request = wrappedProtocol.request(options, callback);
- request.end();
- return request;
- };
- });
- return exports;
-}
+/***/ }),
+/* 450 */
+/***/ (function(module, exports, __webpack_require__) {
-// Exports
-module.exports = wrap({ http: http, https: https });
-module.exports.wrap = wrap;
+"use strict";
-/***/ }),
-/* 479 */
-/***/ (function(module, exports, __webpack_require__) {
+var utils = __webpack_require__(442);
+var normalizeHeaderName = __webpack_require__(451);
-/**
- * Detect Electron renderer process, which is node, but we should
- * treat as a browser.
- */
+var DEFAULT_CONTENT_TYPE = {
+ 'Content-Type': 'application/x-www-form-urlencoded'
+};
-if (typeof process === 'undefined' || process.type === 'renderer') {
- module.exports = __webpack_require__(480);
-} else {
- module.exports = __webpack_require__(483);
+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__(452);
+ } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
+ // For node use HTTP adapter
+ adapter = __webpack_require__(462);
+ }
+ return adapter;
+}
-/***/ }),
-/* 480 */
-/***/ (function(module, exports, __webpack_require__) {
+var defaults = {
+ adapter: getDefaultAdapter(),
-/**
- * This is the web browser implementation of `debug()`.
- *
- * Expose `debug()` as the module.
- */
+ 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;
+ }],
-exports = module.exports = __webpack_require__(481);
-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();
+ transformResponse: [function transformResponse(data) {
+ /*eslint no-param-reassign:0*/
+ if (typeof data === 'string') {
+ try {
+ data = JSON.parse(data);
+ } catch (e) { /* Ignore */ }
+ }
+ return data;
+ }],
-/**
- * Colors.
- */
+ /**
+ * A timeout in milliseconds to abort a request. If set to 0 (default) a
+ * timeout is not created.
+ */
+ timeout: 0,
-exports.colors = [
- '#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC',
- '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF',
- '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC',
- '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF',
- '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC',
- '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033',
- '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366',
- '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933',
- '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC',
- '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF',
- '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'
-];
+ xsrfCookieName: 'XSRF-TOKEN',
+ xsrfHeaderName: 'X-XSRF-TOKEN',
-/**
- * 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
- */
+ maxContentLength: -1,
-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;
+ validateStatus: function validateStatus(status) {
+ return status >= 200 && status < 300;
}
+};
- // Internet Explorer and Edge do not support colors.
- if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
- return false;
+defaults.headers = {
+ common: {
+ 'Accept': 'application/json, text/plain, */*'
}
+};
- // 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.
- */
+utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
+ defaults.headers[method] = {};
+});
-exports.formatters.j = function(v) {
- try {
- return JSON.stringify(v);
- } catch (err) {
- return '[UnexpectedJSONParseError]: ' + err.message;
- }
-};
+utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
+ defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
+});
+module.exports = defaults;
-/**
- * Colorize log arguments if enabled.
- *
- * @api public
- */
-function formatArgs(args) {
- var useColors = this.useColors;
+/***/ }),
+/* 451 */
+/***/ (function(module, exports, __webpack_require__) {
- args[0] = (useColors ? '%c' : '')
- + this.namespace
- + (useColors ? ' %c' : ' ')
- + args[0]
- + (useColors ? '%c ' : ' ')
- + '+' + exports.humanize(this.diff);
+"use strict";
- if (!useColors) return;
- var c = 'color: ' + this.color;
- args.splice(1, 0, c, 'color: inherit')
+var utils = __webpack_require__(442);
- // 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;
+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];
}
});
+};
- args.splice(lastC, 0, c);
-}
-/**
- * Invokes `console.log()` when available.
- * No-op when `console.log` is not a "function".
- *
- * @api public
- */
+/***/ }),
+/* 452 */
+/***/ (function(module, exports, __webpack_require__) {
-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);
-}
+"use strict";
-/**
- * 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) {}
-}
+var utils = __webpack_require__(442);
+var settle = __webpack_require__(453);
+var buildURL = __webpack_require__(445);
+var buildFullPath = __webpack_require__(456);
+var parseHeaders = __webpack_require__(459);
+var isURLSameOrigin = __webpack_require__(460);
+var createError = __webpack_require__(454);
-/**
- * Load `namespaces`.
- *
- * @return {String} returns the previously persisted debug modes
- * @api private
- */
+module.exports = function xhrAdapter(config) {
+ return new Promise(function dispatchXhrRequest(resolve, reject) {
+ var requestData = config.data;
+ var requestHeaders = config.headers;
-function load() {
- var r;
- try {
- r = exports.storage.debug;
- } catch(e) {}
+ if (utils.isFormData(requestData)) {
+ delete requestHeaders['Content-Type']; // Let the browser set it
+ }
- // 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;
- }
+ var request = new XMLHttpRequest();
- return r;
-}
+ // HTTP basic authentication
+ if (config.auth) {
+ var username = config.auth.username || '';
+ var password = config.auth.password || '';
+ requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
+ }
-/**
- * Enable namespaces listed in `localStorage.debug` initially.
- */
+ var fullPath = buildFullPath(config.baseURL, config.url);
+ request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
-exports.enable(load());
+ // Set the request timeout in MS
+ request.timeout = config.timeout;
-/**
- * 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
- */
+ // Listen for ready state
+ request.onreadystatechange = function handleLoad() {
+ if (!request || request.readyState !== 4) {
+ return;
+ }
-function localstorage() {
- try {
- return window.localStorage;
- } catch (e) {}
-}
+ // 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
+ };
-/***/ }),
-/* 481 */
-/***/ (function(module, exports, __webpack_require__) {
+ settle(resolve, reject, response);
+ // Clean up request
+ request = null;
+ };
-/**
- * This is the common logic for both the Node.js and web browser
- * implementations of `debug()`.
- *
- * Expose `debug()` as the module.
- */
+ // Handle browser request cancellation (as opposed to a manual cancellation)
+ request.onabort = function handleAbort() {
+ if (!request) {
+ return;
+ }
-exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
-exports.coerce = coerce;
-exports.disable = disable;
-exports.enable = enable;
-exports.enabled = enabled;
-exports.humanize = __webpack_require__(482);
+ reject(createError('Request aborted', config, 'ECONNABORTED', request));
-/**
- * Active `debug` instances.
- */
-exports.instances = [];
-
-/**
- * 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 = {};
-
-/**
- * Select a color.
- * @param {String} namespace
- * @return {Number}
- * @api private
- */
+ // Clean up request
+ request = null;
+ };
-function selectColor(namespace) {
- var hash = 0, i;
+ // 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));
- for (i in namespace) {
- hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
- hash |= 0; // Convert to 32bit integer
- }
+ // Clean up request
+ request = null;
+ };
- return exports.colors[Math.abs(hash) % exports.colors.length];
-}
+ // 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));
-/**
- * Create a debugger with the given `namespace`.
- *
- * @param {String} namespace
- * @return {Function}
- * @api public
- */
+ // Clean up request
+ request = null;
+ };
-function createDebug(namespace) {
+ // 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()) {
+ var cookies = __webpack_require__(461);
- var prevTime;
+ // Add xsrf header
+ var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?
+ cookies.read(config.xsrfCookieName) :
+ undefined;
- function debug() {
- // disabled?
- if (!debug.enabled) return;
+ if (xsrfValue) {
+ requestHeaders[config.xsrfHeaderName] = xsrfValue;
+ }
+ }
- var self = debug;
+ // 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);
+ }
+ });
+ }
- // set `diff` timestamp
- var curr = +new Date();
- var ms = curr - (prevTime || curr);
- self.diff = ms;
- self.prev = prevTime;
- self.curr = curr;
- prevTime = curr;
+ // Add withCredentials to request if needed
+ if (!utils.isUndefined(config.withCredentials)) {
+ request.withCredentials = !!config.withCredentials;
+ }
- // 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];
+ // 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;
+ }
+ }
}
- args[0] = exports.coerce(args[0]);
+ // Handle progress if needed
+ if (typeof config.onDownloadProgress === 'function') {
+ request.addEventListener('progress', config.onDownloadProgress);
+ }
- if ('string' !== typeof args[0]) {
- // anything else let's inspect with %O
- args.unshift('%O');
+ // Not all browsers support upload events
+ if (typeof config.onUploadProgress === 'function' && request.upload) {
+ request.upload.addEventListener('progress', config.onUploadProgress);
}
- // 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);
+ if (config.cancelToken) {
+ // Handle cancellation
+ config.cancelToken.promise.then(function onCanceled(cancel) {
+ if (!request) {
+ return;
+ }
- // now we need to remove `args[index]` since it's inlined in the `format`
- args.splice(index, 1);
- index--;
- }
- return match;
- });
+ request.abort();
+ reject(cancel);
+ // Clean up request
+ request = null;
+ });
+ }
- // apply env-specific formatting (colors, etc.)
- exports.formatArgs.call(self, args);
+ if (requestData === undefined) {
+ requestData = null;
+ }
- var logFn = debug.log || exports.log || console.log.bind(console);
- logFn.apply(self, args);
- }
+ // Send the request
+ request.send(requestData);
+ });
+};
- debug.namespace = namespace;
- debug.enabled = exports.enabled(namespace);
- debug.useColors = exports.useColors();
- debug.color = selectColor(namespace);
- debug.destroy = destroy;
- // env-specific initialization logic for debug instances
- if ('function' === typeof exports.init) {
- exports.init(debug);
- }
+/***/ }),
+/* 453 */
+/***/ (function(module, exports, __webpack_require__) {
- exports.instances.push(debug);
+"use strict";
- return debug;
-}
-function destroy () {
- var index = exports.instances.indexOf(this);
- if (index !== -1) {
- exports.instances.splice(index, 1);
- return true;
- } else {
- return false;
- }
-}
+var createError = __webpack_require__(454);
/**
- * Enables a debug mode by namespaces. This can include modes
- * separated by a colon and wildcards.
+ * Resolve or reject a Promise based on response status.
*
- * @param {String} namespaces
- * @api public
+ * @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 (!validateStatus || validateStatus(response.status)) {
+ resolve(response);
+ } else {
+ reject(createError(
+ 'Request failed with status code ' + response.status,
+ response.config,
+ null,
+ response.request,
+ response
+ ));
+ }
+};
-function enable(namespaces) {
- exports.save(namespaces);
- exports.names = [];
- exports.skips = [];
+/***/ }),
+/* 454 */
+/***/ (function(module, exports, __webpack_require__) {
- var i;
- var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
- var len = split.length;
+"use strict";
- for (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 + '$'));
- }
- }
- for (i = 0; i < exports.instances.length; i++) {
- var instance = exports.instances[i];
- instance.enabled = exports.enabled(instance.namespace);
- }
-}
+var enhanceError = __webpack_require__(455);
/**
- * Disable debug output.
+ * Create an Error with the specified message, config, error code, request and response.
*
- * @api public
+ * @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);
+};
-function disable() {
- exports.enable('');
-}
-/**
- * Returns true if the given mode name is enabled, false otherwise.
- *
- * @param {String} name
- * @return {Boolean}
- * @api public
- */
+/***/ }),
+/* 455 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
-function enabled(name) {
- if (name[name.length - 1] === '*') {
- return true;
- }
- 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`.
+ * Update an Error with the specified config, error code, and response.
*
- * @param {Mixed} val
- * @return {Mixed}
- * @api private
+ * @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;
+ }
-function coerce(val) {
- if (val instanceof Error) return val.stack || val.message;
- return val;
-}
+ error.request = request;
+ error.response = response;
+ error.isAxiosError = true;
+
+ error.toJSON = function() {
+ 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;
+};
/***/ }),
-/* 482 */
-/***/ (function(module, exports) {
+/* 456 */
+/***/ (function(module, exports, __webpack_require__) {
-/**
- * Helpers.
- */
+"use strict";
-var s = 1000;
-var m = s * 60;
-var h = m * 60;
-var d = h * 24;
-var y = d * 365.25;
+
+var isAbsoluteURL = __webpack_require__(457);
+var combineURLs = __webpack_require__(458);
/**
- * Parse or format the given `val`.
- *
- * Options:
- *
- * - `long` verbose formatting [false]
+ * 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|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
+ * @param {string} baseURL The base URL
+ * @param {string} requestedURL Absolute or relative URL to combine
+ * @returns {string} The combined full path
*/
-
-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);
+module.exports = function buildFullPath(baseURL, requestedURL) {
+ if (baseURL && !isAbsoluteURL(requestedURL)) {
+ return combineURLs(baseURL, requestedURL);
}
- throw new Error(
- 'val is not a non-empty string or a valid number. val=' +
- JSON.stringify(val)
- );
+ return requestedURL;
};
-/**
- * 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;
- }
-}
+/***/ }),
+/* 457 */
+/***/ (function(module, exports, __webpack_require__) {
-/**
- * Short format for `ms`.
- *
- * @param {Number} ms
- * @return {String}
- * @api private
- */
+"use strict";
-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`.
+ * Determines whether the specified URL is absolute
*
- * @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.
+ * @param {string} url The URL to test
+ * @returns {boolean} True if the specified URL is absolute, otherwise false
*/
-
-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';
-}
+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);
+};
/***/ }),
-/* 483 */
+/* 458 */
/***/ (function(module, exports, __webpack_require__) {
-/**
- * Module dependencies.
- */
+"use strict";
-var tty = __webpack_require__(484);
-var util = __webpack_require__(29);
/**
- * This is the Node.js implementation of `debug()`.
+ * Creates a new URL by combining the specified URLs
*
- * Expose `debug()` as the module.
- */
-
-exports = module.exports = __webpack_require__(481);
-exports.init = init;
-exports.log = log;
-exports.formatArgs = formatArgs;
-exports.save = save;
-exports.load = load;
-exports.useColors = useColors;
-
-/**
- * Colors.
+ * @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;
+};
-exports.colors = [ 6, 2, 3, 4, 5, 1 ];
-try {
- var supportsColor = __webpack_require__(485);
- if (supportsColor && supportsColor.level >= 2) {
- exports.colors = [
- 20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68,
- 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 128, 129, 134,
- 135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
- 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202, 203, 204,
- 205, 206, 207, 208, 209, 214, 215, 220, 221
- ];
- }
-} catch (err) {
- // swallow - we only care if `supports-color` is available; it doesn't have to be.
-}
+/***/ }),
+/* 459 */
+/***/ (function(module, exports, __webpack_require__) {
-/**
- * Build up the default `inspectOpts` object from the environment variables.
- *
- * $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
- */
+"use strict";
-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);
+var utils = __webpack_require__(442);
- obj[prop] = val;
- return obj;
-}, {});
+// 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'
+];
/**
- * Is stdout a TTY? Colored output is enabled when `true`.
+ * 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;
-function useColors() {
- return 'colors' in exports.inspectOpts
- ? Boolean(exports.inspectOpts.colors)
- : tty.isatty(process.stderr.fd);
-}
-
-/**
- * Map %o to `util.inspect()`, all on a single line.
- */
+ if (!headers) { return parsed; }
-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(' ');
-};
+ 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));
-/**
- * Map %o to `util.inspect()`, allowing multiple lines if needed.
- */
+ 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;
+ }
+ }
+ });
-exports.formatters.O = function(v) {
- this.inspectOpts.colors = this.useColors;
- return util.inspect(v, this.inspectOpts);
+ return parsed;
};
-/**
- * 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 colorCode = '\u001b[3' + (c < 8 ? c : '8;5;' + c);
- var prefix = ' ' + colorCode + ';1m' + name + ' ' + '\u001b[0m';
-
- args[0] = prefix + args[0].split('\n').join('\n' + prefix);
- args.push(colorCode + 'm+' + exports.humanize(this.diff) + '\u001b[0m');
- } else {
- args[0] = getDate() + name + ' ' + args[0];
- }
-}
-
-function getDate() {
- if (exports.inspectOpts.hideDate) {
- return '';
- } else {
- return new Date().toISOString() + ' ';
- }
-}
-/**
- * Invokes `util.format()` with the specified arguments and writes to stderr.
- */
+/***/ }),
+/* 460 */
+/***/ (function(module, exports, __webpack_require__) {
-function log() {
- return process.stderr.write(util.format.apply(util, arguments) + '\n');
-}
+"use strict";
-/**
- * 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;
- }
-}
+var utils = __webpack_require__(442);
-/**
- * Load `namespaces`.
- *
- * @return {String} returns the previously persisted debug modes
- * @api private
- */
+module.exports = (
+ utils.isStandardBrowserEnv() ?
-function load() {
- return process.env.DEBUG;
-}
+ // 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;
-/**
- * Init logic for `debug` instances.
- *
- * Create a new `inspectOpts` object in case `useColors` is set
- * differently for a particular `debug` instance.
- */
+ /**
+ * Parse a URL to discover it's components
+ *
+ * @param {String} url The URL to be parsed
+ * @returns {Object}
+ */
+ function resolveURL(url) {
+ var href = url;
-function init (debug) {
- debug.inspectOpts = {};
+ if (msie) {
+ // IE needs attribute set twice to normalize properties
+ urlParsingNode.setAttribute('href', href);
+ href = urlParsingNode.href;
+ }
- var keys = Object.keys(exports.inspectOpts);
- for (var i = 0; i < keys.length; i++) {
- debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
- }
-}
+ urlParsingNode.setAttribute('href', href);
-/**
- * Enable namespaces listed in `process.env.DEBUG` initially.
- */
+ // 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
+ };
+ }
-exports.enable(load());
+ 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);
+ };
+ })() :
-/***/ }),
-/* 484 */
-/***/ (function(module, exports) {
+ // Non standard browser envs (web workers, react-native) lack needed support.
+ (function nonStandardBrowserEnv() {
+ return function isURLSameOrigin() {
+ return true;
+ };
+ })()
+);
-module.exports = require("tty");
/***/ }),
-/* 485 */
+/* 461 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const os = __webpack_require__(11);
-const hasFlag = __webpack_require__(12);
-
-const env = process.env;
-let forceColor;
-if (hasFlag('no-color') ||
- hasFlag('no-colors') ||
- hasFlag('color=false')) {
- forceColor = false;
-} else if (hasFlag('color') ||
- hasFlag('colors') ||
- hasFlag('color=true') ||
- hasFlag('color=always')) {
- forceColor = true;
-}
-if ('FORCE_COLOR' in env) {
- forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
-}
+var utils = __webpack_require__(442);
-function translateLevel(level) {
- if (level === 0) {
- return false;
- }
+module.exports = (
+ utils.isStandardBrowserEnv() ?
- return {
- level,
- hasBasic: true,
- has256: level >= 2,
- has16m: level >= 3
- };
-}
+ // 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));
-function supportsColor(stream) {
- if (forceColor === false) {
- return 0;
- }
+ if (utils.isNumber(expires)) {
+ cookie.push('expires=' + new Date(expires).toGMTString());
+ }
- if (hasFlag('color=16m') ||
- hasFlag('color=full') ||
- hasFlag('color=truecolor')) {
- return 3;
- }
+ if (utils.isString(path)) {
+ cookie.push('path=' + path);
+ }
- if (hasFlag('color=256')) {
- return 2;
- }
+ if (utils.isString(domain)) {
+ cookie.push('domain=' + domain);
+ }
- if (stream && !stream.isTTY && forceColor !== true) {
- return 0;
- }
+ if (secure === true) {
+ cookie.push('secure');
+ }
- const min = forceColor ? 1 : 0;
+ document.cookie = cookie.join('; ');
+ },
- if (process.platform === 'win32') {
- // Node.js 7.5.0 is the first version of Node.js to include a patch to
- // libuv that enables 256 color output on Windows. Anything earlier and it
- // won't work. However, here we target Node.js 8 at minimum as it is an LTS
- // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
- // release that supports 256 colors. Windows 10 build 14931 is the first release
- // that supports 16m/TrueColor.
- const osRelease = os.release().split('.');
- if (
- Number(process.versions.node.split('.')[0]) >= 8 &&
- Number(osRelease[0]) >= 10 &&
- Number(osRelease[2]) >= 10586
- ) {
- return Number(osRelease[2]) >= 14931 ? 3 : 2;
- }
+ read: function read(name) {
+ var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
+ return (match ? decodeURIComponent(match[3]) : null);
+ },
- return 1;
- }
+ remove: function remove(name) {
+ this.write(name, '', Date.now() - 86400000);
+ }
+ };
+ })() :
- if ('CI' in env) {
- if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
- return 1;
- }
+ // 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() {}
+ };
+ })()
+);
- return min;
- }
- if ('TEAMCITY_VERSION' in env) {
- return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
- }
+/***/ }),
+/* 462 */
+/***/ (function(module, exports, __webpack_require__) {
- if (env.COLORTERM === 'truecolor') {
- return 3;
- }
+"use strict";
- if ('TERM_PROGRAM' in env) {
- const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
- switch (env.TERM_PROGRAM) {
- case 'iTerm.app':
- return version >= 3 ? 3 : 2;
- case 'Apple_Terminal':
- return 2;
- // No default
- }
- }
+var utils = __webpack_require__(442);
+var settle = __webpack_require__(453);
+var buildFullPath = __webpack_require__(456);
+var buildURL = __webpack_require__(445);
+var http = __webpack_require__(463);
+var https = __webpack_require__(464);
+var httpFollow = __webpack_require__(465).http;
+var httpsFollow = __webpack_require__(465).https;
+var url = __webpack_require__(439);
+var zlib = __webpack_require__(473);
+var pkg = __webpack_require__(474);
+var createError = __webpack_require__(454);
+var enhanceError = __webpack_require__(455);
- if (/-256(color)?$/i.test(env.TERM)) {
- return 2;
- }
+var isHttps = /https:?/;
- if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
- return 1;
- }
+/*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;
- if ('COLORTERM' in env) {
- return 1;
- }
+ // 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 (env.TERM === 'dumb') {
- return min;
- }
+ 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
+ ));
+ }
- return min;
-}
+ // Add Content-Length header if data exists
+ headers['Content-Length'] = data.length;
+ }
-function getSupportLevel(stream) {
- const level = supportsColor(stream);
- return translateLevel(level);
-}
+ // HTTP basic authentication
+ var auth = undefined;
+ if (config.auth) {
+ var username = config.auth.username || '';
+ var password = config.auth.password || '';
+ auth = username + ':' + password;
+ }
-module.exports = {
- supportsColor: getSupportLevel,
- stdout: getSupportLevel(process.stdout),
- stderr: getSupportLevel(process.stderr)
-};
+ // 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;
+ }
-/***/ }),
-/* 486 */
-/***/ (function(module, exports) {
+ if (auth) {
+ delete headers.Authorization;
+ }
-module.exports = require("zlib");
+ var isHttpsRequest = isHttps.test(protocol);
+ var agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
-/***/ }),
-/* 487 */
-/***/ (function(module) {
+ 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
+ };
-module.exports = JSON.parse("{\"name\":\"axios\",\"version\":\"0.19.2\",\"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\"},\"typings\":\"./index.d.ts\",\"dependencies\":{\"follow-redirects\":\"1.5.10\"},\"bundlesize\":[{\"path\":\"./dist/axios.min.js\",\"threshold\":\"5kB\"}]}");
+ if (config.socketPath) {
+ options.socketPath = config.socketPath;
+ } else {
+ options.hostname = parsed.hostname;
+ options.port = parsed.port;
+ }
-/***/ }),
-/* 488 */
-/***/ (function(module, exports, __webpack_require__) {
+ 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;
-"use strict";
+ 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;
+ }
-var utils = __webpack_require__(455);
+ return parsed.hostname === proxyElement;
+ });
+ }
-/**
- * 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', 'params', 'data'];
- var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy'];
- var defaultToConfig2Keys = [
- 'baseURL', 'url', 'transformRequest', 'transformResponse', 'paramsSerializer',
- 'timeout', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName',
- 'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress',
- 'maxContentLength', 'validateStatus', 'maxRedirects', 'httpAgent',
- 'httpsAgent', 'cancelToken', 'socketPath'
- ];
+ if (shouldProxy) {
+ proxy = {
+ host: parsedProxyUrl.hostname,
+ port: parsedProxyUrl.port
+ };
- utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
- if (typeof config2[prop] !== 'undefined') {
- config[prop] = config2[prop];
+ if (parsedProxyUrl.auth) {
+ var proxyUrlAuth = parsedProxyUrl.auth.split(':');
+ proxy.auth = {
+ username: proxyUrlAuth[0],
+ password: proxyUrlAuth[1]
+ };
+ }
+ }
+ }
}
- });
- utils.forEach(mergeDeepPropertiesKeys, function mergeDeepProperties(prop) {
- if (utils.isObject(config2[prop])) {
- config[prop] = utils.deepMerge(config1[prop], config2[prop]);
- } else if (typeof config2[prop] !== 'undefined') {
- config[prop] = config2[prop];
- } else if (utils.isObject(config1[prop])) {
- config[prop] = utils.deepMerge(config1[prop]);
- } else if (typeof config1[prop] !== 'undefined') {
- config[prop] = config1[prop];
- }
- });
+ if (proxy) {
+ options.hostname = proxy.host;
+ options.host = proxy.host;
+ options.headers.host = parsed.hostname + (parsed.port ? ':' + parsed.port : '');
+ options.port = proxy.port;
+ options.path = protocol + '//' + parsed.hostname + (parsed.port ? ':' + parsed.port : '') + options.path;
- utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
- if (typeof config2[prop] !== 'undefined') {
- config[prop] = config2[prop];
- } else if (typeof config1[prop] !== 'undefined') {
- config[prop] = config1[prop];
+ // 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;
+ }
}
- });
-
- var axiosKeys = valueFromConfig2Keys
- .concat(mergeDeepPropertiesKeys)
- .concat(defaultToConfig2Keys);
-
- var otherKeys = Object
- .keys(config2)
- .filter(function filterAxiosKeys(key) {
- return axiosKeys.indexOf(key) === -1;
- });
- utils.forEach(otherKeys, function otherKeysDefaultToConfig2(prop) {
- if (typeof config2[prop] !== 'undefined') {
- config[prop] = config2[prop];
- } else if (typeof config1[prop] !== 'undefined') {
- config[prop] = config1[prop];
+ 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;
}
- });
-
- return config;
-};
+ if (config.maxContentLength && config.maxContentLength > -1) {
+ options.maxBodyLength = config.maxContentLength;
+ }
-/***/ }),
-/* 489 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
+ // 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;
+ 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 = (res.statusCode === 204) ? stream : stream.pipe(zlib.createUnzip());
-/**
- * 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;
-}
+ // remove the content-encoding in order to not confuse downstream operations
+ delete res.headers['content-encoding'];
+ break;
+ }
-Cancel.prototype.toString = function toString() {
- return 'Cancel' + (this.message ? ': ' + this.message : '');
-};
+ // return the last request in case of redirects
+ var lastRequest = res.req || req;
-Cancel.prototype.__CANCEL__ = true;
+ var response = {
+ status: res.statusCode,
+ statusText: res.statusMessage,
+ headers: res.headers,
+ config: config,
+ request: lastRequest
+ };
-module.exports = Cancel;
+ 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));
+ }
+ });
-/***/ }),
-/* 490 */
-/***/ (function(module, exports, __webpack_require__) {
+ stream.on('error', function handleStreamError(err) {
+ if (req.aborted) return;
+ reject(enhanceError(err, config, null, lastRequest));
+ });
-"use strict";
+ stream.on('end', function handleStreamEnd() {
+ var responseData = Buffer.concat(responseBuffer);
+ if (config.responseType !== 'arraybuffer') {
+ responseData = responseData.toString(config.responseEncoding);
+ }
+ response.data = responseData;
+ settle(resolve, reject, response);
+ });
+ }
+ });
-var Cancel = __webpack_require__(489);
+ // Handle errors
+ req.on('error', function handleRequestError(err) {
+ if (req.aborted) return;
+ reject(enhanceError(err, config, null, req));
+ });
-/**
- * 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.');
- }
+ // 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));
+ });
+ }
- var resolvePromise;
- this.promise = new Promise(function promiseExecutor(resolve) {
- resolvePromise = resolve;
- });
+ if (config.cancelToken) {
+ // Handle cancellation
+ config.cancelToken.promise.then(function onCanceled(cancel) {
+ if (req.aborted) return;
- var token = this;
- executor(function cancel(message) {
- if (token.reason) {
- // Cancellation has already been requested
- return;
+ req.abort();
+ reject(cancel);
+ });
}
- token.reason = new Cancel(message);
- resolvePromise(token.reason);
+ // 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);
+ }
});
-}
-
-/**
- * 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;
+/***/ }),
+/* 463 */
+/***/ (function(module, exports) {
+module.exports = require("http");
/***/ }),
-/* 491 */
+/* 464 */
+/***/ (function(module, exports) {
+
+module.exports = require("https");
+
+/***/ }),
+/* 465 */
/***/ (function(module, exports, __webpack_require__) {
-"use strict";
+var url = __webpack_require__(439);
+var http = __webpack_require__(463);
+var https = __webpack_require__(464);
+var assert = __webpack_require__(371);
+var Writable = __webpack_require__(382).Writable;
+var debug = __webpack_require__(466)("follow-redirects");
+// RFC7231§4.2.1: Of the request methods defined by this specification,
+// the GET, HEAD, OPTIONS, and TRACE methods are defined to be safe.
+var SAFE_METHODS = { GET: true, HEAD: true, OPTIONS: true, TRACE: true };
-/**
- * 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);
+// Create handlers that pass events from native requests
+var eventHandlers = Object.create(null);
+["abort", "aborted", "error", "socket", "timeout"].forEach(function (event) {
+ eventHandlers[event] = function (arg) {
+ this._redirectable.emit(event, arg);
};
-};
+});
+// An HTTP(S) request that can be redirected
+function RedirectableRequest(options, responseCallback) {
+ // Initialize the request
+ Writable.call(this);
+ options.headers = options.headers || {};
+ this._options = options;
+ this._redirectCount = 0;
+ this._redirects = [];
+ this._requestBodyLength = 0;
+ this._requestBodyBuffers = [];
-/***/ }),
-/* 492 */
-/***/ (function(module, exports, __webpack_require__) {
+ // 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;
+ }
-"use strict";
+ // Attach a callback if passed
+ if (responseCallback) {
+ this.on("response", responseCallback);
+ }
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-tslib_1.__exportStar(__webpack_require__(493), exports);
+ // React to responses of native requests
+ var self = this;
+ this._onNativeResponse = function (response) {
+ self._processResponse(response);
+ };
+ // 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);
+ }
+ }
-/***/ }),
-/* 493 */
-/***/ (function(module, exports, __webpack_require__) {
+ // Perform the first request
+ this._performRequest();
+}
+RedirectableRequest.prototype = Object.create(Writable.prototype);
-"use strict";
+// Writes buffered data to the current native request
+RedirectableRequest.prototype.write = function (data, encoding, callback) {
+ // Validate input and shift parameters if necessary
+ if (!(typeof data === "string" || typeof data === "object" && ("length" in data))) {
+ throw new Error("data should be a string, Buffer or Uint8Array");
+ }
+ if (typeof encoding === "function") {
+ callback = encoding;
+ encoding = null;
+ }
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAxiosRequestError = (error) => {
- return error && error.config && error.response === undefined;
-};
-exports.isAxiosResponseError = (error) => {
- return error && error.response && error.response.status !== undefined;
+ // 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 Error("Request body larger than maxBodyLength limit"));
+ 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;
+ }
-/***/ }),
-/* 494 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
+ // Write data and end
+ var currentRequest = this._currentRequest;
+ this.write(data || "", encoding, function () {
+ currentRequest.end(null, null, callback);
+ });
+};
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-class KbnClientStatus {
- constructor(requester) {
- this.requester = requester;
- }
- /**
- * Get the full server status
- */
- async get() {
- return await this.requester.request({
- method: 'GET',
- path: 'api/status',
- });
- }
- /**
- * Get the overall/merged state
- */
- async getOverallState() {
- const status = await this.get();
- return status.status.overall.state;
- }
-}
-exports.KbnClientStatus = KbnClientStatus;
+// 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);
+};
-/***/ }),
-/* 495 */
-/***/ (function(module, exports, __webpack_require__) {
+// Proxy all other public ClientRequest methods
+[
+ "abort", "flushHeaders", "getHeader",
+ "setNoDelay", "setSocketKeepAlive", "setTimeout",
+].forEach(function (method) {
+ RedirectableRequest.prototype[method] = function (a, b) {
+ return this._currentRequest[method](a, b);
+ };
+});
-"use strict";
+// Proxy all public ClientRequest properties
+["aborted", "connection", "socket"].forEach(function (property) {
+ Object.defineProperty(RedirectableRequest.prototype, property, {
+ get: function () { return this._currentRequest[property]; },
+ });
+});
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const PLUGIN_STATUS_ID = /^plugin:(.+?)@/;
-class KbnClientPlugins {
- constructor(status) {
- this.status = status;
- }
- /**
- * Get a list of plugin ids that are enabled on the server
- */
- async getEnabledIds() {
- const pluginIds = [];
- const apiResp = await this.status.get();
- for (const status of apiResp.status.statuses) {
- if (status.id) {
- const match = status.id.match(PLUGIN_STATUS_ID);
- if (match) {
- pluginIds.push(match[1]);
- }
- }
- }
- return pluginIds;
+// 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 Error("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]);
}
-}
-exports.KbnClientPlugins = KbnClientPlugins;
+ }
+ // 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 buffers = this._requestBodyBuffers;
+ (function writeNext() {
+ if (i < buffers.length) {
+ var buffer = buffers[i++];
+ request.write(buffer.data, buffer.encoding, writeNext);
+ }
+ else {
+ request.end();
+ }
+ }());
+ }
+};
-/***/ }),
-/* 496 */
-/***/ (function(module, exports, __webpack_require__) {
+// Processes a response from the current native request
+RedirectableRequest.prototype._processResponse = function (response) {
+ // Store the redirected response
+ if (this._options.trackRedirects) {
+ this._redirects.push({
+ url: this._currentUrl,
+ headers: response.headers,
+ statusCode: response.statusCode,
+ });
+ }
-"use strict";
+ // 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 &&
+ response.statusCode >= 300 && response.statusCode < 400) {
+ // 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 Error("Max redirects exceeded."));
+ return;
+ }
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-class KbnClientVersion {
- constructor(status) {
- this.status = status;
+ // RFC7231§6.4: Automatic redirection needs to done with
+ // care for methods not known to be safe […],
+ // since the user might not wish to redirect an unsafe request.
+ // RFC7231§6.4.7: The 307 (Temporary Redirect) status code indicates
+ // that the target resource resides temporarily under a different URI
+ // and the user agent MUST NOT change the request method
+ // if it performs an automatic redirection to that URI.
+ var header;
+ var headers = this._options.headers;
+ if (response.statusCode !== 307 && !(this._options.method in SAFE_METHODS)) {
+ this._options.method = "GET";
+ // Drop a possible entity and headers related to it
+ this._requestBodyBuffers = [];
+ for (header in headers) {
+ if (/^content-/i.test(header)) {
+ delete headers[header];
+ }
+ }
}
- async get() {
- if (this.versionCache !== undefined) {
- return this.versionCache;
+
+ // Drop the Host header, as the redirect might lead to a different host
+ if (!this._isRedirect) {
+ for (header in headers) {
+ if (/^host$/i.test(header)) {
+ delete headers[header];
}
- const status = await this.status.get();
- this.versionCache = status.version.number + (status.version.build_snapshot ? '-SNAPSHOT' : '');
- return this.versionCache;
+ }
}
-}
-exports.KbnClientVersion = KbnClientVersion;
+ // Perform the redirected request
+ var redirectUrl = url.resolve(this._currentUrl, location);
+ debug("redirecting to", redirectUrl);
+ Object.assign(this._options, url.parse(redirectUrl));
+ this._isRedirect = true;
+ this._performRequest();
-/***/ }),
-/* 497 */
-/***/ (function(module, exports, __webpack_require__) {
+ // Discard the remainder of the response to avoid waiting for data
+ response.destroy();
+ }
+ else {
+ // The response is not a redirect; return it as-is
+ response.responseUrl = this._currentUrl;
+ response.redirects = this._redirects;
+ this.emit("response", response);
-"use strict";
+ // Clean up
+ this._requestBodyBuffers = [];
+ }
+};
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const kbn_client_requester_1 = __webpack_require__(451);
-class KbnClientSavedObjects {
- constructor(log, requester) {
- this.log = log;
- this.requester = requester;
- }
- /**
- * Run the saved objects migration
- */
- async migrate() {
- this.log.debug('Migrating saved objects');
- return await this.requester.request({
- description: 'migrate saved objects',
- path: kbn_client_requester_1.uriencode `/internal/saved_objects/_migrate`,
- method: 'POST',
- body: {},
- });
- }
- /**
- * Get an object
- */
- async get(options) {
- this.log.debug('Gettings saved object: %j', options);
- return await this.requester.request({
- description: 'get saved object',
- path: kbn_client_requester_1.uriencode `/api/saved_objects/${options.type}/${options.id}`,
- method: 'GET',
- });
- }
- /**
- * Create a saved object
- */
- async create(options) {
- this.log.debug('Creating saved object: %j', options);
- return await this.requester.request({
- description: 'update saved object',
- path: options.id
- ? kbn_client_requester_1.uriencode `/api/saved_objects/${options.type}/${options.id}`
- : kbn_client_requester_1.uriencode `/api/saved_objects/${options.type}`,
- query: {
- overwrite: options.overwrite,
- },
- method: 'POST',
- body: {
- attributes: options.attributes,
- migrationVersion: options.migrationVersion,
- references: options.references,
- },
- });
- }
- /**
- * Update a saved object
- */
- async update(options) {
- this.log.debug('Updating saved object: %j', options);
- return await this.requester.request({
- description: 'update saved object',
- path: kbn_client_requester_1.uriencode `/api/saved_objects/${options.type}/${options.id}`,
- query: {
- overwrite: options.overwrite,
- },
- method: 'PUT',
- body: {
- attributes: options.attributes,
- migrationVersion: options.migrationVersion,
- references: options.references,
- },
- });
- }
- /**
- * Delete an object
- */
- async delete(options) {
- this.log.debug('Deleting saved object %s/%s', options);
- return await this.requester.request({
- description: 'delete saved object',
- path: kbn_client_requester_1.uriencode `/api/saved_objects/${options.type}/${options.id}`,
- method: 'DELETE',
- });
- }
+// 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 (options, callback) {
+ if (typeof options === "string") {
+ options = url.parse(options);
+ options.maxRedirects = exports.maxRedirects;
+ }
+ else {
+ options = Object.assign({
+ protocol: protocol,
+ maxRedirects: exports.maxRedirects,
+ maxBodyLength: exports.maxBodyLength,
+ }, 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 (options, callback) {
+ var request = wrappedProtocol.request(options, callback);
+ request.end();
+ return request;
+ };
+ });
+ return exports;
}
-exports.KbnClientSavedObjects = KbnClientSavedObjects;
+
+// Exports
+module.exports = wrap({ http: http, https: https });
+module.exports.wrap = wrap;
/***/ }),
-/* 498 */
+/* 466 */
/***/ (function(module, exports, __webpack_require__) {
-"use strict";
-
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
+/**
+ * Detect Electron renderer process, which is node, but we should
+ * treat as a browser.
*/
-Object.defineProperty(exports, "__esModule", { value: true });
-const kbn_client_requester_1 = __webpack_require__(451);
-class KbnClientUiSettings {
- constructor(log, requester, defaults) {
- this.log = log;
- this.requester = requester;
- this.defaults = defaults;
- }
- async get(setting) {
- var _a;
- const all = await this.getAll();
- const value = (_a = all[setting]) === null || _a === void 0 ? void 0 : _a.userValue;
- this.log.verbose('uiSettings.value: %j', value);
- return value;
- }
- /**
- * Gets defaultIndex from the config doc.
- */
- async getDefaultIndex() {
- return await this.get('defaultIndex');
- }
- /**
- * Unset a uiSetting
- */
- async unset(setting) {
- return await this.requester.request({
- path: kbn_client_requester_1.uriencode `/api/kibana/settings/${setting}`,
- method: 'DELETE',
- });
- }
- /**
- * Replace all uiSettings with the `doc` values, `doc` is merged
- * with some defaults
- */
- async replace(doc, { retries = 5 } = {}) {
- this.log.debug('replacing kibana config doc: %j', doc);
- const changes = {
- ...this.defaults,
- ...doc,
- };
- for (const [name, { isOverridden }] of Object.entries(await this.getAll())) {
- if (!isOverridden && !changes.hasOwnProperty(name)) {
- changes[name] = null;
- }
- }
- await this.requester.request({
- method: 'POST',
- path: '/api/kibana/settings',
- body: { changes },
- retries,
- });
- }
- /**
- * Add fields to the config doc (like setting timezone and defaultIndex)
- */
- async update(updates) {
- this.log.debug('applying update to kibana config: %j', updates);
- await this.requester.request({
- path: '/api/kibana/settings',
- method: 'POST',
- body: {
- changes: updates,
- },
- });
- }
- async getAll() {
- const resp = await this.requester.request({
- path: '/api/kibana/settings',
- method: 'GET',
- });
- return resp.settings;
- }
+
+if (typeof process === 'undefined' || process.type === 'renderer') {
+ module.exports = __webpack_require__(467);
+} else {
+ module.exports = __webpack_require__(470);
}
-exports.KbnClientUiSettings = KbnClientUiSettings;
/***/ }),
-/* 499 */
+/* 467 */
/***/ (function(module, exports, __webpack_require__) {
-"use strict";
-
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
+/**
+ * This is the web browser implementation of `debug()`.
*
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
+ * Expose `debug()` as the module.
*/
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-tslib_1.__exportStar(__webpack_require__(500), exports);
+exports = module.exports = __webpack_require__(468);
+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();
-/***/ }),
-/* 500 */
-/***/ (function(module, exports, __webpack_require__) {
+/**
+ * Colors.
+ */
-"use strict";
+exports.colors = [
+ '#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC',
+ '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF',
+ '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC',
+ '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF',
+ '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC',
+ '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033',
+ '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366',
+ '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933',
+ '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC',
+ '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF',
+ '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'
+];
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
+/**
+ * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+ * and the Firebug extension (any Firefox version) are known
+ * to support "%c" CSS customizations.
*
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
+ * TODO: add a `localStorage` variable to explicitly enable/disable colors
*/
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = __webpack_require__(36);
-const util_1 = __webpack_require__(29);
-const axios_1 = tslib_1.__importDefault(__webpack_require__(453));
-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;
-}
-function validateConfig(log, config) {
- 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;
-}
-class CiStatsReporter {
- constructor(config, log) {
- this.config = config;
- this.log = log;
- }
- static fromEnv(log) {
- return new CiStatsReporter(parseConfig(log), log);
- }
- isEnabled() {
- return !!this.config;
- }
- async metrics(metrics) {
- var _a, _b, _c, _d;
- if (!this.config) {
- return;
- }
- let attempt = 0;
- const maxAttempts = 5;
- const bodySummary = metrics
- .map(({ group, id, value }) => `[${group}/${id}=${value}]`)
- .join(' ');
- while (true) {
- attempt += 1;
- try {
- await axios_1.default.request({
- method: 'POST',
- url: '/v1/metrics',
- baseURL: this.config.apiUrl,
- headers: {
- Authorization: `token ${this.config.apiToken}`,
- },
- data: {
- buildId: this.config.buildId,
- metrics,
- },
- });
- return;
- }
- catch (error) {
- if (!((_a = error) === null || _a === void 0 ? void 0 : _a.request)) {
- // not an axios error, must be a usage error that we should notify user about
- throw error;
- }
- if (((_b = error) === null || _b === void 0 ? void 0 : _b.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=${util_1.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}`);
- return;
- }
- // we failed to reach the backend and we have remaining attempts, lets retry after a short delay
- const reason = ((_d = (_c = error) === null || _c === void 0 ? void 0 : _c.response) === null || _d === void 0 ? void 0 : _d.status) ? `${error.response.status} response`
- : 'no response';
- this.log.warning(`failed to reach kibana-ci-stats service [reason=${reason}], retrying in ${attempt} seconds`);
- await new Promise((resolve) => setTimeout(resolve, attempt * 1000));
- }
- }
- }
+
+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;
+ }
+
+ // Internet Explorer and Edge do not support colors.
+ if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+ return false;
+ }
+
+ // 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+)/));
}
-exports.CiStatsReporter = CiStatsReporter;
+/**
+ * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+ */
-/***/ }),
-/* 501 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+exports.formatters.j = function(v) {
+ try {
+ return JSON.stringify(v);
+ } catch (err) {
+ return '[UnexpectedJSONParseError]: ' + err.message;
+ }
+};
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parallelizeBatches", function() { return parallelizeBatches; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parallelize", function() { return parallelize; });
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
+
+/**
+ * Colorize log arguments if enabled.
*
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
+ * @api public
*/
-async function parallelizeBatches(batches, fn) {
- for (const batch of batches) {
- // We need to make sure the entire batch has completed before we can move on
- // to the next batch
- await parallelize(batch, fn);
- }
-}
-async function parallelize(items, fn, concurrency = 4) {
- if (items.length === 0) {
- return;
- }
- return new Promise((resolve, reject) => {
- let activePromises = 0;
- const values = items.slice(0);
+function formatArgs(args) {
+ var useColors = this.useColors;
- async function scheduleItem(item) {
- activePromises++;
+ args[0] = (useColors ? '%c' : '')
+ + this.namespace
+ + (useColors ? ' %c' : ' ')
+ + args[0]
+ + (useColors ? '%c ' : ' ')
+ + '+' + exports.humanize(this.diff);
- try {
- await fn(item);
- activePromises--;
+ if (!useColors) return;
- if (values.length > 0) {
- // We have more work to do, so we schedule the next promise
- scheduleItem(values.shift());
- } else if (activePromises === 0) {
- // We have no more values left, and all items have completed, so we've
- // completed all the work.
- resolve();
- }
- } catch (error) {
- reject(error);
- }
- }
+ var c = 'color: ' + this.color;
+ args.splice(1, 0, c, 'color: inherit')
- values.splice(0, concurrency).map(scheduleItem);
+ // 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;
+ }
});
-}
-/***/ }),
-/* 502 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ args.splice(lastC, 0, c);
+}
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getProjects", function() { return getProjects; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "buildProjectGraph", function() { return buildProjectGraph; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "topologicallyBatchProjects", function() { return topologicallyBatchProjects; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "includeTransitiveProjects", function() { return includeTransitiveProjects; });
-/* harmony import */ var glob__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(503);
-/* harmony import */ var glob__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(glob__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(16);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(29);
-/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(util__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(516);
-/* harmony import */ var _project__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(517);
-/* harmony import */ var _workspaces__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(578);
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
+/**
+ * Invokes `console.log()` when available.
+ * No-op when `console.log` is not a "function".
*
- * http://www.apache.org/licenses/LICENSE-2.0
+ * @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`.
*
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
+ * @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;
+}
-const glob = Object(util__WEBPACK_IMPORTED_MODULE_2__["promisify"])(glob__WEBPACK_IMPORTED_MODULE_0___default.a);
-/** a Map of project names to Project instances */
+/**
+ * Enable namespaces listed in `localStorage.debug` initially.
+ */
-async function getProjects(rootPath, projectsPathsPatterns, {
- include = [],
- exclude = []
-} = {}) {
- const projects = new Map();
- const workspaceProjectsPaths = await Object(_workspaces__WEBPACK_IMPORTED_MODULE_5__["workspacePackagePaths"])(rootPath);
+exports.enable(load());
- for (const pattern of projectsPathsPatterns) {
- const pathsToProcess = await packagesFromGlobPattern({
- pattern,
- rootPath
- });
+/**
+ * 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
+ */
- for (const filePath of pathsToProcess) {
- const projectConfigPath = normalize(filePath);
- const projectDir = path__WEBPACK_IMPORTED_MODULE_1___default.a.dirname(projectConfigPath);
- const project = await _project__WEBPACK_IMPORTED_MODULE_4__["Project"].fromPath(projectDir);
+function localstorage() {
+ try {
+ return window.localStorage;
+ } catch (e) {}
+}
- if (workspaceProjectsPaths.indexOf(filePath) >= 0) {
- project.isWorkspaceProject = true;
- }
- const excludeProject = exclude.includes(project.name) || include.length > 0 && !include.includes(project.name);
+/***/ }),
+/* 468 */
+/***/ (function(module, exports, __webpack_require__) {
- if (excludeProject) {
- continue;
- }
- if (projects.has(project.name)) {
- throw new _errors__WEBPACK_IMPORTED_MODULE_3__["CliError"](`There are multiple projects with the same name [${project.name}]`, {
- name: project.name,
- paths: [project.path, projects.get(project.name).path]
- });
- }
+/**
+ * This is the common logic for both the Node.js and web browser
+ * implementations of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
- projects.set(project.name, project);
- }
- }
+exports = module.exports = createDebug.debug = createDebug['default'] = createDebug;
+exports.coerce = coerce;
+exports.disable = disable;
+exports.enable = enable;
+exports.enabled = enabled;
+exports.humanize = __webpack_require__(469);
- return projects;
-}
+/**
+ * Active `debug` instances.
+ */
+exports.instances = [];
-function packagesFromGlobPattern({
- pattern,
- rootPath
-}) {
- const globOptions = {
- cwd: rootPath,
- // Should throw in case of unusual errors when reading the file system
- strict: true,
- // Always returns absolute paths for matched files
- absolute: true,
- // Do not match ** against multiple filenames
- // (This is only specified because we currently don't have a need for it.)
- noglobstar: true
- };
- return glob(path__WEBPACK_IMPORTED_MODULE_1___default.a.join(pattern, 'package.json'), globOptions);
-} // https://github.com/isaacs/node-glob/blob/master/common.js#L104
-// glob always returns "\\" as "/" in windows, so everyone
-// gets normalized because we can't have nice things.
+/**
+ * The currently active debug mode names, and names to skip.
+ */
+exports.names = [];
+exports.skips = [];
-function normalize(dir) {
- return path__WEBPACK_IMPORTED_MODULE_1___default.a.normalize(dir);
-}
+/**
+ * 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".
+ */
-function buildProjectGraph(projects) {
- const projectGraph = new Map();
+exports.formatters = {};
- for (const project of projects.values()) {
- const projectDeps = [];
- const dependencies = project.allDependencies;
+/**
+ * Select a color.
+ * @param {String} namespace
+ * @return {Number}
+ * @api private
+ */
- for (const depName of Object.keys(dependencies)) {
- if (projects.has(depName)) {
- const dep = projects.get(depName);
- const dependentProjectIsInWorkspace = project.isWorkspaceProject || project.json.name === 'kibana';
- project.ensureValidProjectDependency(dep, dependentProjectIsInWorkspace);
- projectDeps.push(dep);
- }
- }
+function selectColor(namespace) {
+ var hash = 0, i;
- projectGraph.set(project.name, projectDeps);
+ for (i in namespace) {
+ hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
+ hash |= 0; // Convert to 32bit integer
}
- return projectGraph;
+ return exports.colors[Math.abs(hash) % exports.colors.length];
}
-function topologicallyBatchProjects(projectsToBatch, projectGraph, {
- batchByWorkspace = false
-} = {}) {
- // We're going to be chopping stuff out of this list, so copy it.
- const projectsLeftToBatch = new Set(projectsToBatch.keys());
- const batches = [];
- if (batchByWorkspace) {
- const workspaceRootProject = Array.from(projectsToBatch.values()).find(p => p.isWorkspaceRoot);
+/**
+ * Create a debugger with the given `namespace`.
+ *
+ * @param {String} namespace
+ * @return {Function}
+ * @api public
+ */
- if (!workspaceRootProject) {
- throw new _errors__WEBPACK_IMPORTED_MODULE_3__["CliError"](`There was no yarn workspace root found.`);
- } // Push in the workspace root first.
+function createDebug(namespace) {
+ var prevTime;
- batches.push([workspaceRootProject]);
- projectsLeftToBatch.delete(workspaceRootProject.name); // In the next batch, push in all workspace projects.
+ function debug() {
+ // disabled?
+ if (!debug.enabled) return;
- const workspaceBatch = [];
+ var self = debug;
- for (const projectName of projectsLeftToBatch) {
- const project = projectsToBatch.get(projectName);
+ // set `diff` timestamp
+ var curr = +new Date();
+ var ms = curr - (prevTime || curr);
+ self.diff = ms;
+ self.prev = prevTime;
+ self.curr = curr;
+ prevTime = curr;
- if (project.isWorkspaceProject) {
- workspaceBatch.push(project);
- projectsLeftToBatch.delete(projectName);
- }
+ // 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];
}
- batches.push(workspaceBatch);
- }
+ args[0] = exports.coerce(args[0]);
- while (projectsLeftToBatch.size > 0) {
- // Get all projects that have no remaining dependencies within the repo
- // that haven't yet been picked.
- const batch = [];
+ if ('string' !== typeof args[0]) {
+ // anything else let's inspect with %O
+ args.unshift('%O');
+ }
- for (const projectName of projectsLeftToBatch) {
- const projectDeps = projectGraph.get(projectName);
- const needsDependenciesBatched = projectDeps.some(dep => projectsLeftToBatch.has(dep.name));
+ // 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);
- if (!needsDependenciesBatched) {
- batch.push(projectsToBatch.get(projectName));
+ // now we need to remove `args[index]` since it's inlined in the `format`
+ args.splice(index, 1);
+ index--;
}
- } // If we weren't able to find a project with no remaining dependencies,
- // then we've encountered a cycle in the dependency graph.
+ return match;
+ });
+ // apply env-specific formatting (colors, etc.)
+ exports.formatArgs.call(self, args);
- const hasCycles = batch.length === 0;
+ var logFn = debug.log || exports.log || console.log.bind(console);
+ logFn.apply(self, args);
+ }
- if (hasCycles) {
- const cycleProjectNames = [...projectsLeftToBatch];
- const message = 'Encountered a cycle in the dependency graph. Projects in cycle are:\n' + cycleProjectNames.join(', ');
- throw new _errors__WEBPACK_IMPORTED_MODULE_3__["CliError"](message);
- }
+ debug.namespace = namespace;
+ debug.enabled = exports.enabled(namespace);
+ debug.useColors = exports.useColors();
+ debug.color = selectColor(namespace);
+ debug.destroy = destroy;
- batches.push(batch);
- batch.forEach(project => projectsLeftToBatch.delete(project.name));
+ // env-specific initialization logic for debug instances
+ if ('function' === typeof exports.init) {
+ exports.init(debug);
}
- return batches;
-}
-function includeTransitiveProjects(subsetOfProjects, allProjects, {
- onlyProductionDependencies = false
-} = {}) {
- const projectsWithDependents = new Map(); // the current list of packages we are expanding using breadth-first-search
+ exports.instances.push(debug);
- const toProcess = [...subsetOfProjects];
+ return debug;
+}
- while (toProcess.length > 0) {
- const project = toProcess.shift();
- const dependencies = onlyProductionDependencies ? project.productionDependencies : project.allDependencies;
- Object.keys(dependencies).forEach(dep => {
- if (allProjects.has(dep)) {
- toProcess.push(allProjects.get(dep));
- }
- });
- projectsWithDependents.set(project.name, project);
+function destroy () {
+ var index = exports.instances.indexOf(this);
+ if (index !== -1) {
+ exports.instances.splice(index, 1);
+ return true;
+ } else {
+ return false;
}
-
- return projectsWithDependents;
}
-/***/ }),
-/* 503 */
-/***/ (function(module, exports, __webpack_require__) {
-
-// Approach:
-//
-// 1. Get the minimatch set
-// 2. For each pattern in the set, PROCESS(pattern, false)
-// 3. Store matches per-set, then uniq them
-//
-// PROCESS(pattern, inGlobStar)
-// Get the first [n] items from pattern that are all strings
-// Join these together. This is PREFIX.
-// If there is no more remaining, then stat(PREFIX) and
-// add to matches if it succeeds. END.
-//
-// If inGlobStar and PREFIX is symlink and points to dir
-// set ENTRIES = []
-// else readdir(PREFIX) as ENTRIES
-// If fail, END
-//
-// with ENTRIES
-// If pattern[n] is GLOBSTAR
-// // handle the case where the globstar match is empty
-// // by pruning it out, and testing the resulting pattern
-// PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
-// // handle other cases.
-// for ENTRY in ENTRIES (not dotfiles)
-// // attach globstar + tail onto the entry
-// // Mark that this entry is a globstar match
-// PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
-//
-// else // not globstar
-// for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
-// Test ENTRY against pattern[n]
-// If fails, continue
-// If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
-//
-// Caveat:
-// Cache all stats and readdirs results to minimize syscall. Since all
-// we ever care about is existence and directory-ness, we can just keep
-// `true` for files, and [children,...] for directories, or `false` for
-// things that don't exist.
-
-module.exports = glob
+/**
+ * Enables a debug mode by namespaces. This can include modes
+ * separated by a colon and wildcards.
+ *
+ * @param {String} namespaces
+ * @api public
+ */
-var fs = __webpack_require__(23)
-var rp = __webpack_require__(504)
-var minimatch = __webpack_require__(506)
-var Minimatch = minimatch.Minimatch
-var inherits = __webpack_require__(510)
-var EE = __webpack_require__(399).EventEmitter
-var path = __webpack_require__(16)
-var assert = __webpack_require__(30)
-var isAbsolute = __webpack_require__(512)
-var globSync = __webpack_require__(513)
-var common = __webpack_require__(514)
-var alphasort = common.alphasort
-var alphasorti = common.alphasorti
-var setopts = common.setopts
-var ownProp = common.ownProp
-var inflight = __webpack_require__(515)
-var util = __webpack_require__(29)
-var childrenIgnored = common.childrenIgnored
-var isIgnored = common.isIgnored
+function enable(namespaces) {
+ exports.save(namespaces);
-var once = __webpack_require__(404)
+ exports.names = [];
+ exports.skips = [];
-function glob (pattern, options, cb) {
- if (typeof options === 'function') cb = options, options = {}
- if (!options) options = {}
+ var i;
+ var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+ var len = split.length;
- if (options.sync) {
- if (cb)
- throw new TypeError('callback provided to sync glob')
- return globSync(pattern, options)
+ for (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 + '$'));
+ }
}
- return new Glob(pattern, options, cb)
+ for (i = 0; i < exports.instances.length; i++) {
+ var instance = exports.instances[i];
+ instance.enabled = exports.enabled(instance.namespace);
+ }
}
-glob.sync = globSync
-var GlobSync = glob.GlobSync = globSync.GlobSync
+/**
+ * Disable debug output.
+ *
+ * @api public
+ */
-// old api surface
-glob.glob = glob
+function disable() {
+ exports.enable('');
+}
-function extend (origin, add) {
- if (add === null || typeof add !== 'object') {
- return origin
- }
+/**
+ * Returns true if the given mode name is enabled, false otherwise.
+ *
+ * @param {String} name
+ * @return {Boolean}
+ * @api public
+ */
- var keys = Object.keys(add)
- var i = keys.length
- while (i--) {
- origin[keys[i]] = add[keys[i]]
+function enabled(name) {
+ if (name[name.length - 1] === '*') {
+ return true;
}
- return origin
+ 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;
}
-glob.hasMagic = function (pattern, options_) {
- var options = extend({}, options_)
- options.noprocess = true
+/**
+ * Coerce `val`.
+ *
+ * @param {Mixed} val
+ * @return {Mixed}
+ * @api private
+ */
- var g = new Glob(pattern, options)
- var set = g.minimatch.set
+function coerce(val) {
+ if (val instanceof Error) return val.stack || val.message;
+ return val;
+}
- if (!pattern)
- return false
- if (set.length > 1)
- return true
+/***/ }),
+/* 469 */
+/***/ (function(module, exports) {
- for (var j = 0; j < set[0].length; j++) {
- if (typeof set[0][j] !== 'string')
- return true
- }
+/**
+ * Helpers.
+ */
- return false
-}
+var s = 1000;
+var m = s * 60;
+var h = m * 60;
+var d = h * 24;
+var y = d * 365.25;
-glob.Glob = Glob
-inherits(Glob, EE)
-function Glob (pattern, options, cb) {
- if (typeof options === 'function') {
- cb = options
- options = null
- }
+/**
+ * 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
+ */
- if (options && options.sync) {
- if (cb)
- throw new TypeError('callback provided to sync glob')
- return new GlobSync(pattern, options)
+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)
+ );
+};
- if (!(this instanceof Glob))
- return new Glob(pattern, options, cb)
-
- setopts(this, pattern, options)
- this._didRealPath = false
+/**
+ * Parse the given `str` and return milliseconds.
+ *
+ * @param {String} str
+ * @return {Number}
+ * @api private
+ */
- // process each pattern in the minimatch set
- var n = this.minimatch.set.length
+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;
+ }
+}
- // The matches are stored as {: true,...} so that
- // duplicates are automagically pruned.
- // Later, we do an Object.keys() on these.
- // Keep them as a list so we can fill in when nonull is set.
- this.matches = new Array(n)
+/**
+ * Short format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
- if (typeof cb === 'function') {
- cb = once(cb)
- this.on('error', cb)
- this.on('end', function (matches) {
- cb(null, matches)
- })
+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';
+}
- var self = this
- this._processing = 0
-
- this._emitQueue = []
- this._processQueue = []
- this.paused = false
+/**
+ * Long format for `ms`.
+ *
+ * @param {Number} ms
+ * @return {String}
+ * @api private
+ */
- if (this.noprocess)
- return this
+function fmtLong(ms) {
+ return plural(ms, d, 'day') ||
+ plural(ms, h, 'hour') ||
+ plural(ms, m, 'minute') ||
+ plural(ms, s, 'second') ||
+ ms + ' ms';
+}
- if (n === 0)
- return done()
+/**
+ * Pluralization helper.
+ */
- var sync = true
- for (var i = 0; i < n; i ++) {
- this._process(this.minimatch.set[i], i, false, done)
+function plural(ms, n, name) {
+ if (ms < n) {
+ return;
}
- sync = false
-
- function done () {
- --self._processing
- if (self._processing <= 0) {
- if (sync) {
- process.nextTick(function () {
- self._finish()
- })
- } else {
- self._finish()
- }
- }
+ if (ms < n * 1.5) {
+ return Math.floor(ms / n) + ' ' + name;
}
+ return Math.ceil(ms / n) + ' ' + name + 's';
}
-Glob.prototype._finish = function () {
- assert(this instanceof Glob)
- if (this.aborted)
- return
- if (this.realpath && !this._didRealpath)
- return this._realpath()
+/***/ }),
+/* 470 */
+/***/ (function(module, exports, __webpack_require__) {
- common.finish(this)
- this.emit('end', this.found)
-}
+/**
+ * Module dependencies.
+ */
-Glob.prototype._realpath = function () {
- if (this._didRealpath)
- return
+var tty = __webpack_require__(471);
+var util = __webpack_require__(397);
- this._didRealpath = true
+/**
+ * This is the Node.js implementation of `debug()`.
+ *
+ * Expose `debug()` as the module.
+ */
- var n = this.matches.length
- if (n === 0)
- return this._finish()
+exports = module.exports = __webpack_require__(468);
+exports.init = init;
+exports.log = log;
+exports.formatArgs = formatArgs;
+exports.save = save;
+exports.load = load;
+exports.useColors = useColors;
- var self = this
- for (var i = 0; i < this.matches.length; i++)
- this._realpathSet(i, next)
+/**
+ * Colors.
+ */
- function next () {
- if (--n === 0)
- self._finish()
+exports.colors = [ 6, 2, 3, 4, 5, 1 ];
+
+try {
+ var supportsColor = __webpack_require__(472);
+ if (supportsColor && supportsColor.level >= 2) {
+ exports.colors = [
+ 20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68,
+ 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 128, 129, 134,
+ 135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
+ 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202, 203, 204,
+ 205, 206, 207, 208, 209, 214, 215, 220, 221
+ ];
}
+} catch (err) {
+ // swallow - we only care if `supports-color` is available; it doesn't have to be.
}
-Glob.prototype._realpathSet = function (index, cb) {
- var matchset = this.matches[index]
- if (!matchset)
- return cb()
+/**
+ * Build up the default `inspectOpts` object from the environment variables.
+ *
+ * $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+ */
- var found = Object.keys(matchset)
- var self = this
- var n = found.length
+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() });
- if (n === 0)
- return cb()
+ // 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);
- var set = this.matches[index] = Object.create(null)
- found.forEach(function (p, i) {
- // If there's a problem with the stat, then it means that
- // one or more of the links in the realpath couldn't be
- // resolved. just return the abs value in that case.
- p = self._makeAbs(p)
- rp.realpath(p, self.realpathCache, function (er, real) {
- if (!er)
- set[real] = true
- else if (er.syscall === 'stat')
- set[p] = true
- else
- self.emit('error', er) // srsly wtf right here
+ obj[prop] = val;
+ return obj;
+}, {});
- if (--n === 0) {
- self.matches[index] = set
- cb()
- }
- })
- })
+/**
+ * Is stdout a TTY? Colored output is enabled when `true`.
+ */
+
+function useColors() {
+ return 'colors' in exports.inspectOpts
+ ? Boolean(exports.inspectOpts.colors)
+ : tty.isatty(process.stderr.fd);
}
-Glob.prototype._mark = function (p) {
- return common.mark(this, p)
-}
+/**
+ * Map %o to `util.inspect()`, all on a single line.
+ */
-Glob.prototype._makeAbs = function (f) {
- return common.makeAbs(this, f)
-}
+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(' ');
+};
-Glob.prototype.abort = function () {
- this.aborted = true
- this.emit('abort')
-}
+/**
+ * Map %o to `util.inspect()`, allowing multiple lines if needed.
+ */
-Glob.prototype.pause = function () {
- if (!this.paused) {
- this.paused = true
- this.emit('pause')
- }
-}
+exports.formatters.O = function(v) {
+ this.inspectOpts.colors = this.useColors;
+ return util.inspect(v, this.inspectOpts);
+};
-Glob.prototype.resume = function () {
- if (this.paused) {
- this.emit('resume')
- this.paused = false
- if (this._emitQueue.length) {
- var eq = this._emitQueue.slice(0)
- this._emitQueue.length = 0
- for (var i = 0; i < eq.length; i ++) {
- var e = eq[i]
- this._emitMatch(e[0], e[1])
- }
- }
- if (this._processQueue.length) {
- var pq = this._processQueue.slice(0)
- this._processQueue.length = 0
- for (var i = 0; i < pq.length; i ++) {
- var p = pq[i]
- this._processing--
- this._process(p[0], p[1], p[2], p[3])
- }
- }
- }
-}
+/**
+ * Adds ANSI color escape codes if enabled.
+ *
+ * @api public
+ */
-Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
- assert(this instanceof Glob)
- assert(typeof cb === 'function')
+function formatArgs(args) {
+ var name = this.namespace;
+ var useColors = this.useColors;
- if (this.aborted)
- return
+ if (useColors) {
+ var c = this.color;
+ var colorCode = '\u001b[3' + (c < 8 ? c : '8;5;' + c);
+ var prefix = ' ' + colorCode + ';1m' + name + ' ' + '\u001b[0m';
- this._processing++
- if (this.paused) {
- this._processQueue.push([pattern, index, inGlobStar, cb])
- return
+ args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+ args.push(colorCode + 'm+' + exports.humanize(this.diff) + '\u001b[0m');
+ } else {
+ args[0] = getDate() + name + ' ' + args[0];
}
+}
- //console.error('PROCESS %d', this._processing, pattern)
-
- // Get the first [n] parts of pattern that are all strings.
- var n = 0
- while (typeof pattern[n] === 'string') {
- n ++
+function getDate() {
+ if (exports.inspectOpts.hideDate) {
+ return '';
+ } else {
+ return new Date().toISOString() + ' ';
}
- // now n is the index of the first one that is *not* a string.
+}
- // see if there's anything else
- var prefix
- switch (n) {
- // if not, then this is rather simple
- case pattern.length:
- this._processSimple(pattern.join('/'), index, cb)
- return
+/**
+ * Invokes `util.format()` with the specified arguments and writes to stderr.
+ */
- case 0:
- // pattern *starts* with some non-trivial item.
- // going to readdir(cwd), but not include the prefix in matches.
- prefix = null
- break
+function log() {
+ return process.stderr.write(util.format.apply(util, arguments) + '\n');
+}
- default:
- // pattern has some string bits in the front.
- // whatever it starts with, whether that's 'absolute' like /foo/bar,
- // or 'relative' like '../baz'
- prefix = pattern.slice(0, n).join('/')
- break
+/**
+ * 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;
}
+}
- var remain = pattern.slice(n)
+/**
+ * Load `namespaces`.
+ *
+ * @return {String} returns the previously persisted debug modes
+ * @api private
+ */
- // get the list of entries.
- var read
- if (prefix === null)
- read = '.'
- else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
- if (!prefix || !isAbsolute(prefix))
- prefix = '/' + prefix
- read = prefix
- } else
- read = prefix
+function load() {
+ return process.env.DEBUG;
+}
- var abs = this._makeAbs(read)
+/**
+ * Init logic for `debug` instances.
+ *
+ * Create a new `inspectOpts` object in case `useColors` is set
+ * differently for a particular `debug` instance.
+ */
- //if ignored, skip _processing
- if (childrenIgnored(this, read))
- return cb()
+function init (debug) {
+ debug.inspectOpts = {};
- var isGlobStar = remain[0] === minimatch.GLOBSTAR
- if (isGlobStar)
- this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb)
- else
- this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb)
+ var keys = Object.keys(exports.inspectOpts);
+ for (var i = 0; i < keys.length; i++) {
+ debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+ }
}
-Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
- var self = this
- this._readdir(abs, inGlobStar, function (er, entries) {
- return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
- })
-}
+/**
+ * Enable namespaces listed in `process.env.DEBUG` initially.
+ */
-Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+exports.enable(load());
- // if the abs isn't a dir, then nothing can match!
- if (!entries)
- return cb()
- // It will only match dot entries if it starts with a dot, or if
- // dot is set. Stuff like @(.foo|.bar) isn't allowed.
- var pn = remain[0]
- var negate = !!this.minimatch.negate
- var rawGlob = pn._glob
- var dotOk = this.dot || rawGlob.charAt(0) === '.'
+/***/ }),
+/* 471 */
+/***/ (function(module, exports) {
- var matchedEntries = []
- for (var i = 0; i < entries.length; i++) {
- var e = entries[i]
- if (e.charAt(0) !== '.' || dotOk) {
- var m
- if (negate && !prefix) {
- m = !e.match(pn)
- } else {
- m = e.match(pn)
- }
- if (m)
- matchedEntries.push(e)
- }
- }
+module.exports = require("tty");
- //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
+/***/ }),
+/* 472 */
+/***/ (function(module, exports, __webpack_require__) {
- var len = matchedEntries.length
- // If there are no matched entries, then nothing matches.
- if (len === 0)
- return cb()
+"use strict";
- // if this is the last remaining pattern bit, then no need for
- // an additional stat *unless* the user has specified mark or
- // stat explicitly. We know they exist, since readdir returned
- // them.
+const os = __webpack_require__(364);
+const hasFlag = __webpack_require__(394);
- if (remain.length === 1 && !this.mark && !this.stat) {
- if (!this.matches[index])
- this.matches[index] = Object.create(null)
+const env = process.env;
- for (var i = 0; i < len; i ++) {
- var e = matchedEntries[i]
- if (prefix) {
- if (prefix !== '/')
- e = prefix + '/' + e
- else
- e = prefix + e
- }
+let forceColor;
+if (hasFlag('no-color') ||
+ hasFlag('no-colors') ||
+ hasFlag('color=false')) {
+ forceColor = false;
+} else if (hasFlag('color') ||
+ hasFlag('colors') ||
+ hasFlag('color=true') ||
+ hasFlag('color=always')) {
+ forceColor = true;
+}
+if ('FORCE_COLOR' in env) {
+ forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
+}
- if (e.charAt(0) === '/' && !this.nomount) {
- e = path.join(this.root, e)
- }
- this._emitMatch(index, e)
- }
- // This was the last one, and no stats were needed
- return cb()
- }
+function translateLevel(level) {
+ if (level === 0) {
+ return false;
+ }
- // now test all matched entries as stand-ins for that part
- // of the pattern.
- remain.shift()
- for (var i = 0; i < len; i ++) {
- var e = matchedEntries[i]
- var newPattern
- if (prefix) {
- if (prefix !== '/')
- e = prefix + '/' + e
- else
- e = prefix + e
- }
- this._process([e].concat(remain), index, inGlobStar, cb)
- }
- cb()
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
}
-Glob.prototype._emitMatch = function (index, e) {
- if (this.aborted)
- return
+function supportsColor(stream) {
+ if (forceColor === false) {
+ return 0;
+ }
- if (isIgnored(this, e))
- return
+ if (hasFlag('color=16m') ||
+ hasFlag('color=full') ||
+ hasFlag('color=truecolor')) {
+ return 3;
+ }
- if (this.paused) {
- this._emitQueue.push([index, e])
- return
- }
+ if (hasFlag('color=256')) {
+ return 2;
+ }
- var abs = isAbsolute(e) ? e : this._makeAbs(e)
+ if (stream && !stream.isTTY && forceColor !== true) {
+ return 0;
+ }
- if (this.mark)
- e = this._mark(e)
+ const min = forceColor ? 1 : 0;
- if (this.absolute)
- e = abs
+ if (process.platform === 'win32') {
+ // Node.js 7.5.0 is the first version of Node.js to include a patch to
+ // libuv that enables 256 color output on Windows. Anything earlier and it
+ // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+ // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+ // release that supports 256 colors. Windows 10 build 14931 is the first release
+ // that supports 16m/TrueColor.
+ const osRelease = os.release().split('.');
+ if (
+ Number(process.versions.node.split('.')[0]) >= 8 &&
+ Number(osRelease[0]) >= 10 &&
+ Number(osRelease[2]) >= 10586
+ ) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
- if (this.matches[index][e])
- return
+ return 1;
+ }
- if (this.nodir) {
- var c = this.cache[abs]
- if (c === 'DIR' || Array.isArray(c))
- return
- }
+ if ('CI' in env) {
+ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+ return 1;
+ }
- this.matches[index][e] = true
+ return min;
+ }
- var st = this.statCache[abs]
- if (st)
- this.emit('stat', e, st)
+ if ('TEAMCITY_VERSION' in env) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+ }
- this.emit('match', e)
-}
+ if (env.COLORTERM === 'truecolor') {
+ return 3;
+ }
-Glob.prototype._readdirInGlobStar = function (abs, cb) {
- if (this.aborted)
- return
+ if ('TERM_PROGRAM' in env) {
+ const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
- // follow all symlinked directories forever
- // just proceed as if this is a non-globstar situation
- if (this.follow)
- return this._readdir(abs, false, cb)
+ switch (env.TERM_PROGRAM) {
+ case 'iTerm.app':
+ return version >= 3 ? 3 : 2;
+ case 'Apple_Terminal':
+ return 2;
+ // No default
+ }
+ }
- var lstatkey = 'lstat\0' + abs
- var self = this
- var lstatcb = inflight(lstatkey, lstatcb_)
+ if (/-256(color)?$/i.test(env.TERM)) {
+ return 2;
+ }
- if (lstatcb)
- fs.lstat(abs, lstatcb)
+ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+ return 1;
+ }
- function lstatcb_ (er, lstat) {
- if (er && er.code === 'ENOENT')
- return cb()
+ if ('COLORTERM' in env) {
+ return 1;
+ }
- var isSym = lstat && lstat.isSymbolicLink()
- self.symlinks[abs] = isSym
+ if (env.TERM === 'dumb') {
+ return min;
+ }
- // If it's not a symlink or a dir, then it's definitely a regular file.
- // don't bother doing a readdir in that case.
- if (!isSym && lstat && !lstat.isDirectory()) {
- self.cache[abs] = 'FILE'
- cb()
- } else
- self._readdir(abs, false, cb)
- }
+ return min;
}
-Glob.prototype._readdir = function (abs, inGlobStar, cb) {
- if (this.aborted)
- return
-
- cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb)
- if (!cb)
- return
+function getSupportLevel(stream) {
+ const level = supportsColor(stream);
+ return translateLevel(level);
+}
- //console.error('RD %j %j', +inGlobStar, abs)
- if (inGlobStar && !ownProp(this.symlinks, abs))
- return this._readdirInGlobStar(abs, cb)
+module.exports = {
+ supportsColor: getSupportLevel,
+ stdout: getSupportLevel(process.stdout),
+ stderr: getSupportLevel(process.stderr)
+};
- if (ownProp(this.cache, abs)) {
- var c = this.cache[abs]
- if (!c || c === 'FILE')
- return cb()
- if (Array.isArray(c))
- return cb(null, c)
- }
+/***/ }),
+/* 473 */
+/***/ (function(module, exports) {
- var self = this
- fs.readdir(abs, readdirCb(this, abs, cb))
-}
+module.exports = require("zlib");
-function readdirCb (self, abs, cb) {
- return function (er, entries) {
- if (er)
- self._readdirError(abs, er, cb)
- else
- self._readdirEntries(abs, entries, cb)
- }
-}
+/***/ }),
+/* 474 */
+/***/ (function(module) {
-Glob.prototype._readdirEntries = function (abs, entries, cb) {
- if (this.aborted)
- return
+module.exports = JSON.parse("{\"name\":\"axios\",\"version\":\"0.19.2\",\"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\"},\"typings\":\"./index.d.ts\",\"dependencies\":{\"follow-redirects\":\"1.5.10\"},\"bundlesize\":[{\"path\":\"./dist/axios.min.js\",\"threshold\":\"5kB\"}]}");
- // if we haven't asked to stat everything, then just
- // assume that everything in there exists, so we can avoid
- // having to stat it a second time.
- if (!this.mark && !this.stat) {
- for (var i = 0; i < entries.length; i ++) {
- var e = entries[i]
- if (abs === '/')
- e = abs + e
- else
- e = abs + '/' + e
- this.cache[e] = true
- }
- }
+/***/ }),
+/* 475 */
+/***/ (function(module, exports, __webpack_require__) {
- this.cache[abs] = entries
- return cb(null, entries)
-}
+"use strict";
-Glob.prototype._readdirError = function (f, er, cb) {
- if (this.aborted)
- return
- // handle errors, and cache the information
- switch (er.code) {
- case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
- case 'ENOTDIR': // totally normal. means it *does* exist.
- var abs = this._makeAbs(f)
- this.cache[abs] = 'FILE'
- if (abs === this.cwdAbs) {
- var error = new Error(er.code + ' invalid cwd ' + this.cwd)
- error.path = this.cwd
- error.code = er.code
- this.emit('error', error)
- this.abort()
- }
- break
+var utils = __webpack_require__(442);
- case 'ENOENT': // not terribly unusual
- case 'ELOOP':
- case 'ENAMETOOLONG':
- case 'UNKNOWN':
- this.cache[this._makeAbs(f)] = false
- break
+/**
+ * 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 = {};
- default: // some unusual error. Treat as failure.
- this.cache[this._makeAbs(f)] = false
- if (this.strict) {
- this.emit('error', er)
- // If the error is handled, then we abort
- // if not, we threw out of here
- this.abort()
- }
- if (!this.silent)
- console.error('glob error', er)
- break
- }
-
- return cb()
-}
-
-Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
- var self = this
- this._readdir(abs, inGlobStar, function (er, entries) {
- self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
- })
-}
+ var valueFromConfig2Keys = ['url', 'method', 'params', 'data'];
+ var mergeDeepPropertiesKeys = ['headers', 'auth', 'proxy'];
+ var defaultToConfig2Keys = [
+ 'baseURL', 'url', 'transformRequest', 'transformResponse', 'paramsSerializer',
+ 'timeout', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName',
+ 'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress',
+ 'maxContentLength', 'validateStatus', 'maxRedirects', 'httpAgent',
+ 'httpsAgent', 'cancelToken', 'socketPath'
+ ];
+ utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+ if (typeof config2[prop] !== 'undefined') {
+ config[prop] = config2[prop];
+ }
+ });
-Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
- //console.error('pgs2', prefix, remain[0], entries)
+ utils.forEach(mergeDeepPropertiesKeys, function mergeDeepProperties(prop) {
+ if (utils.isObject(config2[prop])) {
+ config[prop] = utils.deepMerge(config1[prop], config2[prop]);
+ } else if (typeof config2[prop] !== 'undefined') {
+ config[prop] = config2[prop];
+ } else if (utils.isObject(config1[prop])) {
+ config[prop] = utils.deepMerge(config1[prop]);
+ } else if (typeof config1[prop] !== 'undefined') {
+ config[prop] = config1[prop];
+ }
+ });
- // no entries means not a dir, so it can never have matches
- // foo.txt/** doesn't match foo.txt
- if (!entries)
- return cb()
+ utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+ if (typeof config2[prop] !== 'undefined') {
+ config[prop] = config2[prop];
+ } else if (typeof config1[prop] !== 'undefined') {
+ config[prop] = config1[prop];
+ }
+ });
- // test without the globstar, and with every child both below
- // and replacing the globstar.
- var remainWithoutGlobStar = remain.slice(1)
- var gspref = prefix ? [ prefix ] : []
- var noGlobStar = gspref.concat(remainWithoutGlobStar)
+ var axiosKeys = valueFromConfig2Keys
+ .concat(mergeDeepPropertiesKeys)
+ .concat(defaultToConfig2Keys);
- // the noGlobStar pattern exits the inGlobStar state
- this._process(noGlobStar, index, false, cb)
+ var otherKeys = Object
+ .keys(config2)
+ .filter(function filterAxiosKeys(key) {
+ return axiosKeys.indexOf(key) === -1;
+ });
- var isSym = this.symlinks[abs]
- var len = entries.length
+ utils.forEach(otherKeys, function otherKeysDefaultToConfig2(prop) {
+ if (typeof config2[prop] !== 'undefined') {
+ config[prop] = config2[prop];
+ } else if (typeof config1[prop] !== 'undefined') {
+ config[prop] = config1[prop];
+ }
+ });
- // If it's a symlink, and we're in a globstar, then stop
- if (isSym && inGlobStar)
- return cb()
+ return config;
+};
- for (var i = 0; i < len; i++) {
- var e = entries[i]
- if (e.charAt(0) === '.' && !this.dot)
- continue
- // these two cases enter the inGlobStar state
- var instead = gspref.concat(entries[i], remainWithoutGlobStar)
- this._process(instead, index, true, cb)
+/***/ }),
+/* 476 */
+/***/ (function(module, exports, __webpack_require__) {
- var below = gspref.concat(entries[i], remain)
- this._process(below, index, true, cb)
- }
+"use strict";
- cb()
-}
-Glob.prototype._processSimple = function (prefix, index, cb) {
- // XXX review this. Shouldn't it be doing the mounting etc
- // before doing stat? kinda weird?
- var self = this
- this._stat(prefix, function (er, exists) {
- self._processSimple2(prefix, index, er, exists, cb)
- })
+/**
+ * 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;
}
-Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
-
- //console.error('ps2', prefix, exists)
-
- if (!this.matches[index])
- this.matches[index] = Object.create(null)
-
- // If it doesn't exist, then just mark the lack of results
- if (!exists)
- return cb()
-
- if (prefix && isAbsolute(prefix) && !this.nomount) {
- var trail = /[\/\\]$/.test(prefix)
- if (prefix.charAt(0) === '/') {
- prefix = path.join(this.root, prefix)
- } else {
- prefix = path.resolve(this.root, prefix)
- if (trail)
- prefix += '/'
- }
- }
-
- if (process.platform === 'win32')
- prefix = prefix.replace(/\\/g, '/')
- // Mark this as a match
- this._emitMatch(index, prefix)
- cb()
-}
+Cancel.prototype.toString = function toString() {
+ return 'Cancel' + (this.message ? ': ' + this.message : '');
+};
-// Returns either 'DIR', 'FILE', or false
-Glob.prototype._stat = function (f, cb) {
- var abs = this._makeAbs(f)
- var needDir = f.slice(-1) === '/'
+Cancel.prototype.__CANCEL__ = true;
- if (f.length > this.maxLength)
- return cb()
+module.exports = Cancel;
- if (!this.stat && ownProp(this.cache, abs)) {
- var c = this.cache[abs]
- if (Array.isArray(c))
- c = 'DIR'
+/***/ }),
+/* 477 */
+/***/ (function(module, exports, __webpack_require__) {
- // It exists, but maybe not how we need it
- if (!needDir || c === 'DIR')
- return cb(null, c)
+"use strict";
- if (needDir && c === 'FILE')
- return cb()
- // otherwise we have to stat, because maybe c=true
- // if we know it exists, but not what it is.
- }
+var Cancel = __webpack_require__(476);
- var exists
- var stat = this.statCache[abs]
- if (stat !== undefined) {
- if (stat === false)
- return cb(null, stat)
- else {
- var type = stat.isDirectory() ? 'DIR' : 'FILE'
- if (needDir && type === 'FILE')
- return cb()
- else
- return cb(null, type, stat)
- }
+/**
+ * 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 self = this
- var statcb = inflight('stat\0' + abs, lstatcb_)
- if (statcb)
- fs.lstat(abs, statcb)
+ var resolvePromise;
+ this.promise = new Promise(function promiseExecutor(resolve) {
+ resolvePromise = resolve;
+ });
- function lstatcb_ (er, lstat) {
- if (lstat && lstat.isSymbolicLink()) {
- // If it's a symlink, then treat it as the target, unless
- // the target does not exist, then treat it as a file.
- return fs.stat(abs, function (er, stat) {
- if (er)
- self._stat2(f, abs, null, lstat, cb)
- else
- self._stat2(f, abs, er, stat, cb)
- })
- } else {
- self._stat2(f, abs, er, lstat, cb)
+ var token = this;
+ executor(function cancel(message) {
+ if (token.reason) {
+ // Cancellation has already been requested
+ return;
}
- }
+
+ token.reason = new Cancel(message);
+ resolvePromise(token.reason);
+ });
}
-Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
- if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
- this.statCache[abs] = false
- return cb()
+/**
+ * Throws a `Cancel` if cancellation has been requested.
+ */
+CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+ if (this.reason) {
+ throw this.reason;
}
+};
- var needDir = f.slice(-1) === '/'
- this.statCache[abs] = stat
-
- if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
- return cb(null, false, stat)
-
- var c = true
- if (stat)
- c = stat.isDirectory() ? 'DIR' : 'FILE'
- this.cache[abs] = this.cache[abs] || c
-
- if (needDir && c === 'FILE')
- return cb()
+/**
+ * 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
+ };
+};
- return cb(null, c, stat)
-}
+module.exports = CancelToken;
/***/ }),
-/* 504 */
+/* 478 */
/***/ (function(module, exports, __webpack_require__) {
-module.exports = realpath
-realpath.realpath = realpath
-realpath.sync = realpathSync
-realpath.realpathSync = realpathSync
-realpath.monkeypatch = monkeypatch
-realpath.unmonkeypatch = unmonkeypatch
-
-var fs = __webpack_require__(23)
-var origRealpath = fs.realpath
-var origRealpathSync = fs.realpathSync
-
-var version = process.version
-var ok = /^v[0-5]\./.test(version)
-var old = __webpack_require__(505)
-
-function newError (er) {
- return er && er.syscall === 'realpath' && (
- er.code === 'ELOOP' ||
- er.code === 'ENOMEM' ||
- er.code === 'ENAMETOOLONG'
- )
-}
+"use strict";
-function realpath (p, cache, cb) {
- if (ok) {
- return origRealpath(p, cache, cb)
- }
- if (typeof cache === 'function') {
- cb = cache
- cache = null
- }
- origRealpath(p, cache, function (er, result) {
- if (newError(er)) {
- old.realpath(p, cache, cb)
- } else {
- cb(er, result)
- }
- })
-}
+/**
+ * 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);
+ };
+};
-function realpathSync (p, cache) {
- if (ok) {
- return origRealpathSync(p, cache)
- }
- try {
- return origRealpathSync(p, cache)
- } catch (er) {
- if (newError(er)) {
- return old.realpathSync(p, cache)
- } else {
- throw er
- }
- }
-}
+/***/ }),
+/* 479 */
+/***/ (function(module, exports, __webpack_require__) {
-function monkeypatch () {
- fs.realpath = realpath
- fs.realpathSync = realpathSync
-}
+"use strict";
-function unmonkeypatch () {
- fs.realpath = origRealpath
- fs.realpathSync = origRealpathSync
-}
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+tslib_1.__exportStar(__webpack_require__(480), exports);
/***/ }),
-/* 505 */
+/* 480 */
/***/ (function(module, exports, __webpack_require__) {
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-var pathModule = __webpack_require__(16);
-var isWindows = process.platform === 'win32';
-var fs = __webpack_require__(23);
+"use strict";
-// JavaScript implementation of realpath, ported from node pre-v6
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAxiosRequestError = (error) => {
+ return error && error.config && error.response === undefined;
+};
+exports.isAxiosResponseError = (error) => {
+ return error && error.response && error.response.status !== undefined;
+};
-var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
-function rethrow() {
- // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
- // is fairly slow to generate.
- var callback;
- if (DEBUG) {
- var backtrace = new Error;
- callback = debugCallback;
- } else
- callback = missingCallback;
+/***/ }),
+/* 481 */
+/***/ (function(module, exports, __webpack_require__) {
- return callback;
+"use strict";
- function debugCallback(err) {
- if (err) {
- backtrace.message = err.message;
- err = backtrace;
- missingCallback(err);
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+class KbnClientStatus {
+ constructor(requester) {
+ this.requester = requester;
}
- }
-
- function missingCallback(err) {
- if (err) {
- if (process.throwDeprecation)
- throw err; // Forgot a callback but don't know where? Use NODE_DEBUG=fs
- else if (!process.noDeprecation) {
- var msg = 'fs: missing callback ' + (err.stack || err.message);
- if (process.traceDeprecation)
- console.trace(msg);
- else
- console.error(msg);
- }
+ /**
+ * Get the full server status
+ */
+ async get() {
+ return await this.requester.request({
+ method: 'GET',
+ path: 'api/status',
+ });
+ }
+ /**
+ * Get the overall/merged state
+ */
+ async getOverallState() {
+ const status = await this.get();
+ return status.status.overall.state;
}
- }
}
+exports.KbnClientStatus = KbnClientStatus;
-function maybeCallback(cb) {
- return typeof cb === 'function' ? cb : rethrow();
-}
-var normalize = pathModule.normalize;
+/***/ }),
+/* 482 */
+/***/ (function(module, exports, __webpack_require__) {
-// Regexp that finds the next partion of a (partial) path
-// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
-if (isWindows) {
- var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
-} else {
- var nextPartRe = /(.*?)(?:[\/]+|$)/g;
-}
+"use strict";
-// Regex to find the device root, including trailing slash. E.g. 'c:\\'.
-if (isWindows) {
- var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
-} else {
- var splitRootRe = /^[\/]*/;
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const PLUGIN_STATUS_ID = /^plugin:(.+?)@/;
+class KbnClientPlugins {
+ constructor(status) {
+ this.status = status;
+ }
+ /**
+ * Get a list of plugin ids that are enabled on the server
+ */
+ async getEnabledIds() {
+ const pluginIds = [];
+ const apiResp = await this.status.get();
+ for (const status of apiResp.status.statuses) {
+ if (status.id) {
+ const match = status.id.match(PLUGIN_STATUS_ID);
+ if (match) {
+ pluginIds.push(match[1]);
+ }
+ }
+ }
+ return pluginIds;
+ }
}
+exports.KbnClientPlugins = KbnClientPlugins;
-exports.realpathSync = function realpathSync(p, cache) {
- // make p is absolute
- p = pathModule.resolve(p);
-
- if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
- return cache[p];
- }
-
- var original = p,
- seenLinks = {},
- knownHard = {};
-
- // current character position in p
- var pos;
- // the partial path so far, including a trailing slash if any
- var current;
- // the partial path without a trailing slash (except when pointing at a root)
- var base;
- // the partial path scanned in the previous round, with slash
- var previous;
-
- start();
-
- function start() {
- // Skip over roots
- var m = splitRootRe.exec(p);
- pos = m[0].length;
- current = m[0];
- base = m[0];
- previous = '';
- // On windows, check that the root exists. On unix there is no need.
- if (isWindows && !knownHard[base]) {
- fs.lstatSync(base);
- knownHard[base] = true;
- }
- }
+/***/ }),
+/* 483 */
+/***/ (function(module, exports, __webpack_require__) {
- // walk down the path, swapping out linked pathparts for their real
- // values
- // NB: p.length changes.
- while (pos < p.length) {
- // find the next part
- nextPartRe.lastIndex = pos;
- var result = nextPartRe.exec(p);
- previous = current;
- current += result[0];
- base = previous + result[1];
- pos = nextPartRe.lastIndex;
+"use strict";
- // continue if not a symlink
- if (knownHard[base] || (cache && cache[base] === base)) {
- continue;
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+class KbnClientVersion {
+ constructor(status) {
+ this.status = status;
}
-
- var resolvedLink;
- if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
- // some known symbolic link. no need to stat again.
- resolvedLink = cache[base];
- } else {
- var stat = fs.lstatSync(base);
- if (!stat.isSymbolicLink()) {
- knownHard[base] = true;
- if (cache) cache[base] = base;
- continue;
- }
-
- // read the link if it wasn't read before
- // dev/ino always return 0 on windows, so skip the check.
- var linkTarget = null;
- if (!isWindows) {
- var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
- if (seenLinks.hasOwnProperty(id)) {
- linkTarget = seenLinks[id];
+ async get() {
+ if (this.versionCache !== undefined) {
+ return this.versionCache;
}
- }
- if (linkTarget === null) {
- fs.statSync(base);
- linkTarget = fs.readlinkSync(base);
- }
- resolvedLink = pathModule.resolve(previous, linkTarget);
- // track this, if given a cache.
- if (cache) cache[base] = resolvedLink;
- if (!isWindows) seenLinks[id] = linkTarget;
+ const status = await this.status.get();
+ this.versionCache = status.version.number + (status.version.build_snapshot ? '-SNAPSHOT' : '');
+ return this.versionCache;
}
+}
+exports.KbnClientVersion = KbnClientVersion;
- // resolve the link, then start over
- p = pathModule.resolve(resolvedLink, p.slice(pos));
- start();
- }
-
- if (cache) cache[original] = p;
-
- return p;
-};
-
-
-exports.realpath = function realpath(p, cache, cb) {
- if (typeof cb !== 'function') {
- cb = maybeCallback(cache);
- cache = null;
- }
- // make p is absolute
- p = pathModule.resolve(p);
+/***/ }),
+/* 484 */
+/***/ (function(module, exports, __webpack_require__) {
- if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
- return process.nextTick(cb.bind(null, null, cache[p]));
- }
+"use strict";
- var original = p,
- seenLinks = {},
- knownHard = {};
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const kbn_client_requester_1 = __webpack_require__(438);
+class KbnClientSavedObjects {
+ constructor(log, requester) {
+ this.log = log;
+ this.requester = requester;
+ }
+ /**
+ * Run the saved objects migration
+ */
+ async migrate() {
+ this.log.debug('Migrating saved objects');
+ return await this.requester.request({
+ description: 'migrate saved objects',
+ path: kbn_client_requester_1.uriencode `/internal/saved_objects/_migrate`,
+ method: 'POST',
+ body: {},
+ });
+ }
+ /**
+ * Get an object
+ */
+ async get(options) {
+ this.log.debug('Gettings saved object: %j', options);
+ return await this.requester.request({
+ description: 'get saved object',
+ path: kbn_client_requester_1.uriencode `/api/saved_objects/${options.type}/${options.id}`,
+ method: 'GET',
+ });
+ }
+ /**
+ * Create a saved object
+ */
+ async create(options) {
+ this.log.debug('Creating saved object: %j', options);
+ return await this.requester.request({
+ description: 'update saved object',
+ path: options.id
+ ? kbn_client_requester_1.uriencode `/api/saved_objects/${options.type}/${options.id}`
+ : kbn_client_requester_1.uriencode `/api/saved_objects/${options.type}`,
+ query: {
+ overwrite: options.overwrite,
+ },
+ method: 'POST',
+ body: {
+ attributes: options.attributes,
+ migrationVersion: options.migrationVersion,
+ references: options.references,
+ },
+ });
+ }
+ /**
+ * Update a saved object
+ */
+ async update(options) {
+ this.log.debug('Updating saved object: %j', options);
+ return await this.requester.request({
+ description: 'update saved object',
+ path: kbn_client_requester_1.uriencode `/api/saved_objects/${options.type}/${options.id}`,
+ query: {
+ overwrite: options.overwrite,
+ },
+ method: 'PUT',
+ body: {
+ attributes: options.attributes,
+ migrationVersion: options.migrationVersion,
+ references: options.references,
+ },
+ });
+ }
+ /**
+ * Delete an object
+ */
+ async delete(options) {
+ this.log.debug('Deleting saved object %s/%s', options);
+ return await this.requester.request({
+ description: 'delete saved object',
+ path: kbn_client_requester_1.uriencode `/api/saved_objects/${options.type}/${options.id}`,
+ method: 'DELETE',
+ });
+ }
+}
+exports.KbnClientSavedObjects = KbnClientSavedObjects;
- // current character position in p
- var pos;
- // the partial path so far, including a trailing slash if any
- var current;
- // the partial path without a trailing slash (except when pointing at a root)
- var base;
- // the partial path scanned in the previous round, with slash
- var previous;
- start();
+/***/ }),
+/* 485 */
+/***/ (function(module, exports, __webpack_require__) {
- function start() {
- // Skip over roots
- var m = splitRootRe.exec(p);
- pos = m[0].length;
- current = m[0];
- base = m[0];
- previous = '';
+"use strict";
- // On windows, check that the root exists. On unix there is no need.
- if (isWindows && !knownHard[base]) {
- fs.lstat(base, function(err) {
- if (err) return cb(err);
- knownHard[base] = true;
- LOOP();
- });
- } else {
- process.nextTick(LOOP);
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const kbn_client_requester_1 = __webpack_require__(438);
+class KbnClientUiSettings {
+ constructor(log, requester, defaults) {
+ this.log = log;
+ this.requester = requester;
+ this.defaults = defaults;
}
- }
-
- // walk down the path, swapping out linked pathparts for their real
- // values
- function LOOP() {
- // stop if scanned past end of path
- if (pos >= p.length) {
- if (cache) cache[original] = p;
- return cb(null, p);
+ async get(setting) {
+ var _a;
+ const all = await this.getAll();
+ const value = (_a = all[setting]) === null || _a === void 0 ? void 0 : _a.userValue;
+ this.log.verbose('uiSettings.value: %j', value);
+ return value;
}
-
- // find the next part
- nextPartRe.lastIndex = pos;
- var result = nextPartRe.exec(p);
- previous = current;
- current += result[0];
- base = previous + result[1];
- pos = nextPartRe.lastIndex;
-
- // continue if not a symlink
- if (knownHard[base] || (cache && cache[base] === base)) {
- return process.nextTick(LOOP);
+ /**
+ * Gets defaultIndex from the config doc.
+ */
+ async getDefaultIndex() {
+ return await this.get('defaultIndex');
}
-
- if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
- // known symbolic link. no need to stat again.
- return gotResolvedLink(cache[base]);
+ /**
+ * Unset a uiSetting
+ */
+ async unset(setting) {
+ return await this.requester.request({
+ path: kbn_client_requester_1.uriencode `/api/kibana/settings/${setting}`,
+ method: 'DELETE',
+ });
}
-
- return fs.lstat(base, gotStat);
- }
-
- function gotStat(err, stat) {
- if (err) return cb(err);
-
- // if not a symlink, skip to the next path part
- if (!stat.isSymbolicLink()) {
- knownHard[base] = true;
- if (cache) cache[base] = base;
- return process.nextTick(LOOP);
+ /**
+ * Replace all uiSettings with the `doc` values, `doc` is merged
+ * with some defaults
+ */
+ async replace(doc, { retries = 5 } = {}) {
+ this.log.debug('replacing kibana config doc: %j', doc);
+ const changes = {
+ ...this.defaults,
+ ...doc,
+ };
+ for (const [name, { isOverridden }] of Object.entries(await this.getAll())) {
+ if (!isOverridden && !changes.hasOwnProperty(name)) {
+ changes[name] = null;
+ }
+ }
+ await this.requester.request({
+ method: 'POST',
+ path: '/api/kibana/settings',
+ body: { changes },
+ retries,
+ });
}
-
- // stat & read the link if not read before
- // call gotTarget as soon as the link target is known
- // dev/ino always return 0 on windows, so skip the check.
- if (!isWindows) {
- var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
- if (seenLinks.hasOwnProperty(id)) {
- return gotTarget(null, seenLinks[id], base);
- }
+ /**
+ * Add fields to the config doc (like setting timezone and defaultIndex)
+ */
+ async update(updates) {
+ this.log.debug('applying update to kibana config: %j', updates);
+ await this.requester.request({
+ path: '/api/kibana/settings',
+ method: 'POST',
+ body: {
+ changes: updates,
+ },
+ });
}
- fs.stat(base, function(err) {
- if (err) return cb(err);
+ async getAll() {
+ const resp = await this.requester.request({
+ path: '/api/kibana/settings',
+ method: 'GET',
+ });
+ return resp.settings;
+ }
+}
+exports.KbnClientUiSettings = KbnClientUiSettings;
- fs.readlink(base, function(err, target) {
- if (!isWindows) seenLinks[id] = target;
- gotTarget(err, target);
- });
- });
- }
- function gotTarget(err, target, base) {
- if (err) return cb(err);
+/***/ }),
+/* 486 */
+/***/ (function(module, exports, __webpack_require__) {
- var resolvedLink = pathModule.resolve(previous, target);
- if (cache) cache[base] = resolvedLink;
- gotResolvedLink(resolvedLink);
- }
+"use strict";
- function gotResolvedLink(resolvedLink) {
- // resolve the link, then start over
- p = pathModule.resolve(resolvedLink, p.slice(pos));
- start();
- }
-};
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+tslib_1.__exportStar(__webpack_require__(487), exports);
/***/ }),
-/* 506 */
+/* 487 */
/***/ (function(module, exports, __webpack_require__) {
-module.exports = minimatch
-minimatch.Minimatch = Minimatch
-
-var path = { sep: '/' }
-try {
- path = __webpack_require__(16)
-} catch (er) {}
-
-var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
-var expand = __webpack_require__(507)
-
-var plTypes = {
- '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
- '?': { open: '(?:', close: ')?' },
- '+': { open: '(?:', close: ')+' },
- '*': { open: '(?:', close: ')*' },
- '@': { open: '(?:', close: ')' }
-}
+"use strict";
-// any single thing other than /
-// don't need to escape / when using new RegExp()
-var qmark = '[^/]'
-
-// * => any number of characters
-var star = qmark + '*?'
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = __webpack_require__(6);
+const util_1 = __webpack_require__(397);
+const axios_1 = tslib_1.__importDefault(__webpack_require__(440));
+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;
+}
+function validateConfig(log, config) {
+ 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;
+}
+class CiStatsReporter {
+ constructor(config, log) {
+ this.config = config;
+ this.log = log;
+ }
+ static fromEnv(log) {
+ return new CiStatsReporter(parseConfig(log), log);
+ }
+ isEnabled() {
+ return !!this.config;
+ }
+ async metrics(metrics) {
+ var _a, _b, _c, _d;
+ if (!this.config) {
+ return;
+ }
+ let attempt = 0;
+ const maxAttempts = 5;
+ const bodySummary = metrics
+ .map(({ group, id, value }) => `[${group}/${id}=${value}]`)
+ .join(' ');
+ while (true) {
+ attempt += 1;
+ try {
+ await axios_1.default.request({
+ method: 'POST',
+ url: '/v1/metrics',
+ baseURL: this.config.apiUrl,
+ headers: {
+ Authorization: `token ${this.config.apiToken}`,
+ },
+ data: {
+ buildId: this.config.buildId,
+ metrics,
+ },
+ });
+ return;
+ }
+ catch (error) {
+ if (!((_a = error) === null || _a === void 0 ? void 0 : _a.request)) {
+ // not an axios error, must be a usage error that we should notify user about
+ throw error;
+ }
+ if (((_b = error) === null || _b === void 0 ? void 0 : _b.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=${util_1.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}`);
+ return;
+ }
+ // we failed to reach the backend and we have remaining attempts, lets retry after a short delay
+ const reason = ((_d = (_c = error) === null || _c === void 0 ? void 0 : _c.response) === null || _d === void 0 ? void 0 : _d.status) ? `${error.response.status} response`
+ : 'no response';
+ this.log.warning(`failed to reach kibana-ci-stats service [reason=${reason}], retrying in ${attempt} seconds`);
+ await new Promise((resolve) => setTimeout(resolve, attempt * 1000));
+ }
+ }
+ }
+}
+exports.CiStatsReporter = CiStatsReporter;
-// ** when dots are allowed. Anything goes, except .. and .
-// not (^ or / followed by one or two dots followed by $ or /),
-// followed by anything, any number of times.
-var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'
-// not a ^ or / followed by a dot,
-// followed by anything, any number of times.
-var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'
+/***/ }),
+/* 488 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
-// characters that need to be escaped in RegExp.
-var reSpecials = charSet('().*{}+?[]^$\\!')
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "commands", function() { return commands; });
+/* harmony import */ var _bootstrap__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(489);
+/* harmony import */ var _clean__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(581);
+/* harmony import */ var _run__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(686);
+/* harmony import */ var _watch__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(687);
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
-// "abc" -> { a:true, b:true, c:true }
-function charSet (s) {
- return s.split('').reduce(function (set, c) {
- set[c] = true
- return set
- }, {})
-}
-// normalizes slashes.
-var slashSplit = /\/+/
-minimatch.filter = filter
-function filter (pattern, options) {
- options = options || {}
- return function (p, i, list) {
- return minimatch(p, pattern, options)
- }
-}
-function ext (a, b) {
- a = a || {}
- b = b || {}
- var t = {}
- Object.keys(b).forEach(function (k) {
- t[k] = b[k]
- })
- Object.keys(a).forEach(function (k) {
- t[k] = a[k]
- })
- return t
-}
+const commands = {
+ bootstrap: _bootstrap__WEBPACK_IMPORTED_MODULE_0__["BootstrapCommand"],
+ clean: _clean__WEBPACK_IMPORTED_MODULE_1__["CleanCommand"],
+ run: _run__WEBPACK_IMPORTED_MODULE_2__["RunCommand"],
+ watch: _watch__WEBPACK_IMPORTED_MODULE_3__["WatchCommand"]
+};
-minimatch.defaults = function (def) {
- if (!def || !Object.keys(def).length) return minimatch
+/***/ }),
+/* 489 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- var orig = minimatch
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BootstrapCommand", function() { return BootstrapCommand; });
+/* harmony import */ var _utils_link_project_executables__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(490);
+/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(500);
+/* harmony import */ var _utils_parallelize__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(501);
+/* harmony import */ var _utils_projects__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(502);
+/* harmony import */ var _utils_project_checksums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(575);
+/* harmony import */ var _utils_bootstrap_cache_file__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(580);
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
- var m = function minimatch (p, pattern, options) {
- return orig.minimatch(p, pattern, ext(def, options))
- }
- m.Minimatch = function Minimatch (pattern, options) {
- return new orig.Minimatch(pattern, ext(def, options))
- }
- return m
-}
-Minimatch.defaults = function (def) {
- if (!def || !Object.keys(def).length) return Minimatch
- return minimatch.defaults(def).Minimatch
-}
-function minimatch (p, pattern, options) {
- if (typeof pattern !== 'string') {
- throw new TypeError('glob pattern string required')
- }
- if (!options) options = {}
+const BootstrapCommand = {
+ description: 'Install dependencies and crosslink projects',
+ name: 'bootstrap',
- // shortcut: comments match nothing.
- if (!options.nocomment && pattern.charAt(0) === '#') {
- return false
- }
+ async run(projects, projectGraph, {
+ options,
+ kbn
+ }) {
+ const batchedProjectsByWorkspace = Object(_utils_projects__WEBPACK_IMPORTED_MODULE_3__["topologicallyBatchProjects"])(projects, projectGraph, {
+ batchByWorkspace: true
+ });
+ const batchedProjects = Object(_utils_projects__WEBPACK_IMPORTED_MODULE_3__["topologicallyBatchProjects"])(projects, projectGraph);
+ const extraArgs = [...(options['frozen-lockfile'] === true ? ['--frozen-lockfile'] : []), ...(options['prefer-offline'] === true ? ['--prefer-offline'] : [])];
- // "" only matches ""
- if (pattern.trim() === '') return p === ''
+ for (const batch of batchedProjectsByWorkspace) {
+ for (const project of batch) {
+ if (project.isWorkspaceProject) {
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].verbose(`Skipping workspace project: ${project.name}`);
+ continue;
+ }
- return new Minimatch(pattern, options).match(p)
-}
+ if (project.hasDependencies()) {
+ await project.installDependencies({
+ extraArgs
+ });
+ }
+ }
+ }
-function Minimatch (pattern, options) {
- if (!(this instanceof Minimatch)) {
- return new Minimatch(pattern, options)
- }
+ await Object(_utils_link_project_executables__WEBPACK_IMPORTED_MODULE_0__["linkProjectExecutables"])(projects, projectGraph);
+ /**
+ * At the end of the bootstrapping process we call all `kbn:bootstrap` scripts
+ * in the list of projects. We do this because some projects need to be
+ * transpiled before they can be used. Ideally we shouldn't do this unless we
+ * have to, as it will slow down the bootstrapping process.
+ */
- if (typeof pattern !== 'string') {
- throw new TypeError('glob pattern string required')
- }
+ const checksums = await Object(_utils_project_checksums__WEBPACK_IMPORTED_MODULE_4__["getAllChecksums"])(kbn, _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"]);
+ const caches = new Map();
+ let cachedProjectCount = 0;
- if (!options) options = {}
- pattern = pattern.trim()
+ for (const project of projects.values()) {
+ if (project.hasScript('kbn:bootstrap')) {
+ const file = new _utils_bootstrap_cache_file__WEBPACK_IMPORTED_MODULE_5__["BootstrapCacheFile"](kbn, project, checksums);
+ const valid = options.cache && file.isValid();
- // windows support: need to use /, not \
- if (path.sep !== '/') {
- pattern = pattern.split(path.sep).join('/')
- }
+ if (valid) {
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].debug(`[${project.name}] cache up to date`);
+ }
- this.options = options
- this.set = []
- this.pattern = pattern
- this.regexp = null
- this.negate = false
- this.comment = false
- this.empty = false
+ caches.set(project, {
+ file,
+ valid
+ });
+ cachedProjectCount += 1;
+ }
+ }
- // make the set of regexps etc.
- this.make()
-}
+ if (cachedProjectCount > 0) {
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].success(`${cachedProjectCount} bootsrap builds are cached`);
+ }
-Minimatch.prototype.debug = function () {}
+ await Object(_utils_parallelize__WEBPACK_IMPORTED_MODULE_2__["parallelizeBatches"])(batchedProjects, async project => {
+ const cache = caches.get(project);
-Minimatch.prototype.make = make
-function make () {
- // don't do it more than once.
- if (this._made) return
+ if (cache && !cache.valid) {
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].info(`[${project.name}] running [kbn:bootstrap] script`);
+ cache.file.delete();
+ await project.runScriptStreaming('kbn:bootstrap');
+ cache.file.write();
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].success(`[${project.name}] bootstrap complete`);
+ }
+ });
+ }
- var pattern = this.pattern
- var options = this.options
+};
- // empty patterns and comments match nothing.
- if (!options.nocomment && pattern.charAt(0) === '#') {
- this.comment = true
- return
- }
- if (!pattern) {
- this.empty = true
- return
- }
+/***/ }),
+/* 490 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- // step 1: figure out negation, etc.
- this.parseNegate()
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "linkProjectExecutables", function() { return linkProjectExecutables; });
+/* 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 _fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(491);
+/* harmony import */ var _log__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(500);
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
- // step 2: expand braces
- var set = this.globSet = this.braceExpand()
- if (options.debug) this.debug = console.error
- this.debug(this.pattern, set)
- // step 3: now we have a set, so turn each one into a series of path-portion
- // matching patterns.
- // These will be regexps, except in the case of "**", which is
- // set to the GLOBSTAR object for globstar behavior,
- // and will not contain any / characters
- set = this.globParts = set.map(function (s) {
- return s.split(slashSplit)
- })
+/**
+ * Yarn does not link the executables from dependencies that are installed
+ * using `link:` https://github.com/yarnpkg/yarn/pull/5046
+ *
+ * We simulate this functionality by walking through each project's project
+ * dependencies, and manually linking their executables if defined. The logic
+ * for linking was mostly adapted from lerna: https://github.com/lerna/lerna/blob/1d7eb9eeff65d5a7de64dea73613b1bf6bfa8d57/src/PackageUtilities.js#L348
+ */
+async function linkProjectExecutables(projectsByName, projectGraph) {
+ _log__WEBPACK_IMPORTED_MODULE_2__["log"].debug(`Linking package executables`);
- this.debug(this.pattern, set)
+ for (const [projectName, projectDeps] of projectGraph) {
+ const project = projectsByName.get(projectName);
+ const binsDir = Object(path__WEBPACK_IMPORTED_MODULE_0__["resolve"])(project.nodeModulesLocation, '.bin');
- // glob --> regexps
- set = set.map(function (s, si, set) {
- return s.map(this.parse, this)
- }, this)
+ for (const projectDep of projectDeps) {
+ const executables = projectDep.getExecutables();
- this.debug(this.pattern, set)
+ for (const name of Object.keys(executables)) {
+ const srcPath = executables[name]; // existing logic from lerna -- ensure that the bin we are going to
+ // point to exists or ignore it
- // filter out everything that didn't compile properly.
- set = set.filter(function (s) {
- return s.indexOf(false) === -1
- })
+ if (!(await Object(_fs__WEBPACK_IMPORTED_MODULE_1__["isFile"])(srcPath))) {
+ continue;
+ }
- this.debug(this.pattern, set)
+ const dest = Object(path__WEBPACK_IMPORTED_MODULE_0__["resolve"])(binsDir, name); // Get relative project path with normalized path separators.
- this.set = set
+ const projectRelativePath = Object(path__WEBPACK_IMPORTED_MODULE_0__["relative"])(project.path, srcPath).split(path__WEBPACK_IMPORTED_MODULE_0__["sep"]).join('/');
+ _log__WEBPACK_IMPORTED_MODULE_2__["log"].debug(`[${project.name}] ${name} -> ${projectRelativePath}`);
+ await Object(_fs__WEBPACK_IMPORTED_MODULE_1__["mkdirp"])(Object(path__WEBPACK_IMPORTED_MODULE_0__["dirname"])(dest));
+ await Object(_fs__WEBPACK_IMPORTED_MODULE_1__["createSymlink"])(srcPath, dest, 'exec');
+ await Object(_fs__WEBPACK_IMPORTED_MODULE_1__["chmod"])(dest, '755');
+ }
+ }
+ }
}
-Minimatch.prototype.parseNegate = parseNegate
-function parseNegate () {
- var pattern = this.pattern
- var negate = false
- var options = this.options
- var negateOffset = 0
+/***/ }),
+/* 491 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- if (options.nonegate) return
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "readFile", function() { return readFile; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chmod", function() { return chmod; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mkdirp", function() { return mkdirp; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "unlink", function() { return unlink; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copyDirectory", function() { return copyDirectory; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isSymlink", function() { return isSymlink; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isDirectory", function() { return isDirectory; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isFile", function() { return isFile; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createSymlink", function() { return createSymlink; });
+/* harmony import */ var cmd_shim__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(492);
+/* harmony import */ var cmd_shim__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(cmd_shim__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(349);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var ncp__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(499);
+/* harmony import */ var ncp__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(ncp__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(397);
+/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(util__WEBPACK_IMPORTED_MODULE_4__);
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
- for (var i = 0, l = pattern.length
- ; i < l && pattern.charAt(i) === '!'
- ; i++) {
- negate = !negate
- negateOffset++
- }
- if (negateOffset) this.pattern = pattern.substr(negateOffset)
- this.negate = negate
-}
-// Brace expansion:
-// a{b,c}d -> abd acd
-// a{b,}c -> abc ac
-// a{0..3}d -> a0d a1d a2d a3d
-// a{b,c{d,e}f}g -> abg acdfg acefg
-// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
-//
-// Invalid sets are not expanded.
-// a{2..}b -> a{2..}b
-// a{b}c -> a{b}c
-minimatch.braceExpand = function (pattern, options) {
- return braceExpand(pattern, options)
-}
-Minimatch.prototype.braceExpand = braceExpand
-function braceExpand (pattern, options) {
- if (!options) {
- if (this instanceof Minimatch) {
- options = this.options
- } else {
- options = {}
- }
- }
+const lstat = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.lstat);
+const readFile = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.readFile);
+const symlink = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.symlink);
+const chmod = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.chmod);
+const cmdShim = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(cmd_shim__WEBPACK_IMPORTED_MODULE_0___default.a);
+const mkdir = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.mkdir);
+const mkdirp = async path => await mkdir(path, {
+ recursive: true
+});
+const unlink = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(fs__WEBPACK_IMPORTED_MODULE_1___default.a.unlink);
+const copyDirectory = Object(util__WEBPACK_IMPORTED_MODULE_4__["promisify"])(ncp__WEBPACK_IMPORTED_MODULE_2__["ncp"]);
- pattern = typeof pattern === 'undefined'
- ? this.pattern : pattern
+async function statTest(path, block) {
+ try {
+ return block((await lstat(path)));
+ } catch (e) {
+ if (e.code === 'ENOENT') {
+ return false;
+ }
- if (typeof pattern === 'undefined') {
- throw new TypeError('undefined pattern')
+ throw e;
}
+}
+/**
+ * Test if a path points to a symlink.
+ * @param path
+ */
- if (options.nobrace ||
- !pattern.match(/\{.*\}/)) {
- // shortcut. no need to expand.
- return [pattern]
- }
- return expand(pattern)
+async function isSymlink(path) {
+ return await statTest(path, stats => stats.isSymbolicLink());
}
+/**
+ * Test if a path points to a directory.
+ * @param path
+ */
-// parse a component of the expanded set.
-// At this point, no pattern may contain "/" in it
-// so we're going to return a 2d array, where each entry is the full
-// pattern, split on '/', and then turned into a regular expression.
-// A regexp is made at the end which joins each array with an
-// escaped /, and another full one which joins each regexp with |.
-//
-// Following the lead of Bash 4.1, note that "**" only has special meaning
-// when it is the *only* thing in a path portion. Otherwise, any series
-// of * is equivalent to a single *. Globstar behavior is enabled by
-// default, and can be disabled by setting options.noglobstar.
-Minimatch.prototype.parse = parse
-var SUBPARSE = {}
-function parse (pattern, isSub) {
- if (pattern.length > 1024 * 64) {
- throw new TypeError('pattern is too long')
- }
-
- var options = this.options
-
- // shortcuts
- if (!options.noglobstar && pattern === '**') return GLOBSTAR
- if (pattern === '') return ''
+async function isDirectory(path) {
+ return await statTest(path, stats => stats.isDirectory());
+}
+/**
+ * Test if a path points to a regular file.
+ * @param path
+ */
- var re = ''
- var hasMagic = !!options.nocase
- var escaping = false
- // ? => one single character
- var patternListStack = []
- var negativeLists = []
- var stateChar
- var inClass = false
- var reClassStart = -1
- var classStart = -1
- // . and .. never match anything that doesn't start with .,
- // even when options.dot is set.
- var patternStart = pattern.charAt(0) === '.' ? '' // anything
- // not (start or / followed by . or .. followed by / or end)
- : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
- : '(?!\\.)'
- var self = this
+async function isFile(path) {
+ return await statTest(path, stats => stats.isFile());
+}
+/**
+ * Create a symlink at dest that points to src. Adapted from
+ * https://github.com/lerna/lerna/blob/2f1b87d9e2295f587e4ac74269f714271d8ed428/src/FileSystemUtilities.js#L103.
+ *
+ * @param src
+ * @param dest
+ * @param type 'dir', 'file', 'junction', or 'exec'. 'exec' on
+ * windows will use the `cmd-shim` module since symlinks can't be used
+ * for executable files on windows.
+ */
- function clearStateChar () {
- if (stateChar) {
- // we had some state-tracking character
- // that wasn't consumed by this pass.
- switch (stateChar) {
- case '*':
- re += star
- hasMagic = true
- break
- case '?':
- re += qmark
- hasMagic = true
- break
- default:
- re += '\\' + stateChar
- break
- }
- self.debug('clearStateChar %j %j', stateChar, re)
- stateChar = false
+async function createSymlink(src, dest, type) {
+ if (process.platform === 'win32') {
+ if (type === 'exec') {
+ await cmdShim(src, dest);
+ } else {
+ await forceCreate(src, dest, type);
}
+ } else {
+ const posixType = type === 'exec' ? 'file' : type;
+ const relativeSource = Object(path__WEBPACK_IMPORTED_MODULE_3__["relative"])(Object(path__WEBPACK_IMPORTED_MODULE_3__["dirname"])(dest), src);
+ await forceCreate(relativeSource, dest, posixType);
}
+}
- for (var i = 0, len = pattern.length, c
- ; (i < len) && (c = pattern.charAt(i))
- ; i++) {
- this.debug('%s\t%s %s %j', pattern, i, re, c)
-
- // skip over any that are escaped.
- if (escaping && reSpecials[c]) {
- re += '\\' + c
- escaping = false
- continue
+async function forceCreate(src, dest, type) {
+ try {
+ // If something exists at `dest` we need to remove it first.
+ await unlink(dest);
+ } catch (error) {
+ if (error.code !== 'ENOENT') {
+ throw error;
}
+ }
- switch (c) {
- case '/':
- // completely not allowed, even escaped.
- // Should already be path-split by now.
- return false
-
- case '\\':
- clearStateChar()
- escaping = true
- continue
-
- // the various stateChar values
- // for the "extglob" stuff.
- case '?':
- case '*':
- case '+':
- case '@':
- case '!':
- this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
-
- // all of those are literals inside a class, except that
- // the glob [!a] means [^a] in regexp
- if (inClass) {
- this.debug(' in class')
- if (c === '!' && i === classStart + 1) c = '^'
- re += c
- continue
- }
-
- // if we already have a stateChar, then it means
- // that there was something like ** or +? in there.
- // Handle the stateChar, then proceed with this one.
- self.debug('call clearStateChar %j', stateChar)
- clearStateChar()
- stateChar = c
- // if extglob is disabled, then +(asdf|foo) isn't a thing.
- // just clear the statechar *now*, rather than even diving into
- // the patternList stuff.
- if (options.noext) clearStateChar()
- continue
-
- case '(':
- if (inClass) {
- re += '('
- continue
- }
-
- if (!stateChar) {
- re += '\\('
- continue
- }
-
- patternListStack.push({
- type: stateChar,
- start: i - 1,
- reStart: re.length,
- open: plTypes[stateChar].open,
- close: plTypes[stateChar].close
- })
- // negation is (?:(?!js)[^/]*)
- re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
- this.debug('plType %j %j', stateChar, re)
- stateChar = false
- continue
-
- case ')':
- if (inClass || !patternListStack.length) {
- re += '\\)'
- continue
- }
-
- clearStateChar()
- hasMagic = true
- var pl = patternListStack.pop()
- // negation is (?:(?!js)[^/]*)
- // The others are (?:)
- re += pl.close
- if (pl.type === '!') {
- negativeLists.push(pl)
- }
- pl.reEnd = re.length
- continue
-
- case '|':
- if (inClass || !patternListStack.length || escaping) {
- re += '\\|'
- escaping = false
- continue
- }
-
- clearStateChar()
- re += '|'
- continue
+ await symlink(src, dest, type);
+}
- // these are mostly the same in regexp and glob
- case '[':
- // swallow any state-tracking char before the [
- clearStateChar()
+/***/ }),
+/* 492 */
+/***/ (function(module, exports, __webpack_require__) {
- if (inClass) {
- re += '\\' + c
- continue
- }
+// On windows, create a .cmd file.
+// Read the #! in the file to see what it uses. The vast majority
+// of the time, this will be either:
+// "#!/usr/bin/env "
+// or:
+// "#! "
+//
+// Write a binroot/pkg.bin + ".cmd" file that has this line in it:
+// @ %~dp0 %*
- inClass = true
- classStart = i
- reClassStart = re.length
- re += c
- continue
+module.exports = cmdShim
+cmdShim.ifExists = cmdShimIfExists
- case ']':
- // a right bracket shall lose its special
- // meaning and represent itself in
- // a bracket expression if it occurs
- // first in the list. -- POSIX.2 2.8.3.2
- if (i === classStart + 1 || !inClass) {
- re += '\\' + c
- escaping = false
- continue
- }
+var fs = __webpack_require__(493)
- // handle the case where we left a class open.
- // "[z-a]" is valid, equivalent to "\[z-a\]"
- if (inClass) {
- // split where the last [ was, make sure we don't have
- // an invalid re. if so, re-walk the contents of the
- // would-be class to re-translate any characters that
- // were passed through as-is
- // TODO: It would probably be faster to determine this
- // without a try/catch and a new RegExp, but it's tricky
- // to do safely. For now, this is safe and works.
- var cs = pattern.substring(classStart + 1, i)
- try {
- RegExp('[' + cs + ']')
- } catch (er) {
- // not a valid class!
- var sp = this.parse(cs, SUBPARSE)
- re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
- hasMagic = hasMagic || sp[1]
- inClass = false
- continue
- }
- }
+var mkdir = __webpack_require__(497)
+ , path = __webpack_require__(4)
+ , toBatchSyntax = __webpack_require__(498)
+ , shebangExpr = /^#\!\s*(?:\/usr\/bin\/env)?\s*([^ \t]+=[^ \t]+\s+)*\s*([^ \t]+)(.*)$/
- // finish up the class.
- hasMagic = true
- inClass = false
- re += c
- continue
+function cmdShimIfExists (from, to, cb) {
+ fs.stat(from, function (er) {
+ if (er) return cb()
+ cmdShim(from, to, cb)
+ })
+}
- default:
- // swallow any state char that wasn't consumed
- clearStateChar()
+// Try to unlink, but ignore errors.
+// Any problems will surface later.
+function rm (path, cb) {
+ fs.unlink(path, function(er) {
+ cb()
+ })
+}
- if (escaping) {
- // no need
- escaping = false
- } else if (reSpecials[c]
- && !(c === '^' && inClass)) {
- re += '\\'
- }
+function cmdShim (from, to, cb) {
+ fs.stat(from, function (er, stat) {
+ if (er)
+ return cb(er)
- re += c
+ cmdShim_(from, to, cb)
+ })
+}
- } // switch
- } // for
+function cmdShim_ (from, to, cb) {
+ var then = times(2, next, cb)
+ rm(to, then)
+ rm(to + ".cmd", then)
- // handle the case where we left a class open.
- // "[abc" is valid, equivalent to "\[abc"
- if (inClass) {
- // split where the last [ was, and escape it
- // this is a huge pita. We now have to re-walk
- // the contents of the would-be class to re-translate
- // any characters that were passed through as-is
- cs = pattern.substr(classStart + 1)
- sp = this.parse(cs, SUBPARSE)
- re = re.substr(0, reClassStart) + '\\[' + sp[0]
- hasMagic = hasMagic || sp[1]
+ function next(er) {
+ writeShim(from, to, cb)
}
+}
- // handle the case where we had a +( thing at the *end*
- // of the pattern.
- // each pattern list stack adds 3 chars, and we need to go through
- // and escape any | chars that were passed through as-is for the regexp.
- // Go through and escape them, taking care not to double-escape any
- // | chars that were already escaped.
- for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
- var tail = re.slice(pl.reStart + pl.open.length)
- this.debug('setting tail', re, pl)
- // maybe some even number of \, then maybe 1 \, followed by a |
- tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
- if (!$2) {
- // the | isn't already escaped, so escape it.
- $2 = '\\'
- }
-
- // need to escape all those slashes *again*, without escaping the
- // one that we need for escaping the | character. As it works out,
- // escaping an even number of slashes can be done by simply repeating
- // it exactly after itself. That's why this trick works.
- //
- // I am sorry that you have to see this.
- return $1 + $1 + $2 + '|'
+function writeShim (from, to, cb) {
+ // make a cmd file and a sh script
+ // First, check if the bin is a #! of some sort.
+ // If not, then assume it's something that'll be compiled, or some other
+ // sort of script, and just call it directly.
+ mkdir(path.dirname(to), function (er) {
+ if (er)
+ return cb(er)
+ fs.readFile(from, "utf8", function (er, data) {
+ if (er) return writeShim_(from, to, null, null, cb)
+ var firstLine = data.trim().split(/\r*\n/)[0]
+ , shebang = firstLine.match(shebangExpr)
+ if (!shebang) return writeShim_(from, to, null, null, null, cb)
+ var vars = shebang[1] || ""
+ , prog = shebang[2]
+ , args = shebang[3] || ""
+ return writeShim_(from, to, prog, args, vars, cb)
})
+ })
+}
- this.debug('tail=%j\n %s', tail, tail, pl, re)
- var t = pl.type === '*' ? star
- : pl.type === '?' ? qmark
- : '\\' + pl.type
-
- hasMagic = true
- re = re.slice(0, pl.reStart) + t + '\\(' + tail
- }
- // handle trailing things that only matter at the very end.
- clearStateChar()
- if (escaping) {
- // trailing \\
- re += '\\\\'
+function writeShim_ (from, to, prog, args, variables, cb) {
+ var shTarget = path.relative(path.dirname(to), from)
+ , target = shTarget.split("/").join("\\")
+ , longProg
+ , shProg = prog && prog.split("\\").join("/")
+ , shLongProg
+ , pwshProg = shProg && "\"" + shProg + "$exe\""
+ , pwshLongProg
+ shTarget = shTarget.split("\\").join("/")
+ args = args || ""
+ variables = variables || ""
+ if (!prog) {
+ prog = "\"%~dp0\\" + target + "\""
+ shProg = "\"$basedir/" + shTarget + "\""
+ pwshProg = shProg
+ args = ""
+ target = ""
+ shTarget = ""
+ } else {
+ longProg = "\"%~dp0\\" + prog + ".exe\""
+ shLongProg = "\"$basedir/" + prog + "\""
+ pwshLongProg = "\"$basedir/" + prog + "$exe\""
+ target = "\"%~dp0\\" + target + "\""
+ shTarget = "\"$basedir/" + shTarget + "\""
}
- // only need to apply the nodot start if the re starts with
- // something that could conceivably capture a dot
- var addPatternStart = false
- switch (re.charAt(0)) {
- case '.':
- case '[':
- case '(': addPatternStart = true
+ // @SETLOCAL
+ //
+ // @IF EXIST "%~dp0\node.exe" (
+ // @SET "_prog=%~dp0\node.exe"
+ // ) ELSE (
+ // @SET "_prog=node"
+ // @SET PATHEXT=%PATHEXT:;.JS;=;%
+ // )
+ //
+ // "%_prog%" "%~dp0\.\node_modules\npm\bin\npm-cli.js" %*
+ // @ENDLOCAL
+ var cmd
+ if (longProg) {
+ shLongProg = shLongProg.trim();
+ args = args.trim();
+ var variableDeclarationsAsBatch = toBatchSyntax.convertToSetCommands(variables)
+ cmd = "@SETLOCAL\r\n"
+ + variableDeclarationsAsBatch
+ + "\r\n"
+ + "@IF EXIST " + longProg + " (\r\n"
+ + " @SET \"_prog=" + longProg.replace(/(^")|("$)/g, '') + "\"\r\n"
+ + ") ELSE (\r\n"
+ + " @SET \"_prog=" + prog.replace(/(^")|("$)/g, '') + "\"\r\n"
+ + " @SET PATHEXT=%PATHEXT:;.JS;=;%\r\n"
+ + ")\r\n"
+ + "\r\n"
+ + "\"%_prog%\" " + args + " " + target + " %*\r\n"
+ + '@ENDLOCAL\r\n'
+ } else {
+ cmd = "@" + prog + " " + args + " " + target + " %*\r\n"
}
- // Hack to work around lack of negative lookbehind in JS
- // A pattern like: *.!(x).!(y|z) needs to ensure that a name
- // like 'a.xyz.yz' doesn't match. So, the first negative
- // lookahead, has to look ALL the way ahead, to the end of
- // the pattern.
- for (var n = negativeLists.length - 1; n > -1; n--) {
- var nl = negativeLists[n]
-
- var nlBefore = re.slice(0, nl.reStart)
- var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
- var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
- var nlAfter = re.slice(nl.reEnd)
-
- nlLast += nlAfter
-
- // Handle nested stuff like *(*.js|!(*.json)), where open parens
- // mean that we should *not* include the ) in the bit that is considered
- // "after" the negated section.
- var openParensBefore = nlBefore.split('(').length - 1
- var cleanAfter = nlAfter
- for (i = 0; i < openParensBefore; i++) {
- cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
- }
- nlAfter = cleanAfter
+ // #!/bin/sh
+ // basedir=`dirname "$0"`
+ //
+ // case `uname` in
+ // *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w "$basedir"`;;
+ // esac
+ //
+ // if [ -x "$basedir/node.exe" ]; then
+ // "$basedir/node.exe" "$basedir/node_modules/npm/bin/npm-cli.js" "$@"
+ // ret=$?
+ // else
+ // node "$basedir/node_modules/npm/bin/npm-cli.js" "$@"
+ // ret=$?
+ // fi
+ // exit $ret
- var dollar = ''
- if (nlAfter === '' && isSub !== SUBPARSE) {
- dollar = '$'
- }
- var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
- re = newRe
- }
+ var sh = "#!/bin/sh\n"
- // if the re is not "" at this point, then we need to make sure
- // it doesn't match against an empty path part.
- // Otherwise a/* will match a/, which it should not.
- if (re !== '' && hasMagic) {
- re = '(?=.)' + re
- }
+ sh = sh
+ + "basedir=$(dirname \"$(echo \"$0\" | sed -e 's,\\\\,/,g')\")\n"
+ + "\n"
+ + "case `uname` in\n"
+ + " *CYGWIN*|*MINGW*|*MSYS*) basedir=`cygpath -w \"$basedir\"`;;\n"
+ + "esac\n"
+ + "\n"
- if (addPatternStart) {
- re = patternStart + re
+ if (shLongProg) {
+ sh = sh
+ + "if [ -x "+shLongProg+" ]; then\n"
+ + " " + variables + shLongProg + " " + args + " " + shTarget + " \"$@\"\n"
+ + " ret=$?\n"
+ + "else \n"
+ + " " + variables + shProg + " " + args + " " + shTarget + " \"$@\"\n"
+ + " ret=$?\n"
+ + "fi\n"
+ + "exit $ret\n"
+ } else {
+ sh = sh
+ + shProg + " " + args + " " + shTarget + " \"$@\"\n"
+ + "exit $?\n"
}
- // parsing just a piece of a larger pattern.
- if (isSub === SUBPARSE) {
- return [re, hasMagic]
- }
-
- // skip the regexp for non-magical patterns
- // unescape anything in it, though, so that it'll be
- // an exact match against a file etc.
- if (!hasMagic) {
- return globUnescape(pattern)
+ // #!/usr/bin/env pwsh
+ // $basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+ //
+ // $ret=0
+ // $exe = ""
+ // if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+ // # Fix case when both the Windows and Linux builds of Node
+ // # are installed in the same directory
+ // $exe = ".exe"
+ // }
+ // if (Test-Path "$basedir/node") {
+ // & "$basedir/node$exe" "$basedir/node_modules/npm/bin/npm-cli.js" $args
+ // $ret=$LASTEXITCODE
+ // } else {
+ // & "node$exe" "$basedir/node_modules/npm/bin/npm-cli.js" $args
+ // $ret=$LASTEXITCODE
+ // }
+ // exit $ret
+ var pwsh = "#!/usr/bin/env pwsh\n"
+ + "$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent\n"
+ + "\n"
+ + "$exe=\"\"\n"
+ + "if ($PSVersionTable.PSVersion -lt \"6.0\" -or $IsWindows) {\n"
+ + " # Fix case when both the Windows and Linux builds of Node\n"
+ + " # are installed in the same directory\n"
+ + " $exe=\".exe\"\n"
+ + "}\n"
+ if (shLongProg) {
+ pwsh = pwsh
+ + "$ret=0\n"
+ + "if (Test-Path " + pwshLongProg + ") {\n"
+ + " & " + pwshLongProg + " " + args + " " + shTarget + " $args\n"
+ + " $ret=$LASTEXITCODE\n"
+ + "} else {\n"
+ + " & " + pwshProg + " " + args + " " + shTarget + " $args\n"
+ + " $ret=$LASTEXITCODE\n"
+ + "}\n"
+ + "exit $ret\n"
+ } else {
+ pwsh = pwsh
+ + "& " + pwshProg + " " + args + " " + shTarget + " $args\n"
+ + "exit $LASTEXITCODE\n"
}
- var flags = options.nocase ? 'i' : ''
- try {
- var regExp = new RegExp('^' + re + '$', flags)
- } catch (er) {
- // If it was an invalid regular expression, then it can't match
- // anything. This trick looks for a character after the end of
- // the string, which is of course impossible, except in multi-line
- // mode, but it's not a /m regex.
- return new RegExp('$.')
+ var then = times(3, next, cb)
+ fs.writeFile(to + ".ps1", pwsh, "utf8", then)
+ fs.writeFile(to + ".cmd", cmd, "utf8", then)
+ fs.writeFile(to, sh, "utf8", then)
+ function next () {
+ chmodShim(to, cb)
}
-
- regExp._glob = pattern
- regExp._src = re
-
- return regExp
}
-minimatch.makeRe = function (pattern, options) {
- return new Minimatch(pattern, options || {}).makeRe()
+function chmodShim (to, cb) {
+ var then = times(2, cb, cb)
+ fs.chmod(to, "0755", then)
+ fs.chmod(to + ".cmd", "0755", then)
+ fs.chmod(to + ".ps1", "0755", then)
}
-Minimatch.prototype.makeRe = makeRe
-function makeRe () {
- if (this.regexp || this.regexp === false) return this.regexp
-
- // at this point, this.set is a 2d array of partial
- // pattern strings, or "**".
- //
- // It's better to use .match(). This function shouldn't
- // be used, really, but it's pretty convenient sometimes,
- // when you just want to work with a regex.
- var set = this.set
-
- if (!set.length) {
- this.regexp = false
- return this.regexp
+function times(n, ok, cb) {
+ var errState = null
+ return function(er) {
+ if (!errState) {
+ if (er)
+ cb(errState = er)
+ else if (--n === 0)
+ ok()
+ }
}
- var options = this.options
+}
- var twoStar = options.noglobstar ? star
- : options.dot ? twoStarDot
- : twoStarNoDot
- var flags = options.nocase ? 'i' : ''
- var re = set.map(function (pattern) {
- return pattern.map(function (p) {
- return (p === GLOBSTAR) ? twoStar
- : (typeof p === 'string') ? regExpEscape(p)
- : p._src
- }).join('\\\/')
- }).join('|')
+/***/ }),
+/* 493 */
+/***/ (function(module, exports, __webpack_require__) {
- // must match entire pattern
- // ending in a * or ** will make it less strict.
- re = '^(?:' + re + ')$'
+var fs = __webpack_require__(349)
+var polyfills = __webpack_require__(494)
+var legacy = __webpack_require__(495)
+var clone = __webpack_require__(496)
- // can match anything, as long as it's not this.
- if (this.negate) re = '^(?!' + re + ').*$'
+var util = __webpack_require__(397)
- try {
- this.regexp = new RegExp(re, flags)
- } catch (ex) {
- this.regexp = false
- }
- return this.regexp
-}
+/* istanbul ignore next - node 0.x polyfill */
+var gracefulQueue
+var previousSymbol
-minimatch.match = function (list, pattern, options) {
- options = options || {}
- var mm = new Minimatch(pattern, options)
- list = list.filter(function (f) {
- return mm.match(f)
- })
- if (mm.options.nonull && !list.length) {
- list.push(pattern)
- }
- return list
+/* istanbul ignore else - node 0.x polyfill */
+if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
+ gracefulQueue = Symbol.for('graceful-fs.queue')
+ // This is used in testing by future versions
+ previousSymbol = Symbol.for('graceful-fs.previous')
+} else {
+ gracefulQueue = '___graceful-fs.queue'
+ previousSymbol = '___graceful-fs.previous'
}
-Minimatch.prototype.match = match
-function match (f, partial) {
- this.debug('match', f, this.pattern)
- // short-circuit in the case of busted things.
- // comments, etc.
- if (this.comment) return false
- if (this.empty) return f === ''
-
- if (f === '/' && partial) return true
-
- var options = this.options
+function noop () {}
- // windows: need to use /, not \
- if (path.sep !== '/') {
- f = f.split(path.sep).join('/')
+var debug = noop
+if (util.debuglog)
+ debug = util.debuglog('gfs4')
+else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+ debug = function() {
+ var m = util.format.apply(util, arguments)
+ m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
+ console.error(m)
}
- // treat the test path as a set of pathparts.
- f = f.split(slashSplit)
- this.debug(this.pattern, 'split', f)
+// Once time initialization
+if (!global[gracefulQueue]) {
+ // This queue can be shared by multiple loaded instances
+ var queue = []
+ Object.defineProperty(global, gracefulQueue, {
+ get: function() {
+ return queue
+ }
+ })
- // just ONE of the pattern sets in this.set needs to match
- // in order for it to be valid. If negating, then just one
- // match means that we have failed.
- // Either way, return on the first hit.
+ // Patch fs.close/closeSync to shared queue version, because we need
+ // to retry() whenever a close happens *anywhere* in the program.
+ // This is essential when multiple graceful-fs instances are
+ // in play at the same time.
+ fs.close = (function (fs$close) {
+ function close (fd, cb) {
+ return fs$close.call(fs, fd, function (err) {
+ // This function uses the graceful-fs shared queue
+ if (!err) {
+ retry()
+ }
- var set = this.set
- this.debug(this.pattern, 'set', set)
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ })
+ }
- // Find the basename of the path by looking for the last non-empty segment
- var filename
- var i
- for (i = f.length - 1; i >= 0; i--) {
- filename = f[i]
- if (filename) break
- }
+ Object.defineProperty(close, previousSymbol, {
+ value: fs$close
+ })
+ return close
+ })(fs.close)
- for (i = 0; i < set.length; i++) {
- var pattern = set[i]
- var file = f
- if (options.matchBase && pattern.length === 1) {
- file = [filename]
- }
- var hit = this.matchOne(file, pattern, partial)
- if (hit) {
- if (options.flipNegate) return true
- return !this.negate
+ fs.closeSync = (function (fs$closeSync) {
+ function closeSync (fd) {
+ // This function uses the graceful-fs shared queue
+ fs$closeSync.apply(fs, arguments)
+ retry()
}
- }
- // didn't get any hits. this is success if it's a negative
- // pattern, failure otherwise.
- if (options.flipNegate) return false
- return this.negate
+ Object.defineProperty(closeSync, previousSymbol, {
+ value: fs$closeSync
+ })
+ return closeSync
+ })(fs.closeSync)
+
+ if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+ process.on('exit', function() {
+ debug(global[gracefulQueue])
+ __webpack_require__(371).equal(global[gracefulQueue].length, 0)
+ })
+ }
}
-// set partial to true to test if, for example,
-// "/a/b" matches the start of "/*/b/*/d"
-// Partial means, if you run out of file before you run
-// out of pattern, then that's fine, as long as all
-// the parts match.
-Minimatch.prototype.matchOne = function (file, pattern, partial) {
- var options = this.options
+module.exports = patch(clone(fs))
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+ module.exports = patch(fs)
+ fs.__patched = true;
+}
- this.debug('matchOne',
- { 'this': this, file: file, pattern: pattern })
+function patch (fs) {
+ // Everything that references the open() function needs to be in here
+ polyfills(fs)
+ fs.gracefulify = patch
- this.debug('matchOne', file.length, pattern.length)
+ fs.createReadStream = createReadStream
+ fs.createWriteStream = createWriteStream
+ var fs$readFile = fs.readFile
+ fs.readFile = readFile
+ function readFile (path, options, cb) {
+ if (typeof options === 'function')
+ cb = options, options = null
- for (var fi = 0,
- pi = 0,
- fl = file.length,
- pl = pattern.length
- ; (fi < fl) && (pi < pl)
- ; fi++, pi++) {
- this.debug('matchOne loop')
- var p = pattern[pi]
- var f = file[fi]
+ return go$readFile(path, options, cb)
- this.debug(pattern, p, f)
+ function go$readFile (path, options, cb) {
+ return fs$readFile(path, options, function (err) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$readFile, [path, options, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ })
+ }
+ }
- // should be impossible.
- // some invalid regexp stuff in the set.
- if (p === false) return false
+ var fs$writeFile = fs.writeFile
+ fs.writeFile = writeFile
+ function writeFile (path, data, options, cb) {
+ if (typeof options === 'function')
+ cb = options, options = null
- if (p === GLOBSTAR) {
- this.debug('GLOBSTAR', [pattern, p, f])
+ return go$writeFile(path, data, options, cb)
- // "**"
- // a/**/b/**/c would match the following:
- // a/b/x/y/z/c
- // a/x/y/z/b/c
- // a/b/x/b/x/c
- // a/b/c
- // To do this, take the rest of the pattern after
- // the **, and see if it would match the file remainder.
- // If so, return success.
- // If not, the ** "swallows" a segment, and try again.
- // This is recursively awful.
- //
- // a/**/b/**/c matching a/b/x/y/z/c
- // - a matches a
- // - doublestar
- // - matchOne(b/x/y/z/c, b/**/c)
- // - b matches b
- // - doublestar
- // - matchOne(x/y/z/c, c) -> no
- // - matchOne(y/z/c, c) -> no
- // - matchOne(z/c, c) -> no
- // - matchOne(c, c) yes, hit
- var fr = fi
- var pr = pi + 1
- if (pr === pl) {
- this.debug('** at the end')
- // a ** at the end will just swallow the rest.
- // We have found a match.
- // however, it will not swallow /.x, unless
- // options.dot is set.
- // . and .. are *never* matched by **, for explosively
- // exponential reasons.
- for (; fi < fl; fi++) {
- if (file[fi] === '.' || file[fi] === '..' ||
- (!options.dot && file[fi].charAt(0) === '.')) return false
+ function go$writeFile (path, data, options, cb) {
+ return fs$writeFile(path, data, options, function (err) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$writeFile, [path, data, options, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
}
- return true
- }
-
- // ok, let's see if we can swallow whatever we can.
- while (fr < fl) {
- var swallowee = file[fr]
+ })
+ }
+ }
- this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
+ var fs$appendFile = fs.appendFile
+ if (fs$appendFile)
+ fs.appendFile = appendFile
+ function appendFile (path, data, options, cb) {
+ if (typeof options === 'function')
+ cb = options, options = null
- // XXX remove this slice. Just pass the start index.
- if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
- this.debug('globstar found match!', fr, fl, swallowee)
- // found a match.
- return true
- } else {
- // can't swallow "." or ".." ever.
- // can only swallow ".foo" when explicitly asked.
- if (swallowee === '.' || swallowee === '..' ||
- (!options.dot && swallowee.charAt(0) === '.')) {
- this.debug('dot detected!', file, fr, pattern, pr)
- break
- }
+ return go$appendFile(path, data, options, cb)
- // ** swallows a segment, and continue.
- this.debug('globstar swallow a segment, and continue')
- fr++
+ function go$appendFile (path, data, options, cb) {
+ return fs$appendFile(path, data, options, function (err) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$appendFile, [path, data, options, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
}
- }
-
- // no match was found.
- // However, in partial mode, we can't say this is necessarily over.
- // If there's more *pattern* left, then
- if (partial) {
- // ran out of file
- this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
- if (fr === fl) return true
- }
- return false
+ })
}
+ }
- // something other than **
- // non-magic patterns just have to match exactly
- // patterns with magic have been turned into regexps.
- var hit
- if (typeof p === 'string') {
- if (options.nocase) {
- hit = f.toLowerCase() === p.toLowerCase()
- } else {
- hit = f === p
- }
- this.debug('string match', p, f, hit)
+ var fs$readdir = fs.readdir
+ fs.readdir = readdir
+ function readdir (path, options, cb) {
+ var args = [path]
+ if (typeof options !== 'function') {
+ args.push(options)
} else {
- hit = f.match(p)
- this.debug('pattern match', p, f, hit)
+ cb = options
}
+ args.push(go$readdir$cb)
- if (!hit) return false
- }
-
- // Note: ending in / means that we'll get a final ""
- // at the end of the pattern. This can only match a
- // corresponding "" at the end of the file.
- // If the file ends in /, then it can only match a
- // a pattern that ends in /, unless the pattern just
- // doesn't have any more for it. But, a/b/ should *not*
- // match "a/b/*", even though "" matches against the
- // [^/]*? pattern, except in partial mode, where it might
- // simply not be reached yet.
- // However, a/b/ should still satisfy a/*
-
- // now either we fell off the end of the pattern, or we're done.
- if (fi === fl && pi === pl) {
- // ran out of pattern and filename at the same time.
- // an exact hit!
- return true
- } else if (fi === fl) {
- // ran out of file, but still had pattern left.
- // this is ok if we're doing the match as part of
- // a glob fs traversal.
- return partial
- } else if (pi === pl) {
- // ran out of pattern, still have file left.
- // this is only acceptable if we're on the very last
- // empty segment of a file with a trailing slash.
- // a/* should match a/b/
- var emptyFileEnd = (fi === fl - 1) && (file[fi] === '')
- return emptyFileEnd
- }
+ return go$readdir(args)
- // should be unreachable.
- throw new Error('wtf?')
-}
+ function go$readdir$cb (err, files) {
+ if (files && files.sort)
+ files.sort()
-// replace stuff like \* with *
-function globUnescape (s) {
- return s.replace(/\\(.)/g, '$1')
-}
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$readdir, [args]])
-function regExpEscape (s) {
- return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
-}
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ }
+ }
+ function go$readdir (args) {
+ return fs$readdir.apply(fs, args)
+ }
-/***/ }),
-/* 507 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (process.version.substr(0, 4) === 'v0.8') {
+ var legStreams = legacy(fs)
+ ReadStream = legStreams.ReadStream
+ WriteStream = legStreams.WriteStream
+ }
-var concatMap = __webpack_require__(508);
-var balanced = __webpack_require__(509);
+ var fs$ReadStream = fs.ReadStream
+ if (fs$ReadStream) {
+ ReadStream.prototype = Object.create(fs$ReadStream.prototype)
+ ReadStream.prototype.open = ReadStream$open
+ }
-module.exports = expandTop;
+ var fs$WriteStream = fs.WriteStream
+ if (fs$WriteStream) {
+ WriteStream.prototype = Object.create(fs$WriteStream.prototype)
+ WriteStream.prototype.open = WriteStream$open
+ }
-var escSlash = '\0SLASH'+Math.random()+'\0';
-var escOpen = '\0OPEN'+Math.random()+'\0';
-var escClose = '\0CLOSE'+Math.random()+'\0';
-var escComma = '\0COMMA'+Math.random()+'\0';
-var escPeriod = '\0PERIOD'+Math.random()+'\0';
-
-function numeric(str) {
- return parseInt(str, 10) == str
- ? parseInt(str, 10)
- : str.charCodeAt(0);
-}
-
-function escapeBraces(str) {
- return str.split('\\\\').join(escSlash)
- .split('\\{').join(escOpen)
- .split('\\}').join(escClose)
- .split('\\,').join(escComma)
- .split('\\.').join(escPeriod);
-}
-
-function unescapeBraces(str) {
- return str.split(escSlash).join('\\')
- .split(escOpen).join('{')
- .split(escClose).join('}')
- .split(escComma).join(',')
- .split(escPeriod).join('.');
-}
-
-
-// Basically just str.split(","), but handling cases
-// where we have nested braced sections, which should be
-// treated as individual members, like {a,{b,c},d}
-function parseCommaParts(str) {
- if (!str)
- return [''];
-
- var parts = [];
- var m = balanced('{', '}', str);
-
- if (!m)
- return str.split(',');
+ Object.defineProperty(fs, 'ReadStream', {
+ get: function () {
+ return ReadStream
+ },
+ set: function (val) {
+ ReadStream = val
+ },
+ enumerable: true,
+ configurable: true
+ })
+ Object.defineProperty(fs, 'WriteStream', {
+ get: function () {
+ return WriteStream
+ },
+ set: function (val) {
+ WriteStream = val
+ },
+ enumerable: true,
+ configurable: true
+ })
- var pre = m.pre;
- var body = m.body;
- var post = m.post;
- var p = pre.split(',');
+ // legacy names
+ var FileReadStream = ReadStream
+ Object.defineProperty(fs, 'FileReadStream', {
+ get: function () {
+ return FileReadStream
+ },
+ set: function (val) {
+ FileReadStream = val
+ },
+ enumerable: true,
+ configurable: true
+ })
+ var FileWriteStream = WriteStream
+ Object.defineProperty(fs, 'FileWriteStream', {
+ get: function () {
+ return FileWriteStream
+ },
+ set: function (val) {
+ FileWriteStream = val
+ },
+ enumerable: true,
+ configurable: true
+ })
- p[p.length-1] += '{' + body + '}';
- var postParts = parseCommaParts(post);
- if (post.length) {
- p[p.length-1] += postParts.shift();
- p.push.apply(p, postParts);
+ function ReadStream (path, options) {
+ if (this instanceof ReadStream)
+ return fs$ReadStream.apply(this, arguments), this
+ else
+ return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
}
- parts.push.apply(parts, p);
-
- return parts;
-}
-
-function expandTop(str) {
- if (!str)
- return [];
+ function ReadStream$open () {
+ var that = this
+ open(that.path, that.flags, that.mode, function (err, fd) {
+ if (err) {
+ if (that.autoClose)
+ that.destroy()
- // I don't know why Bash 4.3 does this, but it does.
- // Anything starting with {} will have the first two bytes preserved
- // but *only* at the top level, so {},a}b will not expand to anything,
- // but a{},b}c will be expanded to [a}c,abc].
- // One could argue that this is a bug in Bash, but since the goal of
- // this module is to match Bash's rules, we escape a leading {}
- if (str.substr(0, 2) === '{}') {
- str = '\\{\\}' + str.substr(2);
+ that.emit('error', err)
+ } else {
+ that.fd = fd
+ that.emit('open', fd)
+ that.read()
+ }
+ })
}
- return expand(escapeBraces(str), true).map(unescapeBraces);
-}
-
-function identity(e) {
- return e;
-}
-
-function embrace(str) {
- return '{' + str + '}';
-}
-function isPadded(el) {
- return /^-?0\d/.test(el);
-}
-
-function lte(i, y) {
- return i <= y;
-}
-function gte(i, y) {
- return i >= y;
-}
-
-function expand(str, isTop) {
- var expansions = [];
-
- var m = balanced('{', '}', str);
- if (!m || /\$$/.test(m.pre)) return [str];
-
- var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
- var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
- var isSequence = isNumericSequence || isAlphaSequence;
- var isOptions = m.body.indexOf(',') >= 0;
- if (!isSequence && !isOptions) {
- // {a},b}
- if (m.post.match(/,.*\}/)) {
- str = m.pre + '{' + m.body + escClose + m.post;
- return expand(str);
- }
- return [str];
+ function WriteStream (path, options) {
+ if (this instanceof WriteStream)
+ return fs$WriteStream.apply(this, arguments), this
+ else
+ return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
}
- var n;
- if (isSequence) {
- n = m.body.split(/\.\./);
- } else {
- n = parseCommaParts(m.body);
- if (n.length === 1) {
- // x{{a,b}}y ==> x{a}y x{b}y
- n = expand(n[0], false).map(embrace);
- if (n.length === 1) {
- var post = m.post.length
- ? expand(m.post, false)
- : [''];
- return post.map(function(p) {
- return m.pre + n[0] + p;
- });
+ function WriteStream$open () {
+ var that = this
+ open(that.path, that.flags, that.mode, function (err, fd) {
+ if (err) {
+ that.destroy()
+ that.emit('error', err)
+ } else {
+ that.fd = fd
+ that.emit('open', fd)
}
- }
+ })
}
- // at this point, n is the parts, and we know it's not a comma set
- // with a single entry.
-
- // no need to expand pre, since it is guaranteed to be free of brace-sets
- var pre = m.pre;
- var post = m.post.length
- ? expand(m.post, false)
- : [''];
+ function createReadStream (path, options) {
+ return new fs.ReadStream(path, options)
+ }
- var N;
+ function createWriteStream (path, options) {
+ return new fs.WriteStream(path, options)
+ }
- if (isSequence) {
- var x = numeric(n[0]);
- var y = numeric(n[1]);
- var width = Math.max(n[0].length, n[1].length)
- var incr = n.length == 3
- ? Math.abs(numeric(n[2]))
- : 1;
- var test = lte;
- var reverse = y < x;
- if (reverse) {
- incr *= -1;
- test = gte;
- }
- var pad = n.some(isPadded);
+ var fs$open = fs.open
+ fs.open = open
+ function open (path, flags, mode, cb) {
+ if (typeof mode === 'function')
+ cb = mode, mode = null
- N = [];
+ return go$open(path, flags, mode, cb)
- for (var i = x; test(i, y); i += incr) {
- var c;
- if (isAlphaSequence) {
- c = String.fromCharCode(i);
- if (c === '\\')
- c = '';
- } else {
- c = String(i);
- if (pad) {
- var need = width - c.length;
- if (need > 0) {
- var z = new Array(need + 1).join('0');
- if (i < 0)
- c = '-' + z + c.slice(1);
- else
- c = z + c;
- }
+ function go$open (path, flags, mode, cb) {
+ return fs$open(path, flags, mode, function (err, fd) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$open, [path, flags, mode, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
}
- }
- N.push(c);
- }
- } else {
- N = concatMap(n, function(el) { return expand(el, false) });
- }
-
- for (var j = 0; j < N.length; j++) {
- for (var k = 0; k < post.length; k++) {
- var expansion = pre + N[j] + post[k];
- if (!isTop || isSequence || expansion)
- expansions.push(expansion);
+ })
}
}
- return expansions;
+ return fs
}
+function enqueue (elem) {
+ debug('ENQUEUE', elem[0].name, elem[1])
+ global[gracefulQueue].push(elem)
+}
-
-/***/ }),
-/* 508 */
-/***/ (function(module, exports) {
-
-module.exports = function (xs, fn) {
- var res = [];
- for (var i = 0; i < xs.length; i++) {
- var x = fn(xs[i], i);
- if (isArray(x)) res.push.apply(res, x);
- else res.push(x);
- }
- return res;
-};
-
-var isArray = Array.isArray || function (xs) {
- return Object.prototype.toString.call(xs) === '[object Array]';
-};
+function retry () {
+ var elem = global[gracefulQueue].shift()
+ if (elem) {
+ debug('RETRY', elem[0].name, elem[1])
+ elem[0].apply(null, elem[1])
+ }
+}
/***/ }),
-/* 509 */
+/* 494 */
/***/ (function(module, exports, __webpack_require__) {
-"use strict";
+var constants = __webpack_require__(411)
-module.exports = balanced;
-function balanced(a, b, str) {
- if (a instanceof RegExp) a = maybeMatch(a, str);
- if (b instanceof RegExp) b = maybeMatch(b, str);
+var origCwd = process.cwd
+var cwd = null
- var r = range(a, b, str);
+var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
- return r && {
- start: r[0],
- end: r[1],
- pre: str.slice(0, r[0]),
- body: str.slice(r[0] + a.length, r[1]),
- post: str.slice(r[1] + b.length)
- };
+process.cwd = function() {
+ if (!cwd)
+ cwd = origCwd.call(process)
+ return cwd
}
+try {
+ process.cwd()
+} catch (er) {}
-function maybeMatch(reg, str) {
- var m = str.match(reg);
- return m ? m[0] : null;
+var chdir = process.chdir
+process.chdir = function(d) {
+ cwd = null
+ chdir.call(process, d)
}
-balanced.range = range;
-function range(a, b, str) {
- var begs, beg, left, right, result;
- var ai = str.indexOf(a);
- var bi = str.indexOf(b, ai + 1);
- var i = ai;
-
- if (ai >= 0 && bi > 0) {
- begs = [];
- left = str.length;
-
- while (i >= 0 && !result) {
- if (i == ai) {
- begs.push(i);
- ai = str.indexOf(a, i + 1);
- } else if (begs.length == 1) {
- result = [ begs.pop(), bi ];
- } else {
- beg = begs.pop();
- if (beg < left) {
- left = beg;
- right = bi;
- }
+module.exports = patch
- bi = str.indexOf(b, i + 1);
- }
+function patch (fs) {
+ // (re-)implement some things that are known busted or missing.
- i = ai < bi && ai >= 0 ? ai : bi;
- }
+ // lchmod, broken prior to 0.6.2
+ // back-port the fix here.
+ if (constants.hasOwnProperty('O_SYMLINK') &&
+ process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+ patchLchmod(fs)
+ }
- if (begs.length) {
- result = [ left, right ];
- }
+ // lutimes implementation, or no-op
+ if (!fs.lutimes) {
+ patchLutimes(fs)
}
- return result;
-}
+ // https://github.com/isaacs/node-graceful-fs/issues/4
+ // Chown should not fail on einval or eperm if non-root.
+ // It should not fail on enosys ever, as this just indicates
+ // that a fs doesn't support the intended operation.
+ fs.chown = chownFix(fs.chown)
+ fs.fchown = chownFix(fs.fchown)
+ fs.lchown = chownFix(fs.lchown)
-/***/ }),
-/* 510 */
-/***/ (function(module, exports, __webpack_require__) {
+ fs.chmod = chmodFix(fs.chmod)
+ fs.fchmod = chmodFix(fs.fchmod)
+ fs.lchmod = chmodFix(fs.lchmod)
-try {
- var util = __webpack_require__(29);
- /* istanbul ignore next */
- if (typeof util.inherits !== 'function') throw '';
- module.exports = util.inherits;
-} catch (e) {
- /* istanbul ignore next */
- module.exports = __webpack_require__(511);
-}
+ fs.chownSync = chownFixSync(fs.chownSync)
+ fs.fchownSync = chownFixSync(fs.fchownSync)
+ fs.lchownSync = chownFixSync(fs.lchownSync)
+ fs.chmodSync = chmodFixSync(fs.chmodSync)
+ fs.fchmodSync = chmodFixSync(fs.fchmodSync)
+ fs.lchmodSync = chmodFixSync(fs.lchmodSync)
-/***/ }),
-/* 511 */
-/***/ (function(module, exports) {
+ fs.stat = statFix(fs.stat)
+ fs.fstat = statFix(fs.fstat)
+ fs.lstat = statFix(fs.lstat)
-if (typeof Object.create === 'function') {
- // implementation from standard node.js 'util' module
- module.exports = function inherits(ctor, superCtor) {
- if (superCtor) {
- ctor.super_ = superCtor
- ctor.prototype = Object.create(superCtor.prototype, {
- constructor: {
- value: ctor,
- enumerable: false,
- writable: true,
- configurable: true
- }
- })
+ fs.statSync = statFixSync(fs.statSync)
+ fs.fstatSync = statFixSync(fs.fstatSync)
+ fs.lstatSync = statFixSync(fs.lstatSync)
+
+ // if lchmod/lchown do not exist, then make them no-ops
+ if (!fs.lchmod) {
+ fs.lchmod = function (path, mode, cb) {
+ if (cb) process.nextTick(cb)
}
- };
-} else {
- // old school shim for old browsers
- module.exports = function inherits(ctor, superCtor) {
- if (superCtor) {
- ctor.super_ = superCtor
- var TempCtor = function () {}
- TempCtor.prototype = superCtor.prototype
- ctor.prototype = new TempCtor()
- ctor.prototype.constructor = ctor
+ fs.lchmodSync = function () {}
+ }
+ if (!fs.lchown) {
+ fs.lchown = function (path, uid, gid, cb) {
+ if (cb) process.nextTick(cb)
}
+ fs.lchownSync = function () {}
}
-}
-
-
-/***/ }),
-/* 512 */
-/***/ (function(module, exports, __webpack_require__) {
-"use strict";
+ // on Windows, A/V software can lock the directory, causing this
+ // to fail with an EACCES or EPERM if the directory contains newly
+ // created files. Try again on failure, for up to 60 seconds.
+ // Set the timeout this long because some Windows Anti-Virus, such as Parity
+ // bit9, may lock files for up to a minute, causing npm package install
+ // failures. Also, take care to yield the scheduler. Windows scheduling gives
+ // CPU to a busy looping process, which can cause the program causing the lock
+ // contention to be starved of CPU by node, so the contention doesn't resolve.
+ if (platform === "win32") {
+ fs.rename = (function (fs$rename) { return function (from, to, cb) {
+ var start = Date.now()
+ var backoff = 0;
+ fs$rename(from, to, function CB (er) {
+ if (er
+ && (er.code === "EACCES" || er.code === "EPERM")
+ && Date.now() - start < 60000) {
+ setTimeout(function() {
+ fs.stat(to, function (stater, st) {
+ if (stater && stater.code === "ENOENT")
+ fs$rename(from, to, CB);
+ else
+ cb(er)
+ })
+ }, backoff)
+ if (backoff < 100)
+ backoff += 10;
+ return;
+ }
+ if (cb) cb(er)
+ })
+ }})(fs.rename)
+ }
-function posix(path) {
- return path.charAt(0) === '/';
-}
+ // if read() returns EAGAIN, then just try it again.
+ fs.read = (function (fs$read) {
+ function read (fd, buffer, offset, length, position, callback_) {
+ var callback
+ if (callback_ && typeof callback_ === 'function') {
+ var eagCounter = 0
+ callback = function (er, _, __) {
+ if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+ eagCounter ++
+ return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+ }
+ callback_.apply(this, arguments)
+ }
+ }
+ return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+ }
-function win32(path) {
- // https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
- var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
- var result = splitDeviceRe.exec(path);
- var device = result[1] || '';
- var isUnc = Boolean(device && device.charAt(1) !== ':');
-
- // UNC paths are always absolute
- return Boolean(result[2] || isUnc);
-}
-
-module.exports = process.platform === 'win32' ? win32 : posix;
-module.exports.posix = posix;
-module.exports.win32 = win32;
+ // This ensures `util.promisify` works as it does for native `fs.read`.
+ read.__proto__ = fs$read
+ return read
+ })(fs.read)
+ fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+ var eagCounter = 0
+ while (true) {
+ try {
+ return fs$readSync.call(fs, fd, buffer, offset, length, position)
+ } catch (er) {
+ if (er.code === 'EAGAIN' && eagCounter < 10) {
+ eagCounter ++
+ continue
+ }
+ throw er
+ }
+ }
+ }})(fs.readSync)
-/***/ }),
-/* 513 */
-/***/ (function(module, exports, __webpack_require__) {
+ function patchLchmod (fs) {
+ fs.lchmod = function (path, mode, callback) {
+ fs.open( path
+ , constants.O_WRONLY | constants.O_SYMLINK
+ , mode
+ , function (err, fd) {
+ if (err) {
+ if (callback) callback(err)
+ return
+ }
+ // prefer to return the chmod error, if one occurs,
+ // but still try to close, and report closing errors if they occur.
+ fs.fchmod(fd, mode, function (err) {
+ fs.close(fd, function(err2) {
+ if (callback) callback(err || err2)
+ })
+ })
+ })
+ }
-module.exports = globSync
-globSync.GlobSync = GlobSync
+ fs.lchmodSync = function (path, mode) {
+ var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
-var fs = __webpack_require__(23)
-var rp = __webpack_require__(504)
-var minimatch = __webpack_require__(506)
-var Minimatch = minimatch.Minimatch
-var Glob = __webpack_require__(503).Glob
-var util = __webpack_require__(29)
-var path = __webpack_require__(16)
-var assert = __webpack_require__(30)
-var isAbsolute = __webpack_require__(512)
-var common = __webpack_require__(514)
-var alphasort = common.alphasort
-var alphasorti = common.alphasorti
-var setopts = common.setopts
-var ownProp = common.ownProp
-var childrenIgnored = common.childrenIgnored
-var isIgnored = common.isIgnored
+ // prefer to return the chmod error, if one occurs,
+ // but still try to close, and report closing errors if they occur.
+ var threw = true
+ var ret
+ try {
+ ret = fs.fchmodSync(fd, mode)
+ threw = false
+ } finally {
+ if (threw) {
+ try {
+ fs.closeSync(fd)
+ } catch (er) {}
+ } else {
+ fs.closeSync(fd)
+ }
+ }
+ return ret
+ }
+ }
-function globSync (pattern, options) {
- if (typeof options === 'function' || arguments.length === 3)
- throw new TypeError('callback provided to sync glob\n'+
- 'See: https://github.com/isaacs/node-glob/issues/167')
+ function patchLutimes (fs) {
+ if (constants.hasOwnProperty("O_SYMLINK")) {
+ fs.lutimes = function (path, at, mt, cb) {
+ fs.open(path, constants.O_SYMLINK, function (er, fd) {
+ if (er) {
+ if (cb) cb(er)
+ return
+ }
+ fs.futimes(fd, at, mt, function (er) {
+ fs.close(fd, function (er2) {
+ if (cb) cb(er || er2)
+ })
+ })
+ })
+ }
- return new GlobSync(pattern, options).found
-}
+ fs.lutimesSync = function (path, at, mt) {
+ var fd = fs.openSync(path, constants.O_SYMLINK)
+ var ret
+ var threw = true
+ try {
+ ret = fs.futimesSync(fd, at, mt)
+ threw = false
+ } finally {
+ if (threw) {
+ try {
+ fs.closeSync(fd)
+ } catch (er) {}
+ } else {
+ fs.closeSync(fd)
+ }
+ }
+ return ret
+ }
-function GlobSync (pattern, options) {
- if (!pattern)
- throw new Error('must provide pattern')
+ } else {
+ fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
+ fs.lutimesSync = function () {}
+ }
+ }
- if (typeof options === 'function' || arguments.length === 3)
- throw new TypeError('callback provided to sync glob\n'+
- 'See: https://github.com/isaacs/node-glob/issues/167')
+ function chmodFix (orig) {
+ if (!orig) return orig
+ return function (target, mode, cb) {
+ return orig.call(fs, target, mode, function (er) {
+ if (chownErOk(er)) er = null
+ if (cb) cb.apply(this, arguments)
+ })
+ }
+ }
- if (!(this instanceof GlobSync))
- return new GlobSync(pattern, options)
+ function chmodFixSync (orig) {
+ if (!orig) return orig
+ return function (target, mode) {
+ try {
+ return orig.call(fs, target, mode)
+ } catch (er) {
+ if (!chownErOk(er)) throw er
+ }
+ }
+ }
- setopts(this, pattern, options)
- if (this.noprocess)
- return this
+ function chownFix (orig) {
+ if (!orig) return orig
+ return function (target, uid, gid, cb) {
+ return orig.call(fs, target, uid, gid, function (er) {
+ if (chownErOk(er)) er = null
+ if (cb) cb.apply(this, arguments)
+ })
+ }
+ }
- var n = this.minimatch.set.length
- this.matches = new Array(n)
- for (var i = 0; i < n; i ++) {
- this._process(this.minimatch.set[i], i, false)
+ function chownFixSync (orig) {
+ if (!orig) return orig
+ return function (target, uid, gid) {
+ try {
+ return orig.call(fs, target, uid, gid)
+ } catch (er) {
+ if (!chownErOk(er)) throw er
+ }
+ }
}
- this._finish()
-}
-GlobSync.prototype._finish = function () {
- assert(this instanceof GlobSync)
- if (this.realpath) {
- var self = this
- this.matches.forEach(function (matchset, index) {
- var set = self.matches[index] = Object.create(null)
- for (var p in matchset) {
- try {
- p = self._makeAbs(p)
- var real = rp.realpathSync(p, self.realpathCache)
- set[real] = true
- } catch (er) {
- if (er.syscall === 'stat')
- set[self._makeAbs(p)] = true
- else
- throw er
+ function statFix (orig) {
+ if (!orig) return orig
+ // Older versions of Node erroneously returned signed integers for
+ // uid + gid.
+ return function (target, options, cb) {
+ if (typeof options === 'function') {
+ cb = options
+ options = null
+ }
+ function callback (er, stats) {
+ if (stats) {
+ if (stats.uid < 0) stats.uid += 0x100000000
+ if (stats.gid < 0) stats.gid += 0x100000000
}
+ if (cb) cb.apply(this, arguments)
}
- })
+ return options ? orig.call(fs, target, options, callback)
+ : orig.call(fs, target, callback)
+ }
}
- common.finish(this)
-}
-
-
-GlobSync.prototype._process = function (pattern, index, inGlobStar) {
- assert(this instanceof GlobSync)
- // Get the first [n] parts of pattern that are all strings.
- var n = 0
- while (typeof pattern[n] === 'string') {
- n ++
+ function statFixSync (orig) {
+ if (!orig) return orig
+ // Older versions of Node erroneously returned signed integers for
+ // uid + gid.
+ return function (target, options) {
+ var stats = options ? orig.call(fs, target, options)
+ : orig.call(fs, target)
+ if (stats.uid < 0) stats.uid += 0x100000000
+ if (stats.gid < 0) stats.gid += 0x100000000
+ return stats;
+ }
}
- // now n is the index of the first one that is *not* a string.
- // See if there's anything else
- var prefix
- switch (n) {
- // if not, then this is rather simple
- case pattern.length:
- this._processSimple(pattern.join('/'), index)
- return
+ // ENOSYS means that the fs doesn't support the op. Just ignore
+ // that, because it doesn't matter.
+ //
+ // if there's no getuid, or if getuid() is something other
+ // than 0, and the error is EINVAL or EPERM, then just ignore
+ // it.
+ //
+ // This specific case is a silent failure in cp, install, tar,
+ // and most other unix tools that manage permissions.
+ //
+ // When running as root, or if other types of errors are
+ // encountered, then it's strict.
+ function chownErOk (er) {
+ if (!er)
+ return true
- case 0:
- // pattern *starts* with some non-trivial item.
- // going to readdir(cwd), but not include the prefix in matches.
- prefix = null
- break
+ if (er.code === "ENOSYS")
+ return true
- default:
- // pattern has some string bits in the front.
- // whatever it starts with, whether that's 'absolute' like /foo/bar,
- // or 'relative' like '../baz'
- prefix = pattern.slice(0, n).join('/')
- break
+ var nonroot = !process.getuid || process.getuid() !== 0
+ if (nonroot) {
+ if (er.code === "EINVAL" || er.code === "EPERM")
+ return true
+ }
+
+ return false
}
+}
- var remain = pattern.slice(n)
- // get the list of entries.
- var read
- if (prefix === null)
- read = '.'
- else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
- if (!prefix || !isAbsolute(prefix))
- prefix = '/' + prefix
- read = prefix
- } else
- read = prefix
+/***/ }),
+/* 495 */
+/***/ (function(module, exports, __webpack_require__) {
- var abs = this._makeAbs(read)
+var Stream = __webpack_require__(382).Stream
- //if ignored, skip processing
- if (childrenIgnored(this, read))
- return
+module.exports = legacy
- var isGlobStar = remain[0] === minimatch.GLOBSTAR
- if (isGlobStar)
- this._processGlobStar(prefix, read, abs, remain, index, inGlobStar)
- else
- this._processReaddir(prefix, read, abs, remain, index, inGlobStar)
-}
+function legacy (fs) {
+ return {
+ ReadStream: ReadStream,
+ WriteStream: WriteStream
+ }
+ function ReadStream (path, options) {
+ if (!(this instanceof ReadStream)) return new ReadStream(path, options);
-GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
- var entries = this._readdir(abs, inGlobStar)
+ Stream.call(this);
- // if the abs isn't a dir, then nothing can match!
- if (!entries)
- return
+ var self = this;
- // It will only match dot entries if it starts with a dot, or if
- // dot is set. Stuff like @(.foo|.bar) isn't allowed.
- var pn = remain[0]
- var negate = !!this.minimatch.negate
- var rawGlob = pn._glob
- var dotOk = this.dot || rawGlob.charAt(0) === '.'
+ this.path = path;
+ this.fd = null;
+ this.readable = true;
+ this.paused = false;
- var matchedEntries = []
- for (var i = 0; i < entries.length; i++) {
- var e = entries[i]
- if (e.charAt(0) !== '.' || dotOk) {
- var m
- if (negate && !prefix) {
- m = !e.match(pn)
- } else {
- m = e.match(pn)
- }
- if (m)
- matchedEntries.push(e)
- }
- }
+ this.flags = 'r';
+ this.mode = 438; /*=0666*/
+ this.bufferSize = 64 * 1024;
- var len = matchedEntries.length
- // If there are no matched entries, then nothing matches.
- if (len === 0)
- return
+ options = options || {};
- // if this is the last remaining pattern bit, then no need for
- // an additional stat *unless* the user has specified mark or
- // stat explicitly. We know they exist, since readdir returned
- // them.
+ // Mixin options into this
+ var keys = Object.keys(options);
+ for (var index = 0, length = keys.length; index < length; index++) {
+ var key = keys[index];
+ this[key] = options[key];
+ }
- if (remain.length === 1 && !this.mark && !this.stat) {
- if (!this.matches[index])
- this.matches[index] = Object.create(null)
+ if (this.encoding) this.setEncoding(this.encoding);
- for (var i = 0; i < len; i ++) {
- var e = matchedEntries[i]
- if (prefix) {
- if (prefix.slice(-1) !== '/')
- e = prefix + '/' + e
- else
- e = prefix + e
+ if (this.start !== undefined) {
+ if ('number' !== typeof this.start) {
+ throw TypeError('start must be a Number');
+ }
+ if (this.end === undefined) {
+ this.end = Infinity;
+ } else if ('number' !== typeof this.end) {
+ throw TypeError('end must be a Number');
}
- if (e.charAt(0) === '/' && !this.nomount) {
- e = path.join(this.root, e)
+ if (this.start > this.end) {
+ throw new Error('start must be <= end');
}
- this._emitMatch(index, e)
+
+ this.pos = this.start;
}
- // This was the last one, and no stats were needed
- return
- }
- // now test all matched entries as stand-ins for that part
- // of the pattern.
- remain.shift()
- for (var i = 0; i < len; i ++) {
- var e = matchedEntries[i]
- var newPattern
- if (prefix)
- newPattern = [prefix, e]
- else
- newPattern = [e]
- this._process(newPattern.concat(remain), index, inGlobStar)
- }
-}
+ if (this.fd !== null) {
+ process.nextTick(function() {
+ self._read();
+ });
+ return;
+ }
+ fs.open(this.path, this.flags, this.mode, function (err, fd) {
+ if (err) {
+ self.emit('error', err);
+ self.readable = false;
+ return;
+ }
-GlobSync.prototype._emitMatch = function (index, e) {
- if (isIgnored(this, e))
- return
+ self.fd = fd;
+ self.emit('open', fd);
+ self._read();
+ })
+ }
- var abs = this._makeAbs(e)
+ function WriteStream (path, options) {
+ if (!(this instanceof WriteStream)) return new WriteStream(path, options);
- if (this.mark)
- e = this._mark(e)
+ Stream.call(this);
- if (this.absolute) {
- e = abs
- }
+ this.path = path;
+ this.fd = null;
+ this.writable = true;
- if (this.matches[index][e])
- return
+ this.flags = 'w';
+ this.encoding = 'binary';
+ this.mode = 438; /*=0666*/
+ this.bytesWritten = 0;
- if (this.nodir) {
- var c = this.cache[abs]
- if (c === 'DIR' || Array.isArray(c))
- return
- }
+ options = options || {};
- this.matches[index][e] = true
+ // Mixin options into this
+ var keys = Object.keys(options);
+ for (var index = 0, length = keys.length; index < length; index++) {
+ var key = keys[index];
+ this[key] = options[key];
+ }
- if (this.stat)
- this._stat(e)
-}
+ if (this.start !== undefined) {
+ if ('number' !== typeof this.start) {
+ throw TypeError('start must be a Number');
+ }
+ if (this.start < 0) {
+ throw new Error('start must be >= zero');
+ }
+ this.pos = this.start;
+ }
-GlobSync.prototype._readdirInGlobStar = function (abs) {
- // follow all symlinked directories forever
- // just proceed as if this is a non-globstar situation
- if (this.follow)
- return this._readdir(abs, false)
+ this.busy = false;
+ this._queue = [];
- var entries
- var lstat
- var stat
- try {
- lstat = fs.lstatSync(abs)
- } catch (er) {
- if (er.code === 'ENOENT') {
- // lstat failed, doesn't exist
- return null
+ if (this.fd === null) {
+ this._open = fs.open;
+ this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+ this.flush();
}
}
+}
- var isSym = lstat && lstat.isSymbolicLink()
- this.symlinks[abs] = isSym
-
- // If it's not a symlink or a dir, then it's definitely a regular file.
- // don't bother doing a readdir in that case.
- if (!isSym && lstat && !lstat.isDirectory())
- this.cache[abs] = 'FILE'
- else
- entries = this._readdir(abs, false)
- return entries
-}
+/***/ }),
+/* 496 */
+/***/ (function(module, exports, __webpack_require__) {
-GlobSync.prototype._readdir = function (abs, inGlobStar) {
- var entries
+"use strict";
- if (inGlobStar && !ownProp(this.symlinks, abs))
- return this._readdirInGlobStar(abs)
- if (ownProp(this.cache, abs)) {
- var c = this.cache[abs]
- if (!c || c === 'FILE')
- return null
+module.exports = clone
- if (Array.isArray(c))
- return c
- }
+function clone (obj) {
+ if (obj === null || typeof obj !== 'object')
+ return obj
- try {
- return this._readdirEntries(abs, fs.readdirSync(abs))
- } catch (er) {
- this._readdirError(abs, er)
- return null
- }
-}
-
-GlobSync.prototype._readdirEntries = function (abs, entries) {
- // if we haven't asked to stat everything, then just
- // assume that everything in there exists, so we can avoid
- // having to stat it a second time.
- if (!this.mark && !this.stat) {
- for (var i = 0; i < entries.length; i ++) {
- var e = entries[i]
- if (abs === '/')
- e = abs + e
- else
- e = abs + '/' + e
- this.cache[e] = true
- }
- }
+ if (obj instanceof Object)
+ var copy = { __proto__: obj.__proto__ }
+ else
+ var copy = Object.create(null)
- this.cache[abs] = entries
+ Object.getOwnPropertyNames(obj).forEach(function (key) {
+ Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
+ })
- // mark and cache dir-ness
- return entries
+ return copy
}
-GlobSync.prototype._readdirError = function (f, er) {
- // handle errors, and cache the information
- switch (er.code) {
- case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
- case 'ENOTDIR': // totally normal. means it *does* exist.
- var abs = this._makeAbs(f)
- this.cache[abs] = 'FILE'
- if (abs === this.cwdAbs) {
- var error = new Error(er.code + ' invalid cwd ' + this.cwd)
- error.path = this.cwd
- error.code = er.code
- throw error
- }
- break
- case 'ENOENT': // not terribly unusual
- case 'ELOOP':
- case 'ENAMETOOLONG':
- case 'UNKNOWN':
- this.cache[this._makeAbs(f)] = false
- break
+/***/ }),
+/* 497 */
+/***/ (function(module, exports, __webpack_require__) {
- default: // some unusual error. Treat as failure.
- this.cache[this._makeAbs(f)] = false
- if (this.strict)
- throw er
- if (!this.silent)
- console.error('glob error', er)
- break
- }
-}
+var path = __webpack_require__(4);
+var fs = __webpack_require__(349);
+var _0777 = parseInt('0777', 8);
-GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {
+module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
- var entries = this._readdir(abs, inGlobStar)
+function mkdirP (p, opts, f, made) {
+ if (typeof opts === 'function') {
+ f = opts;
+ opts = {};
+ }
+ else if (!opts || typeof opts !== 'object') {
+ opts = { mode: opts };
+ }
+
+ var mode = opts.mode;
+ var xfs = opts.fs || fs;
+
+ if (mode === undefined) {
+ mode = _0777 & (~process.umask());
+ }
+ if (!made) made = null;
+
+ var cb = f || function () {};
+ p = path.resolve(p);
+
+ xfs.mkdir(p, mode, function (er) {
+ if (!er) {
+ made = made || p;
+ return cb(null, made);
+ }
+ switch (er.code) {
+ case 'ENOENT':
+ if (path.dirname(p) === p) return cb(er);
+ mkdirP(path.dirname(p), opts, function (er, made) {
+ if (er) cb(er, made);
+ else mkdirP(p, opts, cb, made);
+ });
+ break;
- // no entries means not a dir, so it can never have matches
- // foo.txt/** doesn't match foo.txt
- if (!entries)
- return
+ // In the case of any other error, just see if there's a dir
+ // there already. If so, then hooray! If not, then something
+ // is borked.
+ default:
+ xfs.stat(p, function (er2, stat) {
+ // if the stat fails, then that's super weird.
+ // let the original error be the failure reason.
+ if (er2 || !stat.isDirectory()) cb(er, made)
+ else cb(null, made);
+ });
+ break;
+ }
+ });
+}
- // test without the globstar, and with every child both below
- // and replacing the globstar.
- var remainWithoutGlobStar = remain.slice(1)
- var gspref = prefix ? [ prefix ] : []
- var noGlobStar = gspref.concat(remainWithoutGlobStar)
+mkdirP.sync = function sync (p, opts, made) {
+ if (!opts || typeof opts !== 'object') {
+ opts = { mode: opts };
+ }
+
+ var mode = opts.mode;
+ var xfs = opts.fs || fs;
+
+ if (mode === undefined) {
+ mode = _0777 & (~process.umask());
+ }
+ if (!made) made = null;
- // the noGlobStar pattern exits the inGlobStar state
- this._process(noGlobStar, index, false)
+ p = path.resolve(p);
- var len = entries.length
- var isSym = this.symlinks[abs]
+ try {
+ xfs.mkdirSync(p, mode);
+ made = made || p;
+ }
+ catch (err0) {
+ switch (err0.code) {
+ case 'ENOENT' :
+ made = sync(path.dirname(p), opts, made);
+ sync(p, opts, made);
+ break;
- // If it's a symlink, and we're in a globstar, then stop
- if (isSym && inGlobStar)
- return
+ // In the case of any other error, just see if there's a dir
+ // there already. If so, then hooray! If not, then something
+ // is borked.
+ default:
+ var stat;
+ try {
+ stat = xfs.statSync(p);
+ }
+ catch (err1) {
+ throw err0;
+ }
+ if (!stat.isDirectory()) throw err0;
+ break;
+ }
+ }
- for (var i = 0; i < len; i++) {
- var e = entries[i]
- if (e.charAt(0) === '.' && !this.dot)
- continue
+ return made;
+};
- // these two cases enter the inGlobStar state
- var instead = gspref.concat(entries[i], remainWithoutGlobStar)
- this._process(instead, index, true)
- var below = gspref.concat(entries[i], remain)
- this._process(below, index, true)
- }
-}
+/***/ }),
+/* 498 */
+/***/ (function(module, exports) {
-GlobSync.prototype._processSimple = function (prefix, index) {
- // XXX review this. Shouldn't it be doing the mounting etc
- // before doing stat? kinda weird?
- var exists = this._stat(prefix)
+exports.replaceDollarWithPercentPair = replaceDollarWithPercentPair
+exports.convertToSetCommand = convertToSetCommand
+exports.convertToSetCommands = convertToSetCommands
+
+function convertToSetCommand(key, value) {
+ var line = ""
+ key = key || ""
+ key = key.trim()
+ value = value || ""
+ value = value.trim()
+ if(key && value && value.length > 0) {
+ line = "@SET " + key + "=" + replaceDollarWithPercentPair(value) + "\r\n"
+ }
+ return line
+}
+
+function extractVariableValuePairs(declarations) {
+ var pairs = {}
+ declarations.map(function(declaration) {
+ var split = declaration.split("=")
+ pairs[split[0]]=split[1]
+ })
+ return pairs
+}
+
+function convertToSetCommands(variableString) {
+ var variableValuePairs = extractVariableValuePairs(variableString.split(" "))
+ var variableDeclarationsAsBatch = ""
+ Object.keys(variableValuePairs).forEach(function (key) {
+ variableDeclarationsAsBatch += convertToSetCommand(key, variableValuePairs[key])
+ })
+ return variableDeclarationsAsBatch
+}
+
+function replaceDollarWithPercentPair(value) {
+ var dollarExpressions = /\$\{?([^\$@#\?\- \t{}:]+)\}?/g
+ var result = ""
+ var startIndex = 0
+ value = value || ""
+ do {
+ var match = dollarExpressions.exec(value)
+ if(match) {
+ var betweenMatches = value.substring(startIndex, match.index) || ""
+ result += betweenMatches + "%" + match[1] + "%"
+ startIndex = dollarExpressions.lastIndex
+ }
+ } while (dollarExpressions.lastIndex > 0)
+ result += value.substr(startIndex)
+ return result
+}
+
+
- if (!this.matches[index])
- this.matches[index] = Object.create(null)
- // If it doesn't exist, then just mark the lack of results
- if (!exists)
- return
+/***/ }),
+/* 499 */
+/***/ (function(module, exports, __webpack_require__) {
- if (prefix && isAbsolute(prefix) && !this.nomount) {
- var trail = /[\/\\]$/.test(prefix)
- if (prefix.charAt(0) === '/') {
- prefix = path.join(this.root, prefix)
- } else {
- prefix = path.resolve(this.root, prefix)
- if (trail)
- prefix += '/'
- }
- }
+var fs = __webpack_require__(349),
+ path = __webpack_require__(4);
- if (process.platform === 'win32')
- prefix = prefix.replace(/\\/g, '/')
+module.exports = ncp;
+ncp.ncp = ncp;
- // Mark this as a match
- this._emitMatch(index, prefix)
-}
+function ncp (source, dest, options, callback) {
+ var cback = callback;
-// Returns either 'DIR', 'FILE', or false
-GlobSync.prototype._stat = function (f) {
- var abs = this._makeAbs(f)
- var needDir = f.slice(-1) === '/'
+ if (!callback) {
+ cback = options;
+ options = {};
+ }
- if (f.length > this.maxLength)
- return false
+ var basePath = process.cwd(),
+ currentPath = path.resolve(basePath, source),
+ targetPath = path.resolve(basePath, dest),
+ filter = options.filter,
+ rename = options.rename,
+ transform = options.transform,
+ clobber = options.clobber !== false,
+ modified = options.modified,
+ dereference = options.dereference,
+ errs = null,
+ started = 0,
+ finished = 0,
+ running = 0,
+ limit = options.limit || ncp.limit || 16;
- if (!this.stat && ownProp(this.cache, abs)) {
- var c = this.cache[abs]
+ limit = (limit < 1) ? 1 : (limit > 512) ? 512 : limit;
- if (Array.isArray(c))
- c = 'DIR'
+ startCopy(currentPath);
+
+ function startCopy(source) {
+ started++;
+ if (filter) {
+ if (filter instanceof RegExp) {
+ if (!filter.test(source)) {
+ return cb(true);
+ }
+ }
+ else if (typeof filter === 'function') {
+ if (!filter(source)) {
+ return cb(true);
+ }
+ }
+ }
+ return getStats(source);
+ }
- // It exists, but maybe not how we need it
- if (!needDir || c === 'DIR')
- return c
+ function getStats(source) {
+ var stat = dereference ? fs.stat : fs.lstat;
+ if (running >= limit) {
+ return setImmediate(function () {
+ getStats(source);
+ });
+ }
+ running++;
+ stat(source, function (err, stats) {
+ var item = {};
+ if (err) {
+ return onError(err);
+ }
- if (needDir && c === 'FILE')
- return false
+ // We need to get the mode from the stats object and preserve it.
+ item.name = source;
+ item.mode = stats.mode;
+ item.mtime = stats.mtime; //modified time
+ item.atime = stats.atime; //access time
- // otherwise we have to stat, because maybe c=true
- // if we know it exists, but not what it is.
+ if (stats.isDirectory()) {
+ return onDir(item);
+ }
+ else if (stats.isFile()) {
+ return onFile(item);
+ }
+ else if (stats.isSymbolicLink()) {
+ // Symlinks don't really need to know about the mode.
+ return onLink(source);
+ }
+ });
}
- var exists
- var stat = this.statCache[abs]
- if (!stat) {
- var lstat
- try {
- lstat = fs.lstatSync(abs)
- } catch (er) {
- if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
- this.statCache[abs] = false
- return false
- }
+ function onFile(file) {
+ var target = file.name.replace(currentPath, targetPath);
+ if(rename) {
+ target = rename(target);
}
-
- if (lstat && lstat.isSymbolicLink()) {
- try {
- stat = fs.statSync(abs)
- } catch (er) {
- stat = lstat
+ isWritable(target, function (writable) {
+ if (writable) {
+ return copyFile(file, target);
+ }
+ if(clobber) {
+ rmFile(target, function () {
+ copyFile(file, target);
+ });
+ }
+ if (modified) {
+ var stat = dereference ? fs.stat : fs.lstat;
+ stat(target, function(err, stats) {
+ //if souce modified time greater to target modified time copy file
+ if (file.mtime.getTime()>stats.mtime.getTime())
+ copyFile(file, target);
+ else return cb();
+ });
+ }
+ else {
+ return cb();
}
+ });
+ }
+
+ function copyFile(file, target) {
+ var readStream = fs.createReadStream(file.name),
+ writeStream = fs.createWriteStream(target, { mode: file.mode });
+
+ readStream.on('error', onError);
+ writeStream.on('error', onError);
+
+ if(transform) {
+ transform(readStream, writeStream, file);
} else {
- stat = lstat
+ writeStream.on('open', function() {
+ readStream.pipe(writeStream);
+ });
}
+ writeStream.once('finish', function() {
+ if (modified) {
+ //target file modified date sync.
+ fs.utimesSync(target, file.atime, file.mtime);
+ cb();
+ }
+ else cb();
+ });
}
- this.statCache[abs] = stat
-
- var c = true
- if (stat)
- c = stat.isDirectory() ? 'DIR' : 'FILE'
+ function rmFile(file, done) {
+ fs.unlink(file, function (err) {
+ if (err) {
+ return onError(err);
+ }
+ return done();
+ });
+ }
- this.cache[abs] = this.cache[abs] || c
+ function onDir(dir) {
+ var target = dir.name.replace(currentPath, targetPath);
+ isWritable(target, function (writable) {
+ if (writable) {
+ return mkDir(dir, target);
+ }
+ copyDir(dir.name);
+ });
+ }
- if (needDir && c === 'FILE')
- return false
+ function mkDir(dir, target) {
+ fs.mkdir(target, dir.mode, function (err) {
+ if (err) {
+ return onError(err);
+ }
+ copyDir(dir.name);
+ });
+ }
- return c
-}
+ function copyDir(dir) {
+ fs.readdir(dir, function (err, items) {
+ if (err) {
+ return onError(err);
+ }
+ items.forEach(function (item) {
+ startCopy(path.join(dir, item));
+ });
+ return cb();
+ });
+ }
-GlobSync.prototype._mark = function (p) {
- return common.mark(this, p)
-}
+ function onLink(link) {
+ var target = link.replace(currentPath, targetPath);
+ fs.readlink(link, function (err, resolvedPath) {
+ if (err) {
+ return onError(err);
+ }
+ checkLink(resolvedPath, target);
+ });
+ }
-GlobSync.prototype._makeAbs = function (f) {
- return common.makeAbs(this, f)
-}
+ function checkLink(resolvedPath, target) {
+ if (dereference) {
+ resolvedPath = path.resolve(basePath, resolvedPath);
+ }
+ isWritable(target, function (writable) {
+ if (writable) {
+ return makeLink(resolvedPath, target);
+ }
+ fs.readlink(target, function (err, targetDest) {
+ if (err) {
+ return onError(err);
+ }
+ if (dereference) {
+ targetDest = path.resolve(basePath, targetDest);
+ }
+ if (targetDest === resolvedPath) {
+ return cb();
+ }
+ return rmFile(target, function () {
+ makeLink(resolvedPath, target);
+ });
+ });
+ });
+ }
+ function makeLink(linkPath, target) {
+ fs.symlink(linkPath, target, function (err) {
+ if (err) {
+ return onError(err);
+ }
+ return cb();
+ });
+ }
-/***/ }),
-/* 514 */
-/***/ (function(module, exports, __webpack_require__) {
-
-exports.alphasort = alphasort
-exports.alphasorti = alphasorti
-exports.setopts = setopts
-exports.ownProp = ownProp
-exports.makeAbs = makeAbs
-exports.finish = finish
-exports.mark = mark
-exports.isIgnored = isIgnored
-exports.childrenIgnored = childrenIgnored
-
-function ownProp (obj, field) {
- return Object.prototype.hasOwnProperty.call(obj, field)
-}
-
-var path = __webpack_require__(16)
-var minimatch = __webpack_require__(506)
-var isAbsolute = __webpack_require__(512)
-var Minimatch = minimatch.Minimatch
-
-function alphasorti (a, b) {
- return a.toLowerCase().localeCompare(b.toLowerCase())
-}
-
-function alphasort (a, b) {
- return a.localeCompare(b)
-}
-
-function setupIgnores (self, options) {
- self.ignore = options.ignore || []
-
- if (!Array.isArray(self.ignore))
- self.ignore = [self.ignore]
-
- if (self.ignore.length) {
- self.ignore = self.ignore.map(ignoreMap)
- }
-}
-
-// ignore patterns are always in dot:true mode.
-function ignoreMap (pattern) {
- var gmatcher = null
- if (pattern.slice(-3) === '/**') {
- var gpattern = pattern.replace(/(\/\*\*)+$/, '')
- gmatcher = new Minimatch(gpattern, { dot: true })
- }
-
- return {
- matcher: new Minimatch(pattern, { dot: true }),
- gmatcher: gmatcher
+ function isWritable(path, done) {
+ fs.lstat(path, function (err) {
+ if (err) {
+ if (err.code === 'ENOENT') return done(true);
+ return done(false);
+ }
+ return done(false);
+ });
}
-}
-
-function setopts (self, pattern, options) {
- if (!options)
- options = {}
- // base-matching: just use globstar for that.
- if (options.matchBase && -1 === pattern.indexOf("/")) {
- if (options.noglobstar) {
- throw new Error("base matching requires globstar")
+ function onError(err) {
+ if (options.stopOnError) {
+ return cback(err);
}
- pattern = "**/" + pattern
- }
-
- self.silent = !!options.silent
- self.pattern = pattern
- self.strict = options.strict !== false
- self.realpath = !!options.realpath
- self.realpathCache = options.realpathCache || Object.create(null)
- self.follow = !!options.follow
- self.dot = !!options.dot
- self.mark = !!options.mark
- self.nodir = !!options.nodir
- if (self.nodir)
- self.mark = true
- self.sync = !!options.sync
- self.nounique = !!options.nounique
- self.nonull = !!options.nonull
- self.nosort = !!options.nosort
- self.nocase = !!options.nocase
- self.stat = !!options.stat
- self.noprocess = !!options.noprocess
- self.absolute = !!options.absolute
-
- self.maxLength = options.maxLength || Infinity
- self.cache = options.cache || Object.create(null)
- self.statCache = options.statCache || Object.create(null)
- self.symlinks = options.symlinks || Object.create(null)
-
- setupIgnores(self, options)
-
- self.changedCwd = false
- var cwd = process.cwd()
- if (!ownProp(options, "cwd"))
- self.cwd = cwd
- else {
- self.cwd = path.resolve(options.cwd)
- self.changedCwd = self.cwd !== cwd
- }
-
- self.root = options.root || path.resolve(self.cwd, "/")
- self.root = path.resolve(self.root)
- if (process.platform === "win32")
- self.root = self.root.replace(/\\/g, "/")
-
- // TODO: is an absolute `cwd` supposed to be resolved against `root`?
- // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
- self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd)
- if (process.platform === "win32")
- self.cwdAbs = self.cwdAbs.replace(/\\/g, "/")
- self.nomount = !!options.nomount
-
- // disable comments and negation in Minimatch.
- // Note that they are not supported in Glob itself anyway.
- options.nonegate = true
- options.nocomment = true
-
- self.minimatch = new Minimatch(pattern, options)
- self.options = self.minimatch.options
-}
-
-function finish (self) {
- var nou = self.nounique
- var all = nou ? [] : Object.create(null)
-
- for (var i = 0, l = self.matches.length; i < l; i ++) {
- var matches = self.matches[i]
- if (!matches || Object.keys(matches).length === 0) {
- if (self.nonull) {
- // do like the shell, and spit out the literal glob
- var literal = self.minimatch.globSet[i]
- if (nou)
- all.push(literal)
- else
- all[literal] = true
- }
- } else {
- // had matches
- var m = Object.keys(matches)
- if (nou)
- all.push.apply(all, m)
- else
- m.forEach(function (m) {
- all[m] = true
- })
+ else if (!errs && options.errs) {
+ errs = fs.createWriteStream(options.errs);
}
- }
-
- if (!nou)
- all = Object.keys(all)
-
- if (!self.nosort)
- all = all.sort(self.nocase ? alphasorti : alphasort)
-
- // at *some* point we statted all of these
- if (self.mark) {
- for (var i = 0; i < all.length; i++) {
- all[i] = self._mark(all[i])
+ else if (!errs) {
+ errs = [];
}
- if (self.nodir) {
- all = all.filter(function (e) {
- var notDir = !(/\/$/.test(e))
- var c = self.cache[e] || self.cache[makeAbs(self, e)]
- if (notDir && c)
- notDir = c !== 'DIR' && !Array.isArray(c)
- return notDir
- })
+ if (typeof errs.write === 'undefined') {
+ errs.push(err);
}
+ else {
+ errs.write(err.stack + '\n\n');
+ }
+ return cb();
}
- if (self.ignore.length)
- all = all.filter(function(m) {
- return !isIgnored(self, m)
- })
-
- self.found = all
-}
-
-function mark (self, p) {
- var abs = makeAbs(self, p)
- var c = self.cache[abs]
- var m = p
- if (c) {
- var isDir = c === 'DIR' || Array.isArray(c)
- var slash = p.slice(-1) === '/'
-
- if (isDir && !slash)
- m += '/'
- else if (!isDir && slash)
- m = m.slice(0, -1)
-
- if (m !== p) {
- var mabs = makeAbs(self, m)
- self.statCache[mabs] = self.statCache[abs]
- self.cache[mabs] = self.cache[abs]
+ function cb(skipped) {
+ if (!skipped) running--;
+ finished++;
+ if ((started === finished) && (running === 0)) {
+ if (cback !== undefined ) {
+ return errs ? cback(errs) : cback(null);
+ }
}
}
-
- return m
}
-// lotta situps...
-function makeAbs (self, f) {
- var abs = f
- if (f.charAt(0) === '/') {
- abs = path.join(self.root, f)
- } else if (isAbsolute(f) || f === '') {
- abs = f
- } else if (self.changedCwd) {
- abs = path.resolve(self.cwd, f)
- } else {
- abs = path.resolve(f)
- }
-
- if (process.platform === 'win32')
- abs = abs.replace(/\\/g, '/')
- return abs
-}
-// Return true, if pattern ends with globstar '**', for the accompanying parent directory.
-// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
-function isIgnored (self, path) {
- if (!self.ignore.length)
- return false
+/***/ }),
+/* 500 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- return self.ignore.some(function(item) {
- return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))
- })
-}
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "log", function() { return log; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Log", function() { return Log; });
+/* harmony import */ var _kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5);
+/* harmony import */ var _kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "LogLevel", function() { return _kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0__["LogLevel"]; });
-function childrenIgnored (self, path) {
- if (!self.ignore.length)
- return false
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
- return self.ignore.some(function(item) {
- return !!(item.gmatcher && item.gmatcher.match(path))
- })
-}
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
-/***/ }),
-/* 515 */
-/***/ (function(module, exports, __webpack_require__) {
+class Log extends _kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0__["ToolingLog"] {
+ constructor() {
+ super();
-var wrappy = __webpack_require__(405)
-var reqs = Object.create(null)
-var once = __webpack_require__(404)
+ _defineProperty(this, "logLevel", void 0);
-module.exports = wrappy(inflight)
+ this.setLogLevel('info');
+ }
-function inflight (key, cb) {
- if (reqs[key]) {
- reqs[key].push(cb)
- return null
- } else {
- reqs[key] = [cb]
- return makeres(key)
+ setLogLevel(level) {
+ this.logLevel = Object(_kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0__["parseLogLevel"])(level);
+ this.setWriters([new _kbn_dev_utils__WEBPACK_IMPORTED_MODULE_0__["ToolingLogTextWriter"]({
+ level: this.logLevel.name,
+ writeTo: process.stdout
+ })]);
}
-}
-function makeres (key) {
- return once(function RES () {
- var cbs = reqs[key]
- var len = cbs.length
- var args = slice(arguments)
+ wouldLogLevel(level) {
+ return this.logLevel.flags[level];
+ }
- // XXX It's somewhat ambiguous whether a new callback added in this
- // pass should be queued for later execution if something in the
- // list of callbacks throws, or if it should just be discarded.
- // However, it's such an edge case that it hardly matters, and either
- // choice is likely as surprising as the other.
- // As it happens, we do go ahead and schedule it for later execution.
- try {
- for (var i = 0; i < len; i++) {
- cbs[i].apply(null, args)
- }
- } finally {
- if (cbs.length > len) {
- // added more in the interim.
- // de-zalgo, just in case, but don't call again.
- cbs.splice(0, len)
- process.nextTick(function () {
- RES.apply(null, args)
- })
- } else {
- delete reqs[key]
- }
- }
- })
}
-function slice (args) {
- var length = args.length
- var array = []
-
- for (var i = 0; i < length; i++) array[i] = args[i]
- return array
-}
+const log = new Log();
/***/ }),
-/* 516 */
+/* 501 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CliError", function() { return CliError; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parallelizeBatches", function() { return parallelizeBatches; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parallelize", function() { return parallelize; });
/*
* Licensed to Elasticsearch B.V. under one or more contributor
* license agreements. See the NOTICE file distributed with
@@ -47570,39 +44042,65 @@ __webpack_require__.r(__webpack_exports__);
* specific language governing permissions and limitations
* under the License.
*/
-class CliError extends Error {
- constructor(message, meta = {}) {
- super(message);
- this.meta = meta;
+async function parallelizeBatches(batches, fn) {
+ for (const batch of batches) {
+ // We need to make sure the entire batch has completed before we can move on
+ // to the next batch
+ await parallelize(batch, fn);
+ }
+}
+async function parallelize(items, fn, concurrency = 4) {
+ if (items.length === 0) {
+ return;
}
+ return new Promise((resolve, reject) => {
+ let activePromises = 0;
+ const values = items.slice(0);
+
+ async function scheduleItem(item) {
+ activePromises++;
+
+ try {
+ await fn(item);
+ activePromises--;
+
+ if (values.length > 0) {
+ // We have more work to do, so we schedule the next promise
+ scheduleItem(values.shift());
+ } else if (activePromises === 0) {
+ // We have no more values left, and all items have completed, so we've
+ // completed all the work.
+ resolve();
+ }
+ } catch (error) {
+ reject(error);
+ }
+ }
+
+ values.splice(0, concurrency).map(scheduleItem);
+ });
}
/***/ }),
-/* 517 */
+/* 502 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Project", function() { return Project; });
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(23);
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(16);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(29);
-/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(util__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(516);
-/* harmony import */ var _log__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(34);
-/* harmony import */ var _package_json__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(518);
-/* harmony import */ var _scripts__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(563);
-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; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getProjects", function() { return getProjects; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "buildProjectGraph", function() { return buildProjectGraph; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "topologicallyBatchProjects", function() { return topologicallyBatchProjects; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "includeTransitiveProjects", function() { return includeTransitiveProjects; });
+/* harmony import */ var glob__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(503);
+/* harmony import */ var glob__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(glob__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(397);
+/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(util__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(516);
+/* harmony import */ var _project__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(517);
+/* harmony import */ var _workspaces__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(573);
/*
* Licensed to Elasticsearch B.V. under one or more contributor
* license agreements. See the NOTICE file distributed with
@@ -47627,6243 +44125,8760 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
+const glob = Object(util__WEBPACK_IMPORTED_MODULE_2__["promisify"])(glob__WEBPACK_IMPORTED_MODULE_0___default.a);
+/** a Map of project names to Project instances */
+async function getProjects(rootPath, projectsPathsPatterns, {
+ include = [],
+ exclude = []
+} = {}) {
+ const projects = new Map();
+ const workspaceProjectsPaths = await Object(_workspaces__WEBPACK_IMPORTED_MODULE_5__["workspacePackagePaths"])(rootPath);
-class Project {
- static async fromPath(path) {
- const pkgJson = await Object(_package_json__WEBPACK_IMPORTED_MODULE_6__["readPackageJson"])(path);
- return new Project(pkgJson, path);
- }
- /** parsed package.json */
+ for (const pattern of projectsPathsPatterns) {
+ const pathsToProcess = await packagesFromGlobPattern({
+ pattern,
+ rootPath
+ });
+ for (const filePath of pathsToProcess) {
+ const projectConfigPath = normalize(filePath);
+ const projectDir = path__WEBPACK_IMPORTED_MODULE_1___default.a.dirname(projectConfigPath);
+ const project = await _project__WEBPACK_IMPORTED_MODULE_4__["Project"].fromPath(projectDir);
- constructor(packageJson, projectPath) {
- _defineProperty(this, "json", void 0);
+ if (workspaceProjectsPaths.indexOf(filePath) >= 0) {
+ project.isWorkspaceProject = true;
+ }
- _defineProperty(this, "packageJsonLocation", void 0);
+ const excludeProject = exclude.includes(project.name) || include.length > 0 && !include.includes(project.name);
- _defineProperty(this, "nodeModulesLocation", void 0);
+ if (excludeProject) {
+ continue;
+ }
- _defineProperty(this, "targetLocation", void 0);
+ if (projects.has(project.name)) {
+ throw new _errors__WEBPACK_IMPORTED_MODULE_3__["CliError"](`There are multiple projects with the same name [${project.name}]`, {
+ name: project.name,
+ paths: [project.path, projects.get(project.name).path]
+ });
+ }
- _defineProperty(this, "path", void 0);
+ projects.set(project.name, project);
+ }
+ }
- _defineProperty(this, "version", void 0);
+ return projects;
+}
- _defineProperty(this, "allDependencies", void 0);
+function packagesFromGlobPattern({
+ pattern,
+ rootPath
+}) {
+ const globOptions = {
+ cwd: rootPath,
+ // Should throw in case of unusual errors when reading the file system
+ strict: true,
+ // Always returns absolute paths for matched files
+ absolute: true,
+ // Do not match ** against multiple filenames
+ // (This is only specified because we currently don't have a need for it.)
+ noglobstar: true
+ };
+ return glob(path__WEBPACK_IMPORTED_MODULE_1___default.a.join(pattern, 'package.json'), globOptions);
+} // https://github.com/isaacs/node-glob/blob/master/common.js#L104
+// glob always returns "\\" as "/" in windows, so everyone
+// gets normalized because we can't have nice things.
- _defineProperty(this, "productionDependencies", void 0);
- _defineProperty(this, "devDependencies", void 0);
+function normalize(dir) {
+ return path__WEBPACK_IMPORTED_MODULE_1___default.a.normalize(dir);
+}
- _defineProperty(this, "scripts", void 0);
+function buildProjectGraph(projects) {
+ const projectGraph = new Map();
- _defineProperty(this, "isWorkspaceRoot", false);
+ for (const project of projects.values()) {
+ const projectDeps = [];
+ const dependencies = project.allDependencies;
- _defineProperty(this, "isWorkspaceProject", false);
+ for (const depName of Object.keys(dependencies)) {
+ if (projects.has(depName)) {
+ const dep = projects.get(depName);
+ const dependentProjectIsInWorkspace = project.isWorkspaceProject || project.json.name === 'kibana';
+ project.ensureValidProjectDependency(dep, dependentProjectIsInWorkspace);
+ projectDeps.push(dep);
+ }
+ }
- this.json = Object.freeze(packageJson);
- this.path = projectPath;
- this.packageJsonLocation = path__WEBPACK_IMPORTED_MODULE_2___default.a.resolve(this.path, 'package.json');
- this.nodeModulesLocation = path__WEBPACK_IMPORTED_MODULE_2___default.a.resolve(this.path, 'node_modules');
- this.targetLocation = path__WEBPACK_IMPORTED_MODULE_2___default.a.resolve(this.path, 'target');
- this.version = this.json.version;
- this.productionDependencies = this.json.dependencies || {};
- this.devDependencies = this.json.devDependencies || {};
- this.allDependencies = _objectSpread({}, this.devDependencies, {}, this.productionDependencies);
- this.isWorkspaceRoot = this.json.hasOwnProperty('workspaces');
- this.scripts = this.json.scripts || {};
+ projectGraph.set(project.name, projectDeps);
}
- get name() {
- return this.json.name;
- }
+ return projectGraph;
+}
+function topologicallyBatchProjects(projectsToBatch, projectGraph, {
+ batchByWorkspace = false
+} = {}) {
+ // We're going to be chopping stuff out of this list, so copy it.
+ const projectsLeftToBatch = new Set(projectsToBatch.keys());
+ const batches = [];
- ensureValidProjectDependency(project, dependentProjectIsInWorkspace) {
- const versionInPackageJson = this.allDependencies[project.name];
- let expectedVersionInPackageJson;
+ if (batchByWorkspace) {
+ const workspaceRootProject = Array.from(projectsToBatch.values()).find(p => p.isWorkspaceRoot);
- if (dependentProjectIsInWorkspace) {
- expectedVersionInPackageJson = project.json.version;
- } else {
- const relativePathToProject = normalizePath(path__WEBPACK_IMPORTED_MODULE_2___default.a.relative(this.path, project.path));
- expectedVersionInPackageJson = `link:${relativePathToProject}`;
- } // No issues!
+ if (!workspaceRootProject) {
+ throw new _errors__WEBPACK_IMPORTED_MODULE_3__["CliError"](`There was no yarn workspace root found.`);
+ } // Push in the workspace root first.
- if (versionInPackageJson === expectedVersionInPackageJson) {
- return;
- }
+ batches.push([workspaceRootProject]);
+ projectsLeftToBatch.delete(workspaceRootProject.name); // In the next batch, push in all workspace projects.
- let problemMsg;
+ const workspaceBatch = [];
- if (Object(_package_json__WEBPACK_IMPORTED_MODULE_6__["isLinkDependency"])(versionInPackageJson) && dependentProjectIsInWorkspace) {
- problemMsg = `but should be using a workspace`;
- } else if (Object(_package_json__WEBPACK_IMPORTED_MODULE_6__["isLinkDependency"])(versionInPackageJson)) {
- problemMsg = `using 'link:', but the path is wrong`;
- } else {
- problemMsg = `but it's not using the local package`;
- }
+ for (const projectName of projectsLeftToBatch) {
+ const project = projectsToBatch.get(projectName);
- throw new _errors__WEBPACK_IMPORTED_MODULE_4__["CliError"](`[${this.name}] depends on [${project.name}] ${problemMsg}. Update its package.json to the expected value below.`, {
- actual: `"${project.name}": "${versionInPackageJson}"`,
- expected: `"${project.name}": "${expectedVersionInPackageJson}"`,
- package: `${this.name} (${this.packageJsonLocation})`
- });
- }
+ if (project.isWorkspaceProject) {
+ workspaceBatch.push(project);
+ projectsLeftToBatch.delete(projectName);
+ }
+ }
- getBuildConfig() {
- return this.json.kibana && this.json.kibana.build || {};
+ batches.push(workspaceBatch);
}
- /**
- * Returns the directory that should be copied into the Kibana build artifact.
- * This config can be specified to only include the project's build artifacts
- * instead of everything located in the project directory.
- */
+ while (projectsLeftToBatch.size > 0) {
+ // Get all projects that have no remaining dependencies within the repo
+ // that haven't yet been picked.
+ const batch = [];
- getIntermediateBuildDirectory() {
- return path__WEBPACK_IMPORTED_MODULE_2___default.a.resolve(this.path, this.getBuildConfig().intermediateBuildDirectory || '.');
- }
-
- getCleanConfig() {
- return this.json.kibana && this.json.kibana.clean || {};
- }
+ for (const projectName of projectsLeftToBatch) {
+ const projectDeps = projectGraph.get(projectName);
+ const needsDependenciesBatched = projectDeps.some(dep => projectsLeftToBatch.has(dep.name));
- hasScript(name) {
- return name in this.scripts;
- }
+ if (!needsDependenciesBatched) {
+ batch.push(projectsToBatch.get(projectName));
+ }
+ } // If we weren't able to find a project with no remaining dependencies,
+ // then we've encountered a cycle in the dependency graph.
- getExecutables() {
- const raw = this.json.bin;
- if (!raw) {
- return {};
- }
+ const hasCycles = batch.length === 0;
- if (typeof raw === 'string') {
- return {
- [this.name]: path__WEBPACK_IMPORTED_MODULE_2___default.a.resolve(this.path, raw)
- };
+ if (hasCycles) {
+ const cycleProjectNames = [...projectsLeftToBatch];
+ const message = 'Encountered a cycle in the dependency graph. Projects in cycle are:\n' + cycleProjectNames.join(', ');
+ throw new _errors__WEBPACK_IMPORTED_MODULE_3__["CliError"](message);
}
- if (typeof raw === 'object') {
- const binsConfig = {};
+ batches.push(batch);
+ batch.forEach(project => projectsLeftToBatch.delete(project.name));
+ }
- for (const binName of Object.keys(raw)) {
- binsConfig[binName] = path__WEBPACK_IMPORTED_MODULE_2___default.a.resolve(this.path, raw[binName]);
- }
+ return batches;
+}
+function includeTransitiveProjects(subsetOfProjects, allProjects, {
+ onlyProductionDependencies = false
+} = {}) {
+ const projectsWithDependents = new Map(); // the current list of packages we are expanding using breadth-first-search
- return binsConfig;
- }
+ const toProcess = [...subsetOfProjects];
- throw new _errors__WEBPACK_IMPORTED_MODULE_4__["CliError"](`[${this.name}] has an invalid "bin" field in its package.json, ` + `expected an object or a string`, {
- binConfig: Object(util__WEBPACK_IMPORTED_MODULE_3__["inspect"])(raw),
- package: `${this.name} (${this.packageJsonLocation})`
+ while (toProcess.length > 0) {
+ const project = toProcess.shift();
+ const dependencies = onlyProductionDependencies ? project.productionDependencies : project.allDependencies;
+ Object.keys(dependencies).forEach(dep => {
+ if (allProjects.has(dep)) {
+ toProcess.push(allProjects.get(dep));
+ }
});
+ projectsWithDependents.set(project.name, project);
}
- async runScript(scriptName, args = []) {
- _log__WEBPACK_IMPORTED_MODULE_5__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold(`\n\nRunning script [${chalk__WEBPACK_IMPORTED_MODULE_0___default.a.green(scriptName)}] in [${chalk__WEBPACK_IMPORTED_MODULE_0___default.a.green(this.name)}]:\n`));
- return Object(_scripts__WEBPACK_IMPORTED_MODULE_7__["runScriptInPackage"])(scriptName, args, this);
- }
-
- runScriptStreaming(scriptName, args = []) {
- return Object(_scripts__WEBPACK_IMPORTED_MODULE_7__["runScriptInPackageStreaming"])(scriptName, args, this);
- }
-
- hasDependencies() {
- return Object.keys(this.allDependencies).length > 0;
- }
+ return projectsWithDependents;
+}
- async installDependencies({
- extraArgs
- }) {
- _log__WEBPACK_IMPORTED_MODULE_5__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold(`\n\nInstalling dependencies in [${chalk__WEBPACK_IMPORTED_MODULE_0___default.a.green(this.name)}]:\n`));
- await Object(_scripts__WEBPACK_IMPORTED_MODULE_7__["installInDir"])(this.path, extraArgs);
- await this.removeExtraneousNodeModules();
- }
- /**
- * Yarn workspaces symlinks workspace projects to the root node_modules, even
- * when there is no depenency on the project. This results in unnecicary, and
- * often duplicated code in the build archives.
- */
+/***/ }),
+/* 503 */
+/***/ (function(module, exports, __webpack_require__) {
+// Approach:
+//
+// 1. Get the minimatch set
+// 2. For each pattern in the set, PROCESS(pattern, false)
+// 3. Store matches per-set, then uniq them
+//
+// PROCESS(pattern, inGlobStar)
+// Get the first [n] items from pattern that are all strings
+// Join these together. This is PREFIX.
+// If there is no more remaining, then stat(PREFIX) and
+// add to matches if it succeeds. END.
+//
+// If inGlobStar and PREFIX is symlink and points to dir
+// set ENTRIES = []
+// else readdir(PREFIX) as ENTRIES
+// If fail, END
+//
+// with ENTRIES
+// If pattern[n] is GLOBSTAR
+// // handle the case where the globstar match is empty
+// // by pruning it out, and testing the resulting pattern
+// PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
+// // handle other cases.
+// for ENTRY in ENTRIES (not dotfiles)
+// // attach globstar + tail onto the entry
+// // Mark that this entry is a globstar match
+// PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
+//
+// else // not globstar
+// for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
+// Test ENTRY against pattern[n]
+// If fails, continue
+// If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
+//
+// Caveat:
+// Cache all stats and readdirs results to minimize syscall. Since all
+// we ever care about is existence and directory-ness, we can just keep
+// `true` for files, and [children,...] for directories, or `false` for
+// things that don't exist.
- async removeExtraneousNodeModules() {
- // this is only relevant for the root workspace
- if (!this.isWorkspaceRoot) {
- return;
- }
+module.exports = glob
- const workspacesInfo = await Object(_scripts__WEBPACK_IMPORTED_MODULE_7__["yarnWorkspacesInfo"])(this.path);
- const unusedWorkspaces = new Set(Object.keys(workspacesInfo)); // check for any cross-project dependency
+var fs = __webpack_require__(349)
+var rp = __webpack_require__(504)
+var minimatch = __webpack_require__(506)
+var Minimatch = minimatch.Minimatch
+var inherits = __webpack_require__(510)
+var EE = __webpack_require__(373).EventEmitter
+var path = __webpack_require__(4)
+var assert = __webpack_require__(371)
+var isAbsolute = __webpack_require__(512)
+var globSync = __webpack_require__(513)
+var common = __webpack_require__(514)
+var alphasort = common.alphasort
+var alphasorti = common.alphasorti
+var setopts = common.setopts
+var ownProp = common.ownProp
+var inflight = __webpack_require__(515)
+var util = __webpack_require__(397)
+var childrenIgnored = common.childrenIgnored
+var isIgnored = common.isIgnored
- for (const name of Object.keys(workspacesInfo)) {
- const workspace = workspacesInfo[name];
- workspace.workspaceDependencies.forEach(w => unusedWorkspaces.delete(w));
- }
+var once = __webpack_require__(378)
- unusedWorkspaces.forEach(name => {
- const {
- dependencies,
- devDependencies
- } = this.json;
- const nodeModulesPath = path__WEBPACK_IMPORTED_MODULE_2___default.a.resolve(this.nodeModulesLocation, name);
- const isDependency = dependencies && dependencies.hasOwnProperty(name);
- const isDevDependency = devDependencies && devDependencies.hasOwnProperty(name);
+function glob (pattern, options, cb) {
+ if (typeof options === 'function') cb = options, options = {}
+ if (!options) options = {}
- if (!isDependency && !isDevDependency && fs__WEBPACK_IMPORTED_MODULE_1___default.a.existsSync(nodeModulesPath)) {
- _log__WEBPACK_IMPORTED_MODULE_5__["log"].write(`No dependency on ${name}, removing link in node_modules`);
- fs__WEBPACK_IMPORTED_MODULE_1___default.a.unlinkSync(nodeModulesPath);
- }
- });
+ if (options.sync) {
+ if (cb)
+ throw new TypeError('callback provided to sync glob')
+ return globSync(pattern, options)
}
-} // We normalize all path separators to `/` in generated files
-
-function normalizePath(path) {
- return path.replace(/[\\\/]+/g, '/');
+ return new Glob(pattern, options, cb)
}
-/***/ }),
-/* 518 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+glob.sync = globSync
+var GlobSync = glob.GlobSync = globSync.GlobSync
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "readPackageJson", function() { return readPackageJson; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "writePackageJson", function() { return writePackageJson; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isLinkDependency", function() { return isLinkDependency; });
-/* harmony import */ var read_pkg__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(519);
-/* harmony import */ var read_pkg__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(read_pkg__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var write_pkg__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(545);
-/* harmony import */ var write_pkg__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(write_pkg__WEBPACK_IMPORTED_MODULE_1__);
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
+// old api surface
+glob.glob = glob
+function extend (origin, add) {
+ if (add === null || typeof add !== 'object') {
+ return origin
+ }
-function readPackageJson(cwd) {
- return read_pkg__WEBPACK_IMPORTED_MODULE_0___default()({
- cwd,
- normalize: false
- });
-}
-function writePackageJson(path, json) {
- return write_pkg__WEBPACK_IMPORTED_MODULE_1___default()(path, json);
+ var keys = Object.keys(add)
+ var i = keys.length
+ while (i--) {
+ origin[keys[i]] = add[keys[i]]
+ }
+ return origin
}
-const isLinkDependency = depVersion => depVersion.startsWith('link:');
-
-/***/ }),
-/* 519 */
-/***/ (function(module, exports, __webpack_require__) {
-"use strict";
+glob.hasMagic = function (pattern, options_) {
+ var options = extend({}, options_)
+ options.noprocess = true
-const {promisify} = __webpack_require__(29);
-const fs = __webpack_require__(23);
-const path = __webpack_require__(16);
-const parseJson = __webpack_require__(520);
+ var g = new Glob(pattern, options)
+ var set = g.minimatch.set
-const readFileAsync = promisify(fs.readFile);
+ if (!pattern)
+ return false
-module.exports = async options => {
- options = {
- cwd: process.cwd(),
- normalize: true,
- ...options
- };
+ if (set.length > 1)
+ return true
- const filePath = path.resolve(options.cwd, 'package.json');
- const json = parseJson(await readFileAsync(filePath, 'utf8'));
+ for (var j = 0; j < set[0].length; j++) {
+ if (typeof set[0][j] !== 'string')
+ return true
+ }
- if (options.normalize) {
- __webpack_require__(521)(json);
- }
+ return false
+}
- return json;
-};
+glob.Glob = Glob
+inherits(Glob, EE)
+function Glob (pattern, options, cb) {
+ if (typeof options === 'function') {
+ cb = options
+ options = null
+ }
-module.exports.sync = options => {
- options = {
- cwd: process.cwd(),
- normalize: true,
- ...options
- };
+ if (options && options.sync) {
+ if (cb)
+ throw new TypeError('callback provided to sync glob')
+ return new GlobSync(pattern, options)
+ }
- const filePath = path.resolve(options.cwd, 'package.json');
- const json = parseJson(fs.readFileSync(filePath, 'utf8'));
+ if (!(this instanceof Glob))
+ return new Glob(pattern, options, cb)
- if (options.normalize) {
- __webpack_require__(521)(json);
- }
+ setopts(this, pattern, options)
+ this._didRealPath = false
- return json;
-};
+ // process each pattern in the minimatch set
+ var n = this.minimatch.set.length
+ // The matches are stored as {: true,...} so that
+ // duplicates are automagically pruned.
+ // Later, we do an Object.keys() on these.
+ // Keep them as a list so we can fill in when nonull is set.
+ this.matches = new Array(n)
-/***/ }),
-/* 520 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (typeof cb === 'function') {
+ cb = once(cb)
+ this.on('error', cb)
+ this.on('end', function (matches) {
+ cb(null, matches)
+ })
+ }
-"use strict";
+ var self = this
+ this._processing = 0
-const errorEx = __webpack_require__(429);
-const fallback = __webpack_require__(431);
-const {default: LinesAndColumns} = __webpack_require__(432);
-const {codeFrameColumns} = __webpack_require__(433);
+ this._emitQueue = []
+ this._processQueue = []
+ this.paused = false
-const JSONError = errorEx('JSONError', {
- fileName: errorEx.append('in %s'),
- codeFrame: errorEx.append('\n\n%s\n')
-});
+ if (this.noprocess)
+ return this
-module.exports = (string, reviver, filename) => {
- if (typeof reviver === 'string') {
- filename = reviver;
- reviver = null;
- }
+ if (n === 0)
+ return done()
- try {
- try {
- return JSON.parse(string, reviver);
- } catch (error) {
- fallback(string, reviver);
- throw error;
- }
- } catch (error) {
- error.message = error.message.replace(/\n/g, '');
- const indexMatch = error.message.match(/in JSON at position (\d+) while parsing near/);
+ var sync = true
+ for (var i = 0; i < n; i ++) {
+ this._process(this.minimatch.set[i], i, false, done)
+ }
+ sync = false
- const jsonError = new JSONError(error);
- if (filename) {
- jsonError.fileName = filename;
- }
+ function done () {
+ --self._processing
+ if (self._processing <= 0) {
+ if (sync) {
+ process.nextTick(function () {
+ self._finish()
+ })
+ } else {
+ self._finish()
+ }
+ }
+ }
+}
- if (indexMatch && indexMatch.length > 0) {
- const lines = new LinesAndColumns(string);
- const index = Number(indexMatch[1]);
- const location = lines.locationForIndex(index);
+Glob.prototype._finish = function () {
+ assert(this instanceof Glob)
+ if (this.aborted)
+ return
- const codeFrame = codeFrameColumns(
- string,
- {start: {line: location.line + 1, column: location.column + 1}},
- {highlightCode: true}
- );
+ if (this.realpath && !this._didRealpath)
+ return this._realpath()
- jsonError.codeFrame = codeFrame;
- }
+ common.finish(this)
+ this.emit('end', this.found)
+}
- throw jsonError;
- }
-};
+Glob.prototype._realpath = function () {
+ if (this._didRealpath)
+ return
+ this._didRealpath = true
-/***/ }),
-/* 521 */
-/***/ (function(module, exports, __webpack_require__) {
+ var n = this.matches.length
+ if (n === 0)
+ return this._finish()
-module.exports = normalize
+ var self = this
+ for (var i = 0; i < this.matches.length; i++)
+ this._realpathSet(i, next)
-var fixer = __webpack_require__(522)
-normalize.fixer = fixer
+ function next () {
+ if (--n === 0)
+ self._finish()
+ }
+}
-var makeWarning = __webpack_require__(543)
+Glob.prototype._realpathSet = function (index, cb) {
+ var matchset = this.matches[index]
+ if (!matchset)
+ return cb()
-var fieldsToFix = ['name','version','description','repository','modules','scripts'
- ,'files','bin','man','bugs','keywords','readme','homepage','license']
-var otherThingsToFix = ['dependencies','people', 'typos']
+ var found = Object.keys(matchset)
+ var self = this
+ var n = found.length
-var thingsToFix = fieldsToFix.map(function(fieldName) {
- return ucFirst(fieldName) + "Field"
-})
-// two ways to do this in CoffeeScript on only one line, sub-70 chars:
-// thingsToFix = fieldsToFix.map (name) -> ucFirst(name) + "Field"
-// thingsToFix = (ucFirst(name) + "Field" for name in fieldsToFix)
-thingsToFix = thingsToFix.concat(otherThingsToFix)
+ if (n === 0)
+ return cb()
-function normalize (data, warn, strict) {
- if(warn === true) warn = null, strict = true
- if(!strict) strict = false
- if(!warn || data.private) warn = function(msg) { /* noop */ }
+ var set = this.matches[index] = Object.create(null)
+ found.forEach(function (p, i) {
+ // If there's a problem with the stat, then it means that
+ // one or more of the links in the realpath couldn't be
+ // resolved. just return the abs value in that case.
+ p = self._makeAbs(p)
+ rp.realpath(p, self.realpathCache, function (er, real) {
+ if (!er)
+ set[real] = true
+ else if (er.syscall === 'stat')
+ set[p] = true
+ else
+ self.emit('error', er) // srsly wtf right here
- if (data.scripts &&
- data.scripts.install === "node-gyp rebuild" &&
- !data.scripts.preinstall) {
- data.gypfile = true
- }
- fixer.warn = function() { warn(makeWarning.apply(null, arguments)) }
- thingsToFix.forEach(function(thingName) {
- fixer["fix" + ucFirst(thingName)](data, strict)
+ if (--n === 0) {
+ self.matches[index] = set
+ cb()
+ }
+ })
})
- data._id = data.name + "@" + data.version
}
-function ucFirst (string) {
- return string.charAt(0).toUpperCase() + string.slice(1);
+Glob.prototype._mark = function (p) {
+ return common.mark(this, p)
}
+Glob.prototype._makeAbs = function (f) {
+ return common.makeAbs(this, f)
+}
-/***/ }),
-/* 522 */
-/***/ (function(module, exports, __webpack_require__) {
+Glob.prototype.abort = function () {
+ this.aborted = true
+ this.emit('abort')
+}
-var semver = __webpack_require__(523)
-var validateLicense = __webpack_require__(524);
-var hostedGitInfo = __webpack_require__(529)
-var isBuiltinModule = __webpack_require__(532).isCore
-var depTypes = ["dependencies","devDependencies","optionalDependencies"]
-var extractDescription = __webpack_require__(541)
-var url = __webpack_require__(452)
-var typos = __webpack_require__(542)
+Glob.prototype.pause = function () {
+ if (!this.paused) {
+ this.paused = true
+ this.emit('pause')
+ }
+}
-var fixer = module.exports = {
- // default warning function
- warn: function() {},
-
- fixRepositoryField: function(data) {
- if (data.repositories) {
- this.warn("repositories");
- data.repository = data.repositories[0]
- }
- if (!data.repository) return this.warn("missingRepository")
- if (typeof data.repository === "string") {
- data.repository = {
- type: "git",
- url: data.repository
+Glob.prototype.resume = function () {
+ if (this.paused) {
+ this.emit('resume')
+ this.paused = false
+ if (this._emitQueue.length) {
+ var eq = this._emitQueue.slice(0)
+ this._emitQueue.length = 0
+ for (var i = 0; i < eq.length; i ++) {
+ var e = eq[i]
+ this._emitMatch(e[0], e[1])
}
}
- var r = data.repository.url || ""
- if (r) {
- var hosted = hostedGitInfo.fromUrl(r)
- if (hosted) {
- r = data.repository.url
- = hosted.getDefaultRepresentation() == "shortcut" ? hosted.https() : hosted.toString()
+ if (this._processQueue.length) {
+ var pq = this._processQueue.slice(0)
+ this._processQueue.length = 0
+ for (var i = 0; i < pq.length; i ++) {
+ var p = pq[i]
+ this._processing--
+ this._process(p[0], p[1], p[2], p[3])
}
}
+ }
+}
- if (r.match(/github.com\/[^\/]+\/[^\/]+\.git\.git$/)) {
- this.warn("brokenGitUrl", r)
- }
+Glob.prototype._process = function (pattern, index, inGlobStar, cb) {
+ assert(this instanceof Glob)
+ assert(typeof cb === 'function')
+
+ if (this.aborted)
+ return
+
+ this._processing++
+ if (this.paused) {
+ this._processQueue.push([pattern, index, inGlobStar, cb])
+ return
}
-, fixTypos: function(data) {
- Object.keys(typos.topLevel).forEach(function (d) {
- if (data.hasOwnProperty(d)) {
- this.warn("typo", d, typos.topLevel[d])
- }
- }, this)
+ //console.error('PROCESS %d', this._processing, pattern)
+
+ // Get the first [n] parts of pattern that are all strings.
+ var n = 0
+ while (typeof pattern[n] === 'string') {
+ n ++
}
+ // now n is the index of the first one that is *not* a string.
-, fixScriptsField: function(data) {
- if (!data.scripts) return
- if (typeof data.scripts !== "object") {
- this.warn("nonObjectScripts")
- delete data.scripts
+ // see if there's anything else
+ var prefix
+ switch (n) {
+ // if not, then this is rather simple
+ case pattern.length:
+ this._processSimple(pattern.join('/'), index, cb)
return
- }
- Object.keys(data.scripts).forEach(function (k) {
- if (typeof data.scripts[k] !== "string") {
- this.warn("nonStringScript")
- delete data.scripts[k]
- } else if (typos.script[k] && !data.scripts[typos.script[k]]) {
- this.warn("typo", k, typos.script[k], "scripts")
- }
- }, this)
- }
-, fixFilesField: function(data) {
- var files = data.files
- if (files && !Array.isArray(files)) {
- this.warn("nonArrayFiles")
- delete data.files
- } else if (data.files) {
- data.files = data.files.filter(function(file) {
- if (!file || typeof file !== "string") {
- this.warn("invalidFilename", file)
- return false
- } else {
- return true
- }
- }, this)
- }
+ case 0:
+ // pattern *starts* with some non-trivial item.
+ // going to readdir(cwd), but not include the prefix in matches.
+ prefix = null
+ break
+
+ default:
+ // pattern has some string bits in the front.
+ // whatever it starts with, whether that's 'absolute' like /foo/bar,
+ // or 'relative' like '../baz'
+ prefix = pattern.slice(0, n).join('/')
+ break
}
-, fixBinField: function(data) {
- if (!data.bin) return;
- if (typeof data.bin === "string") {
- var b = {}
- var match
- if (match = data.name.match(/^@[^/]+[/](.*)$/)) {
- b[match[1]] = data.bin
+ var remain = pattern.slice(n)
+
+ // get the list of entries.
+ var read
+ if (prefix === null)
+ read = '.'
+ else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+ if (!prefix || !isAbsolute(prefix))
+ prefix = '/' + prefix
+ read = prefix
+ } else
+ read = prefix
+
+ var abs = this._makeAbs(read)
+
+ //if ignored, skip _processing
+ if (childrenIgnored(this, read))
+ return cb()
+
+ var isGlobStar = remain[0] === minimatch.GLOBSTAR
+ if (isGlobStar)
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb)
+ else
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb)
+}
+
+Glob.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar, cb) {
+ var self = this
+ this._readdir(abs, inGlobStar, function (er, entries) {
+ return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
+ })
+}
+
+Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+
+ // if the abs isn't a dir, then nothing can match!
+ if (!entries)
+ return cb()
+
+ // It will only match dot entries if it starts with a dot, or if
+ // dot is set. Stuff like @(.foo|.bar) isn't allowed.
+ var pn = remain[0]
+ var negate = !!this.minimatch.negate
+ var rawGlob = pn._glob
+ var dotOk = this.dot || rawGlob.charAt(0) === '.'
+
+ var matchedEntries = []
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i]
+ if (e.charAt(0) !== '.' || dotOk) {
+ var m
+ if (negate && !prefix) {
+ m = !e.match(pn)
} else {
- b[data.name] = data.bin
+ m = e.match(pn)
}
- data.bin = b
+ if (m)
+ matchedEntries.push(e)
}
}
-, fixManField: function(data) {
- if (!data.man) return;
- if (typeof data.man === "string") {
- data.man = [ data.man ]
- }
- }
-, fixBundleDependenciesField: function(data) {
- var bdd = "bundledDependencies"
- var bd = "bundleDependencies"
- if (data[bdd] && !data[bd]) {
- data[bd] = data[bdd]
- delete data[bdd]
- }
- if (data[bd] && !Array.isArray(data[bd])) {
- this.warn("nonArrayBundleDependencies")
- delete data[bd]
- } else if (data[bd]) {
- data[bd] = data[bd].filter(function(bd) {
- if (!bd || typeof bd !== 'string') {
- this.warn("nonStringBundleDependency", bd)
- return false
- } else {
- if (!data.dependencies) {
- data.dependencies = {}
- }
- if (!data.dependencies.hasOwnProperty(bd)) {
- this.warn("nonDependencyBundleDependency", bd)
- data.dependencies[bd] = "*"
- }
- return true
- }
- }, this)
- }
- }
+ //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
-, fixDependencies: function(data, strict) {
- var loose = !strict
- objectifyDeps(data, this.warn)
- addOptionalDepsToDeps(data, this.warn)
- this.fixBundleDependenciesField(data)
+ var len = matchedEntries.length
+ // If there are no matched entries, then nothing matches.
+ if (len === 0)
+ return cb()
- ;['dependencies','devDependencies'].forEach(function(deps) {
- if (!(deps in data)) return
- if (!data[deps] || typeof data[deps] !== "object") {
- this.warn("nonObjectDependencies", deps)
- delete data[deps]
- return
+ // if this is the last remaining pattern bit, then no need for
+ // an additional stat *unless* the user has specified mark or
+ // stat explicitly. We know they exist, since readdir returned
+ // them.
+
+ if (remain.length === 1 && !this.mark && !this.stat) {
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null)
+
+ for (var i = 0; i < len; i ++) {
+ var e = matchedEntries[i]
+ if (prefix) {
+ if (prefix !== '/')
+ e = prefix + '/' + e
+ else
+ e = prefix + e
}
- Object.keys(data[deps]).forEach(function (d) {
- var r = data[deps][d]
- if (typeof r !== 'string') {
- this.warn("nonStringDependency", d, JSON.stringify(r))
- delete data[deps][d]
- }
- var hosted = hostedGitInfo.fromUrl(data[deps][d])
- if (hosted) data[deps][d] = hosted.toString()
- }, this)
- }, this)
- }
-, fixModulesField: function (data) {
- if (data.modules) {
- this.warn("deprecatedModules")
- delete data.modules
+ if (e.charAt(0) === '/' && !this.nomount) {
+ e = path.join(this.root, e)
+ }
+ this._emitMatch(index, e)
}
+ // This was the last one, and no stats were needed
+ return cb()
}
-, fixKeywordsField: function (data) {
- if (typeof data.keywords === "string") {
- data.keywords = data.keywords.split(/,\s+/)
- }
- if (data.keywords && !Array.isArray(data.keywords)) {
- delete data.keywords
- this.warn("nonArrayKeywords")
- } else if (data.keywords) {
- data.keywords = data.keywords.filter(function(kw) {
- if (typeof kw !== "string" || !kw) {
- this.warn("nonStringKeyword");
- return false
- } else {
- return true
- }
- }, this)
+ // now test all matched entries as stand-ins for that part
+ // of the pattern.
+ remain.shift()
+ for (var i = 0; i < len; i ++) {
+ var e = matchedEntries[i]
+ var newPattern
+ if (prefix) {
+ if (prefix !== '/')
+ e = prefix + '/' + e
+ else
+ e = prefix + e
}
+ this._process([e].concat(remain), index, inGlobStar, cb)
}
+ cb()
+}
-, fixVersionField: function(data, strict) {
- // allow "loose" semver 1.0 versions in non-strict mode
- // enforce strict semver 2.0 compliance in strict mode
- var loose = !strict
- if (!data.version) {
- data.version = ""
- return true
- }
- if (!semver.valid(data.version, loose)) {
- throw new Error('Invalid version: "'+ data.version + '"')
- }
- data.version = semver.clean(data.version, loose)
- return true
- }
+Glob.prototype._emitMatch = function (index, e) {
+ if (this.aborted)
+ return
-, fixPeople: function(data) {
- modifyPeople(data, unParsePerson)
- modifyPeople(data, parsePerson)
- }
+ if (isIgnored(this, e))
+ return
-, fixNameField: function(data, options) {
- if (typeof options === "boolean") options = {strict: options}
- else if (typeof options === "undefined") options = {}
- var strict = options.strict
- if (!data.name && !strict) {
- data.name = ""
- return
- }
- if (typeof data.name !== "string") {
- throw new Error("name field must be a string.")
- }
- if (!strict)
- data.name = data.name.trim()
- ensureValidName(data.name, strict, options.allowLegacyCase)
- if (isBuiltinModule(data.name))
- this.warn("conflictingName", data.name)
+ if (this.paused) {
+ this._emitQueue.push([index, e])
+ return
}
+ var abs = isAbsolute(e) ? e : this._makeAbs(e)
-, fixDescriptionField: function (data) {
- if (data.description && typeof data.description !== 'string') {
- this.warn("nonStringDescription")
- delete data.description
- }
- if (data.readme && !data.description)
- data.description = extractDescription(data.readme)
- if(data.description === undefined) delete data.description;
- if (!data.description) this.warn("missingDescription")
- }
+ if (this.mark)
+ e = this._mark(e)
-, fixReadmeField: function (data) {
- if (!data.readme) {
- this.warn("missingReadme")
- data.readme = "ERROR: No README data found!"
- }
- }
+ if (this.absolute)
+ e = abs
-, fixBugsField: function(data) {
- if (!data.bugs && data.repository && data.repository.url) {
- var hosted = hostedGitInfo.fromUrl(data.repository.url)
- if(hosted && hosted.bugs()) {
- data.bugs = {url: hosted.bugs()}
- }
- }
- else if(data.bugs) {
- var emailRe = /^.+@.*\..+$/
- if(typeof data.bugs == "string") {
- if(emailRe.test(data.bugs))
- data.bugs = {email:data.bugs}
- else if(url.parse(data.bugs).protocol)
- data.bugs = {url: data.bugs}
- else
- this.warn("nonEmailUrlBugsString")
- }
- else {
- bugsTypos(data.bugs, this.warn)
- var oldBugs = data.bugs
- data.bugs = {}
- if(oldBugs.url) {
- if(typeof(oldBugs.url) == "string" && url.parse(oldBugs.url).protocol)
- data.bugs.url = oldBugs.url
- else
- this.warn("nonUrlBugsUrlField")
- }
- if(oldBugs.email) {
- if(typeof(oldBugs.email) == "string" && emailRe.test(oldBugs.email))
- data.bugs.email = oldBugs.email
- else
- this.warn("nonEmailBugsEmailField")
- }
- }
- if(!data.bugs.email && !data.bugs.url) {
- delete data.bugs
- this.warn("emptyNormalizedBugs")
- }
- }
+ if (this.matches[index][e])
+ return
+
+ if (this.nodir) {
+ var c = this.cache[abs]
+ if (c === 'DIR' || Array.isArray(c))
+ return
}
-, fixHomepageField: function(data) {
- if (!data.homepage && data.repository && data.repository.url) {
- var hosted = hostedGitInfo.fromUrl(data.repository.url)
- if (hosted && hosted.docs()) data.homepage = hosted.docs()
- }
- if (!data.homepage) return
+ this.matches[index][e] = true
- if(typeof data.homepage !== "string") {
- this.warn("nonUrlHomepage")
- return delete data.homepage
- }
- if(!url.parse(data.homepage).protocol) {
- data.homepage = "http://" + data.homepage
- }
- }
+ var st = this.statCache[abs]
+ if (st)
+ this.emit('stat', e, st)
-, fixLicenseField: function(data) {
- if (!data.license) {
- return this.warn("missingLicense")
- } else{
- if (
- typeof(data.license) !== 'string' ||
- data.license.length < 1 ||
- data.license.trim() === ''
- ) {
- this.warn("invalidLicense")
- } else {
- if (!validateLicense(data.license).validForNewPackages)
- this.warn("invalidLicense")
- }
- }
- }
+ this.emit('match', e)
}
-function isValidScopedPackageName(spec) {
- if (spec.charAt(0) !== '@') return false
+Glob.prototype._readdirInGlobStar = function (abs, cb) {
+ if (this.aborted)
+ return
- var rest = spec.slice(1).split('/')
- if (rest.length !== 2) return false
+ // follow all symlinked directories forever
+ // just proceed as if this is a non-globstar situation
+ if (this.follow)
+ return this._readdir(abs, false, cb)
- return rest[0] && rest[1] &&
- rest[0] === encodeURIComponent(rest[0]) &&
- rest[1] === encodeURIComponent(rest[1])
-}
+ var lstatkey = 'lstat\0' + abs
+ var self = this
+ var lstatcb = inflight(lstatkey, lstatcb_)
-function isCorrectlyEncodedName(spec) {
- return !spec.match(/[\/@\s\+%:]/) &&
- spec === encodeURIComponent(spec)
-}
+ if (lstatcb)
+ fs.lstat(abs, lstatcb)
-function ensureValidName (name, strict, allowLegacyCase) {
- if (name.charAt(0) === "." ||
- !(isValidScopedPackageName(name) || isCorrectlyEncodedName(name)) ||
- (strict && (!allowLegacyCase) && name !== name.toLowerCase()) ||
- name.toLowerCase() === "node_modules" ||
- name.toLowerCase() === "favicon.ico") {
- throw new Error("Invalid name: " + JSON.stringify(name))
+ function lstatcb_ (er, lstat) {
+ if (er && er.code === 'ENOENT')
+ return cb()
+
+ var isSym = lstat && lstat.isSymbolicLink()
+ self.symlinks[abs] = isSym
+
+ // If it's not a symlink or a dir, then it's definitely a regular file.
+ // don't bother doing a readdir in that case.
+ if (!isSym && lstat && !lstat.isDirectory()) {
+ self.cache[abs] = 'FILE'
+ cb()
+ } else
+ self._readdir(abs, false, cb)
}
}
-function modifyPeople (data, fn) {
- if (data.author) data.author = fn(data.author)
- ;["maintainers", "contributors"].forEach(function (set) {
- if (!Array.isArray(data[set])) return;
- data[set] = data[set].map(fn)
- })
- return data
-}
+Glob.prototype._readdir = function (abs, inGlobStar, cb) {
+ if (this.aborted)
+ return
-function unParsePerson (person) {
- if (typeof person === "string") return person
- var name = person.name || ""
- var u = person.url || person.web
- var url = u ? (" ("+u+")") : ""
- var e = person.email || person.mail
- var email = e ? (" <"+e+">") : ""
- return name+email+url
-}
+ cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb)
+ if (!cb)
+ return
-function parsePerson (person) {
- if (typeof person !== "string") return person
- var name = person.match(/^([^\(<]+)/)
- var url = person.match(/\(([^\)]+)\)/)
- var email = person.match(/<([^>]+)>/)
- var obj = {}
- if (name && name[0].trim()) obj.name = name[0].trim()
- if (email) obj.email = email[1];
- if (url) obj.url = url[1];
- return obj
-}
+ //console.error('RD %j %j', +inGlobStar, abs)
+ if (inGlobStar && !ownProp(this.symlinks, abs))
+ return this._readdirInGlobStar(abs, cb)
-function addOptionalDepsToDeps (data, warn) {
- var o = data.optionalDependencies
- if (!o) return;
- var d = data.dependencies || {}
- Object.keys(o).forEach(function (k) {
- d[k] = o[k]
- })
- data.dependencies = d
-}
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs]
+ if (!c || c === 'FILE')
+ return cb()
-function depObjectify (deps, type, warn) {
- if (!deps) return {}
- if (typeof deps === "string") {
- deps = deps.trim().split(/[\n\r\s\t ,]+/)
+ if (Array.isArray(c))
+ return cb(null, c)
}
- if (!Array.isArray(deps)) return deps
- warn("deprecatedArrayDependencies", type)
- var o = {}
- deps.filter(function (d) {
- return typeof d === "string"
- }).forEach(function(d) {
- d = d.trim().split(/(:?[@\s><=])/)
- var dn = d.shift()
- var dv = d.join("")
- dv = dv.trim()
- dv = dv.replace(/^@/, "")
- o[dn] = dv
- })
- return o
-}
-function objectifyDeps (data, warn) {
- depTypes.forEach(function (type) {
- if (!data[type]) return;
- data[type] = depObjectify(data[type], type, warn)
- })
+ var self = this
+ fs.readdir(abs, readdirCb(this, abs, cb))
}
-function bugsTypos(bugs, warn) {
- if (!bugs) return
- Object.keys(bugs).forEach(function (k) {
- if (typos.bugs[k]) {
- warn("typo", k, typos.bugs[k], "bugs")
- bugs[typos.bugs[k]] = bugs[k]
- delete bugs[k]
- }
- })
+function readdirCb (self, abs, cb) {
+ return function (er, entries) {
+ if (er)
+ self._readdirError(abs, er, cb)
+ else
+ self._readdirEntries(abs, entries, cb)
+ }
}
+Glob.prototype._readdirEntries = function (abs, entries, cb) {
+ if (this.aborted)
+ return
-/***/ }),
-/* 523 */
-/***/ (function(module, exports) {
-
-exports = module.exports = SemVer
-
-var debug
-/* istanbul ignore next */
-if (typeof process === 'object' &&
- process.env &&
- process.env.NODE_DEBUG &&
- /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
- debug = function () {
- var args = Array.prototype.slice.call(arguments, 0)
- args.unshift('SEMVER')
- console.log.apply(console, args)
+ // if we haven't asked to stat everything, then just
+ // assume that everything in there exists, so we can avoid
+ // having to stat it a second time.
+ if (!this.mark && !this.stat) {
+ for (var i = 0; i < entries.length; i ++) {
+ var e = entries[i]
+ if (abs === '/')
+ e = abs + e
+ else
+ e = abs + '/' + e
+ this.cache[e] = true
+ }
}
-} else {
- debug = function () {}
-}
-// Note: this is the semver.org version of the spec that it implements
-// Not necessarily the package version of this code.
-exports.SEMVER_SPEC_VERSION = '2.0.0'
+ this.cache[abs] = entries
+ return cb(null, entries)
+}
-var MAX_LENGTH = 256
-var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
- /* istanbul ignore next */ 9007199254740991
+Glob.prototype._readdirError = function (f, er, cb) {
+ if (this.aborted)
+ return
-// Max safe segment length for coercion.
-var MAX_SAFE_COMPONENT_LENGTH = 16
+ // handle errors, and cache the information
+ switch (er.code) {
+ case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
+ case 'ENOTDIR': // totally normal. means it *does* exist.
+ var abs = this._makeAbs(f)
+ this.cache[abs] = 'FILE'
+ if (abs === this.cwdAbs) {
+ var error = new Error(er.code + ' invalid cwd ' + this.cwd)
+ error.path = this.cwd
+ error.code = er.code
+ this.emit('error', error)
+ this.abort()
+ }
+ break
-// The actual regexps go on exports.re
-var re = exports.re = []
-var src = exports.src = []
-var R = 0
+ case 'ENOENT': // not terribly unusual
+ case 'ELOOP':
+ case 'ENAMETOOLONG':
+ case 'UNKNOWN':
+ this.cache[this._makeAbs(f)] = false
+ break
-// The following Regular Expressions can be used for tokenizing,
-// validating, and parsing SemVer version strings.
+ default: // some unusual error. Treat as failure.
+ this.cache[this._makeAbs(f)] = false
+ if (this.strict) {
+ this.emit('error', er)
+ // If the error is handled, then we abort
+ // if not, we threw out of here
+ this.abort()
+ }
+ if (!this.silent)
+ console.error('glob error', er)
+ break
+ }
-// ## Numeric Identifier
-// A single `0`, or a non-zero digit followed by zero or more digits.
+ return cb()
+}
-var NUMERICIDENTIFIER = R++
-src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'
-var NUMERICIDENTIFIERLOOSE = R++
-src[NUMERICIDENTIFIERLOOSE] = '[0-9]+'
+Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar, cb) {
+ var self = this
+ this._readdir(abs, inGlobStar, function (er, entries) {
+ self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb)
+ })
+}
-// ## Non-numeric Identifier
-// Zero or more digits, followed by a letter or hyphen, and then zero or
-// more letters, digits, or hyphens.
-var NONNUMERICIDENTIFIER = R++
-src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
+Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+ //console.error('pgs2', prefix, remain[0], entries)
-// ## Main Version
-// Three dot-separated numeric identifiers.
+ // no entries means not a dir, so it can never have matches
+ // foo.txt/** doesn't match foo.txt
+ if (!entries)
+ return cb()
-var MAINVERSION = R++
-src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
- '(' + src[NUMERICIDENTIFIER] + ')\\.' +
- '(' + src[NUMERICIDENTIFIER] + ')'
+ // test without the globstar, and with every child both below
+ // and replacing the globstar.
+ var remainWithoutGlobStar = remain.slice(1)
+ var gspref = prefix ? [ prefix ] : []
+ var noGlobStar = gspref.concat(remainWithoutGlobStar)
-var MAINVERSIONLOOSE = R++
-src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
- '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
- '(' + src[NUMERICIDENTIFIERLOOSE] + ')'
+ // the noGlobStar pattern exits the inGlobStar state
+ this._process(noGlobStar, index, false, cb)
-// ## Pre-release Version Identifier
-// A numeric identifier, or a non-numeric identifier.
+ var isSym = this.symlinks[abs]
+ var len = entries.length
-var PRERELEASEIDENTIFIER = R++
-src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
- '|' + src[NONNUMERICIDENTIFIER] + ')'
+ // If it's a symlink, and we're in a globstar, then stop
+ if (isSym && inGlobStar)
+ return cb()
-var PRERELEASEIDENTIFIERLOOSE = R++
-src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
- '|' + src[NONNUMERICIDENTIFIER] + ')'
+ for (var i = 0; i < len; i++) {
+ var e = entries[i]
+ if (e.charAt(0) === '.' && !this.dot)
+ continue
-// ## Pre-release Version
-// Hyphen, followed by one or more dot-separated pre-release version
-// identifiers.
+ // these two cases enter the inGlobStar state
+ var instead = gspref.concat(entries[i], remainWithoutGlobStar)
+ this._process(instead, index, true, cb)
-var PRERELEASE = R++
-src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
- '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'
+ var below = gspref.concat(entries[i], remain)
+ this._process(below, index, true, cb)
+ }
-var PRERELEASELOOSE = R++
-src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
- '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'
+ cb()
+}
-// ## Build Metadata Identifier
-// Any combination of digits, letters, or hyphens.
+Glob.prototype._processSimple = function (prefix, index, cb) {
+ // XXX review this. Shouldn't it be doing the mounting etc
+ // before doing stat? kinda weird?
+ var self = this
+ this._stat(prefix, function (er, exists) {
+ self._processSimple2(prefix, index, er, exists, cb)
+ })
+}
+Glob.prototype._processSimple2 = function (prefix, index, er, exists, cb) {
-var BUILDIDENTIFIER = R++
-src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
+ //console.error('ps2', prefix, exists)
-// ## Build Metadata
-// Plus sign, followed by one or more period-separated build metadata
-// identifiers.
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null)
-var BUILD = R++
-src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
- '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'
+ // If it doesn't exist, then just mark the lack of results
+ if (!exists)
+ return cb()
-// ## Full Version String
-// A main version, followed optionally by a pre-release version and
-// build metadata.
+ if (prefix && isAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix)
+ if (prefix.charAt(0) === '/') {
+ prefix = path.join(this.root, prefix)
+ } else {
+ prefix = path.resolve(this.root, prefix)
+ if (trail)
+ prefix += '/'
+ }
+ }
-// Note that the only major, minor, patch, and pre-release sections of
-// the version string are capturing groups. The build metadata is not a
-// capturing group, because it should not ever be used in version
-// comparison.
+ if (process.platform === 'win32')
+ prefix = prefix.replace(/\\/g, '/')
-var FULL = R++
-var FULLPLAIN = 'v?' + src[MAINVERSION] +
- src[PRERELEASE] + '?' +
- src[BUILD] + '?'
+ // Mark this as a match
+ this._emitMatch(index, prefix)
+ cb()
+}
-src[FULL] = '^' + FULLPLAIN + '$'
+// Returns either 'DIR', 'FILE', or false
+Glob.prototype._stat = function (f, cb) {
+ var abs = this._makeAbs(f)
+ var needDir = f.slice(-1) === '/'
-// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
-// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
-// common in the npm registry.
-var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
- src[PRERELEASELOOSE] + '?' +
- src[BUILD] + '?'
+ if (f.length > this.maxLength)
+ return cb()
-var LOOSE = R++
-src[LOOSE] = '^' + LOOSEPLAIN + '$'
+ if (!this.stat && ownProp(this.cache, abs)) {
+ var c = this.cache[abs]
-var GTLT = R++
-src[GTLT] = '((?:<|>)?=?)'
+ if (Array.isArray(c))
+ c = 'DIR'
-// Something like "2.*" or "1.2.x".
-// Note that "x.x" is a valid xRange identifer, meaning "any version"
-// Only the first item is strictly required.
-var XRANGEIDENTIFIERLOOSE = R++
-src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
-var XRANGEIDENTIFIER = R++
-src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'
+ // It exists, but maybe not how we need it
+ if (!needDir || c === 'DIR')
+ return cb(null, c)
-var XRANGEPLAIN = R++
-src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
- '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
- '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
- '(?:' + src[PRERELEASE] + ')?' +
- src[BUILD] + '?' +
- ')?)?'
+ if (needDir && c === 'FILE')
+ return cb()
-var XRANGEPLAINLOOSE = R++
-src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
- '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
- '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
- '(?:' + src[PRERELEASELOOSE] + ')?' +
- src[BUILD] + '?' +
- ')?)?'
+ // otherwise we have to stat, because maybe c=true
+ // if we know it exists, but not what it is.
+ }
-var XRANGE = R++
-src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'
-var XRANGELOOSE = R++
-src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'
+ var exists
+ var stat = this.statCache[abs]
+ if (stat !== undefined) {
+ if (stat === false)
+ return cb(null, stat)
+ else {
+ var type = stat.isDirectory() ? 'DIR' : 'FILE'
+ if (needDir && type === 'FILE')
+ return cb()
+ else
+ return cb(null, type, stat)
+ }
+ }
-// Coercion.
-// Extract anything that could conceivably be a part of a valid semver
-var COERCE = R++
-src[COERCE] = '(?:^|[^\\d])' +
- '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
- '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
- '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
- '(?:$|[^\\d])'
+ var self = this
+ var statcb = inflight('stat\0' + abs, lstatcb_)
+ if (statcb)
+ fs.lstat(abs, statcb)
-// Tilde ranges.
-// Meaning is "reasonably at or greater than"
-var LONETILDE = R++
-src[LONETILDE] = '(?:~>?)'
+ function lstatcb_ (er, lstat) {
+ if (lstat && lstat.isSymbolicLink()) {
+ // If it's a symlink, then treat it as the target, unless
+ // the target does not exist, then treat it as a file.
+ return fs.stat(abs, function (er, stat) {
+ if (er)
+ self._stat2(f, abs, null, lstat, cb)
+ else
+ self._stat2(f, abs, er, stat, cb)
+ })
+ } else {
+ self._stat2(f, abs, er, lstat, cb)
+ }
+ }
+}
-var TILDETRIM = R++
-src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'
-re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g')
-var tildeTrimReplace = '$1~'
+Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
+ if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
+ this.statCache[abs] = false
+ return cb()
+ }
-var TILDE = R++
-src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'
-var TILDELOOSE = R++
-src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'
+ var needDir = f.slice(-1) === '/'
+ this.statCache[abs] = stat
-// Caret ranges.
-// Meaning is "at least and backwards compatible with"
-var LONECARET = R++
-src[LONECARET] = '(?:\\^)'
+ if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
+ return cb(null, false, stat)
-var CARETTRIM = R++
-src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'
-re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g')
-var caretTrimReplace = '$1^'
+ var c = true
+ if (stat)
+ c = stat.isDirectory() ? 'DIR' : 'FILE'
+ this.cache[abs] = this.cache[abs] || c
-var CARET = R++
-src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'
-var CARETLOOSE = R++
-src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'
+ if (needDir && c === 'FILE')
+ return cb()
-// A simple gt/lt/eq thing, or just "" to indicate "any version"
-var COMPARATORLOOSE = R++
-src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'
-var COMPARATOR = R++
-src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'
+ return cb(null, c, stat)
+}
-// An expression to strip any whitespace between the gtlt and the thing
-// it modifies, so that `> 1.2.3` ==> `>1.2.3`
-var COMPARATORTRIM = R++
-src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
- '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'
-// this one has to use the /g flag
-re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g')
-var comparatorTrimReplace = '$1$2$3'
+/***/ }),
+/* 504 */
+/***/ (function(module, exports, __webpack_require__) {
-// Something like `1.2.3 - 1.2.4`
-// Note that these all use the loose form, because they'll be
-// checked against either the strict or loose comparator form
-// later.
-var HYPHENRANGE = R++
-src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
- '\\s+-\\s+' +
- '(' + src[XRANGEPLAIN] + ')' +
- '\\s*$'
+module.exports = realpath
+realpath.realpath = realpath
+realpath.sync = realpathSync
+realpath.realpathSync = realpathSync
+realpath.monkeypatch = monkeypatch
+realpath.unmonkeypatch = unmonkeypatch
-var HYPHENRANGELOOSE = R++
-src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
- '\\s+-\\s+' +
- '(' + src[XRANGEPLAINLOOSE] + ')' +
- '\\s*$'
+var fs = __webpack_require__(349)
+var origRealpath = fs.realpath
+var origRealpathSync = fs.realpathSync
-// Star ranges basically just allow anything at all.
-var STAR = R++
-src[STAR] = '(<|>)?=?\\s*\\*'
+var version = process.version
+var ok = /^v[0-5]\./.test(version)
+var old = __webpack_require__(505)
-// Compile to actual regexp objects.
-// All are flag-free, unless they were created above with a flag.
-for (var i = 0; i < R; i++) {
- debug(i, src[i])
- if (!re[i]) {
- re[i] = new RegExp(src[i])
- }
+function newError (er) {
+ return er && er.syscall === 'realpath' && (
+ er.code === 'ELOOP' ||
+ er.code === 'ENOMEM' ||
+ er.code === 'ENAMETOOLONG'
+ )
}
-exports.parse = parse
-function parse (version, options) {
- if (!options || typeof options !== 'object') {
- options = {
- loose: !!options,
- includePrerelease: false
- }
- }
-
- if (version instanceof SemVer) {
- return version
- }
-
- if (typeof version !== 'string') {
- return null
+function realpath (p, cache, cb) {
+ if (ok) {
+ return origRealpath(p, cache, cb)
}
- if (version.length > MAX_LENGTH) {
- return null
+ if (typeof cache === 'function') {
+ cb = cache
+ cache = null
}
+ origRealpath(p, cache, function (er, result) {
+ if (newError(er)) {
+ old.realpath(p, cache, cb)
+ } else {
+ cb(er, result)
+ }
+ })
+}
- var r = options.loose ? re[LOOSE] : re[FULL]
- if (!r.test(version)) {
- return null
+function realpathSync (p, cache) {
+ if (ok) {
+ return origRealpathSync(p, cache)
}
try {
- return new SemVer(version, options)
+ return origRealpathSync(p, cache)
} catch (er) {
- return null
+ if (newError(er)) {
+ return old.realpathSync(p, cache)
+ } else {
+ throw er
+ }
}
}
-exports.valid = valid
-function valid (version, options) {
- var v = parse(version, options)
- return v ? v.version : null
+function monkeypatch () {
+ fs.realpath = realpath
+ fs.realpathSync = realpathSync
}
-exports.clean = clean
-function clean (version, options) {
- var s = parse(version.trim().replace(/^[=v]+/, ''), options)
- return s ? s.version : null
+function unmonkeypatch () {
+ fs.realpath = origRealpath
+ fs.realpathSync = origRealpathSync
}
-exports.SemVer = SemVer
-
-function SemVer (version, options) {
- if (!options || typeof options !== 'object') {
- options = {
- loose: !!options,
- includePrerelease: false
- }
- }
- if (version instanceof SemVer) {
- if (version.loose === options.loose) {
- return version
- } else {
- version = version.version
- }
- } else if (typeof version !== 'string') {
- throw new TypeError('Invalid Version: ' + version)
- }
-
- if (version.length > MAX_LENGTH) {
- throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
- }
-
- if (!(this instanceof SemVer)) {
- return new SemVer(version, options)
- }
- debug('SemVer', version, options)
- this.options = options
- this.loose = !!options.loose
+/***/ }),
+/* 505 */
+/***/ (function(module, exports, __webpack_require__) {
- var m = version.trim().match(options.loose ? re[LOOSE] : re[FULL])
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
- if (!m) {
- throw new TypeError('Invalid Version: ' + version)
- }
+var pathModule = __webpack_require__(4);
+var isWindows = process.platform === 'win32';
+var fs = __webpack_require__(349);
- this.raw = version
+// JavaScript implementation of realpath, ported from node pre-v6
- // these are actually numbers
- this.major = +m[1]
- this.minor = +m[2]
- this.patch = +m[3]
+var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
- if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
- throw new TypeError('Invalid major version')
- }
+function rethrow() {
+ // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
+ // is fairly slow to generate.
+ var callback;
+ if (DEBUG) {
+ var backtrace = new Error;
+ callback = debugCallback;
+ } else
+ callback = missingCallback;
- if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
- throw new TypeError('Invalid minor version')
- }
+ return callback;
- if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
- throw new TypeError('Invalid patch version')
+ function debugCallback(err) {
+ if (err) {
+ backtrace.message = err.message;
+ err = backtrace;
+ missingCallback(err);
+ }
}
- // numberify any prerelease numeric ids
- if (!m[4]) {
- this.prerelease = []
- } else {
- this.prerelease = m[4].split('.').map(function (id) {
- if (/^[0-9]+$/.test(id)) {
- var num = +id
- if (num >= 0 && num < MAX_SAFE_INTEGER) {
- return num
- }
+ function missingCallback(err) {
+ if (err) {
+ if (process.throwDeprecation)
+ throw err; // Forgot a callback but don't know where? Use NODE_DEBUG=fs
+ else if (!process.noDeprecation) {
+ var msg = 'fs: missing callback ' + (err.stack || err.message);
+ if (process.traceDeprecation)
+ console.trace(msg);
+ else
+ console.error(msg);
}
- return id
- })
+ }
}
+}
- this.build = m[5] ? m[5].split('.') : []
- this.format()
+function maybeCallback(cb) {
+ return typeof cb === 'function' ? cb : rethrow();
}
-SemVer.prototype.format = function () {
- this.version = this.major + '.' + this.minor + '.' + this.patch
- if (this.prerelease.length) {
- this.version += '-' + this.prerelease.join('.')
- }
- return this.version
+var normalize = pathModule.normalize;
+
+// Regexp that finds the next partion of a (partial) path
+// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
+if (isWindows) {
+ var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+} else {
+ var nextPartRe = /(.*?)(?:[\/]+|$)/g;
}
-SemVer.prototype.toString = function () {
- return this.version
+// Regex to find the device root, including trailing slash. E.g. 'c:\\'.
+if (isWindows) {
+ var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+} else {
+ var splitRootRe = /^[\/]*/;
}
-SemVer.prototype.compare = function (other) {
- debug('SemVer.compare', this.version, this.options, other)
- if (!(other instanceof SemVer)) {
- other = new SemVer(other, this.options)
+exports.realpathSync = function realpathSync(p, cache) {
+ // make p is absolute
+ p = pathModule.resolve(p);
+
+ if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+ return cache[p];
}
- return this.compareMain(other) || this.comparePre(other)
-}
+ var original = p,
+ seenLinks = {},
+ knownHard = {};
-SemVer.prototype.compareMain = function (other) {
- if (!(other instanceof SemVer)) {
- other = new SemVer(other, this.options)
- }
+ // current character position in p
+ var pos;
+ // the partial path so far, including a trailing slash if any
+ var current;
+ // the partial path without a trailing slash (except when pointing at a root)
+ var base;
+ // the partial path scanned in the previous round, with slash
+ var previous;
- return compareIdentifiers(this.major, other.major) ||
- compareIdentifiers(this.minor, other.minor) ||
- compareIdentifiers(this.patch, other.patch)
-}
+ start();
-SemVer.prototype.comparePre = function (other) {
- if (!(other instanceof SemVer)) {
- other = new SemVer(other, this.options)
- }
+ function start() {
+ // Skip over roots
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = '';
- // NOT having a prerelease is > having one
- if (this.prerelease.length && !other.prerelease.length) {
- return -1
- } else if (!this.prerelease.length && other.prerelease.length) {
- return 1
- } else if (!this.prerelease.length && !other.prerelease.length) {
- return 0
+ // On windows, check that the root exists. On unix there is no need.
+ if (isWindows && !knownHard[base]) {
+ fs.lstatSync(base);
+ knownHard[base] = true;
+ }
}
- var i = 0
- do {
- var a = this.prerelease[i]
- var b = other.prerelease[i]
- debug('prerelease compare', i, a, b)
- if (a === undefined && b === undefined) {
- return 0
- } else if (b === undefined) {
- return 1
- } else if (a === undefined) {
- return -1
- } else if (a === b) {
- continue
- } else {
- return compareIdentifiers(a, b)
+ // walk down the path, swapping out linked pathparts for their real
+ // values
+ // NB: p.length changes.
+ while (pos < p.length) {
+ // find the next part
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+
+ // continue if not a symlink
+ if (knownHard[base] || (cache && cache[base] === base)) {
+ continue;
}
- } while (++i)
-}
-// preminor will bump the version up to the next minor release, and immediately
-// down to pre-release. premajor and prepatch work the same way.
-SemVer.prototype.inc = function (release, identifier) {
- switch (release) {
- case 'premajor':
- this.prerelease.length = 0
- this.patch = 0
- this.minor = 0
- this.major++
- this.inc('pre', identifier)
- break
- case 'preminor':
- this.prerelease.length = 0
- this.patch = 0
- this.minor++
- this.inc('pre', identifier)
- break
- case 'prepatch':
- // If this is already a prerelease, it will bump to the next version
- // drop any prereleases that might already exist, since they are not
- // relevant at this point.
- this.prerelease.length = 0
- this.inc('patch', identifier)
- this.inc('pre', identifier)
- break
- // If the input is a non-prerelease version, this acts the same as
- // prepatch.
- case 'prerelease':
- if (this.prerelease.length === 0) {
- this.inc('patch', identifier)
+ var resolvedLink;
+ if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+ // some known symbolic link. no need to stat again.
+ resolvedLink = cache[base];
+ } else {
+ var stat = fs.lstatSync(base);
+ if (!stat.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache) cache[base] = base;
+ continue;
}
- this.inc('pre', identifier)
- break
- case 'major':
- // If this is a pre-major version, bump up to the same major version.
- // Otherwise increment major.
- // 1.0.0-5 bumps to 1.0.0
- // 1.1.0 bumps to 2.0.0
- if (this.minor !== 0 ||
- this.patch !== 0 ||
- this.prerelease.length === 0) {
- this.major++
- }
- this.minor = 0
- this.patch = 0
- this.prerelease = []
- break
- case 'minor':
- // If this is a pre-minor version, bump up to the same minor version.
- // Otherwise increment minor.
- // 1.2.0-5 bumps to 1.2.0
- // 1.2.1 bumps to 1.3.0
- if (this.patch !== 0 || this.prerelease.length === 0) {
- this.minor++
- }
- this.patch = 0
- this.prerelease = []
- break
- case 'patch':
- // If this is not a pre-release version, it will increment the patch.
- // If it is a pre-release it will bump up to the same patch version.
- // 1.2.0-5 patches to 1.2.0
- // 1.2.0 patches to 1.2.1
- if (this.prerelease.length === 0) {
- this.patch++
- }
- this.prerelease = []
- break
- // This probably shouldn't be used publicly.
- // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
- case 'pre':
- if (this.prerelease.length === 0) {
- this.prerelease = [0]
- } else {
- var i = this.prerelease.length
- while (--i >= 0) {
- if (typeof this.prerelease[i] === 'number') {
- this.prerelease[i]++
- i = -2
- }
- }
- if (i === -1) {
- // didn't increment anything
- this.prerelease.push(0)
+ // read the link if it wasn't read before
+ // dev/ino always return 0 on windows, so skip the check.
+ var linkTarget = null;
+ if (!isWindows) {
+ var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ linkTarget = seenLinks[id];
}
}
- if (identifier) {
- // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
- // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
- if (this.prerelease[0] === identifier) {
- if (isNaN(this.prerelease[1])) {
- this.prerelease = [identifier, 0]
- }
- } else {
- this.prerelease = [identifier, 0]
- }
+ if (linkTarget === null) {
+ fs.statSync(base);
+ linkTarget = fs.readlinkSync(base);
}
- break
+ resolvedLink = pathModule.resolve(previous, linkTarget);
+ // track this, if given a cache.
+ if (cache) cache[base] = resolvedLink;
+ if (!isWindows) seenLinks[id] = linkTarget;
+ }
- default:
- throw new Error('invalid increment argument: ' + release)
+ // resolve the link, then start over
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
+ start();
}
- this.format()
- this.raw = this.version
- return this
-}
-exports.inc = inc
-function inc (version, release, loose, identifier) {
- if (typeof (loose) === 'string') {
- identifier = loose
- loose = undefined
- }
+ if (cache) cache[original] = p;
- try {
- return new SemVer(version, loose).inc(release, identifier).version
- } catch (er) {
- return null
- }
-}
+ return p;
+};
-exports.diff = diff
-function diff (version1, version2) {
- if (eq(version1, version2)) {
- return null
- } else {
- var v1 = parse(version1)
- var v2 = parse(version2)
- var prefix = ''
- if (v1.prerelease.length || v2.prerelease.length) {
- prefix = 'pre'
- var defaultResult = 'prerelease'
- }
- for (var key in v1) {
- if (key === 'major' || key === 'minor' || key === 'patch') {
- if (v1[key] !== v2[key]) {
- return prefix + key
- }
- }
- }
- return defaultResult // may be undefined
- }
-}
-exports.compareIdentifiers = compareIdentifiers
+exports.realpath = function realpath(p, cache, cb) {
+ if (typeof cb !== 'function') {
+ cb = maybeCallback(cache);
+ cache = null;
+ }
-var numeric = /^[0-9]+$/
-function compareIdentifiers (a, b) {
- var anum = numeric.test(a)
- var bnum = numeric.test(b)
+ // make p is absolute
+ p = pathModule.resolve(p);
- if (anum && bnum) {
- a = +a
- b = +b
+ if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+ return process.nextTick(cb.bind(null, null, cache[p]));
}
- return a === b ? 0
- : (anum && !bnum) ? -1
- : (bnum && !anum) ? 1
- : a < b ? -1
- : 1
-}
+ var original = p,
+ seenLinks = {},
+ knownHard = {};
-exports.rcompareIdentifiers = rcompareIdentifiers
-function rcompareIdentifiers (a, b) {
- return compareIdentifiers(b, a)
-}
+ // current character position in p
+ var pos;
+ // the partial path so far, including a trailing slash if any
+ var current;
+ // the partial path without a trailing slash (except when pointing at a root)
+ var base;
+ // the partial path scanned in the previous round, with slash
+ var previous;
-exports.major = major
-function major (a, loose) {
- return new SemVer(a, loose).major
-}
+ start();
-exports.minor = minor
-function minor (a, loose) {
- return new SemVer(a, loose).minor
-}
+ function start() {
+ // Skip over roots
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = '';
-exports.patch = patch
-function patch (a, loose) {
- return new SemVer(a, loose).patch
-}
+ // On windows, check that the root exists. On unix there is no need.
+ if (isWindows && !knownHard[base]) {
+ fs.lstat(base, function(err) {
+ if (err) return cb(err);
+ knownHard[base] = true;
+ LOOP();
+ });
+ } else {
+ process.nextTick(LOOP);
+ }
+ }
-exports.compare = compare
-function compare (a, b, loose) {
- return new SemVer(a, loose).compare(new SemVer(b, loose))
-}
+ // walk down the path, swapping out linked pathparts for their real
+ // values
+ function LOOP() {
+ // stop if scanned past end of path
+ if (pos >= p.length) {
+ if (cache) cache[original] = p;
+ return cb(null, p);
+ }
-exports.compareLoose = compareLoose
-function compareLoose (a, b) {
- return compare(a, b, true)
-}
+ // find the next part
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
-exports.rcompare = rcompare
-function rcompare (a, b, loose) {
- return compare(b, a, loose)
-}
+ // continue if not a symlink
+ if (knownHard[base] || (cache && cache[base] === base)) {
+ return process.nextTick(LOOP);
+ }
-exports.sort = sort
-function sort (list, loose) {
- return list.sort(function (a, b) {
- return exports.compare(a, b, loose)
- })
-}
-
-exports.rsort = rsort
-function rsort (list, loose) {
- return list.sort(function (a, b) {
- return exports.rcompare(a, b, loose)
- })
-}
-
-exports.gt = gt
-function gt (a, b, loose) {
- return compare(a, b, loose) > 0
-}
+ if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+ // known symbolic link. no need to stat again.
+ return gotResolvedLink(cache[base]);
+ }
-exports.lt = lt
-function lt (a, b, loose) {
- return compare(a, b, loose) < 0
-}
+ return fs.lstat(base, gotStat);
+ }
-exports.eq = eq
-function eq (a, b, loose) {
- return compare(a, b, loose) === 0
-}
+ function gotStat(err, stat) {
+ if (err) return cb(err);
-exports.neq = neq
-function neq (a, b, loose) {
- return compare(a, b, loose) !== 0
-}
+ // if not a symlink, skip to the next path part
+ if (!stat.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache) cache[base] = base;
+ return process.nextTick(LOOP);
+ }
-exports.gte = gte
-function gte (a, b, loose) {
- return compare(a, b, loose) >= 0
-}
+ // stat & read the link if not read before
+ // call gotTarget as soon as the link target is known
+ // dev/ino always return 0 on windows, so skip the check.
+ if (!isWindows) {
+ var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ return gotTarget(null, seenLinks[id], base);
+ }
+ }
+ fs.stat(base, function(err) {
+ if (err) return cb(err);
-exports.lte = lte
-function lte (a, b, loose) {
- return compare(a, b, loose) <= 0
-}
+ fs.readlink(base, function(err, target) {
+ if (!isWindows) seenLinks[id] = target;
+ gotTarget(err, target);
+ });
+ });
+ }
-exports.cmp = cmp
-function cmp (a, op, b, loose) {
- switch (op) {
- case '===':
- if (typeof a === 'object')
- a = a.version
- if (typeof b === 'object')
- b = b.version
- return a === b
+ function gotTarget(err, target, base) {
+ if (err) return cb(err);
- case '!==':
- if (typeof a === 'object')
- a = a.version
- if (typeof b === 'object')
- b = b.version
- return a !== b
+ var resolvedLink = pathModule.resolve(previous, target);
+ if (cache) cache[base] = resolvedLink;
+ gotResolvedLink(resolvedLink);
+ }
- case '':
- case '=':
- case '==':
- return eq(a, b, loose)
+ function gotResolvedLink(resolvedLink) {
+ // resolve the link, then start over
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+};
- case '!=':
- return neq(a, b, loose)
- case '>':
- return gt(a, b, loose)
+/***/ }),
+/* 506 */
+/***/ (function(module, exports, __webpack_require__) {
- case '>=':
- return gte(a, b, loose)
+module.exports = minimatch
+minimatch.Minimatch = Minimatch
- case '<':
- return lt(a, b, loose)
+var path = { sep: '/' }
+try {
+ path = __webpack_require__(4)
+} catch (er) {}
- case '<=':
- return lte(a, b, loose)
+var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
+var expand = __webpack_require__(507)
- default:
- throw new TypeError('Invalid operator: ' + op)
- }
+var plTypes = {
+ '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
+ '?': { open: '(?:', close: ')?' },
+ '+': { open: '(?:', close: ')+' },
+ '*': { open: '(?:', close: ')*' },
+ '@': { open: '(?:', close: ')' }
}
-exports.Comparator = Comparator
-function Comparator (comp, options) {
- if (!options || typeof options !== 'object') {
- options = {
- loose: !!options,
- includePrerelease: false
- }
- }
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+var qmark = '[^/]'
- if (comp instanceof Comparator) {
- if (comp.loose === !!options.loose) {
- return comp
- } else {
- comp = comp.value
- }
- }
+// * => any number of characters
+var star = qmark + '*?'
- if (!(this instanceof Comparator)) {
- return new Comparator(comp, options)
- }
+// ** when dots are allowed. Anything goes, except .. and .
+// not (^ or / followed by one or two dots followed by $ or /),
+// followed by anything, any number of times.
+var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'
- debug('comparator', comp, options)
- this.options = options
- this.loose = !!options.loose
- this.parse(comp)
+// not a ^ or / followed by a dot,
+// followed by anything, any number of times.
+var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'
- if (this.semver === ANY) {
- this.value = ''
- } else {
- this.value = this.operator + this.semver.version
- }
+// characters that need to be escaped in RegExp.
+var reSpecials = charSet('().*{}+?[]^$\\!')
- debug('comp', this)
+// "abc" -> { a:true, b:true, c:true }
+function charSet (s) {
+ return s.split('').reduce(function (set, c) {
+ set[c] = true
+ return set
+ }, {})
}
-var ANY = {}
-Comparator.prototype.parse = function (comp) {
- var r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
- var m = comp.match(r)
-
- if (!m) {
- throw new TypeError('Invalid comparator: ' + comp)
- }
-
- this.operator = m[1]
- if (this.operator === '=') {
- this.operator = ''
- }
+// normalizes slashes.
+var slashSplit = /\/+/
- // if it literally is just '>' or '' then allow anything.
- if (!m[2]) {
- this.semver = ANY
- } else {
- this.semver = new SemVer(m[2], this.options.loose)
+minimatch.filter = filter
+function filter (pattern, options) {
+ options = options || {}
+ return function (p, i, list) {
+ return minimatch(p, pattern, options)
}
}
-Comparator.prototype.toString = function () {
- return this.value
+function ext (a, b) {
+ a = a || {}
+ b = b || {}
+ var t = {}
+ Object.keys(b).forEach(function (k) {
+ t[k] = b[k]
+ })
+ Object.keys(a).forEach(function (k) {
+ t[k] = a[k]
+ })
+ return t
}
-Comparator.prototype.test = function (version) {
- debug('Comparator.test', version, this.options.loose)
+minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return minimatch
- if (this.semver === ANY) {
- return true
+ var orig = minimatch
+
+ var m = function minimatch (p, pattern, options) {
+ return orig.minimatch(p, pattern, ext(def, options))
}
- if (typeof version === 'string') {
- version = new SemVer(version, this.options)
+ m.Minimatch = function Minimatch (pattern, options) {
+ return new orig.Minimatch(pattern, ext(def, options))
}
- return cmp(version, this.operator, this.semver, this.options)
+ return m
}
-Comparator.prototype.intersects = function (comp, options) {
- if (!(comp instanceof Comparator)) {
- throw new TypeError('a Comparator is required')
- }
+Minimatch.defaults = function (def) {
+ if (!def || !Object.keys(def).length) return Minimatch
+ return minimatch.defaults(def).Minimatch
+}
- if (!options || typeof options !== 'object') {
- options = {
- loose: !!options,
- includePrerelease: false
- }
+function minimatch (p, pattern, options) {
+ if (typeof pattern !== 'string') {
+ throw new TypeError('glob pattern string required')
}
- var rangeTmp
+ if (!options) options = {}
- if (this.operator === '') {
- rangeTmp = new Range(comp.value, options)
- return satisfies(this.value, rangeTmp, options)
- } else if (comp.operator === '') {
- rangeTmp = new Range(this.value, options)
- return satisfies(comp.semver, rangeTmp, options)
+ // shortcut: comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === '#') {
+ return false
}
- var sameDirectionIncreasing =
- (this.operator === '>=' || this.operator === '>') &&
- (comp.operator === '>=' || comp.operator === '>')
- var sameDirectionDecreasing =
- (this.operator === '<=' || this.operator === '<') &&
- (comp.operator === '<=' || comp.operator === '<')
- var sameSemVer = this.semver.version === comp.semver.version
- var differentDirectionsInclusive =
- (this.operator === '>=' || this.operator === '<=') &&
- (comp.operator === '>=' || comp.operator === '<=')
- var oppositeDirectionsLessThan =
- cmp(this.semver, '<', comp.semver, options) &&
- ((this.operator === '>=' || this.operator === '>') &&
- (comp.operator === '<=' || comp.operator === '<'))
- var oppositeDirectionsGreaterThan =
- cmp(this.semver, '>', comp.semver, options) &&
- ((this.operator === '<=' || this.operator === '<') &&
- (comp.operator === '>=' || comp.operator === '>'))
+ // "" only matches ""
+ if (pattern.trim() === '') return p === ''
- return sameDirectionIncreasing || sameDirectionDecreasing ||
- (sameSemVer && differentDirectionsInclusive) ||
- oppositeDirectionsLessThan || oppositeDirectionsGreaterThan
+ return new Minimatch(pattern, options).match(p)
}
-exports.Range = Range
-function Range (range, options) {
- if (!options || typeof options !== 'object') {
- options = {
- loose: !!options,
- includePrerelease: false
- }
+function Minimatch (pattern, options) {
+ if (!(this instanceof Minimatch)) {
+ return new Minimatch(pattern, options)
}
- if (range instanceof Range) {
- if (range.loose === !!options.loose &&
- range.includePrerelease === !!options.includePrerelease) {
- return range
- } else {
- return new Range(range.raw, options)
- }
+ if (typeof pattern !== 'string') {
+ throw new TypeError('glob pattern string required')
}
- if (range instanceof Comparator) {
- return new Range(range.value, options)
- }
+ if (!options) options = {}
+ pattern = pattern.trim()
- if (!(this instanceof Range)) {
- return new Range(range, options)
+ // windows support: need to use /, not \
+ if (path.sep !== '/') {
+ pattern = pattern.split(path.sep).join('/')
}
this.options = options
- this.loose = !!options.loose
- this.includePrerelease = !!options.includePrerelease
-
- // First, split based on boolean or ||
- this.raw = range
- this.set = range.split(/\s*\|\|\s*/).map(function (range) {
- return this.parseRange(range.trim())
- }, this).filter(function (c) {
- // throw out any that are not relevant for whatever reason
- return c.length
- })
-
- if (!this.set.length) {
- throw new TypeError('Invalid SemVer Range: ' + range)
- }
+ this.set = []
+ this.pattern = pattern
+ this.regexp = null
+ this.negate = false
+ this.comment = false
+ this.empty = false
- this.format()
+ // make the set of regexps etc.
+ this.make()
}
-Range.prototype.format = function () {
- this.range = this.set.map(function (comps) {
- return comps.join(' ').trim()
- }).join('||').trim()
- return this.range
-}
+Minimatch.prototype.debug = function () {}
-Range.prototype.toString = function () {
- return this.range
-}
+Minimatch.prototype.make = make
+function make () {
+ // don't do it more than once.
+ if (this._made) return
-Range.prototype.parseRange = function (range) {
- var loose = this.options.loose
- range = range.trim()
- // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
- var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE]
- range = range.replace(hr, hyphenReplace)
- debug('hyphen replace', range)
- // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
- range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace)
- debug('comparator trim', range, re[COMPARATORTRIM])
+ var pattern = this.pattern
+ var options = this.options
- // `~ 1.2.3` => `~1.2.3`
- range = range.replace(re[TILDETRIM], tildeTrimReplace)
+ // empty patterns and comments match nothing.
+ if (!options.nocomment && pattern.charAt(0) === '#') {
+ this.comment = true
+ return
+ }
+ if (!pattern) {
+ this.empty = true
+ return
+ }
- // `^ 1.2.3` => `^1.2.3`
- range = range.replace(re[CARETTRIM], caretTrimReplace)
+ // step 1: figure out negation, etc.
+ this.parseNegate()
- // normalize spaces
- range = range.split(/\s+/).join(' ')
+ // step 2: expand braces
+ var set = this.globSet = this.braceExpand()
- // At this point, the range is completely trimmed and
- // ready to be split into comparators.
+ if (options.debug) this.debug = console.error
- var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
- var set = range.split(' ').map(function (comp) {
- return parseComparator(comp, this.options)
- }, this).join(' ').split(/\s+/)
- if (this.options.loose) {
- // in loose mode, throw out any that are not valid comparators
- set = set.filter(function (comp) {
- return !!comp.match(compRe)
- })
- }
- set = set.map(function (comp) {
- return new Comparator(comp, this.options)
- }, this)
+ this.debug(this.pattern, set)
- return set
-}
+ // step 3: now we have a set, so turn each one into a series of path-portion
+ // matching patterns.
+ // These will be regexps, except in the case of "**", which is
+ // set to the GLOBSTAR object for globstar behavior,
+ // and will not contain any / characters
+ set = this.globParts = set.map(function (s) {
+ return s.split(slashSplit)
+ })
-Range.prototype.intersects = function (range, options) {
- if (!(range instanceof Range)) {
- throw new TypeError('a Range is required')
- }
+ this.debug(this.pattern, set)
- return this.set.some(function (thisComparators) {
- return thisComparators.every(function (thisComparator) {
- return range.set.some(function (rangeComparators) {
- return rangeComparators.every(function (rangeComparator) {
- return thisComparator.intersects(rangeComparator, options)
- })
- })
- })
- })
-}
+ // glob --> regexps
+ set = set.map(function (s, si, set) {
+ return s.map(this.parse, this)
+ }, this)
-// Mostly just for testing and legacy API reasons
-exports.toComparators = toComparators
-function toComparators (range, options) {
- return new Range(range, options).set.map(function (comp) {
- return comp.map(function (c) {
- return c.value
- }).join(' ').trim().split(' ')
+ this.debug(this.pattern, set)
+
+ // filter out everything that didn't compile properly.
+ set = set.filter(function (s) {
+ return s.indexOf(false) === -1
})
-}
-// comprised of xranges, tildes, stars, and gtlt's at this point.
-// already replaced the hyphen ranges
-// turn into a set of JUST comparators.
-function parseComparator (comp, options) {
- debug('comp', comp, options)
- comp = replaceCarets(comp, options)
- debug('caret', comp)
- comp = replaceTildes(comp, options)
- debug('tildes', comp)
- comp = replaceXRanges(comp, options)
- debug('xrange', comp)
- comp = replaceStars(comp, options)
- debug('stars', comp)
- return comp
-}
+ this.debug(this.pattern, set)
-function isX (id) {
- return !id || id.toLowerCase() === 'x' || id === '*'
+ this.set = set
}
-// ~, ~> --> * (any, kinda silly)
-// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
-// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
-// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
-// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
-// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
-function replaceTildes (comp, options) {
- return comp.trim().split(/\s+/).map(function (comp) {
- return replaceTilde(comp, options)
- }).join(' ')
-}
+Minimatch.prototype.parseNegate = parseNegate
+function parseNegate () {
+ var pattern = this.pattern
+ var negate = false
+ var options = this.options
+ var negateOffset = 0
-function replaceTilde (comp, options) {
- var r = options.loose ? re[TILDELOOSE] : re[TILDE]
- return comp.replace(r, function (_, M, m, p, pr) {
- debug('tilde', comp, _, M, m, p, pr)
- var ret
+ if (options.nonegate) return
- if (isX(M)) {
- ret = ''
- } else if (isX(m)) {
- ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
- } else if (isX(p)) {
- // ~1.2 == >=1.2.0 <1.3.0
- ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
- } else if (pr) {
- debug('replaceTilde pr', pr)
- ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
- ' <' + M + '.' + (+m + 1) + '.0'
- } else {
- // ~1.2.3 == >=1.2.3 <1.3.0
- ret = '>=' + M + '.' + m + '.' + p +
- ' <' + M + '.' + (+m + 1) + '.0'
- }
+ for (var i = 0, l = pattern.length
+ ; i < l && pattern.charAt(i) === '!'
+ ; i++) {
+ negate = !negate
+ negateOffset++
+ }
- debug('tilde return', ret)
- return ret
- })
+ if (negateOffset) this.pattern = pattern.substr(negateOffset)
+ this.negate = negate
}
-// ^ --> * (any, kinda silly)
-// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
-// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
-// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
-// ^1.2.3 --> >=1.2.3 <2.0.0
-// ^1.2.0 --> >=1.2.0 <2.0.0
-function replaceCarets (comp, options) {
- return comp.trim().split(/\s+/).map(function (comp) {
- return replaceCaret(comp, options)
- }).join(' ')
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+minimatch.braceExpand = function (pattern, options) {
+ return braceExpand(pattern, options)
}
-function replaceCaret (comp, options) {
- debug('caret', comp, options)
- var r = options.loose ? re[CARETLOOSE] : re[CARET]
- return comp.replace(r, function (_, M, m, p, pr) {
- debug('caret', comp, _, M, m, p, pr)
- var ret
+Minimatch.prototype.braceExpand = braceExpand
- if (isX(M)) {
- ret = ''
- } else if (isX(m)) {
- ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
- } else if (isX(p)) {
- if (M === '0') {
- ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
- } else {
- ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'
- }
- } else if (pr) {
- debug('replaceCaret pr', pr)
- if (M === '0') {
- if (m === '0') {
- ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
- ' <' + M + '.' + m + '.' + (+p + 1)
- } else {
- ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
- ' <' + M + '.' + (+m + 1) + '.0'
- }
- } else {
- ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
- ' <' + (+M + 1) + '.0.0'
- }
+function braceExpand (pattern, options) {
+ if (!options) {
+ if (this instanceof Minimatch) {
+ options = this.options
} else {
- debug('no pr')
- if (M === '0') {
- if (m === '0') {
- ret = '>=' + M + '.' + m + '.' + p +
- ' <' + M + '.' + m + '.' + (+p + 1)
- } else {
- ret = '>=' + M + '.' + m + '.' + p +
- ' <' + M + '.' + (+m + 1) + '.0'
- }
- } else {
- ret = '>=' + M + '.' + m + '.' + p +
- ' <' + (+M + 1) + '.0.0'
- }
- }
-
- debug('caret return', ret)
- return ret
- })
-}
-
-function replaceXRanges (comp, options) {
- debug('replaceXRanges', comp, options)
- return comp.split(/\s+/).map(function (comp) {
- return replaceXRange(comp, options)
- }).join(' ')
-}
-
-function replaceXRange (comp, options) {
- comp = comp.trim()
- var r = options.loose ? re[XRANGELOOSE] : re[XRANGE]
- return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
- debug('xRange', comp, ret, gtlt, M, m, p, pr)
- var xM = isX(M)
- var xm = xM || isX(m)
- var xp = xm || isX(p)
- var anyX = xp
-
- if (gtlt === '=' && anyX) {
- gtlt = ''
- }
-
- if (xM) {
- if (gtlt === '>' || gtlt === '<') {
- // nothing is allowed
- ret = '<0.0.0'
- } else {
- // nothing is forbidden
- ret = '*'
- }
- } else if (gtlt && anyX) {
- // we know patch is an x, because we have any x at all.
- // replace X with 0
- if (xm) {
- m = 0
- }
- p = 0
-
- if (gtlt === '>') {
- // >1 => >=2.0.0
- // >1.2 => >=1.3.0
- // >1.2.3 => >= 1.2.4
- gtlt = '>='
- if (xm) {
- M = +M + 1
- m = 0
- p = 0
- } else {
- m = +m + 1
- p = 0
- }
- } else if (gtlt === '<=') {
- // <=0.7.x is actually <0.8.0, since any 0.7.x should
- // pass. Similarly, <=7.x is actually <8.0.0, etc.
- gtlt = '<'
- if (xm) {
- M = +M + 1
- } else {
- m = +m + 1
- }
- }
-
- ret = gtlt + M + '.' + m + '.' + p
- } else if (xm) {
- ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
- } else if (xp) {
- ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+ options = {}
}
+ }
- debug('xRange return', ret)
-
- return ret
- })
-}
-
-// Because * is AND-ed with everything else in the comparator,
-// and '' means "any version", just remove the *s entirely.
-function replaceStars (comp, options) {
- debug('replaceStars', comp, options)
- // Looseness is ignored here. star is always as loose as it gets!
- return comp.trim().replace(re[STAR], '')
-}
+ pattern = typeof pattern === 'undefined'
+ ? this.pattern : pattern
-// This function is passed to string.replace(re[HYPHENRANGE])
-// M, m, patch, prerelease, build
-// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
-// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
-// 1.2 - 3.4 => >=1.2.0 <3.5.0
-function hyphenReplace ($0,
- from, fM, fm, fp, fpr, fb,
- to, tM, tm, tp, tpr, tb) {
- if (isX(fM)) {
- from = ''
- } else if (isX(fm)) {
- from = '>=' + fM + '.0.0'
- } else if (isX(fp)) {
- from = '>=' + fM + '.' + fm + '.0'
- } else {
- from = '>=' + from
+ if (typeof pattern === 'undefined') {
+ throw new TypeError('undefined pattern')
}
- if (isX(tM)) {
- to = ''
- } else if (isX(tm)) {
- to = '<' + (+tM + 1) + '.0.0'
- } else if (isX(tp)) {
- to = '<' + tM + '.' + (+tm + 1) + '.0'
- } else if (tpr) {
- to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr
- } else {
- to = '<=' + to
+ if (options.nobrace ||
+ !pattern.match(/\{.*\}/)) {
+ // shortcut. no need to expand.
+ return [pattern]
}
- return (from + ' ' + to).trim()
+ return expand(pattern)
}
-// if ANY of the sets match ALL of its comparators, then pass
-Range.prototype.test = function (version) {
- if (!version) {
- return false
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion. Otherwise, any series
+// of * is equivalent to a single *. Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+Minimatch.prototype.parse = parse
+var SUBPARSE = {}
+function parse (pattern, isSub) {
+ if (pattern.length > 1024 * 64) {
+ throw new TypeError('pattern is too long')
}
- if (typeof version === 'string') {
- version = new SemVer(version, this.options)
- }
+ var options = this.options
- for (var i = 0; i < this.set.length; i++) {
- if (testSet(this.set[i], version, this.options)) {
- return true
- }
- }
- return false
-}
+ // shortcuts
+ if (!options.noglobstar && pattern === '**') return GLOBSTAR
+ if (pattern === '') return ''
-function testSet (set, version, options) {
- for (var i = 0; i < set.length; i++) {
- if (!set[i].test(version)) {
- return false
+ var re = ''
+ var hasMagic = !!options.nocase
+ var escaping = false
+ // ? => one single character
+ var patternListStack = []
+ var negativeLists = []
+ var stateChar
+ var inClass = false
+ var reClassStart = -1
+ var classStart = -1
+ // . and .. never match anything that doesn't start with .,
+ // even when options.dot is set.
+ var patternStart = pattern.charAt(0) === '.' ? '' // anything
+ // not (start or / followed by . or .. followed by / or end)
+ : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
+ : '(?!\\.)'
+ var self = this
+
+ function clearStateChar () {
+ if (stateChar) {
+ // we had some state-tracking character
+ // that wasn't consumed by this pass.
+ switch (stateChar) {
+ case '*':
+ re += star
+ hasMagic = true
+ break
+ case '?':
+ re += qmark
+ hasMagic = true
+ break
+ default:
+ re += '\\' + stateChar
+ break
+ }
+ self.debug('clearStateChar %j %j', stateChar, re)
+ stateChar = false
}
}
- if (version.prerelease.length && !options.includePrerelease) {
- // Find the set of versions that are allowed to have prereleases
- // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
- // That should allow `1.2.3-pr.2` to pass.
- // However, `1.2.4-alpha.notready` should NOT be allowed,
- // even though it's within the range set by the comparators.
- for (i = 0; i < set.length; i++) {
- debug(set[i].semver)
- if (set[i].semver === ANY) {
- continue
- }
+ for (var i = 0, len = pattern.length, c
+ ; (i < len) && (c = pattern.charAt(i))
+ ; i++) {
+ this.debug('%s\t%s %s %j', pattern, i, re, c)
- if (set[i].semver.prerelease.length > 0) {
- var allowed = set[i].semver
- if (allowed.major === version.major &&
- allowed.minor === version.minor &&
- allowed.patch === version.patch) {
- return true
- }
- }
+ // skip over any that are escaped.
+ if (escaping && reSpecials[c]) {
+ re += '\\' + c
+ escaping = false
+ continue
}
- // Version has a -pre, but it's not one of the ones we like.
- return false
- }
+ switch (c) {
+ case '/':
+ // completely not allowed, even escaped.
+ // Should already be path-split by now.
+ return false
- return true
-}
+ case '\\':
+ clearStateChar()
+ escaping = true
+ continue
-exports.satisfies = satisfies
-function satisfies (version, range, options) {
- try {
- range = new Range(range, options)
- } catch (er) {
- return false
- }
- return range.test(version)
-}
+ // the various stateChar values
+ // for the "extglob" stuff.
+ case '?':
+ case '*':
+ case '+':
+ case '@':
+ case '!':
+ this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
-exports.maxSatisfying = maxSatisfying
-function maxSatisfying (versions, range, options) {
- var max = null
- var maxSV = null
- try {
- var rangeObj = new Range(range, options)
- } catch (er) {
- return null
- }
- versions.forEach(function (v) {
- if (rangeObj.test(v)) {
- // satisfies(v, range, options)
- if (!max || maxSV.compare(v) === -1) {
- // compare(max, v, true)
- max = v
- maxSV = new SemVer(max, options)
- }
- }
- })
- return max
-}
+ // all of those are literals inside a class, except that
+ // the glob [!a] means [^a] in regexp
+ if (inClass) {
+ this.debug(' in class')
+ if (c === '!' && i === classStart + 1) c = '^'
+ re += c
+ continue
+ }
-exports.minSatisfying = minSatisfying
-function minSatisfying (versions, range, options) {
- var min = null
- var minSV = null
- try {
- var rangeObj = new Range(range, options)
- } catch (er) {
- return null
- }
- versions.forEach(function (v) {
- if (rangeObj.test(v)) {
- // satisfies(v, range, options)
- if (!min || minSV.compare(v) === 1) {
- // compare(min, v, true)
- min = v
- minSV = new SemVer(min, options)
- }
- }
- })
- return min
-}
+ // if we already have a stateChar, then it means
+ // that there was something like ** or +? in there.
+ // Handle the stateChar, then proceed with this one.
+ self.debug('call clearStateChar %j', stateChar)
+ clearStateChar()
+ stateChar = c
+ // if extglob is disabled, then +(asdf|foo) isn't a thing.
+ // just clear the statechar *now*, rather than even diving into
+ // the patternList stuff.
+ if (options.noext) clearStateChar()
+ continue
-exports.minVersion = minVersion
-function minVersion (range, loose) {
- range = new Range(range, loose)
+ case '(':
+ if (inClass) {
+ re += '('
+ continue
+ }
- var minver = new SemVer('0.0.0')
- if (range.test(minver)) {
- return minver
- }
+ if (!stateChar) {
+ re += '\\('
+ continue
+ }
- minver = new SemVer('0.0.0-0')
- if (range.test(minver)) {
- return minver
- }
+ patternListStack.push({
+ type: stateChar,
+ start: i - 1,
+ reStart: re.length,
+ open: plTypes[stateChar].open,
+ close: plTypes[stateChar].close
+ })
+ // negation is (?:(?!js)[^/]*)
+ re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
+ this.debug('plType %j %j', stateChar, re)
+ stateChar = false
+ continue
- minver = null
- for (var i = 0; i < range.set.length; ++i) {
- var comparators = range.set[i]
+ case ')':
+ if (inClass || !patternListStack.length) {
+ re += '\\)'
+ continue
+ }
- comparators.forEach(function (comparator) {
- // Clone to avoid manipulating the comparator's semver object.
- var compver = new SemVer(comparator.semver.version)
- switch (comparator.operator) {
- case '>':
- if (compver.prerelease.length === 0) {
- compver.patch++
- } else {
- compver.prerelease.push(0)
- }
- compver.raw = compver.format()
- /* fallthrough */
- case '':
- case '>=':
- if (!minver || gt(minver, compver)) {
- minver = compver
- }
- break
- case '<':
- case '<=':
- /* Ignore maximum versions */
- break
- /* istanbul ignore next */
- default:
- throw new Error('Unexpected operation: ' + comparator.operator)
- }
- })
- }
+ clearStateChar()
+ hasMagic = true
+ var pl = patternListStack.pop()
+ // negation is (?:(?!js)[^/]*)
+ // The others are (?:)
+ re += pl.close
+ if (pl.type === '!') {
+ negativeLists.push(pl)
+ }
+ pl.reEnd = re.length
+ continue
- if (minver && range.test(minver)) {
- return minver
- }
+ case '|':
+ if (inClass || !patternListStack.length || escaping) {
+ re += '\\|'
+ escaping = false
+ continue
+ }
- return null
-}
+ clearStateChar()
+ re += '|'
+ continue
-exports.validRange = validRange
-function validRange (range, options) {
- try {
- // Return '*' instead of '' so that truthiness works.
- // This will throw if it's invalid anyway
- return new Range(range, options).range || '*'
- } catch (er) {
- return null
- }
-}
+ // these are mostly the same in regexp and glob
+ case '[':
+ // swallow any state-tracking char before the [
+ clearStateChar()
-// Determine if version is less than all the versions possible in the range
-exports.ltr = ltr
-function ltr (version, range, options) {
- return outside(version, range, '<', options)
-}
+ if (inClass) {
+ re += '\\' + c
+ continue
+ }
-// Determine if version is greater than all the versions possible in the range.
-exports.gtr = gtr
-function gtr (version, range, options) {
- return outside(version, range, '>', options)
-}
+ inClass = true
+ classStart = i
+ reClassStart = re.length
+ re += c
+ continue
-exports.outside = outside
-function outside (version, range, hilo, options) {
- version = new SemVer(version, options)
- range = new Range(range, options)
+ case ']':
+ // a right bracket shall lose its special
+ // meaning and represent itself in
+ // a bracket expression if it occurs
+ // first in the list. -- POSIX.2 2.8.3.2
+ if (i === classStart + 1 || !inClass) {
+ re += '\\' + c
+ escaping = false
+ continue
+ }
- var gtfn, ltefn, ltfn, comp, ecomp
- switch (hilo) {
- case '>':
- gtfn = gt
- ltefn = lte
- ltfn = lt
- comp = '>'
- ecomp = '>='
- break
- case '<':
- gtfn = lt
- ltefn = gte
- ltfn = gt
- comp = '<'
- ecomp = '<='
- break
- default:
- throw new TypeError('Must provide a hilo val of "<" or ">"')
- }
+ // handle the case where we left a class open.
+ // "[z-a]" is valid, equivalent to "\[z-a\]"
+ if (inClass) {
+ // split where the last [ was, make sure we don't have
+ // an invalid re. if so, re-walk the contents of the
+ // would-be class to re-translate any characters that
+ // were passed through as-is
+ // TODO: It would probably be faster to determine this
+ // without a try/catch and a new RegExp, but it's tricky
+ // to do safely. For now, this is safe and works.
+ var cs = pattern.substring(classStart + 1, i)
+ try {
+ RegExp('[' + cs + ']')
+ } catch (er) {
+ // not a valid class!
+ var sp = this.parse(cs, SUBPARSE)
+ re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
+ hasMagic = hasMagic || sp[1]
+ inClass = false
+ continue
+ }
+ }
- // If it satisifes the range it is not outside
- if (satisfies(version, range, options)) {
- return false
- }
+ // finish up the class.
+ hasMagic = true
+ inClass = false
+ re += c
+ continue
- // From now on, variable terms are as if we're in "gtr" mode.
- // but note that everything is flipped for the "ltr" function.
+ default:
+ // swallow any state char that wasn't consumed
+ clearStateChar()
- for (var i = 0; i < range.set.length; ++i) {
- var comparators = range.set[i]
+ if (escaping) {
+ // no need
+ escaping = false
+ } else if (reSpecials[c]
+ && !(c === '^' && inClass)) {
+ re += '\\'
+ }
- var high = null
- var low = null
+ re += c
- comparators.forEach(function (comparator) {
- if (comparator.semver === ANY) {
- comparator = new Comparator('>=0.0.0')
- }
- high = high || comparator
- low = low || comparator
- if (gtfn(comparator.semver, high.semver, options)) {
- high = comparator
- } else if (ltfn(comparator.semver, low.semver, options)) {
- low = comparator
+ } // switch
+ } // for
+
+ // handle the case where we left a class open.
+ // "[abc" is valid, equivalent to "\[abc"
+ if (inClass) {
+ // split where the last [ was, and escape it
+ // this is a huge pita. We now have to re-walk
+ // the contents of the would-be class to re-translate
+ // any characters that were passed through as-is
+ cs = pattern.substr(classStart + 1)
+ sp = this.parse(cs, SUBPARSE)
+ re = re.substr(0, reClassStart) + '\\[' + sp[0]
+ hasMagic = hasMagic || sp[1]
+ }
+
+ // handle the case where we had a +( thing at the *end*
+ // of the pattern.
+ // each pattern list stack adds 3 chars, and we need to go through
+ // and escape any | chars that were passed through as-is for the regexp.
+ // Go through and escape them, taking care not to double-escape any
+ // | chars that were already escaped.
+ for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+ var tail = re.slice(pl.reStart + pl.open.length)
+ this.debug('setting tail', re, pl)
+ // maybe some even number of \, then maybe 1 \, followed by a |
+ tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
+ if (!$2) {
+ // the | isn't already escaped, so escape it.
+ $2 = '\\'
}
+
+ // need to escape all those slashes *again*, without escaping the
+ // one that we need for escaping the | character. As it works out,
+ // escaping an even number of slashes can be done by simply repeating
+ // it exactly after itself. That's why this trick works.
+ //
+ // I am sorry that you have to see this.
+ return $1 + $1 + $2 + '|'
})
- // If the edge version comparator has a operator then our version
- // isn't outside it
- if (high.operator === comp || high.operator === ecomp) {
- return false
- }
+ this.debug('tail=%j\n %s', tail, tail, pl, re)
+ var t = pl.type === '*' ? star
+ : pl.type === '?' ? qmark
+ : '\\' + pl.type
- // If the lowest version comparator has an operator and our version
- // is less than it then it isn't higher than the range
- if ((!low.operator || low.operator === comp) &&
- ltefn(version, low.semver)) {
- return false
- } else if (low.operator === ecomp && ltfn(version, low.semver)) {
- return false
- }
+ hasMagic = true
+ re = re.slice(0, pl.reStart) + t + '\\(' + tail
}
- return true
-}
-
-exports.prerelease = prerelease
-function prerelease (version, options) {
- var parsed = parse(version, options)
- return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
-}
-exports.intersects = intersects
-function intersects (r1, r2, options) {
- r1 = new Range(r1, options)
- r2 = new Range(r2, options)
- return r1.intersects(r2)
-}
-
-exports.coerce = coerce
-function coerce (version) {
- if (version instanceof SemVer) {
- return version
+ // handle trailing things that only matter at the very end.
+ clearStateChar()
+ if (escaping) {
+ // trailing \\
+ re += '\\\\'
}
- if (typeof version !== 'string') {
- return null
+ // only need to apply the nodot start if the re starts with
+ // something that could conceivably capture a dot
+ var addPatternStart = false
+ switch (re.charAt(0)) {
+ case '.':
+ case '[':
+ case '(': addPatternStart = true
}
- var match = version.match(re[COERCE])
+ // Hack to work around lack of negative lookbehind in JS
+ // A pattern like: *.!(x).!(y|z) needs to ensure that a name
+ // like 'a.xyz.yz' doesn't match. So, the first negative
+ // lookahead, has to look ALL the way ahead, to the end of
+ // the pattern.
+ for (var n = negativeLists.length - 1; n > -1; n--) {
+ var nl = negativeLists[n]
- if (match == null) {
- return null
+ var nlBefore = re.slice(0, nl.reStart)
+ var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
+ var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
+ var nlAfter = re.slice(nl.reEnd)
+
+ nlLast += nlAfter
+
+ // Handle nested stuff like *(*.js|!(*.json)), where open parens
+ // mean that we should *not* include the ) in the bit that is considered
+ // "after" the negated section.
+ var openParensBefore = nlBefore.split('(').length - 1
+ var cleanAfter = nlAfter
+ for (i = 0; i < openParensBefore; i++) {
+ cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
+ }
+ nlAfter = cleanAfter
+
+ var dollar = ''
+ if (nlAfter === '' && isSub !== SUBPARSE) {
+ dollar = '$'
+ }
+ var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
+ re = newRe
}
- return parse(match[1] +
- '.' + (match[2] || '0') +
- '.' + (match[3] || '0'))
-}
+ // if the re is not "" at this point, then we need to make sure
+ // it doesn't match against an empty path part.
+ // Otherwise a/* will match a/, which it should not.
+ if (re !== '' && hasMagic) {
+ re = '(?=.)' + re
+ }
+ if (addPatternStart) {
+ re = patternStart + re
+ }
-/***/ }),
-/* 524 */
-/***/ (function(module, exports, __webpack_require__) {
+ // parsing just a piece of a larger pattern.
+ if (isSub === SUBPARSE) {
+ return [re, hasMagic]
+ }
-var parse = __webpack_require__(525);
-var correct = __webpack_require__(527);
+ // skip the regexp for non-magical patterns
+ // unescape anything in it, though, so that it'll be
+ // an exact match against a file etc.
+ if (!hasMagic) {
+ return globUnescape(pattern)
+ }
-var genericWarning = (
- 'license should be ' +
- 'a valid SPDX license expression (without "LicenseRef"), ' +
- '"UNLICENSED", or ' +
- '"SEE LICENSE IN "'
-);
+ var flags = options.nocase ? 'i' : ''
+ try {
+ var regExp = new RegExp('^' + re + '$', flags)
+ } catch (er) {
+ // If it was an invalid regular expression, then it can't match
+ // anything. This trick looks for a character after the end of
+ // the string, which is of course impossible, except in multi-line
+ // mode, but it's not a /m regex.
+ return new RegExp('$.')
+ }
-var fileReferenceRE = /^SEE LICEN[CS]E IN (.+)$/;
+ regExp._glob = pattern
+ regExp._src = re
-function startsWith(prefix, string) {
- return string.slice(0, prefix.length) === prefix;
+ return regExp
}
-function usesLicenseRef(ast) {
- if (ast.hasOwnProperty('license')) {
- var license = ast.license;
- return (
- startsWith('LicenseRef', license) ||
- startsWith('DocumentRef', license)
- );
- } else {
- return (
- usesLicenseRef(ast.left) ||
- usesLicenseRef(ast.right)
- );
- }
+minimatch.makeRe = function (pattern, options) {
+ return new Minimatch(pattern, options || {}).makeRe()
}
-module.exports = function(argument) {
- var ast;
+Minimatch.prototype.makeRe = makeRe
+function makeRe () {
+ if (this.regexp || this.regexp === false) return this.regexp
- try {
- ast = parse(argument);
- } catch (e) {
- var match
- if (
- argument === 'UNLICENSED' ||
- argument === 'UNLICENCED'
- ) {
- return {
- validForOldPackages: true,
- validForNewPackages: true,
- unlicensed: true
- };
- } else if (match = fileReferenceRE.exec(argument)) {
- return {
- validForOldPackages: true,
- validForNewPackages: true,
- inFile: match[1]
- };
- } else {
- var result = {
- validForOldPackages: false,
- validForNewPackages: false,
- warnings: [genericWarning]
- };
- var corrected = correct(argument);
- if (corrected) {
- result.warnings.push(
- 'license is similar to the valid expression "' + corrected + '"'
- );
- }
- return result;
- }
- }
+ // at this point, this.set is a 2d array of partial
+ // pattern strings, or "**".
+ //
+ // It's better to use .match(). This function shouldn't
+ // be used, really, but it's pretty convenient sometimes,
+ // when you just want to work with a regex.
+ var set = this.set
- if (usesLicenseRef(ast)) {
- return {
- validForNewPackages: false,
- validForOldPackages: false,
- spdx: true,
- warnings: [genericWarning]
- };
- } else {
- return {
- validForNewPackages: true,
- validForOldPackages: true,
- spdx: true
- };
+ if (!set.length) {
+ this.regexp = false
+ return this.regexp
}
-};
+ var options = this.options
+ var twoStar = options.noglobstar ? star
+ : options.dot ? twoStarDot
+ : twoStarNoDot
+ var flags = options.nocase ? 'i' : ''
-/***/ }),
-/* 525 */
-/***/ (function(module, exports, __webpack_require__) {
+ var re = set.map(function (pattern) {
+ return pattern.map(function (p) {
+ return (p === GLOBSTAR) ? twoStar
+ : (typeof p === 'string') ? regExpEscape(p)
+ : p._src
+ }).join('\\\/')
+ }).join('|')
-var parser = __webpack_require__(526).parser
+ // must match entire pattern
+ // ending in a * or ** will make it less strict.
+ re = '^(?:' + re + ')$'
-module.exports = function (argument) {
- return parser.parse(argument)
+ // can match anything, as long as it's not this.
+ if (this.negate) re = '^(?!' + re + ').*$'
+
+ try {
+ this.regexp = new RegExp(re, flags)
+ } catch (ex) {
+ this.regexp = false
+ }
+ return this.regexp
}
+minimatch.match = function (list, pattern, options) {
+ options = options || {}
+ var mm = new Minimatch(pattern, options)
+ list = list.filter(function (f) {
+ return mm.match(f)
+ })
+ if (mm.options.nonull && !list.length) {
+ list.push(pattern)
+ }
+ return list
+}
-/***/ }),
-/* 526 */
-/***/ (function(module, exports, __webpack_require__) {
+Minimatch.prototype.match = match
+function match (f, partial) {
+ this.debug('match', f, this.pattern)
+ // short-circuit in the case of busted things.
+ // comments, etc.
+ if (this.comment) return false
+ if (this.empty) return f === ''
-/* WEBPACK VAR INJECTION */(function(module) {/* parser generated by jison 0.4.17 */
-/*
- Returns a Parser object of the following structure:
+ if (f === '/' && partial) return true
- Parser: {
- yy: {}
+ var options = this.options
+
+ // windows: need to use /, not \
+ if (path.sep !== '/') {
+ f = f.split(path.sep).join('/')
}
- Parser.prototype: {
- yy: {},
- trace: function(),
- symbols_: {associative list: name ==> number},
- terminals_: {associative list: number ==> name},
- productions_: [...],
- performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
- table: [...],
- defaultActions: {...},
- parseError: function(str, hash),
- parse: function(input),
+ // treat the test path as a set of pathparts.
+ f = f.split(slashSplit)
+ this.debug(this.pattern, 'split', f)
- lexer: {
- EOF: 1,
- parseError: function(str, hash),
- setInput: function(input),
- input: function(),
- unput: function(str),
- more: function(),
- less: function(n),
- pastInput: function(),
- upcomingInput: function(),
- showPosition: function(),
- test_match: function(regex_match_array, rule_index),
- next: function(),
- lex: function(),
- begin: function(condition),
- popState: function(),
- _currentRules: function(),
- topState: function(),
- pushState: function(condition),
+ // just ONE of the pattern sets in this.set needs to match
+ // in order for it to be valid. If negating, then just one
+ // match means that we have failed.
+ // Either way, return on the first hit.
- options: {
- ranges: boolean (optional: true ==> token location info will include a .range[] member)
- flex: boolean (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
- backtrack_lexer: boolean (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
- },
+ var set = this.set
+ this.debug(this.pattern, 'set', set)
- performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
- rules: [...],
- conditions: {associative list: name ==> set},
+ // Find the basename of the path by looking for the last non-empty segment
+ var filename
+ var i
+ for (i = f.length - 1; i >= 0; i--) {
+ filename = f[i]
+ if (filename) break
+ }
+
+ for (i = 0; i < set.length; i++) {
+ var pattern = set[i]
+ var file = f
+ if (options.matchBase && pattern.length === 1) {
+ file = [filename]
+ }
+ var hit = this.matchOne(file, pattern, partial)
+ if (hit) {
+ if (options.flipNegate) return true
+ return !this.negate
}
}
+ // didn't get any hits. this is success if it's a negative
+ // pattern, failure otherwise.
+ if (options.flipNegate) return false
+ return this.negate
+}
- token location info (@$, _$, etc.): {
- first_line: n,
- last_line: n,
- first_column: n,
- last_column: n,
- range: [start_number, end_number] (where the numbers are indexes into the input string, regular zero-based)
- }
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+Minimatch.prototype.matchOne = function (file, pattern, partial) {
+ var options = this.options
+ this.debug('matchOne',
+ { 'this': this, file: file, pattern: pattern })
- the parseError function receives a 'hash' object with these members for lexer and parser errors: {
- text: (matched text)
- token: (the produced terminal token, if any)
- line: (yylineno)
- }
- while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
- loc: (yylloc)
- expected: (string describing the set of expected tokens)
- recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
- }
-*/
-var spdxparse = (function(){
-var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[1,5],$V1=[1,6],$V2=[1,7],$V3=[1,4],$V4=[1,9],$V5=[1,10],$V6=[5,14,15,17],$V7=[5,12,14,15,17];
-var parser = {trace: function trace() { },
-yy: {},
-symbols_: {"error":2,"start":3,"expression":4,"EOS":5,"simpleExpression":6,"LICENSE":7,"PLUS":8,"LICENSEREF":9,"DOCUMENTREF":10,"COLON":11,"WITH":12,"EXCEPTION":13,"AND":14,"OR":15,"OPEN":16,"CLOSE":17,"$accept":0,"$end":1},
-terminals_: {2:"error",5:"EOS",7:"LICENSE",8:"PLUS",9:"LICENSEREF",10:"DOCUMENTREF",11:"COLON",12:"WITH",13:"EXCEPTION",14:"AND",15:"OR",16:"OPEN",17:"CLOSE"},
-productions_: [0,[3,2],[6,1],[6,2],[6,1],[6,3],[4,1],[4,3],[4,3],[4,3],[4,3]],
-performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
-/* this == yyval */
+ this.debug('matchOne', file.length, pattern.length)
-var $0 = $$.length - 1;
-switch (yystate) {
-case 1:
-return this.$ = $$[$0-1]
-break;
-case 2: case 4: case 5:
-this.$ = {license: yytext}
-break;
-case 3:
-this.$ = {license: $$[$0-1], plus: true}
-break;
-case 6:
-this.$ = $$[$0]
-break;
-case 7:
-this.$ = {exception: $$[$0]}
-this.$.license = $$[$0-2].license
-if ($$[$0-2].hasOwnProperty('plus')) {
- this.$.plus = $$[$0-2].plus
-}
-break;
-case 8:
-this.$ = {conjunction: 'and', left: $$[$0-2], right: $$[$0]}
-break;
-case 9:
-this.$ = {conjunction: 'or', left: $$[$0-2], right: $$[$0]}
-break;
-case 10:
-this.$ = $$[$0-1]
-break;
-}
-},
-table: [{3:1,4:2,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{1:[3]},{5:[1,8],14:$V4,15:$V5},o($V6,[2,6],{12:[1,11]}),{4:12,6:3,7:$V0,9:$V1,10:$V2,16:$V3},o($V7,[2,2],{8:[1,13]}),o($V7,[2,4]),{11:[1,14]},{1:[2,1]},{4:15,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{4:16,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{13:[1,17]},{14:$V4,15:$V5,17:[1,18]},o($V7,[2,3]),{9:[1,19]},o($V6,[2,8]),o([5,15,17],[2,9],{14:$V4}),o($V6,[2,7]),o($V6,[2,10]),o($V7,[2,5])],
-defaultActions: {8:[2,1]},
-parseError: function parseError(str, hash) {
- if (hash.recoverable) {
- this.trace(str);
- } else {
- function _parseError (msg, hash) {
- this.message = msg;
- this.hash = hash;
- }
- _parseError.prototype = Error;
+ for (var fi = 0,
+ pi = 0,
+ fl = file.length,
+ pl = pattern.length
+ ; (fi < fl) && (pi < pl)
+ ; fi++, pi++) {
+ this.debug('matchOne loop')
+ var p = pattern[pi]
+ var f = file[fi]
- throw new _parseError(str, hash);
- }
-},
-parse: function parse(input) {
- var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
- var args = lstack.slice.call(arguments, 1);
- var lexer = Object.create(this.lexer);
- var sharedState = { yy: {} };
- for (var k in this.yy) {
- if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
- sharedState.yy[k] = this.yy[k];
+ this.debug(pattern, p, f)
+
+ // should be impossible.
+ // some invalid regexp stuff in the set.
+ if (p === false) return false
+
+ if (p === GLOBSTAR) {
+ this.debug('GLOBSTAR', [pattern, p, f])
+
+ // "**"
+ // a/**/b/**/c would match the following:
+ // a/b/x/y/z/c
+ // a/x/y/z/b/c
+ // a/b/x/b/x/c
+ // a/b/c
+ // To do this, take the rest of the pattern after
+ // the **, and see if it would match the file remainder.
+ // If so, return success.
+ // If not, the ** "swallows" a segment, and try again.
+ // This is recursively awful.
+ //
+ // a/**/b/**/c matching a/b/x/y/z/c
+ // - a matches a
+ // - doublestar
+ // - matchOne(b/x/y/z/c, b/**/c)
+ // - b matches b
+ // - doublestar
+ // - matchOne(x/y/z/c, c) -> no
+ // - matchOne(y/z/c, c) -> no
+ // - matchOne(z/c, c) -> no
+ // - matchOne(c, c) yes, hit
+ var fr = fi
+ var pr = pi + 1
+ if (pr === pl) {
+ this.debug('** at the end')
+ // a ** at the end will just swallow the rest.
+ // We have found a match.
+ // however, it will not swallow /.x, unless
+ // options.dot is set.
+ // . and .. are *never* matched by **, for explosively
+ // exponential reasons.
+ for (; fi < fl; fi++) {
+ if (file[fi] === '.' || file[fi] === '..' ||
+ (!options.dot && file[fi].charAt(0) === '.')) return false
}
- }
- lexer.setInput(input, sharedState.yy);
- sharedState.yy.lexer = lexer;
- sharedState.yy.parser = this;
- if (typeof lexer.yylloc == 'undefined') {
- lexer.yylloc = {};
- }
- var yyloc = lexer.yylloc;
- lstack.push(yyloc);
- var ranges = lexer.options && lexer.options.ranges;
- if (typeof sharedState.yy.parseError === 'function') {
- this.parseError = sharedState.yy.parseError;
- } else {
- this.parseError = Object.getPrototypeOf(this).parseError;
- }
- function popStack(n) {
- stack.length = stack.length - 2 * n;
- vstack.length = vstack.length - n;
- lstack.length = lstack.length - n;
- }
- _token_stack:
- var lex = function () {
- var token;
- token = lexer.lex() || EOF;
- if (typeof token !== 'number') {
- token = self.symbols_[token] || token;
- }
- return token;
- };
- var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
- while (true) {
- state = stack[stack.length - 1];
- if (this.defaultActions[state]) {
- action = this.defaultActions[state];
+ return true
+ }
+
+ // ok, let's see if we can swallow whatever we can.
+ while (fr < fl) {
+ var swallowee = file[fr]
+
+ this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
+
+ // XXX remove this slice. Just pass the start index.
+ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+ this.debug('globstar found match!', fr, fl, swallowee)
+ // found a match.
+ return true
} else {
- if (symbol === null || typeof symbol == 'undefined') {
- symbol = lex();
- }
- action = table[state] && table[state][symbol];
- }
- if (typeof action === 'undefined' || !action.length || !action[0]) {
- var errStr = '';
- expected = [];
- for (p in table[state]) {
- if (this.terminals_[p] && p > TERROR) {
- expected.push('\'' + this.terminals_[p] + '\'');
- }
- }
- if (lexer.showPosition) {
- errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
- } else {
- errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
- }
- this.parseError(errStr, {
- text: lexer.match,
- token: this.terminals_[symbol] || symbol,
- line: lexer.yylineno,
- loc: yyloc,
- expected: expected
- });
- }
- if (action[0] instanceof Array && action.length > 1) {
- throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
- }
- switch (action[0]) {
- case 1:
- stack.push(symbol);
- vstack.push(lexer.yytext);
- lstack.push(lexer.yylloc);
- stack.push(action[1]);
- symbol = null;
- if (!preErrorSymbol) {
- yyleng = lexer.yyleng;
- yytext = lexer.yytext;
- yylineno = lexer.yylineno;
- yyloc = lexer.yylloc;
- if (recovering > 0) {
- recovering--;
- }
- } else {
- symbol = preErrorSymbol;
- preErrorSymbol = null;
- }
- break;
- case 2:
- len = this.productions_[action[1]][1];
- yyval.$ = vstack[vstack.length - len];
- yyval._$ = {
- first_line: lstack[lstack.length - (len || 1)].first_line,
- last_line: lstack[lstack.length - 1].last_line,
- first_column: lstack[lstack.length - (len || 1)].first_column,
- last_column: lstack[lstack.length - 1].last_column
- };
- if (ranges) {
- yyval._$.range = [
- lstack[lstack.length - (len || 1)].range[0],
- lstack[lstack.length - 1].range[1]
- ];
- }
- r = this.performAction.apply(yyval, [
- yytext,
- yyleng,
- yylineno,
- sharedState.yy,
- action[1],
- vstack,
- lstack
- ].concat(args));
- if (typeof r !== 'undefined') {
- return r;
- }
- if (len) {
- stack = stack.slice(0, -1 * len * 2);
- vstack = vstack.slice(0, -1 * len);
- lstack = lstack.slice(0, -1 * len);
- }
- stack.push(this.productions_[action[1]][0]);
- vstack.push(yyval.$);
- lstack.push(yyval._$);
- newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
- stack.push(newState);
- break;
- case 3:
- return true;
+ // can't swallow "." or ".." ever.
+ // can only swallow ".foo" when explicitly asked.
+ if (swallowee === '.' || swallowee === '..' ||
+ (!options.dot && swallowee.charAt(0) === '.')) {
+ this.debug('dot detected!', file, fr, pattern, pr)
+ break
+ }
+
+ // ** swallows a segment, and continue.
+ this.debug('globstar swallow a segment, and continue')
+ fr++
}
+ }
+
+ // no match was found.
+ // However, in partial mode, we can't say this is necessarily over.
+ // If there's more *pattern* left, then
+ if (partial) {
+ // ran out of file
+ this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
+ if (fr === fl) return true
+ }
+ return false
}
- return true;
-}};
-/* generated by jison-lex 0.3.4 */
-var lexer = (function(){
-var lexer = ({
-EOF:1,
+ // something other than **
+ // non-magic patterns just have to match exactly
+ // patterns with magic have been turned into regexps.
+ var hit
+ if (typeof p === 'string') {
+ if (options.nocase) {
+ hit = f.toLowerCase() === p.toLowerCase()
+ } else {
+ hit = f === p
+ }
+ this.debug('string match', p, f, hit)
+ } else {
+ hit = f.match(p)
+ this.debug('pattern match', p, f, hit)
+ }
-parseError:function parseError(str, hash) {
- if (this.yy.parser) {
- this.yy.parser.parseError(str, hash);
- } else {
- throw new Error(str);
- }
- },
+ if (!hit) return false
+ }
-// resets the lexer, sets new input
-setInput:function (input, yy) {
- this.yy = yy || this.yy || {};
- this._input = input;
- this._more = this._backtrack = this.done = false;
- this.yylineno = this.yyleng = 0;
- this.yytext = this.matched = this.match = '';
- this.conditionStack = ['INITIAL'];
- this.yylloc = {
- first_line: 1,
- first_column: 0,
- last_line: 1,
- last_column: 0
- };
- if (this.options.ranges) {
- this.yylloc.range = [0,0];
- }
- this.offset = 0;
- return this;
- },
+ // Note: ending in / means that we'll get a final ""
+ // at the end of the pattern. This can only match a
+ // corresponding "" at the end of the file.
+ // If the file ends in /, then it can only match a
+ // a pattern that ends in /, unless the pattern just
+ // doesn't have any more for it. But, a/b/ should *not*
+ // match "a/b/*", even though "" matches against the
+ // [^/]*? pattern, except in partial mode, where it might
+ // simply not be reached yet.
+ // However, a/b/ should still satisfy a/*
-// consumes and returns one char from the input
-input:function () {
- var ch = this._input[0];
- this.yytext += ch;
- this.yyleng++;
- this.offset++;
- this.match += ch;
- this.matched += ch;
- var lines = ch.match(/(?:\r\n?|\n).*/g);
- if (lines) {
- this.yylineno++;
- this.yylloc.last_line++;
- } else {
- this.yylloc.last_column++;
- }
- if (this.options.ranges) {
- this.yylloc.range[1]++;
- }
+ // now either we fell off the end of the pattern, or we're done.
+ if (fi === fl && pi === pl) {
+ // ran out of pattern and filename at the same time.
+ // an exact hit!
+ return true
+ } else if (fi === fl) {
+ // ran out of file, but still had pattern left.
+ // this is ok if we're doing the match as part of
+ // a glob fs traversal.
+ return partial
+ } else if (pi === pl) {
+ // ran out of pattern, still have file left.
+ // this is only acceptable if we're on the very last
+ // empty segment of a file with a trailing slash.
+ // a/* should match a/b/
+ var emptyFileEnd = (fi === fl - 1) && (file[fi] === '')
+ return emptyFileEnd
+ }
- this._input = this._input.slice(1);
- return ch;
- },
+ // should be unreachable.
+ throw new Error('wtf?')
+}
-// unshifts one char (or a string) into the input
-unput:function (ch) {
- var len = ch.length;
- var lines = ch.split(/(?:\r\n?|\n)/g);
+// replace stuff like \* with *
+function globUnescape (s) {
+ return s.replace(/\\(.)/g, '$1')
+}
- this._input = ch + this._input;
- this.yytext = this.yytext.substr(0, this.yytext.length - len);
- //this.yyleng -= len;
- this.offset -= len;
- var oldLines = this.match.split(/(?:\r\n?|\n)/g);
- this.match = this.match.substr(0, this.match.length - 1);
- this.matched = this.matched.substr(0, this.matched.length - 1);
+function regExpEscape (s) {
+ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
+}
- if (lines.length - 1) {
- this.yylineno -= lines.length - 1;
- }
- var r = this.yylloc.range;
- this.yylloc = {
- first_line: this.yylloc.first_line,
- last_line: this.yylineno + 1,
- first_column: this.yylloc.first_column,
- last_column: lines ?
- (lines.length === oldLines.length ? this.yylloc.first_column : 0)
- + oldLines[oldLines.length - lines.length].length - lines[0].length :
- this.yylloc.first_column - len
- };
+/***/ }),
+/* 507 */
+/***/ (function(module, exports, __webpack_require__) {
- if (this.options.ranges) {
- this.yylloc.range = [r[0], r[0] + this.yyleng - len];
- }
- this.yyleng = this.yytext.length;
- return this;
- },
+var concatMap = __webpack_require__(508);
+var balanced = __webpack_require__(509);
-// When called from action, caches matched text and appends it on next action
-more:function () {
- this._more = true;
- return this;
- },
+module.exports = expandTop;
-// When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
-reject:function () {
- if (this.options.backtrack_lexer) {
- this._backtrack = true;
- } else {
- return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
- text: "",
- token: null,
- line: this.yylineno
- });
+var escSlash = '\0SLASH'+Math.random()+'\0';
+var escOpen = '\0OPEN'+Math.random()+'\0';
+var escClose = '\0CLOSE'+Math.random()+'\0';
+var escComma = '\0COMMA'+Math.random()+'\0';
+var escPeriod = '\0PERIOD'+Math.random()+'\0';
- }
- return this;
- },
+function numeric(str) {
+ return parseInt(str, 10) == str
+ ? parseInt(str, 10)
+ : str.charCodeAt(0);
+}
-// retain first n characters of the match
-less:function (n) {
- this.unput(this.match.slice(n));
- },
+function escapeBraces(str) {
+ return str.split('\\\\').join(escSlash)
+ .split('\\{').join(escOpen)
+ .split('\\}').join(escClose)
+ .split('\\,').join(escComma)
+ .split('\\.').join(escPeriod);
+}
-// displays already matched input, i.e. for error messages
-pastInput:function () {
- var past = this.matched.substr(0, this.matched.length - this.match.length);
- return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
- },
+function unescapeBraces(str) {
+ return str.split(escSlash).join('\\')
+ .split(escOpen).join('{')
+ .split(escClose).join('}')
+ .split(escComma).join(',')
+ .split(escPeriod).join('.');
+}
-// displays upcoming input, i.e. for error messages
-upcomingInput:function () {
- var next = this.match;
- if (next.length < 20) {
- next += this._input.substr(0, 20-next.length);
- }
- return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
- },
-// displays the character position where the lexing error occurred, i.e. for error messages
-showPosition:function () {
- var pre = this.pastInput();
- var c = new Array(pre.length + 1).join("-");
- return pre + this.upcomingInput() + "\n" + c + "^";
- },
+// Basically just str.split(","), but handling cases
+// where we have nested braced sections, which should be
+// treated as individual members, like {a,{b,c},d}
+function parseCommaParts(str) {
+ if (!str)
+ return [''];
-// test the lexed token: return FALSE when not a match, otherwise return token
-test_match:function (match, indexed_rule) {
- var token,
- lines,
- backup;
+ var parts = [];
+ var m = balanced('{', '}', str);
- if (this.options.backtrack_lexer) {
- // save context
- backup = {
- yylineno: this.yylineno,
- yylloc: {
- first_line: this.yylloc.first_line,
- last_line: this.last_line,
- first_column: this.yylloc.first_column,
- last_column: this.yylloc.last_column
- },
- yytext: this.yytext,
- match: this.match,
- matches: this.matches,
- matched: this.matched,
- yyleng: this.yyleng,
- offset: this.offset,
- _more: this._more,
- _input: this._input,
- yy: this.yy,
- conditionStack: this.conditionStack.slice(0),
- done: this.done
- };
- if (this.options.ranges) {
- backup.yylloc.range = this.yylloc.range.slice(0);
- }
- }
+ if (!m)
+ return str.split(',');
- lines = match[0].match(/(?:\r\n?|\n).*/g);
- if (lines) {
- this.yylineno += lines.length;
- }
- this.yylloc = {
- first_line: this.yylloc.last_line,
- last_line: this.yylineno + 1,
- first_column: this.yylloc.last_column,
- last_column: lines ?
- lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length :
- this.yylloc.last_column + match[0].length
- };
- this.yytext += match[0];
- this.match += match[0];
- this.matches = match;
- this.yyleng = this.yytext.length;
- if (this.options.ranges) {
- this.yylloc.range = [this.offset, this.offset += this.yyleng];
- }
- this._more = false;
- this._backtrack = false;
- this._input = this._input.slice(match[0].length);
- this.matched += match[0];
- token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
- if (this.done && this._input) {
- this.done = false;
- }
- if (token) {
- return token;
- } else if (this._backtrack) {
- // recover context
- for (var k in backup) {
- this[k] = backup[k];
- }
- return false; // rule action called reject() implying the next rule should be tested instead.
- }
- return false;
- },
+ var pre = m.pre;
+ var body = m.body;
+ var post = m.post;
+ var p = pre.split(',');
-// return next match in input
-next:function () {
- if (this.done) {
- return this.EOF;
- }
- if (!this._input) {
- this.done = true;
- }
+ p[p.length-1] += '{' + body + '}';
+ var postParts = parseCommaParts(post);
+ if (post.length) {
+ p[p.length-1] += postParts.shift();
+ p.push.apply(p, postParts);
+ }
- var token,
- match,
- tempMatch,
- index;
- if (!this._more) {
- this.yytext = '';
- this.match = '';
- }
- var rules = this._currentRules();
- for (var i = 0; i < rules.length; i++) {
- tempMatch = this._input.match(this.rules[rules[i]]);
- if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
- match = tempMatch;
- index = i;
- if (this.options.backtrack_lexer) {
- token = this.test_match(tempMatch, rules[i]);
- if (token !== false) {
- return token;
- } else if (this._backtrack) {
- match = false;
- continue; // rule action called reject() implying a rule MISmatch.
- } else {
- // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
- return false;
- }
- } else if (!this.options.flex) {
- break;
- }
- }
- }
- if (match) {
- token = this.test_match(match, rules[index]);
- if (token !== false) {
- return token;
- }
- // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
- return false;
- }
- if (this._input === "") {
- return this.EOF;
- } else {
- return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
- text: "",
- token: null,
- line: this.yylineno
- });
- }
- },
+ parts.push.apply(parts, p);
-// return next match that has a token
-lex:function lex() {
- var r = this.next();
- if (r) {
- return r;
- } else {
- return this.lex();
+ return parts;
+}
+
+function expandTop(str) {
+ if (!str)
+ return [];
+
+ // I don't know why Bash 4.3 does this, but it does.
+ // Anything starting with {} will have the first two bytes preserved
+ // but *only* at the top level, so {},a}b will not expand to anything,
+ // but a{},b}c will be expanded to [a}c,abc].
+ // One could argue that this is a bug in Bash, but since the goal of
+ // this module is to match Bash's rules, we escape a leading {}
+ if (str.substr(0, 2) === '{}') {
+ str = '\\{\\}' + str.substr(2);
+ }
+
+ return expand(escapeBraces(str), true).map(unescapeBraces);
+}
+
+function identity(e) {
+ return e;
+}
+
+function embrace(str) {
+ return '{' + str + '}';
+}
+function isPadded(el) {
+ return /^-?0\d/.test(el);
+}
+
+function lte(i, y) {
+ return i <= y;
+}
+function gte(i, y) {
+ return i >= y;
+}
+
+function expand(str, isTop) {
+ var expansions = [];
+
+ var m = balanced('{', '}', str);
+ if (!m || /\$$/.test(m.pre)) return [str];
+
+ var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+ var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+ var isSequence = isNumericSequence || isAlphaSequence;
+ var isOptions = m.body.indexOf(',') >= 0;
+ if (!isSequence && !isOptions) {
+ // {a},b}
+ if (m.post.match(/,.*\}/)) {
+ str = m.pre + '{' + m.body + escClose + m.post;
+ return expand(str);
+ }
+ return [str];
+ }
+
+ var n;
+ if (isSequence) {
+ n = m.body.split(/\.\./);
+ } else {
+ n = parseCommaParts(m.body);
+ if (n.length === 1) {
+ // x{{a,b}}y ==> x{a}y x{b}y
+ n = expand(n[0], false).map(embrace);
+ if (n.length === 1) {
+ var post = m.post.length
+ ? expand(m.post, false)
+ : [''];
+ return post.map(function(p) {
+ return m.pre + n[0] + p;
+ });
+ }
+ }
+ }
+
+ // at this point, n is the parts, and we know it's not a comma set
+ // with a single entry.
+
+ // no need to expand pre, since it is guaranteed to be free of brace-sets
+ var pre = m.pre;
+ var post = m.post.length
+ ? expand(m.post, false)
+ : [''];
+
+ var N;
+
+ if (isSequence) {
+ var x = numeric(n[0]);
+ var y = numeric(n[1]);
+ var width = Math.max(n[0].length, n[1].length)
+ var incr = n.length == 3
+ ? Math.abs(numeric(n[2]))
+ : 1;
+ var test = lte;
+ var reverse = y < x;
+ if (reverse) {
+ incr *= -1;
+ test = gte;
+ }
+ var pad = n.some(isPadded);
+
+ N = [];
+
+ for (var i = x; test(i, y); i += incr) {
+ var c;
+ if (isAlphaSequence) {
+ c = String.fromCharCode(i);
+ if (c === '\\')
+ c = '';
+ } else {
+ c = String(i);
+ if (pad) {
+ var need = width - c.length;
+ if (need > 0) {
+ var z = new Array(need + 1).join('0');
+ if (i < 0)
+ c = '-' + z + c.slice(1);
+ else
+ c = z + c;
+ }
}
- },
+ }
+ N.push(c);
+ }
+ } else {
+ N = concatMap(n, function(el) { return expand(el, false) });
+ }
-// activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
-begin:function begin(condition) {
- this.conditionStack.push(condition);
- },
+ for (var j = 0; j < N.length; j++) {
+ for (var k = 0; k < post.length; k++) {
+ var expansion = pre + N[j] + post[k];
+ if (!isTop || isSequence || expansion)
+ expansions.push(expansion);
+ }
+ }
-// pop the previously active lexer condition state off the condition stack
-popState:function popState() {
- var n = this.conditionStack.length - 1;
- if (n > 0) {
- return this.conditionStack.pop();
- } else {
- return this.conditionStack[0];
+ return expansions;
+}
+
+
+
+/***/ }),
+/* 508 */
+/***/ (function(module, exports) {
+
+module.exports = function (xs, fn) {
+ var res = [];
+ for (var i = 0; i < xs.length; i++) {
+ var x = fn(xs[i], i);
+ if (isArray(x)) res.push.apply(res, x);
+ else res.push(x);
+ }
+ return res;
+};
+
+var isArray = Array.isArray || function (xs) {
+ return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+
+/***/ }),
+/* 509 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+module.exports = balanced;
+function balanced(a, b, str) {
+ if (a instanceof RegExp) a = maybeMatch(a, str);
+ if (b instanceof RegExp) b = maybeMatch(b, str);
+
+ var r = range(a, b, str);
+
+ return r && {
+ start: r[0],
+ end: r[1],
+ pre: str.slice(0, r[0]),
+ body: str.slice(r[0] + a.length, r[1]),
+ post: str.slice(r[1] + b.length)
+ };
+}
+
+function maybeMatch(reg, str) {
+ var m = str.match(reg);
+ return m ? m[0] : null;
+}
+
+balanced.range = range;
+function range(a, b, str) {
+ var begs, beg, left, right, result;
+ var ai = str.indexOf(a);
+ var bi = str.indexOf(b, ai + 1);
+ var i = ai;
+
+ if (ai >= 0 && bi > 0) {
+ begs = [];
+ left = str.length;
+
+ while (i >= 0 && !result) {
+ if (i == ai) {
+ begs.push(i);
+ ai = str.indexOf(a, i + 1);
+ } else if (begs.length == 1) {
+ result = [ begs.pop(), bi ];
+ } else {
+ beg = begs.pop();
+ if (beg < left) {
+ left = beg;
+ right = bi;
}
- },
-// produce the lexer rule set which is active for the currently active lexer condition state
-_currentRules:function _currentRules() {
- if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
- return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
- } else {
- return this.conditions["INITIAL"].rules;
+ bi = str.indexOf(b, i + 1);
+ }
+
+ i = ai < bi && ai >= 0 ? ai : bi;
+ }
+
+ if (begs.length) {
+ result = [ left, right ];
+ }
+ }
+
+ return result;
+}
+
+
+/***/ }),
+/* 510 */
+/***/ (function(module, exports, __webpack_require__) {
+
+try {
+ var util = __webpack_require__(397);
+ /* istanbul ignore next */
+ if (typeof util.inherits !== 'function') throw '';
+ module.exports = util.inherits;
+} catch (e) {
+ /* istanbul ignore next */
+ module.exports = __webpack_require__(511);
+}
+
+
+/***/ }),
+/* 511 */
+/***/ (function(module, exports) {
+
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
}
- },
+ })
+ }
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+ }
+}
-// return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
-topState:function topState(n) {
- n = this.conditionStack.length - 1 - Math.abs(n || 0);
- if (n >= 0) {
- return this.conditionStack[n];
- } else {
- return "INITIAL";
+
+/***/ }),
+/* 512 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function posix(path) {
+ return path.charAt(0) === '/';
+}
+
+function win32(path) {
+ // https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
+ var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+ var result = splitDeviceRe.exec(path);
+ var device = result[1] || '';
+ var isUnc = Boolean(device && device.charAt(1) !== ':');
+
+ // UNC paths are always absolute
+ return Boolean(result[2] || isUnc);
+}
+
+module.exports = process.platform === 'win32' ? win32 : posix;
+module.exports.posix = posix;
+module.exports.win32 = win32;
+
+
+/***/ }),
+/* 513 */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = globSync
+globSync.GlobSync = GlobSync
+
+var fs = __webpack_require__(349)
+var rp = __webpack_require__(504)
+var minimatch = __webpack_require__(506)
+var Minimatch = minimatch.Minimatch
+var Glob = __webpack_require__(503).Glob
+var util = __webpack_require__(397)
+var path = __webpack_require__(4)
+var assert = __webpack_require__(371)
+var isAbsolute = __webpack_require__(512)
+var common = __webpack_require__(514)
+var alphasort = common.alphasort
+var alphasorti = common.alphasorti
+var setopts = common.setopts
+var ownProp = common.ownProp
+var childrenIgnored = common.childrenIgnored
+var isIgnored = common.isIgnored
+
+function globSync (pattern, options) {
+ if (typeof options === 'function' || arguments.length === 3)
+ throw new TypeError('callback provided to sync glob\n'+
+ 'See: https://github.com/isaacs/node-glob/issues/167')
+
+ return new GlobSync(pattern, options).found
+}
+
+function GlobSync (pattern, options) {
+ if (!pattern)
+ throw new Error('must provide pattern')
+
+ if (typeof options === 'function' || arguments.length === 3)
+ throw new TypeError('callback provided to sync glob\n'+
+ 'See: https://github.com/isaacs/node-glob/issues/167')
+
+ if (!(this instanceof GlobSync))
+ return new GlobSync(pattern, options)
+
+ setopts(this, pattern, options)
+
+ if (this.noprocess)
+ return this
+
+ var n = this.minimatch.set.length
+ this.matches = new Array(n)
+ for (var i = 0; i < n; i ++) {
+ this._process(this.minimatch.set[i], i, false)
+ }
+ this._finish()
+}
+
+GlobSync.prototype._finish = function () {
+ assert(this instanceof GlobSync)
+ if (this.realpath) {
+ var self = this
+ this.matches.forEach(function (matchset, index) {
+ var set = self.matches[index] = Object.create(null)
+ for (var p in matchset) {
+ try {
+ p = self._makeAbs(p)
+ var real = rp.realpathSync(p, self.realpathCache)
+ set[real] = true
+ } catch (er) {
+ if (er.syscall === 'stat')
+ set[self._makeAbs(p)] = true
+ else
+ throw er
}
- },
+ }
+ })
+ }
+ common.finish(this)
+}
-// alias for begin(condition)
-pushState:function pushState(condition) {
- this.begin(condition);
- },
-// return the number of states currently on the stack
-stateStackSize:function stateStackSize() {
- return this.conditionStack.length;
- },
-options: {},
-performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
-var YYSTATE=YY_START;
-switch($avoiding_name_collisions) {
-case 0:return 5
-break;
-case 1:/* skip whitespace */
-break;
-case 2:return 8
-break;
-case 3:return 16
-break;
-case 4:return 17
-break;
-case 5:return 11
-break;
-case 6:return 10
-break;
-case 7:return 9
-break;
-case 8:return 14
-break;
-case 9:return 15
-break;
-case 10:return 12
-break;
-case 11:return 7
-break;
-case 12:return 7
-break;
-case 13:return 7
-break;
-case 14:return 7
-break;
-case 15:return 7
-break;
-case 16:return 7
-break;
-case 17:return 7
-break;
-case 18:return 7
-break;
-case 19:return 7
-break;
-case 20:return 7
-break;
-case 21:return 7
-break;
-case 22:return 7
-break;
-case 23:return 7
-break;
-case 24:return 13
-break;
-case 25:return 13
-break;
-case 26:return 13
-break;
-case 27:return 13
-break;
-case 28:return 13
-break;
-case 29:return 13
-break;
-case 30:return 13
-break;
-case 31:return 13
-break;
-case 32:return 7
-break;
-case 33:return 13
-break;
-case 34:return 7
-break;
-case 35:return 13
-break;
-case 36:return 7
-break;
-case 37:return 13
-break;
-case 38:return 13
-break;
-case 39:return 7
-break;
-case 40:return 13
-break;
-case 41:return 13
-break;
-case 42:return 13
-break;
-case 43:return 13
-break;
-case 44:return 13
-break;
-case 45:return 7
-break;
-case 46:return 13
-break;
-case 47:return 7
-break;
-case 48:return 7
-break;
-case 49:return 7
-break;
-case 50:return 7
-break;
-case 51:return 7
-break;
-case 52:return 7
-break;
-case 53:return 7
-break;
-case 54:return 7
-break;
-case 55:return 7
-break;
-case 56:return 7
-break;
-case 57:return 7
-break;
-case 58:return 7
-break;
-case 59:return 7
-break;
-case 60:return 7
-break;
-case 61:return 7
-break;
-case 62:return 7
-break;
-case 63:return 13
-break;
-case 64:return 7
-break;
-case 65:return 7
-break;
-case 66:return 13
-break;
-case 67:return 7
-break;
-case 68:return 7
-break;
-case 69:return 7
-break;
-case 70:return 7
-break;
-case 71:return 7
-break;
-case 72:return 7
-break;
-case 73:return 13
-break;
-case 74:return 7
-break;
-case 75:return 13
-break;
-case 76:return 7
-break;
-case 77:return 7
-break;
-case 78:return 7
-break;
-case 79:return 7
-break;
-case 80:return 7
-break;
-case 81:return 7
-break;
-case 82:return 7
-break;
-case 83:return 7
-break;
-case 84:return 7
-break;
-case 85:return 7
-break;
-case 86:return 7
-break;
-case 87:return 7
-break;
-case 88:return 7
-break;
-case 89:return 7
-break;
-case 90:return 7
-break;
-case 91:return 7
-break;
-case 92:return 7
-break;
-case 93:return 7
-break;
-case 94:return 7
-break;
-case 95:return 7
-break;
-case 96:return 7
-break;
-case 97:return 7
-break;
-case 98:return 7
-break;
-case 99:return 7
-break;
-case 100:return 7
-break;
-case 101:return 7
-break;
-case 102:return 7
-break;
-case 103:return 7
-break;
-case 104:return 7
-break;
-case 105:return 7
-break;
-case 106:return 7
-break;
-case 107:return 7
-break;
-case 108:return 7
-break;
-case 109:return 7
-break;
-case 110:return 7
-break;
-case 111:return 7
-break;
-case 112:return 7
-break;
-case 113:return 7
-break;
-case 114:return 7
-break;
-case 115:return 7
-break;
-case 116:return 7
-break;
-case 117:return 7
-break;
-case 118:return 7
-break;
-case 119:return 7
-break;
-case 120:return 7
-break;
-case 121:return 7
-break;
-case 122:return 7
-break;
-case 123:return 7
-break;
-case 124:return 7
-break;
-case 125:return 7
-break;
-case 126:return 7
-break;
-case 127:return 7
-break;
-case 128:return 7
-break;
-case 129:return 7
-break;
-case 130:return 7
-break;
-case 131:return 7
-break;
-case 132:return 7
-break;
-case 133:return 7
-break;
-case 134:return 7
-break;
-case 135:return 7
-break;
-case 136:return 7
-break;
-case 137:return 7
-break;
-case 138:return 7
-break;
-case 139:return 7
-break;
-case 140:return 7
-break;
-case 141:return 7
-break;
-case 142:return 7
-break;
-case 143:return 7
-break;
-case 144:return 7
-break;
-case 145:return 7
-break;
-case 146:return 7
-break;
-case 147:return 7
-break;
-case 148:return 7
-break;
-case 149:return 7
-break;
-case 150:return 7
-break;
-case 151:return 7
-break;
-case 152:return 7
-break;
-case 153:return 7
-break;
-case 154:return 7
-break;
-case 155:return 7
-break;
-case 156:return 7
-break;
-case 157:return 7
-break;
-case 158:return 7
-break;
-case 159:return 7
-break;
-case 160:return 7
-break;
-case 161:return 7
-break;
-case 162:return 7
-break;
-case 163:return 7
-break;
-case 164:return 7
-break;
-case 165:return 7
-break;
-case 166:return 7
-break;
-case 167:return 7
-break;
-case 168:return 7
-break;
-case 169:return 7
-break;
-case 170:return 7
-break;
-case 171:return 7
-break;
-case 172:return 7
-break;
-case 173:return 7
-break;
-case 174:return 7
-break;
-case 175:return 7
-break;
-case 176:return 7
-break;
-case 177:return 7
-break;
-case 178:return 7
-break;
-case 179:return 7
-break;
-case 180:return 7
-break;
-case 181:return 7
-break;
-case 182:return 7
-break;
-case 183:return 7
-break;
-case 184:return 7
-break;
-case 185:return 7
-break;
-case 186:return 7
-break;
-case 187:return 7
-break;
-case 188:return 7
-break;
-case 189:return 7
-break;
-case 190:return 7
-break;
-case 191:return 7
-break;
-case 192:return 7
-break;
-case 193:return 7
-break;
-case 194:return 7
-break;
-case 195:return 7
-break;
-case 196:return 7
-break;
-case 197:return 7
-break;
-case 198:return 7
-break;
-case 199:return 7
-break;
-case 200:return 7
-break;
-case 201:return 7
-break;
-case 202:return 7
-break;
-case 203:return 7
-break;
-case 204:return 7
-break;
-case 205:return 7
-break;
-case 206:return 7
-break;
-case 207:return 7
-break;
-case 208:return 7
-break;
-case 209:return 7
-break;
-case 210:return 7
-break;
-case 211:return 7
-break;
-case 212:return 7
-break;
-case 213:return 7
-break;
-case 214:return 7
-break;
-case 215:return 7
-break;
-case 216:return 7
-break;
-case 217:return 7
-break;
-case 218:return 7
-break;
-case 219:return 7
-break;
-case 220:return 7
-break;
-case 221:return 7
-break;
-case 222:return 7
-break;
-case 223:return 7
-break;
-case 224:return 7
-break;
-case 225:return 7
-break;
-case 226:return 7
-break;
-case 227:return 7
-break;
-case 228:return 7
-break;
-case 229:return 7
-break;
-case 230:return 7
-break;
-case 231:return 7
-break;
-case 232:return 7
-break;
-case 233:return 7
-break;
-case 234:return 7
-break;
-case 235:return 7
-break;
-case 236:return 7
-break;
-case 237:return 7
-break;
-case 238:return 7
-break;
-case 239:return 7
-break;
-case 240:return 7
-break;
-case 241:return 7
-break;
-case 242:return 7
-break;
-case 243:return 7
-break;
-case 244:return 7
-break;
-case 245:return 7
-break;
-case 246:return 7
-break;
-case 247:return 7
-break;
-case 248:return 7
-break;
-case 249:return 7
-break;
-case 250:return 7
-break;
-case 251:return 7
-break;
-case 252:return 7
-break;
-case 253:return 7
-break;
-case 254:return 7
-break;
-case 255:return 7
-break;
-case 256:return 7
-break;
-case 257:return 7
-break;
-case 258:return 7
-break;
-case 259:return 7
-break;
-case 260:return 7
-break;
-case 261:return 7
-break;
-case 262:return 7
-break;
-case 263:return 7
-break;
-case 264:return 7
-break;
-case 265:return 7
-break;
-case 266:return 7
-break;
-case 267:return 7
-break;
-case 268:return 7
-break;
-case 269:return 7
-break;
-case 270:return 7
-break;
-case 271:return 7
-break;
-case 272:return 7
-break;
-case 273:return 7
-break;
-case 274:return 7
-break;
-case 275:return 7
-break;
-case 276:return 7
-break;
-case 277:return 7
-break;
-case 278:return 7
-break;
-case 279:return 7
-break;
-case 280:return 7
-break;
-case 281:return 7
-break;
-case 282:return 7
-break;
-case 283:return 7
-break;
-case 284:return 7
-break;
-case 285:return 7
-break;
-case 286:return 7
-break;
-case 287:return 7
-break;
-case 288:return 7
-break;
-case 289:return 7
-break;
-case 290:return 7
-break;
-case 291:return 7
-break;
-case 292:return 7
-break;
-case 293:return 7
-break;
-case 294:return 7
-break;
-case 295:return 7
-break;
-case 296:return 7
-break;
-case 297:return 7
-break;
-case 298:return 7
-break;
-case 299:return 7
-break;
-case 300:return 7
-break;
-case 301:return 7
-break;
-case 302:return 7
-break;
-case 303:return 7
-break;
-case 304:return 7
-break;
-case 305:return 7
-break;
-case 306:return 7
-break;
-case 307:return 7
-break;
-case 308:return 7
-break;
-case 309:return 7
-break;
-case 310:return 7
-break;
-case 311:return 7
-break;
-case 312:return 7
-break;
-case 313:return 7
-break;
-case 314:return 7
-break;
-case 315:return 7
-break;
-case 316:return 7
-break;
-case 317:return 7
-break;
-case 318:return 7
-break;
-case 319:return 7
-break;
-case 320:return 7
-break;
-case 321:return 7
-break;
-case 322:return 7
-break;
-case 323:return 7
-break;
-case 324:return 7
-break;
-case 325:return 7
-break;
-case 326:return 7
-break;
-case 327:return 7
-break;
-case 328:return 7
-break;
-case 329:return 7
-break;
-case 330:return 7
-break;
-case 331:return 7
-break;
-case 332:return 7
-break;
-case 333:return 7
-break;
-case 334:return 7
-break;
-case 335:return 7
-break;
-case 336:return 7
-break;
-case 337:return 7
-break;
-case 338:return 7
-break;
-case 339:return 7
-break;
-case 340:return 7
-break;
-case 341:return 7
-break;
-case 342:return 7
-break;
-case 343:return 7
-break;
-case 344:return 7
-break;
-case 345:return 7
-break;
-case 346:return 7
-break;
-case 347:return 7
-break;
-case 348:return 7
-break;
-case 349:return 7
-break;
-case 350:return 7
-break;
-case 351:return 7
-break;
-case 352:return 7
-break;
-case 353:return 7
-break;
-case 354:return 7
-break;
-case 355:return 7
-break;
-case 356:return 7
-break;
-case 357:return 7
-break;
-case 358:return 7
-break;
-case 359:return 7
-break;
-case 360:return 7
-break;
-case 361:return 7
-break;
-case 362:return 7
-break;
-case 363:return 7
-break;
-case 364:return 7
-break;
+GlobSync.prototype._process = function (pattern, index, inGlobStar) {
+ assert(this instanceof GlobSync)
+
+ // Get the first [n] parts of pattern that are all strings.
+ var n = 0
+ while (typeof pattern[n] === 'string') {
+ n ++
+ }
+ // now n is the index of the first one that is *not* a string.
+
+ // See if there's anything else
+ var prefix
+ switch (n) {
+ // if not, then this is rather simple
+ case pattern.length:
+ this._processSimple(pattern.join('/'), index)
+ return
+
+ case 0:
+ // pattern *starts* with some non-trivial item.
+ // going to readdir(cwd), but not include the prefix in matches.
+ prefix = null
+ break
+
+ default:
+ // pattern has some string bits in the front.
+ // whatever it starts with, whether that's 'absolute' like /foo/bar,
+ // or 'relative' like '../baz'
+ prefix = pattern.slice(0, n).join('/')
+ break
+ }
+
+ var remain = pattern.slice(n)
+
+ // get the list of entries.
+ var read
+ if (prefix === null)
+ read = '.'
+ else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+ if (!prefix || !isAbsolute(prefix))
+ prefix = '/' + prefix
+ read = prefix
+ } else
+ read = prefix
+
+ var abs = this._makeAbs(read)
+
+ //if ignored, skip processing
+ if (childrenIgnored(this, read))
+ return
+
+ var isGlobStar = remain[0] === minimatch.GLOBSTAR
+ if (isGlobStar)
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar)
+ else
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar)
+}
+
+
+GlobSync.prototype._processReaddir = function (prefix, read, abs, remain, index, inGlobStar) {
+ var entries = this._readdir(abs, inGlobStar)
+
+ // if the abs isn't a dir, then nothing can match!
+ if (!entries)
+ return
+
+ // It will only match dot entries if it starts with a dot, or if
+ // dot is set. Stuff like @(.foo|.bar) isn't allowed.
+ var pn = remain[0]
+ var negate = !!this.minimatch.negate
+ var rawGlob = pn._glob
+ var dotOk = this.dot || rawGlob.charAt(0) === '.'
+
+ var matchedEntries = []
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i]
+ if (e.charAt(0) !== '.' || dotOk) {
+ var m
+ if (negate && !prefix) {
+ m = !e.match(pn)
+ } else {
+ m = e.match(pn)
+ }
+ if (m)
+ matchedEntries.push(e)
+ }
+ }
+
+ var len = matchedEntries.length
+ // If there are no matched entries, then nothing matches.
+ if (len === 0)
+ return
+
+ // if this is the last remaining pattern bit, then no need for
+ // an additional stat *unless* the user has specified mark or
+ // stat explicitly. We know they exist, since readdir returned
+ // them.
+
+ if (remain.length === 1 && !this.mark && !this.stat) {
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null)
+
+ for (var i = 0; i < len; i ++) {
+ var e = matchedEntries[i]
+ if (prefix) {
+ if (prefix.slice(-1) !== '/')
+ e = prefix + '/' + e
+ else
+ e = prefix + e
+ }
+
+ if (e.charAt(0) === '/' && !this.nomount) {
+ e = path.join(this.root, e)
+ }
+ this._emitMatch(index, e)
+ }
+ // This was the last one, and no stats were needed
+ return
+ }
+
+ // now test all matched entries as stand-ins for that part
+ // of the pattern.
+ remain.shift()
+ for (var i = 0; i < len; i ++) {
+ var e = matchedEntries[i]
+ var newPattern
+ if (prefix)
+ newPattern = [prefix, e]
+ else
+ newPattern = [e]
+ this._process(newPattern.concat(remain), index, inGlobStar)
+ }
+}
+
+
+GlobSync.prototype._emitMatch = function (index, e) {
+ if (isIgnored(this, e))
+ return
+
+ var abs = this._makeAbs(e)
+
+ if (this.mark)
+ e = this._mark(e)
+
+ if (this.absolute) {
+ e = abs
+ }
+
+ if (this.matches[index][e])
+ return
+
+ if (this.nodir) {
+ var c = this.cache[abs]
+ if (c === 'DIR' || Array.isArray(c))
+ return
+ }
+
+ this.matches[index][e] = true
+
+ if (this.stat)
+ this._stat(e)
+}
+
+
+GlobSync.prototype._readdirInGlobStar = function (abs) {
+ // follow all symlinked directories forever
+ // just proceed as if this is a non-globstar situation
+ if (this.follow)
+ return this._readdir(abs, false)
+
+ var entries
+ var lstat
+ var stat
+ try {
+ lstat = fs.lstatSync(abs)
+ } catch (er) {
+ if (er.code === 'ENOENT') {
+ // lstat failed, doesn't exist
+ return null
+ }
+ }
+
+ var isSym = lstat && lstat.isSymbolicLink()
+ this.symlinks[abs] = isSym
+
+ // If it's not a symlink or a dir, then it's definitely a regular file.
+ // don't bother doing a readdir in that case.
+ if (!isSym && lstat && !lstat.isDirectory())
+ this.cache[abs] = 'FILE'
+ else
+ entries = this._readdir(abs, false)
+
+ return entries
+}
+
+GlobSync.prototype._readdir = function (abs, inGlobStar) {
+ var entries
+
+ if (inGlobStar && !ownProp(this.symlinks, abs))
+ return this._readdirInGlobStar(abs)
+
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs]
+ if (!c || c === 'FILE')
+ return null
+
+ if (Array.isArray(c))
+ return c
+ }
+
+ try {
+ return this._readdirEntries(abs, fs.readdirSync(abs))
+ } catch (er) {
+ this._readdirError(abs, er)
+ return null
+ }
+}
+
+GlobSync.prototype._readdirEntries = function (abs, entries) {
+ // if we haven't asked to stat everything, then just
+ // assume that everything in there exists, so we can avoid
+ // having to stat it a second time.
+ if (!this.mark && !this.stat) {
+ for (var i = 0; i < entries.length; i ++) {
+ var e = entries[i]
+ if (abs === '/')
+ e = abs + e
+ else
+ e = abs + '/' + e
+ this.cache[e] = true
+ }
+ }
+
+ this.cache[abs] = entries
+
+ // mark and cache dir-ness
+ return entries
+}
+
+GlobSync.prototype._readdirError = function (f, er) {
+ // handle errors, and cache the information
+ switch (er.code) {
+ case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
+ case 'ENOTDIR': // totally normal. means it *does* exist.
+ var abs = this._makeAbs(f)
+ this.cache[abs] = 'FILE'
+ if (abs === this.cwdAbs) {
+ var error = new Error(er.code + ' invalid cwd ' + this.cwd)
+ error.path = this.cwd
+ error.code = er.code
+ throw error
+ }
+ break
+
+ case 'ENOENT': // not terribly unusual
+ case 'ELOOP':
+ case 'ENAMETOOLONG':
+ case 'UNKNOWN':
+ this.cache[this._makeAbs(f)] = false
+ break
+
+ default: // some unusual error. Treat as failure.
+ this.cache[this._makeAbs(f)] = false
+ if (this.strict)
+ throw er
+ if (!this.silent)
+ console.error('glob error', er)
+ break
+ }
+}
+
+GlobSync.prototype._processGlobStar = function (prefix, read, abs, remain, index, inGlobStar) {
+
+ var entries = this._readdir(abs, inGlobStar)
+
+ // no entries means not a dir, so it can never have matches
+ // foo.txt/** doesn't match foo.txt
+ if (!entries)
+ return
+
+ // test without the globstar, and with every child both below
+ // and replacing the globstar.
+ var remainWithoutGlobStar = remain.slice(1)
+ var gspref = prefix ? [ prefix ] : []
+ var noGlobStar = gspref.concat(remainWithoutGlobStar)
+
+ // the noGlobStar pattern exits the inGlobStar state
+ this._process(noGlobStar, index, false)
+
+ var len = entries.length
+ var isSym = this.symlinks[abs]
+
+ // If it's a symlink, and we're in a globstar, then stop
+ if (isSym && inGlobStar)
+ return
+
+ for (var i = 0; i < len; i++) {
+ var e = entries[i]
+ if (e.charAt(0) === '.' && !this.dot)
+ continue
+
+ // these two cases enter the inGlobStar state
+ var instead = gspref.concat(entries[i], remainWithoutGlobStar)
+ this._process(instead, index, true)
+
+ var below = gspref.concat(entries[i], remain)
+ this._process(below, index, true)
+ }
+}
+
+GlobSync.prototype._processSimple = function (prefix, index) {
+ // XXX review this. Shouldn't it be doing the mounting etc
+ // before doing stat? kinda weird?
+ var exists = this._stat(prefix)
+
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null)
+
+ // If it doesn't exist, then just mark the lack of results
+ if (!exists)
+ return
+
+ if (prefix && isAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix)
+ if (prefix.charAt(0) === '/') {
+ prefix = path.join(this.root, prefix)
+ } else {
+ prefix = path.resolve(this.root, prefix)
+ if (trail)
+ prefix += '/'
+ }
+ }
+
+ if (process.platform === 'win32')
+ prefix = prefix.replace(/\\/g, '/')
+
+ // Mark this as a match
+ this._emitMatch(index, prefix)
+}
+
+// Returns either 'DIR', 'FILE', or false
+GlobSync.prototype._stat = function (f) {
+ var abs = this._makeAbs(f)
+ var needDir = f.slice(-1) === '/'
+
+ if (f.length > this.maxLength)
+ return false
+
+ if (!this.stat && ownProp(this.cache, abs)) {
+ var c = this.cache[abs]
+
+ if (Array.isArray(c))
+ c = 'DIR'
+
+ // It exists, but maybe not how we need it
+ if (!needDir || c === 'DIR')
+ return c
+
+ if (needDir && c === 'FILE')
+ return false
+
+ // otherwise we have to stat, because maybe c=true
+ // if we know it exists, but not what it is.
+ }
+
+ var exists
+ var stat = this.statCache[abs]
+ if (!stat) {
+ var lstat
+ try {
+ lstat = fs.lstatSync(abs)
+ } catch (er) {
+ if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
+ this.statCache[abs] = false
+ return false
+ }
+ }
+
+ if (lstat && lstat.isSymbolicLink()) {
+ try {
+ stat = fs.statSync(abs)
+ } catch (er) {
+ stat = lstat
+ }
+ } else {
+ stat = lstat
+ }
+ }
+
+ this.statCache[abs] = stat
+
+ var c = true
+ if (stat)
+ c = stat.isDirectory() ? 'DIR' : 'FILE'
+
+ this.cache[abs] = this.cache[abs] || c
+
+ if (needDir && c === 'FILE')
+ return false
+
+ return c
+}
+
+GlobSync.prototype._mark = function (p) {
+ return common.mark(this, p)
+}
+
+GlobSync.prototype._makeAbs = function (f) {
+ return common.makeAbs(this, f)
+}
+
+
+/***/ }),
+/* 514 */
+/***/ (function(module, exports, __webpack_require__) {
+
+exports.alphasort = alphasort
+exports.alphasorti = alphasorti
+exports.setopts = setopts
+exports.ownProp = ownProp
+exports.makeAbs = makeAbs
+exports.finish = finish
+exports.mark = mark
+exports.isIgnored = isIgnored
+exports.childrenIgnored = childrenIgnored
+
+function ownProp (obj, field) {
+ return Object.prototype.hasOwnProperty.call(obj, field)
+}
+
+var path = __webpack_require__(4)
+var minimatch = __webpack_require__(506)
+var isAbsolute = __webpack_require__(512)
+var Minimatch = minimatch.Minimatch
+
+function alphasorti (a, b) {
+ return a.toLowerCase().localeCompare(b.toLowerCase())
+}
+
+function alphasort (a, b) {
+ return a.localeCompare(b)
+}
+
+function setupIgnores (self, options) {
+ self.ignore = options.ignore || []
+
+ if (!Array.isArray(self.ignore))
+ self.ignore = [self.ignore]
+
+ if (self.ignore.length) {
+ self.ignore = self.ignore.map(ignoreMap)
+ }
+}
+
+// ignore patterns are always in dot:true mode.
+function ignoreMap (pattern) {
+ var gmatcher = null
+ if (pattern.slice(-3) === '/**') {
+ var gpattern = pattern.replace(/(\/\*\*)+$/, '')
+ gmatcher = new Minimatch(gpattern, { dot: true })
+ }
+
+ return {
+ matcher: new Minimatch(pattern, { dot: true }),
+ gmatcher: gmatcher
+ }
+}
+
+function setopts (self, pattern, options) {
+ if (!options)
+ options = {}
+
+ // base-matching: just use globstar for that.
+ if (options.matchBase && -1 === pattern.indexOf("/")) {
+ if (options.noglobstar) {
+ throw new Error("base matching requires globstar")
+ }
+ pattern = "**/" + pattern
+ }
+
+ self.silent = !!options.silent
+ self.pattern = pattern
+ self.strict = options.strict !== false
+ self.realpath = !!options.realpath
+ self.realpathCache = options.realpathCache || Object.create(null)
+ self.follow = !!options.follow
+ self.dot = !!options.dot
+ self.mark = !!options.mark
+ self.nodir = !!options.nodir
+ if (self.nodir)
+ self.mark = true
+ self.sync = !!options.sync
+ self.nounique = !!options.nounique
+ self.nonull = !!options.nonull
+ self.nosort = !!options.nosort
+ self.nocase = !!options.nocase
+ self.stat = !!options.stat
+ self.noprocess = !!options.noprocess
+ self.absolute = !!options.absolute
+
+ self.maxLength = options.maxLength || Infinity
+ self.cache = options.cache || Object.create(null)
+ self.statCache = options.statCache || Object.create(null)
+ self.symlinks = options.symlinks || Object.create(null)
+
+ setupIgnores(self, options)
+
+ self.changedCwd = false
+ var cwd = process.cwd()
+ if (!ownProp(options, "cwd"))
+ self.cwd = cwd
+ else {
+ self.cwd = path.resolve(options.cwd)
+ self.changedCwd = self.cwd !== cwd
+ }
+
+ self.root = options.root || path.resolve(self.cwd, "/")
+ self.root = path.resolve(self.root)
+ if (process.platform === "win32")
+ self.root = self.root.replace(/\\/g, "/")
+
+ // TODO: is an absolute `cwd` supposed to be resolved against `root`?
+ // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
+ self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd)
+ if (process.platform === "win32")
+ self.cwdAbs = self.cwdAbs.replace(/\\/g, "/")
+ self.nomount = !!options.nomount
+
+ // disable comments and negation in Minimatch.
+ // Note that they are not supported in Glob itself anyway.
+ options.nonegate = true
+ options.nocomment = true
+
+ self.minimatch = new Minimatch(pattern, options)
+ self.options = self.minimatch.options
+}
+
+function finish (self) {
+ var nou = self.nounique
+ var all = nou ? [] : Object.create(null)
+
+ for (var i = 0, l = self.matches.length; i < l; i ++) {
+ var matches = self.matches[i]
+ if (!matches || Object.keys(matches).length === 0) {
+ if (self.nonull) {
+ // do like the shell, and spit out the literal glob
+ var literal = self.minimatch.globSet[i]
+ if (nou)
+ all.push(literal)
+ else
+ all[literal] = true
+ }
+ } else {
+ // had matches
+ var m = Object.keys(matches)
+ if (nou)
+ all.push.apply(all, m)
+ else
+ m.forEach(function (m) {
+ all[m] = true
+ })
+ }
+ }
+
+ if (!nou)
+ all = Object.keys(all)
+
+ if (!self.nosort)
+ all = all.sort(self.nocase ? alphasorti : alphasort)
+
+ // at *some* point we statted all of these
+ if (self.mark) {
+ for (var i = 0; i < all.length; i++) {
+ all[i] = self._mark(all[i])
+ }
+ if (self.nodir) {
+ all = all.filter(function (e) {
+ var notDir = !(/\/$/.test(e))
+ var c = self.cache[e] || self.cache[makeAbs(self, e)]
+ if (notDir && c)
+ notDir = c !== 'DIR' && !Array.isArray(c)
+ return notDir
+ })
+ }
+ }
+
+ if (self.ignore.length)
+ all = all.filter(function(m) {
+ return !isIgnored(self, m)
+ })
+
+ self.found = all
+}
+
+function mark (self, p) {
+ var abs = makeAbs(self, p)
+ var c = self.cache[abs]
+ var m = p
+ if (c) {
+ var isDir = c === 'DIR' || Array.isArray(c)
+ var slash = p.slice(-1) === '/'
+
+ if (isDir && !slash)
+ m += '/'
+ else if (!isDir && slash)
+ m = m.slice(0, -1)
+
+ if (m !== p) {
+ var mabs = makeAbs(self, m)
+ self.statCache[mabs] = self.statCache[abs]
+ self.cache[mabs] = self.cache[abs]
+ }
+ }
+
+ return m
+}
+
+// lotta situps...
+function makeAbs (self, f) {
+ var abs = f
+ if (f.charAt(0) === '/') {
+ abs = path.join(self.root, f)
+ } else if (isAbsolute(f) || f === '') {
+ abs = f
+ } else if (self.changedCwd) {
+ abs = path.resolve(self.cwd, f)
+ } else {
+ abs = path.resolve(f)
+ }
+
+ if (process.platform === 'win32')
+ abs = abs.replace(/\\/g, '/')
+
+ return abs
+}
+
+
+// Return true, if pattern ends with globstar '**', for the accompanying parent directory.
+// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
+function isIgnored (self, path) {
+ if (!self.ignore.length)
+ return false
+
+ return self.ignore.some(function(item) {
+ return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))
+ })
+}
+
+function childrenIgnored (self, path) {
+ if (!self.ignore.length)
+ return false
+
+ return self.ignore.some(function(item) {
+ return !!(item.gmatcher && item.gmatcher.match(path))
+ })
+}
+
+
+/***/ }),
+/* 515 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var wrappy = __webpack_require__(379)
+var reqs = Object.create(null)
+var once = __webpack_require__(378)
+
+module.exports = wrappy(inflight)
+
+function inflight (key, cb) {
+ if (reqs[key]) {
+ reqs[key].push(cb)
+ return null
+ } else {
+ reqs[key] = [cb]
+ return makeres(key)
+ }
+}
+
+function makeres (key) {
+ return once(function RES () {
+ var cbs = reqs[key]
+ var len = cbs.length
+ var args = slice(arguments)
+
+ // XXX It's somewhat ambiguous whether a new callback added in this
+ // pass should be queued for later execution if something in the
+ // list of callbacks throws, or if it should just be discarded.
+ // However, it's such an edge case that it hardly matters, and either
+ // choice is likely as surprising as the other.
+ // As it happens, we do go ahead and schedule it for later execution.
+ try {
+ for (var i = 0; i < len; i++) {
+ cbs[i].apply(null, args)
+ }
+ } finally {
+ if (cbs.length > len) {
+ // added more in the interim.
+ // de-zalgo, just in case, but don't call again.
+ cbs.splice(0, len)
+ process.nextTick(function () {
+ RES.apply(null, args)
+ })
+ } else {
+ delete reqs[key]
+ }
+ }
+ })
+}
+
+function slice (args) {
+ var length = args.length
+ var array = []
+
+ for (var i = 0; i < length; i++) array[i] = args[i]
+ return array
+}
+
+
+/***/ }),
+/* 516 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CliError", function() { return CliError; });
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+class CliError extends Error {
+ constructor(message, meta = {}) {
+ super(message);
+ this.meta = meta;
+ }
+
+}
+
+/***/ }),
+/* 517 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Project", function() { return Project; });
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(349);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(397);
+/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(util__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(516);
+/* harmony import */ var _log__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(500);
+/* harmony import */ var _package_json__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(518);
+/* harmony import */ var _scripts__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(563);
+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; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+
+
+
+
+
+
+class Project {
+ static async fromPath(path) {
+ const pkgJson = await Object(_package_json__WEBPACK_IMPORTED_MODULE_5__["readPackageJson"])(path);
+ return new Project(pkgJson, path);
+ }
+ /** parsed package.json */
+
+
+ constructor(packageJson, projectPath) {
+ _defineProperty(this, "json", void 0);
+
+ _defineProperty(this, "packageJsonLocation", void 0);
+
+ _defineProperty(this, "nodeModulesLocation", void 0);
+
+ _defineProperty(this, "targetLocation", void 0);
+
+ _defineProperty(this, "path", void 0);
+
+ _defineProperty(this, "version", void 0);
+
+ _defineProperty(this, "allDependencies", void 0);
+
+ _defineProperty(this, "productionDependencies", void 0);
+
+ _defineProperty(this, "devDependencies", void 0);
+
+ _defineProperty(this, "scripts", void 0);
+
+ _defineProperty(this, "isWorkspaceRoot", false);
+
+ _defineProperty(this, "isWorkspaceProject", false);
+
+ this.json = Object.freeze(packageJson);
+ this.path = projectPath;
+ this.packageJsonLocation = path__WEBPACK_IMPORTED_MODULE_1___default.a.resolve(this.path, 'package.json');
+ this.nodeModulesLocation = path__WEBPACK_IMPORTED_MODULE_1___default.a.resolve(this.path, 'node_modules');
+ this.targetLocation = path__WEBPACK_IMPORTED_MODULE_1___default.a.resolve(this.path, 'target');
+ this.version = this.json.version;
+ this.productionDependencies = this.json.dependencies || {};
+ this.devDependencies = this.json.devDependencies || {};
+ this.allDependencies = _objectSpread({}, this.devDependencies, {}, this.productionDependencies);
+ this.isWorkspaceRoot = this.json.hasOwnProperty('workspaces');
+ this.scripts = this.json.scripts || {};
+ }
+
+ get name() {
+ return this.json.name;
+ }
+
+ ensureValidProjectDependency(project, dependentProjectIsInWorkspace) {
+ const versionInPackageJson = this.allDependencies[project.name];
+ let expectedVersionInPackageJson;
+
+ if (dependentProjectIsInWorkspace) {
+ expectedVersionInPackageJson = project.json.version;
+ } else {
+ const relativePathToProject = normalizePath(path__WEBPACK_IMPORTED_MODULE_1___default.a.relative(this.path, project.path));
+ expectedVersionInPackageJson = `link:${relativePathToProject}`;
+ } // No issues!
+
+
+ if (versionInPackageJson === expectedVersionInPackageJson) {
+ return;
+ }
+
+ let problemMsg;
+
+ if (Object(_package_json__WEBPACK_IMPORTED_MODULE_5__["isLinkDependency"])(versionInPackageJson) && dependentProjectIsInWorkspace) {
+ problemMsg = `but should be using a workspace`;
+ } else if (Object(_package_json__WEBPACK_IMPORTED_MODULE_5__["isLinkDependency"])(versionInPackageJson)) {
+ problemMsg = `using 'link:', but the path is wrong`;
+ } else {
+ problemMsg = `but it's not using the local package`;
+ }
+
+ throw new _errors__WEBPACK_IMPORTED_MODULE_3__["CliError"](`[${this.name}] depends on [${project.name}] ${problemMsg}. Update its package.json to the expected value below.`, {
+ actual: `"${project.name}": "${versionInPackageJson}"`,
+ expected: `"${project.name}": "${expectedVersionInPackageJson}"`,
+ package: `${this.name} (${this.packageJsonLocation})`
+ });
+ }
+
+ getBuildConfig() {
+ return this.json.kibana && this.json.kibana.build || {};
+ }
+ /**
+ * Returns the directory that should be copied into the Kibana build artifact.
+ * This config can be specified to only include the project's build artifacts
+ * instead of everything located in the project directory.
+ */
+
+
+ getIntermediateBuildDirectory() {
+ return path__WEBPACK_IMPORTED_MODULE_1___default.a.resolve(this.path, this.getBuildConfig().intermediateBuildDirectory || '.');
+ }
+
+ getCleanConfig() {
+ return this.json.kibana && this.json.kibana.clean || {};
+ }
+
+ hasScript(name) {
+ return name in this.scripts;
+ }
+
+ getExecutables() {
+ const raw = this.json.bin;
+
+ if (!raw) {
+ return {};
+ }
+
+ if (typeof raw === 'string') {
+ return {
+ [this.name]: path__WEBPACK_IMPORTED_MODULE_1___default.a.resolve(this.path, raw)
+ };
+ }
+
+ if (typeof raw === 'object') {
+ const binsConfig = {};
+
+ for (const binName of Object.keys(raw)) {
+ binsConfig[binName] = path__WEBPACK_IMPORTED_MODULE_1___default.a.resolve(this.path, raw[binName]);
+ }
+
+ return binsConfig;
+ }
+
+ throw new _errors__WEBPACK_IMPORTED_MODULE_3__["CliError"](`[${this.name}] has an invalid "bin" field in its package.json, ` + `expected an object or a string`, {
+ binConfig: Object(util__WEBPACK_IMPORTED_MODULE_2__["inspect"])(raw),
+ package: `${this.name} (${this.packageJsonLocation})`
+ });
+ }
+
+ async runScript(scriptName, args = []) {
+ _log__WEBPACK_IMPORTED_MODULE_4__["log"].info(`Running script [${scriptName}] in [${this.name}]:`);
+ return Object(_scripts__WEBPACK_IMPORTED_MODULE_6__["runScriptInPackage"])(scriptName, args, this);
+ }
+
+ runScriptStreaming(scriptName, options = {}) {
+ return Object(_scripts__WEBPACK_IMPORTED_MODULE_6__["runScriptInPackageStreaming"])({
+ script: scriptName,
+ args: options.args || [],
+ pkg: this,
+ debug: options.debug
+ });
+ }
+
+ hasDependencies() {
+ return Object.keys(this.allDependencies).length > 0;
+ }
+
+ async installDependencies({
+ extraArgs
+ }) {
+ _log__WEBPACK_IMPORTED_MODULE_4__["log"].info(`[${this.name}] running yarn`);
+ _log__WEBPACK_IMPORTED_MODULE_4__["log"].write('');
+ await Object(_scripts__WEBPACK_IMPORTED_MODULE_6__["installInDir"])(this.path, extraArgs);
+ _log__WEBPACK_IMPORTED_MODULE_4__["log"].write('');
+ await this.removeExtraneousNodeModules();
+ }
+ /**
+ * Yarn workspaces symlinks workspace projects to the root node_modules, even
+ * when there is no depenency on the project. This results in unnecicary, and
+ * often duplicated code in the build archives.
+ */
+
+
+ async removeExtraneousNodeModules() {
+ // this is only relevant for the root workspace
+ if (!this.isWorkspaceRoot) {
+ return;
+ }
+
+ const workspacesInfo = await Object(_scripts__WEBPACK_IMPORTED_MODULE_6__["yarnWorkspacesInfo"])(this.path);
+ const unusedWorkspaces = new Set(Object.keys(workspacesInfo)); // check for any cross-project dependency
+
+ for (const name of Object.keys(workspacesInfo)) {
+ const workspace = workspacesInfo[name];
+ workspace.workspaceDependencies.forEach(w => unusedWorkspaces.delete(w));
+ }
+
+ unusedWorkspaces.forEach(name => {
+ const {
+ dependencies,
+ devDependencies
+ } = this.json;
+ const nodeModulesPath = path__WEBPACK_IMPORTED_MODULE_1___default.a.resolve(this.nodeModulesLocation, name);
+ const isDependency = dependencies && dependencies.hasOwnProperty(name);
+ const isDevDependency = devDependencies && devDependencies.hasOwnProperty(name);
+
+ if (!isDependency && !isDevDependency && fs__WEBPACK_IMPORTED_MODULE_0___default.a.existsSync(nodeModulesPath)) {
+ _log__WEBPACK_IMPORTED_MODULE_4__["log"].debug(`No dependency on ${name}, removing link in node_modules`);
+ fs__WEBPACK_IMPORTED_MODULE_0___default.a.unlinkSync(nodeModulesPath);
+ }
+ });
+ }
+
+} // We normalize all path separators to `/` in generated files
+
+function normalizePath(path) {
+ return path.replace(/[\\\/]+/g, '/');
+}
+
+/***/ }),
+/* 518 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "readPackageJson", function() { return readPackageJson; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "writePackageJson", function() { return writePackageJson; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isLinkDependency", function() { return isLinkDependency; });
+/* harmony import */ var read_pkg__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(519);
+/* harmony import */ var read_pkg__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(read_pkg__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var write_pkg__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(545);
+/* harmony import */ var write_pkg__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(write_pkg__WEBPACK_IMPORTED_MODULE_1__);
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+
+function readPackageJson(cwd) {
+ return read_pkg__WEBPACK_IMPORTED_MODULE_0___default()({
+ cwd,
+ normalize: false
+ });
+}
+function writePackageJson(path, json) {
+ return write_pkg__WEBPACK_IMPORTED_MODULE_1___default()(path, json);
+}
+const isLinkDependency = depVersion => depVersion.startsWith('link:');
+
+/***/ }),
+/* 519 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+const {promisify} = __webpack_require__(397);
+const fs = __webpack_require__(349);
+const path = __webpack_require__(4);
+const parseJson = __webpack_require__(520);
+
+const readFileAsync = promisify(fs.readFile);
+
+module.exports = async options => {
+ options = {
+ cwd: process.cwd(),
+ normalize: true,
+ ...options
+ };
+
+ const filePath = path.resolve(options.cwd, 'package.json');
+ const json = parseJson(await readFileAsync(filePath, 'utf8'));
+
+ if (options.normalize) {
+ __webpack_require__(521)(json);
+ }
+
+ return json;
+};
+
+module.exports.sync = options => {
+ options = {
+ cwd: process.cwd(),
+ normalize: true,
+ ...options
+ };
+
+ const filePath = path.resolve(options.cwd, 'package.json');
+ const json = parseJson(fs.readFileSync(filePath, 'utf8'));
+
+ if (options.normalize) {
+ __webpack_require__(521)(json);
+ }
+
+ return json;
+};
+
+
+/***/ }),
+/* 520 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+const errorEx = __webpack_require__(416);
+const fallback = __webpack_require__(418);
+const {default: LinesAndColumns} = __webpack_require__(419);
+const {codeFrameColumns} = __webpack_require__(420);
+
+const JSONError = errorEx('JSONError', {
+ fileName: errorEx.append('in %s'),
+ codeFrame: errorEx.append('\n\n%s\n')
+});
+
+module.exports = (string, reviver, filename) => {
+ if (typeof reviver === 'string') {
+ filename = reviver;
+ reviver = null;
+ }
+
+ try {
+ try {
+ return JSON.parse(string, reviver);
+ } catch (error) {
+ fallback(string, reviver);
+ throw error;
+ }
+ } catch (error) {
+ error.message = error.message.replace(/\n/g, '');
+ const indexMatch = error.message.match(/in JSON at position (\d+) while parsing near/);
+
+ const jsonError = new JSONError(error);
+ if (filename) {
+ jsonError.fileName = filename;
+ }
+
+ if (indexMatch && indexMatch.length > 0) {
+ const lines = new LinesAndColumns(string);
+ const index = Number(indexMatch[1]);
+ const location = lines.locationForIndex(index);
+
+ const codeFrame = codeFrameColumns(
+ string,
+ {start: {line: location.line + 1, column: location.column + 1}},
+ {highlightCode: true}
+ );
+
+ jsonError.codeFrame = codeFrame;
+ }
+
+ throw jsonError;
+ }
+};
+
+
+/***/ }),
+/* 521 */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = normalize
+
+var fixer = __webpack_require__(522)
+normalize.fixer = fixer
+
+var makeWarning = __webpack_require__(543)
+
+var fieldsToFix = ['name','version','description','repository','modules','scripts'
+ ,'files','bin','man','bugs','keywords','readme','homepage','license']
+var otherThingsToFix = ['dependencies','people', 'typos']
+
+var thingsToFix = fieldsToFix.map(function(fieldName) {
+ return ucFirst(fieldName) + "Field"
+})
+// two ways to do this in CoffeeScript on only one line, sub-70 chars:
+// thingsToFix = fieldsToFix.map (name) -> ucFirst(name) + "Field"
+// thingsToFix = (ucFirst(name) + "Field" for name in fieldsToFix)
+thingsToFix = thingsToFix.concat(otherThingsToFix)
+
+function normalize (data, warn, strict) {
+ if(warn === true) warn = null, strict = true
+ if(!strict) strict = false
+ if(!warn || data.private) warn = function(msg) { /* noop */ }
+
+ if (data.scripts &&
+ data.scripts.install === "node-gyp rebuild" &&
+ !data.scripts.preinstall) {
+ data.gypfile = true
+ }
+ fixer.warn = function() { warn(makeWarning.apply(null, arguments)) }
+ thingsToFix.forEach(function(thingName) {
+ fixer["fix" + ucFirst(thingName)](data, strict)
+ })
+ data._id = data.name + "@" + data.version
+}
+
+function ucFirst (string) {
+ return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+
+/***/ }),
+/* 522 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var semver = __webpack_require__(523)
+var validateLicense = __webpack_require__(524);
+var hostedGitInfo = __webpack_require__(529)
+var isBuiltinModule = __webpack_require__(532).isCore
+var depTypes = ["dependencies","devDependencies","optionalDependencies"]
+var extractDescription = __webpack_require__(541)
+var url = __webpack_require__(439)
+var typos = __webpack_require__(542)
+
+var fixer = module.exports = {
+ // default warning function
+ warn: function() {},
+
+ fixRepositoryField: function(data) {
+ if (data.repositories) {
+ this.warn("repositories");
+ data.repository = data.repositories[0]
+ }
+ if (!data.repository) return this.warn("missingRepository")
+ if (typeof data.repository === "string") {
+ data.repository = {
+ type: "git",
+ url: data.repository
+ }
+ }
+ var r = data.repository.url || ""
+ if (r) {
+ var hosted = hostedGitInfo.fromUrl(r)
+ if (hosted) {
+ r = data.repository.url
+ = hosted.getDefaultRepresentation() == "shortcut" ? hosted.https() : hosted.toString()
+ }
+ }
+
+ if (r.match(/github.com\/[^\/]+\/[^\/]+\.git\.git$/)) {
+ this.warn("brokenGitUrl", r)
+ }
+ }
+
+, fixTypos: function(data) {
+ Object.keys(typos.topLevel).forEach(function (d) {
+ if (data.hasOwnProperty(d)) {
+ this.warn("typo", d, typos.topLevel[d])
+ }
+ }, this)
+ }
+
+, fixScriptsField: function(data) {
+ if (!data.scripts) return
+ if (typeof data.scripts !== "object") {
+ this.warn("nonObjectScripts")
+ delete data.scripts
+ return
+ }
+ Object.keys(data.scripts).forEach(function (k) {
+ if (typeof data.scripts[k] !== "string") {
+ this.warn("nonStringScript")
+ delete data.scripts[k]
+ } else if (typos.script[k] && !data.scripts[typos.script[k]]) {
+ this.warn("typo", k, typos.script[k], "scripts")
+ }
+ }, this)
+ }
+
+, fixFilesField: function(data) {
+ var files = data.files
+ if (files && !Array.isArray(files)) {
+ this.warn("nonArrayFiles")
+ delete data.files
+ } else if (data.files) {
+ data.files = data.files.filter(function(file) {
+ if (!file || typeof file !== "string") {
+ this.warn("invalidFilename", file)
+ return false
+ } else {
+ return true
+ }
+ }, this)
+ }
+ }
+
+, fixBinField: function(data) {
+ if (!data.bin) return;
+ if (typeof data.bin === "string") {
+ var b = {}
+ var match
+ if (match = data.name.match(/^@[^/]+[/](.*)$/)) {
+ b[match[1]] = data.bin
+ } else {
+ b[data.name] = data.bin
+ }
+ data.bin = b
+ }
+ }
+
+, fixManField: function(data) {
+ if (!data.man) return;
+ if (typeof data.man === "string") {
+ data.man = [ data.man ]
+ }
+ }
+, fixBundleDependenciesField: function(data) {
+ var bdd = "bundledDependencies"
+ var bd = "bundleDependencies"
+ if (data[bdd] && !data[bd]) {
+ data[bd] = data[bdd]
+ delete data[bdd]
+ }
+ if (data[bd] && !Array.isArray(data[bd])) {
+ this.warn("nonArrayBundleDependencies")
+ delete data[bd]
+ } else if (data[bd]) {
+ data[bd] = data[bd].filter(function(bd) {
+ if (!bd || typeof bd !== 'string') {
+ this.warn("nonStringBundleDependency", bd)
+ return false
+ } else {
+ if (!data.dependencies) {
+ data.dependencies = {}
+ }
+ if (!data.dependencies.hasOwnProperty(bd)) {
+ this.warn("nonDependencyBundleDependency", bd)
+ data.dependencies[bd] = "*"
+ }
+ return true
+ }
+ }, this)
+ }
+ }
+
+, fixDependencies: function(data, strict) {
+ var loose = !strict
+ objectifyDeps(data, this.warn)
+ addOptionalDepsToDeps(data, this.warn)
+ this.fixBundleDependenciesField(data)
+
+ ;['dependencies','devDependencies'].forEach(function(deps) {
+ if (!(deps in data)) return
+ if (!data[deps] || typeof data[deps] !== "object") {
+ this.warn("nonObjectDependencies", deps)
+ delete data[deps]
+ return
+ }
+ Object.keys(data[deps]).forEach(function (d) {
+ var r = data[deps][d]
+ if (typeof r !== 'string') {
+ this.warn("nonStringDependency", d, JSON.stringify(r))
+ delete data[deps][d]
+ }
+ var hosted = hostedGitInfo.fromUrl(data[deps][d])
+ if (hosted) data[deps][d] = hosted.toString()
+ }, this)
+ }, this)
+ }
+
+, fixModulesField: function (data) {
+ if (data.modules) {
+ this.warn("deprecatedModules")
+ delete data.modules
+ }
+ }
+
+, fixKeywordsField: function (data) {
+ if (typeof data.keywords === "string") {
+ data.keywords = data.keywords.split(/,\s+/)
+ }
+ if (data.keywords && !Array.isArray(data.keywords)) {
+ delete data.keywords
+ this.warn("nonArrayKeywords")
+ } else if (data.keywords) {
+ data.keywords = data.keywords.filter(function(kw) {
+ if (typeof kw !== "string" || !kw) {
+ this.warn("nonStringKeyword");
+ return false
+ } else {
+ return true
+ }
+ }, this)
+ }
+ }
+
+, fixVersionField: function(data, strict) {
+ // allow "loose" semver 1.0 versions in non-strict mode
+ // enforce strict semver 2.0 compliance in strict mode
+ var loose = !strict
+ if (!data.version) {
+ data.version = ""
+ return true
+ }
+ if (!semver.valid(data.version, loose)) {
+ throw new Error('Invalid version: "'+ data.version + '"')
+ }
+ data.version = semver.clean(data.version, loose)
+ return true
+ }
+
+, fixPeople: function(data) {
+ modifyPeople(data, unParsePerson)
+ modifyPeople(data, parsePerson)
+ }
+
+, fixNameField: function(data, options) {
+ if (typeof options === "boolean") options = {strict: options}
+ else if (typeof options === "undefined") options = {}
+ var strict = options.strict
+ if (!data.name && !strict) {
+ data.name = ""
+ return
+ }
+ if (typeof data.name !== "string") {
+ throw new Error("name field must be a string.")
+ }
+ if (!strict)
+ data.name = data.name.trim()
+ ensureValidName(data.name, strict, options.allowLegacyCase)
+ if (isBuiltinModule(data.name))
+ this.warn("conflictingName", data.name)
+ }
+
+
+, fixDescriptionField: function (data) {
+ if (data.description && typeof data.description !== 'string') {
+ this.warn("nonStringDescription")
+ delete data.description
+ }
+ if (data.readme && !data.description)
+ data.description = extractDescription(data.readme)
+ if(data.description === undefined) delete data.description;
+ if (!data.description) this.warn("missingDescription")
+ }
+
+, fixReadmeField: function (data) {
+ if (!data.readme) {
+ this.warn("missingReadme")
+ data.readme = "ERROR: No README data found!"
+ }
+ }
+
+, fixBugsField: function(data) {
+ if (!data.bugs && data.repository && data.repository.url) {
+ var hosted = hostedGitInfo.fromUrl(data.repository.url)
+ if(hosted && hosted.bugs()) {
+ data.bugs = {url: hosted.bugs()}
+ }
+ }
+ else if(data.bugs) {
+ var emailRe = /^.+@.*\..+$/
+ if(typeof data.bugs == "string") {
+ if(emailRe.test(data.bugs))
+ data.bugs = {email:data.bugs}
+ else if(url.parse(data.bugs).protocol)
+ data.bugs = {url: data.bugs}
+ else
+ this.warn("nonEmailUrlBugsString")
+ }
+ else {
+ bugsTypos(data.bugs, this.warn)
+ var oldBugs = data.bugs
+ data.bugs = {}
+ if(oldBugs.url) {
+ if(typeof(oldBugs.url) == "string" && url.parse(oldBugs.url).protocol)
+ data.bugs.url = oldBugs.url
+ else
+ this.warn("nonUrlBugsUrlField")
+ }
+ if(oldBugs.email) {
+ if(typeof(oldBugs.email) == "string" && emailRe.test(oldBugs.email))
+ data.bugs.email = oldBugs.email
+ else
+ this.warn("nonEmailBugsEmailField")
+ }
+ }
+ if(!data.bugs.email && !data.bugs.url) {
+ delete data.bugs
+ this.warn("emptyNormalizedBugs")
+ }
+ }
+ }
+
+, fixHomepageField: function(data) {
+ if (!data.homepage && data.repository && data.repository.url) {
+ var hosted = hostedGitInfo.fromUrl(data.repository.url)
+ if (hosted && hosted.docs()) data.homepage = hosted.docs()
+ }
+ if (!data.homepage) return
+
+ if(typeof data.homepage !== "string") {
+ this.warn("nonUrlHomepage")
+ return delete data.homepage
+ }
+ if(!url.parse(data.homepage).protocol) {
+ data.homepage = "http://" + data.homepage
+ }
+ }
+
+, fixLicenseField: function(data) {
+ if (!data.license) {
+ return this.warn("missingLicense")
+ } else{
+ if (
+ typeof(data.license) !== 'string' ||
+ data.license.length < 1 ||
+ data.license.trim() === ''
+ ) {
+ this.warn("invalidLicense")
+ } else {
+ if (!validateLicense(data.license).validForNewPackages)
+ this.warn("invalidLicense")
+ }
+ }
+ }
+}
+
+function isValidScopedPackageName(spec) {
+ if (spec.charAt(0) !== '@') return false
+
+ var rest = spec.slice(1).split('/')
+ if (rest.length !== 2) return false
+
+ return rest[0] && rest[1] &&
+ rest[0] === encodeURIComponent(rest[0]) &&
+ rest[1] === encodeURIComponent(rest[1])
+}
+
+function isCorrectlyEncodedName(spec) {
+ return !spec.match(/[\/@\s\+%:]/) &&
+ spec === encodeURIComponent(spec)
+}
+
+function ensureValidName (name, strict, allowLegacyCase) {
+ if (name.charAt(0) === "." ||
+ !(isValidScopedPackageName(name) || isCorrectlyEncodedName(name)) ||
+ (strict && (!allowLegacyCase) && name !== name.toLowerCase()) ||
+ name.toLowerCase() === "node_modules" ||
+ name.toLowerCase() === "favicon.ico") {
+ throw new Error("Invalid name: " + JSON.stringify(name))
+ }
+}
+
+function modifyPeople (data, fn) {
+ if (data.author) data.author = fn(data.author)
+ ;["maintainers", "contributors"].forEach(function (set) {
+ if (!Array.isArray(data[set])) return;
+ data[set] = data[set].map(fn)
+ })
+ return data
+}
+
+function unParsePerson (person) {
+ if (typeof person === "string") return person
+ var name = person.name || ""
+ var u = person.url || person.web
+ var url = u ? (" ("+u+")") : ""
+ var e = person.email || person.mail
+ var email = e ? (" <"+e+">") : ""
+ return name+email+url
+}
+
+function parsePerson (person) {
+ if (typeof person !== "string") return person
+ var name = person.match(/^([^\(<]+)/)
+ var url = person.match(/\(([^\)]+)\)/)
+ var email = person.match(/<([^>]+)>/)
+ var obj = {}
+ if (name && name[0].trim()) obj.name = name[0].trim()
+ if (email) obj.email = email[1];
+ if (url) obj.url = url[1];
+ return obj
+}
+
+function addOptionalDepsToDeps (data, warn) {
+ var o = data.optionalDependencies
+ if (!o) return;
+ var d = data.dependencies || {}
+ Object.keys(o).forEach(function (k) {
+ d[k] = o[k]
+ })
+ data.dependencies = d
+}
+
+function depObjectify (deps, type, warn) {
+ if (!deps) return {}
+ if (typeof deps === "string") {
+ deps = deps.trim().split(/[\n\r\s\t ,]+/)
+ }
+ if (!Array.isArray(deps)) return deps
+ warn("deprecatedArrayDependencies", type)
+ var o = {}
+ deps.filter(function (d) {
+ return typeof d === "string"
+ }).forEach(function(d) {
+ d = d.trim().split(/(:?[@\s><=])/)
+ var dn = d.shift()
+ var dv = d.join("")
+ dv = dv.trim()
+ dv = dv.replace(/^@/, "")
+ o[dn] = dv
+ })
+ return o
+}
+
+function objectifyDeps (data, warn) {
+ depTypes.forEach(function (type) {
+ if (!data[type]) return;
+ data[type] = depObjectify(data[type], type, warn)
+ })
+}
+
+function bugsTypos(bugs, warn) {
+ if (!bugs) return
+ Object.keys(bugs).forEach(function (k) {
+ if (typos.bugs[k]) {
+ warn("typo", k, typos.bugs[k], "bugs")
+ bugs[typos.bugs[k]] = bugs[k]
+ delete bugs[k]
+ }
+ })
+}
+
+
+/***/ }),
+/* 523 */
+/***/ (function(module, exports) {
+
+exports = module.exports = SemVer
+
+var debug
+/* istanbul ignore next */
+if (typeof process === 'object' &&
+ process.env &&
+ process.env.NODE_DEBUG &&
+ /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
+ debug = function () {
+ var args = Array.prototype.slice.call(arguments, 0)
+ args.unshift('SEMVER')
+ console.log.apply(console, args)
+ }
+} else {
+ debug = function () {}
+}
+
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+exports.SEMVER_SPEC_VERSION = '2.0.0'
+
+var MAX_LENGTH = 256
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
+ /* istanbul ignore next */ 9007199254740991
+
+// Max safe segment length for coercion.
+var MAX_SAFE_COMPONENT_LENGTH = 16
+
+// The actual regexps go on exports.re
+var re = exports.re = []
+var src = exports.src = []
+var R = 0
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+var NUMERICIDENTIFIER = R++
+src[NUMERICIDENTIFIER] = '0|[1-9]\\d*'
+var NUMERICIDENTIFIERLOOSE = R++
+src[NUMERICIDENTIFIERLOOSE] = '[0-9]+'
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+var NONNUMERICIDENTIFIER = R++
+src[NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+var MAINVERSION = R++
+src[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIER] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIER] + ')'
+
+var MAINVERSIONLOOSE = R++
+src[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\.' +
+ '(' + src[NUMERICIDENTIFIERLOOSE] + ')'
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+var PRERELEASEIDENTIFIER = R++
+src[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +
+ '|' + src[NONNUMERICIDENTIFIER] + ')'
+
+var PRERELEASEIDENTIFIERLOOSE = R++
+src[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +
+ '|' + src[NONNUMERICIDENTIFIER] + ')'
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+var PRERELEASE = R++
+src[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +
+ '(?:\\.' + src[PRERELEASEIDENTIFIER] + ')*))'
+
+var PRERELEASELOOSE = R++
+src[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +
+ '(?:\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+var BUILDIDENTIFIER = R++
+src[BUILDIDENTIFIER] = '[0-9A-Za-z-]+'
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+var BUILD = R++
+src[BUILD] = '(?:\\+(' + src[BUILDIDENTIFIER] +
+ '(?:\\.' + src[BUILDIDENTIFIER] + ')*))'
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups. The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+var FULL = R++
+var FULLPLAIN = 'v?' + src[MAINVERSION] +
+ src[PRERELEASE] + '?' +
+ src[BUILD] + '?'
+
+src[FULL] = '^' + FULLPLAIN + '$'
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+var LOOSEPLAIN = '[v=\\s]*' + src[MAINVERSIONLOOSE] +
+ src[PRERELEASELOOSE] + '?' +
+ src[BUILD] + '?'
+
+var LOOSE = R++
+src[LOOSE] = '^' + LOOSEPLAIN + '$'
+
+var GTLT = R++
+src[GTLT] = '((?:<|>)?=?)'
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+var XRANGEIDENTIFIERLOOSE = R++
+src[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\*'
+var XRANGEIDENTIFIER = R++
+src[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\*'
+
+var XRANGEPLAIN = R++
+src[XRANGEPLAIN] = '[v=\\s]*(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIER] + ')' +
+ '(?:' + src[PRERELEASE] + ')?' +
+ src[BUILD] + '?' +
+ ')?)?'
+
+var XRANGEPLAINLOOSE = R++
+src[XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +
+ '(?:' + src[PRERELEASELOOSE] + ')?' +
+ src[BUILD] + '?' +
+ ')?)?'
+
+var XRANGE = R++
+src[XRANGE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAIN] + '$'
+var XRANGELOOSE = R++
+src[XRANGELOOSE] = '^' + src[GTLT] + '\\s*' + src[XRANGEPLAINLOOSE] + '$'
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+var COERCE = R++
+src[COERCE] = '(?:^|[^\\d])' +
+ '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
+ '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+ '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+ '(?:$|[^\\d])'
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+var LONETILDE = R++
+src[LONETILDE] = '(?:~>?)'
+
+var TILDETRIM = R++
+src[TILDETRIM] = '(\\s*)' + src[LONETILDE] + '\\s+'
+re[TILDETRIM] = new RegExp(src[TILDETRIM], 'g')
+var tildeTrimReplace = '$1~'
+
+var TILDE = R++
+src[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'
+var TILDELOOSE = R++
+src[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+var LONECARET = R++
+src[LONECARET] = '(?:\\^)'
+
+var CARETTRIM = R++
+src[CARETTRIM] = '(\\s*)' + src[LONECARET] + '\\s+'
+re[CARETTRIM] = new RegExp(src[CARETTRIM], 'g')
+var caretTrimReplace = '$1^'
+
+var CARET = R++
+src[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'
+var CARETLOOSE = R++
+src[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+var COMPARATORLOOSE = R++
+src[COMPARATORLOOSE] = '^' + src[GTLT] + '\\s*(' + LOOSEPLAIN + ')$|^$'
+var COMPARATOR = R++
+src[COMPARATOR] = '^' + src[GTLT] + '\\s*(' + FULLPLAIN + ')$|^$'
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+var COMPARATORTRIM = R++
+src[COMPARATORTRIM] = '(\\s*)' + src[GTLT] +
+ '\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'
+
+// this one has to use the /g flag
+re[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g')
+var comparatorTrimReplace = '$1$2$3'
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+var HYPHENRANGE = R++
+src[HYPHENRANGE] = '^\\s*(' + src[XRANGEPLAIN] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[XRANGEPLAIN] + ')' +
+ '\\s*$'
+
+var HYPHENRANGELOOSE = R++
+src[HYPHENRANGELOOSE] = '^\\s*(' + src[XRANGEPLAINLOOSE] + ')' +
+ '\\s+-\\s+' +
+ '(' + src[XRANGEPLAINLOOSE] + ')' +
+ '\\s*$'
+
+// Star ranges basically just allow anything at all.
+var STAR = R++
+src[STAR] = '(<|>)?=?\\s*\\*'
+
+// Compile to actual regexp objects.
+// All are flag-free, unless they were created above with a flag.
+for (var i = 0; i < R; i++) {
+ debug(i, src[i])
+ if (!re[i]) {
+ re[i] = new RegExp(src[i])
+ }
+}
+
+exports.parse = parse
+function parse (version, options) {
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ }
+ }
+
+ if (version instanceof SemVer) {
+ return version
+ }
+
+ if (typeof version !== 'string') {
+ return null
+ }
+
+ if (version.length > MAX_LENGTH) {
+ return null
+ }
+
+ var r = options.loose ? re[LOOSE] : re[FULL]
+ if (!r.test(version)) {
+ return null
+ }
+
+ try {
+ return new SemVer(version, options)
+ } catch (er) {
+ return null
+ }
+}
+
+exports.valid = valid
+function valid (version, options) {
+ var v = parse(version, options)
+ return v ? v.version : null
+}
+
+exports.clean = clean
+function clean (version, options) {
+ var s = parse(version.trim().replace(/^[=v]+/, ''), options)
+ return s ? s.version : null
+}
+
+exports.SemVer = SemVer
+
+function SemVer (version, options) {
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ }
+ }
+ if (version instanceof SemVer) {
+ if (version.loose === options.loose) {
+ return version
+ } else {
+ version = version.version
+ }
+ } else if (typeof version !== 'string') {
+ throw new TypeError('Invalid Version: ' + version)
+ }
+
+ if (version.length > MAX_LENGTH) {
+ throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
+ }
+
+ if (!(this instanceof SemVer)) {
+ return new SemVer(version, options)
+ }
+
+ debug('SemVer', version, options)
+ this.options = options
+ this.loose = !!options.loose
+
+ var m = version.trim().match(options.loose ? re[LOOSE] : re[FULL])
+
+ if (!m) {
+ throw new TypeError('Invalid Version: ' + version)
+ }
+
+ this.raw = version
+
+ // these are actually numbers
+ this.major = +m[1]
+ this.minor = +m[2]
+ this.patch = +m[3]
+
+ if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+ throw new TypeError('Invalid major version')
+ }
+
+ if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+ throw new TypeError('Invalid minor version')
+ }
+
+ if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+ throw new TypeError('Invalid patch version')
+ }
+
+ // numberify any prerelease numeric ids
+ if (!m[4]) {
+ this.prerelease = []
+ } else {
+ this.prerelease = m[4].split('.').map(function (id) {
+ if (/^[0-9]+$/.test(id)) {
+ var num = +id
+ if (num >= 0 && num < MAX_SAFE_INTEGER) {
+ return num
+ }
+ }
+ return id
+ })
+ }
+
+ this.build = m[5] ? m[5].split('.') : []
+ this.format()
}
-},
-rules: [/^(?:$)/,/^(?:\s+)/,/^(?:\+)/,/^(?:\()/,/^(?:\))/,/^(?::)/,/^(?:DocumentRef-([0-9A-Za-z-+.]+))/,/^(?:LicenseRef-([0-9A-Za-z-+.]+))/,/^(?:AND)/,/^(?:OR)/,/^(?:WITH)/,/^(?:BSD-3-Clause-No-Nuclear-License-2014)/,/^(?:BSD-3-Clause-No-Nuclear-Warranty)/,/^(?:GPL-2\.0-with-classpath-exception)/,/^(?:GPL-3\.0-with-autoconf-exception)/,/^(?:GPL-2\.0-with-autoconf-exception)/,/^(?:BSD-3-Clause-No-Nuclear-License)/,/^(?:MPL-2\.0-no-copyleft-exception)/,/^(?:GPL-2\.0-with-bison-exception)/,/^(?:GPL-2\.0-with-font-exception)/,/^(?:GPL-2\.0-with-GCC-exception)/,/^(?:CNRI-Python-GPL-Compatible)/,/^(?:GPL-3\.0-with-GCC-exception)/,/^(?:BSD-3-Clause-Attribution)/,/^(?:Classpath-exception-2\.0)/,/^(?:WxWindows-exception-3\.1)/,/^(?:freertos-exception-2\.0)/,/^(?:Autoconf-exception-3\.0)/,/^(?:i2p-gpl-java-exception)/,/^(?:gnu-javamail-exception)/,/^(?:Nokia-Qt-exception-1\.1)/,/^(?:Autoconf-exception-2\.0)/,/^(?:BSD-2-Clause-FreeBSD)/,/^(?:u-boot-exception-2\.0)/,/^(?:zlib-acknowledgement)/,/^(?:Bison-exception-2\.2)/,/^(?:BSD-2-Clause-NetBSD)/,/^(?:CLISP-exception-2\.0)/,/^(?:eCos-exception-2\.0)/,/^(?:BSD-3-Clause-Clear)/,/^(?:Font-exception-2\.0)/,/^(?:FLTK-exception-2\.0)/,/^(?:GCC-exception-2\.0)/,/^(?:Qwt-exception-1\.0)/,/^(?:Libtool-exception)/,/^(?:BSD-3-Clause-LBNL)/,/^(?:GCC-exception-3\.1)/,/^(?:Artistic-1\.0-Perl)/,/^(?:Artistic-1\.0-cl8)/,/^(?:CC-BY-NC-SA-2\.5)/,/^(?:MIT-advertising)/,/^(?:BSD-Source-Code)/,/^(?:CC-BY-NC-SA-4\.0)/,/^(?:LiLiQ-Rplus-1\.1)/,/^(?:CC-BY-NC-SA-3\.0)/,/^(?:BSD-4-Clause-UC)/,/^(?:CC-BY-NC-SA-2\.0)/,/^(?:CC-BY-NC-SA-1\.0)/,/^(?:CC-BY-NC-ND-4\.0)/,/^(?:CC-BY-NC-ND-3\.0)/,/^(?:CC-BY-NC-ND-2\.5)/,/^(?:CC-BY-NC-ND-2\.0)/,/^(?:CC-BY-NC-ND-1\.0)/,/^(?:LZMA-exception)/,/^(?:BitTorrent-1\.1)/,/^(?:CrystalStacker)/,/^(?:FLTK-exception)/,/^(?:SugarCRM-1\.1\.3)/,/^(?:BSD-Protection)/,/^(?:BitTorrent-1\.0)/,/^(?:HaskellReport)/,/^(?:Interbase-1\.0)/,/^(?:StandardML-NJ)/,/^(?:mif-exception)/,/^(?:Frameworx-1\.0)/,/^(?:389-exception)/,/^(?:CC-BY-NC-2\.0)/,/^(?:CC-BY-NC-2\.5)/,/^(?:CC-BY-NC-3\.0)/,/^(?:CC-BY-NC-4\.0)/,/^(?:W3C-19980720)/,/^(?:CC-BY-SA-1\.0)/,/^(?:CC-BY-SA-2\.0)/,/^(?:CC-BY-SA-2\.5)/,/^(?:CC-BY-ND-2\.0)/,/^(?:CC-BY-SA-4\.0)/,/^(?:CC-BY-SA-3\.0)/,/^(?:Artistic-1\.0)/,/^(?:Artistic-2\.0)/,/^(?:CC-BY-ND-2\.5)/,/^(?:CC-BY-ND-3\.0)/,/^(?:CC-BY-ND-4\.0)/,/^(?:CC-BY-ND-1\.0)/,/^(?:BSD-4-Clause)/,/^(?:BSD-3-Clause)/,/^(?:BSD-2-Clause)/,/^(?:CC-BY-NC-1\.0)/,/^(?:bzip2-1\.0\.6)/,/^(?:Unicode-TOU)/,/^(?:CNRI-Jython)/,/^(?:ImageMagick)/,/^(?:Adobe-Glyph)/,/^(?:CUA-OPL-1\.0)/,/^(?:OLDAP-2\.2\.2)/,/^(?:LiLiQ-R-1\.1)/,/^(?:bzip2-1\.0\.5)/,/^(?:LiLiQ-P-1\.1)/,/^(?:OLDAP-2\.0\.1)/,/^(?:OLDAP-2\.2\.1)/,/^(?:CNRI-Python)/,/^(?:XFree86-1\.1)/,/^(?:OSET-PL-2\.1)/,/^(?:Apache-2\.0)/,/^(?:Watcom-1\.0)/,/^(?:PostgreSQL)/,/^(?:Python-2\.0)/,/^(?:RHeCos-1\.1)/,/^(?:EUDatagrid)/,/^(?:Spencer-99)/,/^(?:Intel-ACPI)/,/^(?:CECILL-1\.0)/,/^(?:CECILL-1\.1)/,/^(?:JasPer-2\.0)/,/^(?:CECILL-2\.0)/,/^(?:CECILL-2\.1)/,/^(?:gSOAP-1\.3b)/,/^(?:Spencer-94)/,/^(?:Apache-1\.1)/,/^(?:Spencer-86)/,/^(?:Apache-1\.0)/,/^(?:ClArtistic)/,/^(?:TORQUE-1\.1)/,/^(?:CATOSL-1\.1)/,/^(?:Adobe-2006)/,/^(?:Zimbra-1\.4)/,/^(?:Zimbra-1\.3)/,/^(?:Condor-1\.1)/,/^(?:CC-BY-3\.0)/,/^(?:CC-BY-2\.5)/,/^(?:OLDAP-2\.4)/,/^(?:SGI-B-1\.1)/,/^(?:SISSL-1\.2)/,/^(?:SGI-B-1\.0)/,/^(?:OLDAP-2\.3)/,/^(?:CC-BY-4\.0)/,/^(?:Crossword)/,/^(?:SimPL-2\.0)/,/^(?:OLDAP-2\.2)/,/^(?:OLDAP-2\.1)/,/^(?:ErlPL-1\.1)/,/^(?:LPPL-1\.3a)/,/^(?:LPPL-1\.3c)/,/^(?:OLDAP-2\.0)/,/^(?:Leptonica)/,/^(?:CPOL-1\.02)/,/^(?:OLDAP-1\.4)/,/^(?:OLDAP-1\.3)/,/^(?:CC-BY-2\.0)/,/^(?:Unlicense)/,/^(?:OLDAP-2\.8)/,/^(?:OLDAP-1\.2)/,/^(?:MakeIndex)/,/^(?:OLDAP-2\.7)/,/^(?:OLDAP-1\.1)/,/^(?:Sleepycat)/,/^(?:D-FSL-1\.0)/,/^(?:CC-BY-1\.0)/,/^(?:OLDAP-2\.6)/,/^(?:WXwindows)/,/^(?:NPOSL-3\.0)/,/^(?:FreeImage)/,/^(?:SGI-B-2\.0)/,/^(?:OLDAP-2\.5)/,/^(?:Beerware)/,/^(?:Newsletr)/,/^(?:NBPL-1\.0)/,/^(?:NASA-1\.3)/,/^(?:NLOD-1\.0)/,/^(?:AGPL-1\.0)/,/^(?:OCLC-2\.0)/,/^(?:ODbL-1\.0)/,/^(?:PDDL-1\.0)/,/^(?:Motosoto)/,/^(?:Afmparse)/,/^(?:ANTLR-PD)/,/^(?:LPL-1\.02)/,/^(?:Abstyles)/,/^(?:eCos-2\.0)/,/^(?:APSL-1\.0)/,/^(?:LPPL-1\.2)/,/^(?:LPPL-1\.1)/,/^(?:LPPL-1\.0)/,/^(?:APSL-1\.1)/,/^(?:APSL-2\.0)/,/^(?:Info-ZIP)/,/^(?:Zend-2\.0)/,/^(?:IBM-pibs)/,/^(?:LGPL-2\.0)/,/^(?:LGPL-3\.0)/,/^(?:LGPL-2\.1)/,/^(?:GFDL-1\.3)/,/^(?:PHP-3\.01)/,/^(?:GFDL-1\.2)/,/^(?:GFDL-1\.1)/,/^(?:AGPL-3\.0)/,/^(?:Giftware)/,/^(?:EUPL-1\.1)/,/^(?:RPSL-1\.0)/,/^(?:EUPL-1\.0)/,/^(?:MIT-enna)/,/^(?:CECILL-B)/,/^(?:diffmark)/,/^(?:CECILL-C)/,/^(?:CDDL-1\.0)/,/^(?:Sendmail)/,/^(?:CDDL-1\.1)/,/^(?:CPAL-1\.0)/,/^(?:APSL-1\.2)/,/^(?:NPL-1\.1)/,/^(?:AFL-1\.2)/,/^(?:Caldera)/,/^(?:AFL-2\.0)/,/^(?:FSFULLR)/,/^(?:AFL-2\.1)/,/^(?:VSL-1\.0)/,/^(?:VOSTROM)/,/^(?:UPL-1\.0)/,/^(?:Dotseqn)/,/^(?:CPL-1\.0)/,/^(?:dvipdfm)/,/^(?:EPL-1\.0)/,/^(?:OCCT-PL)/,/^(?:ECL-1\.0)/,/^(?:Latex2e)/,/^(?:ECL-2\.0)/,/^(?:GPL-1\.0)/,/^(?:GPL-2\.0)/,/^(?:GPL-3\.0)/,/^(?:AFL-3\.0)/,/^(?:LAL-1\.2)/,/^(?:LAL-1\.3)/,/^(?:EFL-1\.0)/,/^(?:EFL-2\.0)/,/^(?:gnuplot)/,/^(?:Aladdin)/,/^(?:LPL-1\.0)/,/^(?:libtiff)/,/^(?:Entessa)/,/^(?:AMDPLPA)/,/^(?:IPL-1\.0)/,/^(?:OPL-1\.0)/,/^(?:OSL-1\.0)/,/^(?:OSL-1\.1)/,/^(?:OSL-2\.0)/,/^(?:OSL-2\.1)/,/^(?:OSL-3\.0)/,/^(?:OpenSSL)/,/^(?:ZPL-2\.1)/,/^(?:PHP-3\.0)/,/^(?:ZPL-2\.0)/,/^(?:ZPL-1\.1)/,/^(?:CC0-1\.0)/,/^(?:SPL-1\.0)/,/^(?:psutils)/,/^(?:MPL-1\.0)/,/^(?:QPL-1\.0)/,/^(?:MPL-1\.1)/,/^(?:MPL-2\.0)/,/^(?:APL-1\.0)/,/^(?:RPL-1\.1)/,/^(?:RPL-1\.5)/,/^(?:MIT-CMU)/,/^(?:Multics)/,/^(?:Eurosym)/,/^(?:BSL-1\.0)/,/^(?:MIT-feh)/,/^(?:Saxpath)/,/^(?:Borceux)/,/^(?:OFL-1\.1)/,/^(?:OFL-1\.0)/,/^(?:AFL-1\.1)/,/^(?:YPL-1\.1)/,/^(?:YPL-1\.0)/,/^(?:NPL-1\.0)/,/^(?:iMatix)/,/^(?:mpich2)/,/^(?:APAFML)/,/^(?:Bahyph)/,/^(?:RSA-MD)/,/^(?:psfrag)/,/^(?:Plexus)/,/^(?:eGenix)/,/^(?:Glulxe)/,/^(?:SAX-PD)/,/^(?:Imlib2)/,/^(?:Wsuipa)/,/^(?:LGPLLR)/,/^(?:Libpng)/,/^(?:xinetd)/,/^(?:MITNFA)/,/^(?:NetCDF)/,/^(?:Naumen)/,/^(?:SMPPL)/,/^(?:Nunit)/,/^(?:FSFUL)/,/^(?:GL2PS)/,/^(?:SMLNJ)/,/^(?:Rdisc)/,/^(?:Noweb)/,/^(?:Nokia)/,/^(?:SISSL)/,/^(?:Qhull)/,/^(?:Intel)/,/^(?:Glide)/,/^(?:Xerox)/,/^(?:AMPAS)/,/^(?:WTFPL)/,/^(?:MS-PL)/,/^(?:XSkat)/,/^(?:MS-RL)/,/^(?:MirOS)/,/^(?:RSCPL)/,/^(?:TMate)/,/^(?:OGTSL)/,/^(?:FSFAP)/,/^(?:NCSA)/,/^(?:Zlib)/,/^(?:SCEA)/,/^(?:SNIA)/,/^(?:NGPL)/,/^(?:NOSL)/,/^(?:ADSL)/,/^(?:MTLL)/,/^(?:NLPL)/,/^(?:Ruby)/,/^(?:JSON)/,/^(?:Barr)/,/^(?:0BSD)/,/^(?:Xnet)/,/^(?:Cube)/,/^(?:curl)/,/^(?:DSDP)/,/^(?:Fair)/,/^(?:HPND)/,/^(?:TOSL)/,/^(?:IJG)/,/^(?:SWL)/,/^(?:Vim)/,/^(?:FTL)/,/^(?:ICU)/,/^(?:OML)/,/^(?:NRL)/,/^(?:DOC)/,/^(?:TCL)/,/^(?:W3C)/,/^(?:NTP)/,/^(?:IPA)/,/^(?:ISC)/,/^(?:X11)/,/^(?:AAL)/,/^(?:AML)/,/^(?:xpp)/,/^(?:Zed)/,/^(?:MIT)/,/^(?:Mup)/],
-conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364],"inclusive":true}}
-});
-return lexer;
-})();
-parser.lexer = lexer;
-function Parser () {
- this.yy = {};
+
+SemVer.prototype.format = function () {
+ this.version = this.major + '.' + this.minor + '.' + this.patch
+ if (this.prerelease.length) {
+ this.version += '-' + this.prerelease.join('.')
+ }
+ return this.version
}
-Parser.prototype = parser;parser.Parser = Parser;
-return new Parser;
-})();
+SemVer.prototype.toString = function () {
+ return this.version
+}
+
+SemVer.prototype.compare = function (other) {
+ debug('SemVer.compare', this.version, this.options, other)
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options)
+ }
+
+ return this.compareMain(other) || this.comparePre(other)
+}
+
+SemVer.prototype.compareMain = function (other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options)
+ }
+
+ return compareIdentifiers(this.major, other.major) ||
+ compareIdentifiers(this.minor, other.minor) ||
+ compareIdentifiers(this.patch, other.patch)
+}
+
+SemVer.prototype.comparePre = function (other) {
+ if (!(other instanceof SemVer)) {
+ other = new SemVer(other, this.options)
+ }
+
+ // NOT having a prerelease is > having one
+ if (this.prerelease.length && !other.prerelease.length) {
+ return -1
+ } else if (!this.prerelease.length && other.prerelease.length) {
+ return 1
+ } else if (!this.prerelease.length && !other.prerelease.length) {
+ return 0
+ }
+
+ var i = 0
+ do {
+ var a = this.prerelease[i]
+ var b = other.prerelease[i]
+ debug('prerelease compare', i, a, b)
+ if (a === undefined && b === undefined) {
+ return 0
+ } else if (b === undefined) {
+ return 1
+ } else if (a === undefined) {
+ return -1
+ } else if (a === b) {
+ continue
+ } else {
+ return compareIdentifiers(a, b)
+ }
+ } while (++i)
+}
+
+// preminor will bump the version up to the next minor release, and immediately
+// down to pre-release. premajor and prepatch work the same way.
+SemVer.prototype.inc = function (release, identifier) {
+ switch (release) {
+ case 'premajor':
+ this.prerelease.length = 0
+ this.patch = 0
+ this.minor = 0
+ this.major++
+ this.inc('pre', identifier)
+ break
+ case 'preminor':
+ this.prerelease.length = 0
+ this.patch = 0
+ this.minor++
+ this.inc('pre', identifier)
+ break
+ case 'prepatch':
+ // If this is already a prerelease, it will bump to the next version
+ // drop any prereleases that might already exist, since they are not
+ // relevant at this point.
+ this.prerelease.length = 0
+ this.inc('patch', identifier)
+ this.inc('pre', identifier)
+ break
+ // If the input is a non-prerelease version, this acts the same as
+ // prepatch.
+ case 'prerelease':
+ if (this.prerelease.length === 0) {
+ this.inc('patch', identifier)
+ }
+ this.inc('pre', identifier)
+ break
+
+ case 'major':
+ // If this is a pre-major version, bump up to the same major version.
+ // Otherwise increment major.
+ // 1.0.0-5 bumps to 1.0.0
+ // 1.1.0 bumps to 2.0.0
+ if (this.minor !== 0 ||
+ this.patch !== 0 ||
+ this.prerelease.length === 0) {
+ this.major++
+ }
+ this.minor = 0
+ this.patch = 0
+ this.prerelease = []
+ break
+ case 'minor':
+ // If this is a pre-minor version, bump up to the same minor version.
+ // Otherwise increment minor.
+ // 1.2.0-5 bumps to 1.2.0
+ // 1.2.1 bumps to 1.3.0
+ if (this.patch !== 0 || this.prerelease.length === 0) {
+ this.minor++
+ }
+ this.patch = 0
+ this.prerelease = []
+ break
+ case 'patch':
+ // If this is not a pre-release version, it will increment the patch.
+ // If it is a pre-release it will bump up to the same patch version.
+ // 1.2.0-5 patches to 1.2.0
+ // 1.2.0 patches to 1.2.1
+ if (this.prerelease.length === 0) {
+ this.patch++
+ }
+ this.prerelease = []
+ break
+ // This probably shouldn't be used publicly.
+ // 1.0.0 "pre" would become 1.0.0-0 which is the wrong direction.
+ case 'pre':
+ if (this.prerelease.length === 0) {
+ this.prerelease = [0]
+ } else {
+ var i = this.prerelease.length
+ while (--i >= 0) {
+ if (typeof this.prerelease[i] === 'number') {
+ this.prerelease[i]++
+ i = -2
+ }
+ }
+ if (i === -1) {
+ // didn't increment anything
+ this.prerelease.push(0)
+ }
+ }
+ if (identifier) {
+ // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+ // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+ if (this.prerelease[0] === identifier) {
+ if (isNaN(this.prerelease[1])) {
+ this.prerelease = [identifier, 0]
+ }
+ } else {
+ this.prerelease = [identifier, 0]
+ }
+ }
+ break
+
+ default:
+ throw new Error('invalid increment argument: ' + release)
+ }
+ this.format()
+ this.raw = this.version
+ return this
+}
+
+exports.inc = inc
+function inc (version, release, loose, identifier) {
+ if (typeof (loose) === 'string') {
+ identifier = loose
+ loose = undefined
+ }
+
+ try {
+ return new SemVer(version, loose).inc(release, identifier).version
+ } catch (er) {
+ return null
+ }
+}
+
+exports.diff = diff
+function diff (version1, version2) {
+ if (eq(version1, version2)) {
+ return null
+ } else {
+ var v1 = parse(version1)
+ var v2 = parse(version2)
+ var prefix = ''
+ if (v1.prerelease.length || v2.prerelease.length) {
+ prefix = 'pre'
+ var defaultResult = 'prerelease'
+ }
+ for (var key in v1) {
+ if (key === 'major' || key === 'minor' || key === 'patch') {
+ if (v1[key] !== v2[key]) {
+ return prefix + key
+ }
+ }
+ }
+ return defaultResult // may be undefined
+ }
+}
+
+exports.compareIdentifiers = compareIdentifiers
+
+var numeric = /^[0-9]+$/
+function compareIdentifiers (a, b) {
+ var anum = numeric.test(a)
+ var bnum = numeric.test(b)
+
+ if (anum && bnum) {
+ a = +a
+ b = +b
+ }
+
+ return a === b ? 0
+ : (anum && !bnum) ? -1
+ : (bnum && !anum) ? 1
+ : a < b ? -1
+ : 1
+}
+
+exports.rcompareIdentifiers = rcompareIdentifiers
+function rcompareIdentifiers (a, b) {
+ return compareIdentifiers(b, a)
+}
+
+exports.major = major
+function major (a, loose) {
+ return new SemVer(a, loose).major
+}
+
+exports.minor = minor
+function minor (a, loose) {
+ return new SemVer(a, loose).minor
+}
+
+exports.patch = patch
+function patch (a, loose) {
+ return new SemVer(a, loose).patch
+}
+
+exports.compare = compare
+function compare (a, b, loose) {
+ return new SemVer(a, loose).compare(new SemVer(b, loose))
+}
+
+exports.compareLoose = compareLoose
+function compareLoose (a, b) {
+ return compare(a, b, true)
+}
+
+exports.rcompare = rcompare
+function rcompare (a, b, loose) {
+ return compare(b, a, loose)
+}
+
+exports.sort = sort
+function sort (list, loose) {
+ return list.sort(function (a, b) {
+ return exports.compare(a, b, loose)
+ })
+}
+
+exports.rsort = rsort
+function rsort (list, loose) {
+ return list.sort(function (a, b) {
+ return exports.rcompare(a, b, loose)
+ })
+}
+
+exports.gt = gt
+function gt (a, b, loose) {
+ return compare(a, b, loose) > 0
+}
+
+exports.lt = lt
+function lt (a, b, loose) {
+ return compare(a, b, loose) < 0
+}
+
+exports.eq = eq
+function eq (a, b, loose) {
+ return compare(a, b, loose) === 0
+}
+
+exports.neq = neq
+function neq (a, b, loose) {
+ return compare(a, b, loose) !== 0
+}
+
+exports.gte = gte
+function gte (a, b, loose) {
+ return compare(a, b, loose) >= 0
+}
+
+exports.lte = lte
+function lte (a, b, loose) {
+ return compare(a, b, loose) <= 0
+}
+
+exports.cmp = cmp
+function cmp (a, op, b, loose) {
+ switch (op) {
+ case '===':
+ if (typeof a === 'object')
+ a = a.version
+ if (typeof b === 'object')
+ b = b.version
+ return a === b
+
+ case '!==':
+ if (typeof a === 'object')
+ a = a.version
+ if (typeof b === 'object')
+ b = b.version
+ return a !== b
+
+ case '':
+ case '=':
+ case '==':
+ return eq(a, b, loose)
+
+ case '!=':
+ return neq(a, b, loose)
+
+ case '>':
+ return gt(a, b, loose)
+
+ case '>=':
+ return gte(a, b, loose)
+
+ case '<':
+ return lt(a, b, loose)
+
+ case '<=':
+ return lte(a, b, loose)
+
+ default:
+ throw new TypeError('Invalid operator: ' + op)
+ }
+}
+
+exports.Comparator = Comparator
+function Comparator (comp, options) {
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ }
+ }
+
+ if (comp instanceof Comparator) {
+ if (comp.loose === !!options.loose) {
+ return comp
+ } else {
+ comp = comp.value
+ }
+ }
+
+ if (!(this instanceof Comparator)) {
+ return new Comparator(comp, options)
+ }
+
+ debug('comparator', comp, options)
+ this.options = options
+ this.loose = !!options.loose
+ this.parse(comp)
+
+ if (this.semver === ANY) {
+ this.value = ''
+ } else {
+ this.value = this.operator + this.semver.version
+ }
+
+ debug('comp', this)
+}
+
+var ANY = {}
+Comparator.prototype.parse = function (comp) {
+ var r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
+ var m = comp.match(r)
+
+ if (!m) {
+ throw new TypeError('Invalid comparator: ' + comp)
+ }
+
+ this.operator = m[1]
+ if (this.operator === '=') {
+ this.operator = ''
+ }
+
+ // if it literally is just '>' or '' then allow anything.
+ if (!m[2]) {
+ this.semver = ANY
+ } else {
+ this.semver = new SemVer(m[2], this.options.loose)
+ }
+}
+
+Comparator.prototype.toString = function () {
+ return this.value
+}
+
+Comparator.prototype.test = function (version) {
+ debug('Comparator.test', version, this.options.loose)
+
+ if (this.semver === ANY) {
+ return true
+ }
+
+ if (typeof version === 'string') {
+ version = new SemVer(version, this.options)
+ }
+
+ return cmp(version, this.operator, this.semver, this.options)
+}
+
+Comparator.prototype.intersects = function (comp, options) {
+ if (!(comp instanceof Comparator)) {
+ throw new TypeError('a Comparator is required')
+ }
+
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ }
+ }
+
+ var rangeTmp
+
+ if (this.operator === '') {
+ rangeTmp = new Range(comp.value, options)
+ return satisfies(this.value, rangeTmp, options)
+ } else if (comp.operator === '') {
+ rangeTmp = new Range(this.value, options)
+ return satisfies(comp.semver, rangeTmp, options)
+ }
+
+ var sameDirectionIncreasing =
+ (this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '>=' || comp.operator === '>')
+ var sameDirectionDecreasing =
+ (this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '<=' || comp.operator === '<')
+ var sameSemVer = this.semver.version === comp.semver.version
+ var differentDirectionsInclusive =
+ (this.operator === '>=' || this.operator === '<=') &&
+ (comp.operator === '>=' || comp.operator === '<=')
+ var oppositeDirectionsLessThan =
+ cmp(this.semver, '<', comp.semver, options) &&
+ ((this.operator === '>=' || this.operator === '>') &&
+ (comp.operator === '<=' || comp.operator === '<'))
+ var oppositeDirectionsGreaterThan =
+ cmp(this.semver, '>', comp.semver, options) &&
+ ((this.operator === '<=' || this.operator === '<') &&
+ (comp.operator === '>=' || comp.operator === '>'))
+
+ return sameDirectionIncreasing || sameDirectionDecreasing ||
+ (sameSemVer && differentDirectionsInclusive) ||
+ oppositeDirectionsLessThan || oppositeDirectionsGreaterThan
+}
+
+exports.Range = Range
+function Range (range, options) {
+ if (!options || typeof options !== 'object') {
+ options = {
+ loose: !!options,
+ includePrerelease: false
+ }
+ }
+
+ if (range instanceof Range) {
+ if (range.loose === !!options.loose &&
+ range.includePrerelease === !!options.includePrerelease) {
+ return range
+ } else {
+ return new Range(range.raw, options)
+ }
+ }
+
+ if (range instanceof Comparator) {
+ return new Range(range.value, options)
+ }
+
+ if (!(this instanceof Range)) {
+ return new Range(range, options)
+ }
+
+ this.options = options
+ this.loose = !!options.loose
+ this.includePrerelease = !!options.includePrerelease
+
+ // First, split based on boolean or ||
+ this.raw = range
+ this.set = range.split(/\s*\|\|\s*/).map(function (range) {
+ return this.parseRange(range.trim())
+ }, this).filter(function (c) {
+ // throw out any that are not relevant for whatever reason
+ return c.length
+ })
-if (true) {
-exports.parser = spdxparse;
-exports.Parser = spdxparse.Parser;
-exports.parse = function () { return spdxparse.parse.apply(spdxparse, arguments); };
-exports.main = function commonjsMain(args) {
- if (!args[1]) {
- console.log('Usage: '+args[0]+' FILE');
- process.exit(1);
- }
- var source = __webpack_require__(23).readFileSync(__webpack_require__(16).normalize(args[1]), "utf8");
- return exports.parser.parse(source);
-};
-if ( true && __webpack_require__.c[__webpack_require__.s] === module) {
- exports.main(process.argv.slice(1));
+ if (!this.set.length) {
+ throw new TypeError('Invalid SemVer Range: ' + range)
+ }
+
+ this.format()
}
+
+Range.prototype.format = function () {
+ this.range = this.set.map(function (comps) {
+ return comps.join(' ').trim()
+ }).join('||').trim()
+ return this.range
}
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(5)(module)))
+Range.prototype.toString = function () {
+ return this.range
+}
-/***/ }),
-/* 527 */
-/***/ (function(module, exports, __webpack_require__) {
+Range.prototype.parseRange = function (range) {
+ var loose = this.options.loose
+ range = range.trim()
+ // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+ var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE]
+ range = range.replace(hr, hyphenReplace)
+ debug('hyphen replace', range)
+ // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+ range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace)
+ debug('comparator trim', range, re[COMPARATORTRIM])
-var licenseIDs = __webpack_require__(528);
+ // `~ 1.2.3` => `~1.2.3`
+ range = range.replace(re[TILDETRIM], tildeTrimReplace)
-function valid(string) {
- return licenseIDs.indexOf(string) > -1;
-}
+ // `^ 1.2.3` => `^1.2.3`
+ range = range.replace(re[CARETTRIM], caretTrimReplace)
-// Common transpositions of license identifier acronyms
-var transpositions = [
- ['APGL', 'AGPL'],
- ['Gpl', 'GPL'],
- ['GLP', 'GPL'],
- ['APL', 'Apache'],
- ['ISD', 'ISC'],
- ['GLP', 'GPL'],
- ['IST', 'ISC'],
- ['Claude', 'Clause'],
- [' or later', '+'],
- [' International', ''],
- ['GNU', 'GPL'],
- ['GUN', 'GPL'],
- ['+', ''],
- ['GNU GPL', 'GPL'],
- ['GNU/GPL', 'GPL'],
- ['GNU GLP', 'GPL'],
- ['GNU General Public License', 'GPL'],
- ['Gnu public license', 'GPL'],
- ['GNU Public License', 'GPL'],
- ['GNU GENERAL PUBLIC LICENSE', 'GPL'],
- ['MTI', 'MIT'],
- ['Mozilla Public License', 'MPL'],
- ['WTH', 'WTF'],
- ['-License', '']
-];
+ // normalize spaces
+ range = range.split(/\s+/).join(' ')
-var TRANSPOSED = 0;
-var CORRECT = 1;
+ // At this point, the range is completely trimmed and
+ // ready to be split into comparators.
-// Simple corrections to nearly valid identifiers.
-var transforms = [
- // e.g. 'mit'
- function(argument) {
- return argument.toUpperCase();
- },
- // e.g. 'MIT '
- function(argument) {
- return argument.trim();
- },
- // e.g. 'M.I.T.'
- function(argument) {
- return argument.replace(/\./g, '');
- },
- // e.g. 'Apache- 2.0'
- function(argument) {
- return argument.replace(/\s+/g, '');
- },
- // e.g. 'CC BY 4.0''
- function(argument) {
- return argument.replace(/\s+/g, '-');
- },
- // e.g. 'LGPLv2.1'
- function(argument) {
- return argument.replace('v', '-');
- },
- // e.g. 'Apache 2.0'
- function(argument) {
- return argument.replace(/,?\s*(\d)/, '-$1');
- },
- // e.g. 'GPL 2'
- function(argument) {
- return argument.replace(/,?\s*(\d)/, '-$1.0');
- },
- // e.g. 'Apache Version 2.0'
- function(argument) {
- return argument.replace(/,?\s*(V\.|v\.|V|v|Version|version)\s*(\d)/, '-$2');
- },
- // e.g. 'Apache Version 2'
- function(argument) {
- return argument.replace(/,?\s*(V\.|v\.|V|v|Version|version)\s*(\d)/, '-$2.0');
- },
- // e.g. 'ZLIB'
- function(argument) {
- return argument[0].toUpperCase() + argument.slice(1);
- },
- // e.g. 'MPL/2.0'
- function(argument) {
- return argument.replace('/', '-');
- },
- // e.g. 'Apache 2'
- function(argument) {
- return argument
- .replace(/\s*V\s*(\d)/, '-$1')
- .replace(/(\d)$/, '$1.0');
- },
- // e.g. 'GPL-2.0-'
- function(argument) {
- return argument.slice(0, argument.length - 1);
- },
- // e.g. 'GPL2'
- function(argument) {
- return argument.replace(/(\d)$/, '-$1.0');
- },
- // e.g. 'BSD 3'
- function(argument) {
- return argument.replace(/(-| )?(\d)$/, '-$2-Clause');
- },
- // e.g. 'BSD clause 3'
- function(argument) {
- return argument.replace(/(-| )clause(-| )(\d)/, '-$3-Clause');
- },
- // e.g. 'BY-NC-4.0'
- function(argument) {
- return 'CC-' + argument;
- },
- // e.g. 'BY-NC'
- function(argument) {
- return 'CC-' + argument + '-4.0';
- },
- // e.g. 'Attribution-NonCommercial'
- function(argument) {
- return argument
- .replace('Attribution', 'BY')
- .replace('NonCommercial', 'NC')
- .replace('NoDerivatives', 'ND')
- .replace(/ (\d)/, '-$1')
- .replace(/ ?International/, '');
- },
- // e.g. 'Attribution-NonCommercial'
- function(argument) {
- return 'CC-' +
- argument
- .replace('Attribution', 'BY')
- .replace('NonCommercial', 'NC')
- .replace('NoDerivatives', 'ND')
- .replace(/ (\d)/, '-$1')
- .replace(/ ?International/, '') +
- '-4.0';
+ var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR]
+ var set = range.split(' ').map(function (comp) {
+ return parseComparator(comp, this.options)
+ }, this).join(' ').split(/\s+/)
+ if (this.options.loose) {
+ // in loose mode, throw out any that are not valid comparators
+ set = set.filter(function (comp) {
+ return !!comp.match(compRe)
+ })
}
-];
-
-// If all else fails, guess that strings containing certain substrings
-// meant to identify certain licenses.
-var lastResorts = [
- ['UNLI', 'Unlicense'],
- ['WTF', 'WTFPL'],
- ['2 CLAUSE', 'BSD-2-Clause'],
- ['2-CLAUSE', 'BSD-2-Clause'],
- ['3 CLAUSE', 'BSD-3-Clause'],
- ['3-CLAUSE', 'BSD-3-Clause'],
- ['AFFERO', 'AGPL-3.0'],
- ['AGPL', 'AGPL-3.0'],
- ['APACHE', 'Apache-2.0'],
- ['ARTISTIC', 'Artistic-2.0'],
- ['Affero', 'AGPL-3.0'],
- ['BEER', 'Beerware'],
- ['BOOST', 'BSL-1.0'],
- ['BSD', 'BSD-2-Clause'],
- ['ECLIPSE', 'EPL-1.0'],
- ['FUCK', 'WTFPL'],
- ['GNU', 'GPL-3.0'],
- ['LGPL', 'LGPL-3.0'],
- ['GPL', 'GPL-3.0'],
- ['MIT', 'MIT'],
- ['MPL', 'MPL-2.0'],
- ['X11', 'X11'],
- ['ZLIB', 'Zlib']
-];
+ set = set.map(function (comp) {
+ return new Comparator(comp, this.options)
+ }, this)
-var SUBSTRING = 0;
-var IDENTIFIER = 1;
+ return set
+}
-var validTransformation = function(identifier) {
- for (var i = 0; i < transforms.length; i++) {
- var transformed = transforms[i](identifier);
- if (transformed !== identifier && valid(transformed)) {
- return transformed;
- }
+Range.prototype.intersects = function (range, options) {
+ if (!(range instanceof Range)) {
+ throw new TypeError('a Range is required')
}
- return null;
-};
-var validLastResort = function(identifier) {
- var upperCased = identifier.toUpperCase();
- for (var i = 0; i < lastResorts.length; i++) {
- var lastResort = lastResorts[i];
- if (upperCased.indexOf(lastResort[SUBSTRING]) > -1) {
- return lastResort[IDENTIFIER];
- }
- }
- return null;
-};
+ return this.set.some(function (thisComparators) {
+ return thisComparators.every(function (thisComparator) {
+ return range.set.some(function (rangeComparators) {
+ return rangeComparators.every(function (rangeComparator) {
+ return thisComparator.intersects(rangeComparator, options)
+ })
+ })
+ })
+ })
+}
-var anyCorrection = function(identifier, check) {
- for (var i = 0; i < transpositions.length; i++) {
- var transposition = transpositions[i];
- var transposed = transposition[TRANSPOSED];
- if (identifier.indexOf(transposed) > -1) {
- var corrected = identifier.replace(
- transposed,
- transposition[CORRECT]
- );
- var checked = check(corrected);
- if (checked !== null) {
- return checked;
- }
+// Mostly just for testing and legacy API reasons
+exports.toComparators = toComparators
+function toComparators (range, options) {
+ return new Range(range, options).set.map(function (comp) {
+ return comp.map(function (c) {
+ return c.value
+ }).join(' ').trim().split(' ')
+ })
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+function parseComparator (comp, options) {
+ debug('comp', comp, options)
+ comp = replaceCarets(comp, options)
+ debug('caret', comp)
+ comp = replaceTildes(comp, options)
+ debug('tildes', comp)
+ comp = replaceXRanges(comp, options)
+ debug('xrange', comp)
+ comp = replaceStars(comp, options)
+ debug('stars', comp)
+ return comp
+}
+
+function isX (id) {
+ return !id || id.toLowerCase() === 'x' || id === '*'
+}
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+function replaceTildes (comp, options) {
+ return comp.trim().split(/\s+/).map(function (comp) {
+ return replaceTilde(comp, options)
+ }).join(' ')
+}
+
+function replaceTilde (comp, options) {
+ var r = options.loose ? re[TILDELOOSE] : re[TILDE]
+ return comp.replace(r, function (_, M, m, p, pr) {
+ debug('tilde', comp, _, M, m, p, pr)
+ var ret
+
+ if (isX(M)) {
+ ret = ''
+ } else if (isX(m)) {
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
+ } else if (isX(p)) {
+ // ~1.2 == >=1.2.0 <1.3.0
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+ } else if (pr) {
+ debug('replaceTilde pr', pr)
+ ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+ ' <' + M + '.' + (+m + 1) + '.0'
+ } else {
+ // ~1.2.3 == >=1.2.3 <1.3.0
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0'
}
- }
- return null;
-};
-module.exports = function(identifier) {
- identifier = identifier.replace(/\+$/, '');
- if (valid(identifier)) {
- return identifier;
- }
- var transformed = validTransformation(identifier);
- if (transformed !== null) {
- return transformed;
- }
- transformed = anyCorrection(identifier, function(argument) {
- if (valid(argument)) {
- return argument;
+ debug('tilde return', ret)
+ return ret
+ })
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2.0 --> >=1.2.0 <2.0.0
+function replaceCarets (comp, options) {
+ return comp.trim().split(/\s+/).map(function (comp) {
+ return replaceCaret(comp, options)
+ }).join(' ')
+}
+
+function replaceCaret (comp, options) {
+ debug('caret', comp, options)
+ var r = options.loose ? re[CARETLOOSE] : re[CARET]
+ return comp.replace(r, function (_, M, m, p, pr) {
+ debug('caret', comp, _, M, m, p, pr)
+ var ret
+
+ if (isX(M)) {
+ ret = ''
+ } else if (isX(m)) {
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
+ } else if (isX(p)) {
+ if (M === '0') {
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+ } else {
+ ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'
+ }
+ } else if (pr) {
+ debug('replaceCaret pr', pr)
+ if (M === '0') {
+ if (m === '0') {
+ ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+ ' <' + M + '.' + m + '.' + (+p + 1)
+ } else {
+ ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+ ' <' + M + '.' + (+m + 1) + '.0'
+ }
+ } else {
+ ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+ ' <' + (+M + 1) + '.0.0'
+ }
+ } else {
+ debug('no pr')
+ if (M === '0') {
+ if (m === '0') {
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + m + '.' + (+p + 1)
+ } else {
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + M + '.' + (+m + 1) + '.0'
+ }
+ } else {
+ ret = '>=' + M + '.' + m + '.' + p +
+ ' <' + (+M + 1) + '.0.0'
+ }
}
- return validTransformation(argument);
- });
- if (transformed !== null) {
- return transformed;
- }
- transformed = validLastResort(identifier);
- if (transformed !== null) {
- return transformed;
- }
- transformed = anyCorrection(identifier, validLastResort);
- if (transformed !== null) {
- return transformed;
- }
- return null;
-};
+ debug('caret return', ret)
+ return ret
+ })
+}
-/***/ }),
-/* 528 */
-/***/ (function(module) {
+function replaceXRanges (comp, options) {
+ debug('replaceXRanges', comp, options)
+ return comp.split(/\s+/).map(function (comp) {
+ return replaceXRange(comp, options)
+ }).join(' ')
+}
-module.exports = JSON.parse("[\"Glide\",\"Abstyles\",\"AFL-1.1\",\"AFL-1.2\",\"AFL-2.0\",\"AFL-2.1\",\"AFL-3.0\",\"AMPAS\",\"APL-1.0\",\"Adobe-Glyph\",\"APAFML\",\"Adobe-2006\",\"AGPL-1.0\",\"Afmparse\",\"Aladdin\",\"ADSL\",\"AMDPLPA\",\"ANTLR-PD\",\"Apache-1.0\",\"Apache-1.1\",\"Apache-2.0\",\"AML\",\"APSL-1.0\",\"APSL-1.1\",\"APSL-1.2\",\"APSL-2.0\",\"Artistic-1.0\",\"Artistic-1.0-Perl\",\"Artistic-1.0-cl8\",\"Artistic-2.0\",\"AAL\",\"Bahyph\",\"Barr\",\"Beerware\",\"BitTorrent-1.0\",\"BitTorrent-1.1\",\"BSL-1.0\",\"Borceux\",\"BSD-2-Clause\",\"BSD-2-Clause-FreeBSD\",\"BSD-2-Clause-NetBSD\",\"BSD-3-Clause\",\"BSD-3-Clause-Clear\",\"BSD-4-Clause\",\"BSD-Protection\",\"BSD-Source-Code\",\"BSD-3-Clause-Attribution\",\"0BSD\",\"BSD-4-Clause-UC\",\"bzip2-1.0.5\",\"bzip2-1.0.6\",\"Caldera\",\"CECILL-1.0\",\"CECILL-1.1\",\"CECILL-2.0\",\"CECILL-2.1\",\"CECILL-B\",\"CECILL-C\",\"ClArtistic\",\"MIT-CMU\",\"CNRI-Jython\",\"CNRI-Python\",\"CNRI-Python-GPL-Compatible\",\"CPOL-1.02\",\"CDDL-1.0\",\"CDDL-1.1\",\"CPAL-1.0\",\"CPL-1.0\",\"CATOSL-1.1\",\"Condor-1.1\",\"CC-BY-1.0\",\"CC-BY-2.0\",\"CC-BY-2.5\",\"CC-BY-3.0\",\"CC-BY-4.0\",\"CC-BY-ND-1.0\",\"CC-BY-ND-2.0\",\"CC-BY-ND-2.5\",\"CC-BY-ND-3.0\",\"CC-BY-ND-4.0\",\"CC-BY-NC-1.0\",\"CC-BY-NC-2.0\",\"CC-BY-NC-2.5\",\"CC-BY-NC-3.0\",\"CC-BY-NC-4.0\",\"CC-BY-NC-ND-1.0\",\"CC-BY-NC-ND-2.0\",\"CC-BY-NC-ND-2.5\",\"CC-BY-NC-ND-3.0\",\"CC-BY-NC-ND-4.0\",\"CC-BY-NC-SA-1.0\",\"CC-BY-NC-SA-2.0\",\"CC-BY-NC-SA-2.5\",\"CC-BY-NC-SA-3.0\",\"CC-BY-NC-SA-4.0\",\"CC-BY-SA-1.0\",\"CC-BY-SA-2.0\",\"CC-BY-SA-2.5\",\"CC-BY-SA-3.0\",\"CC-BY-SA-4.0\",\"CC0-1.0\",\"Crossword\",\"CrystalStacker\",\"CUA-OPL-1.0\",\"Cube\",\"curl\",\"D-FSL-1.0\",\"diffmark\",\"WTFPL\",\"DOC\",\"Dotseqn\",\"DSDP\",\"dvipdfm\",\"EPL-1.0\",\"ECL-1.0\",\"ECL-2.0\",\"eGenix\",\"EFL-1.0\",\"EFL-2.0\",\"MIT-advertising\",\"MIT-enna\",\"Entessa\",\"ErlPL-1.1\",\"EUDatagrid\",\"EUPL-1.0\",\"EUPL-1.1\",\"Eurosym\",\"Fair\",\"MIT-feh\",\"Frameworx-1.0\",\"FreeImage\",\"FTL\",\"FSFAP\",\"FSFUL\",\"FSFULLR\",\"Giftware\",\"GL2PS\",\"Glulxe\",\"AGPL-3.0\",\"GFDL-1.1\",\"GFDL-1.2\",\"GFDL-1.3\",\"GPL-1.0\",\"GPL-2.0\",\"GPL-3.0\",\"LGPL-2.1\",\"LGPL-3.0\",\"LGPL-2.0\",\"gnuplot\",\"gSOAP-1.3b\",\"HaskellReport\",\"HPND\",\"IBM-pibs\",\"IPL-1.0\",\"ICU\",\"ImageMagick\",\"iMatix\",\"Imlib2\",\"IJG\",\"Info-ZIP\",\"Intel-ACPI\",\"Intel\",\"Interbase-1.0\",\"IPA\",\"ISC\",\"JasPer-2.0\",\"JSON\",\"LPPL-1.0\",\"LPPL-1.1\",\"LPPL-1.2\",\"LPPL-1.3a\",\"LPPL-1.3c\",\"Latex2e\",\"BSD-3-Clause-LBNL\",\"Leptonica\",\"LGPLLR\",\"Libpng\",\"libtiff\",\"LAL-1.2\",\"LAL-1.3\",\"LiLiQ-P-1.1\",\"LiLiQ-Rplus-1.1\",\"LiLiQ-R-1.1\",\"LPL-1.02\",\"LPL-1.0\",\"MakeIndex\",\"MTLL\",\"MS-PL\",\"MS-RL\",\"MirOS\",\"MITNFA\",\"MIT\",\"Motosoto\",\"MPL-1.0\",\"MPL-1.1\",\"MPL-2.0\",\"MPL-2.0-no-copyleft-exception\",\"mpich2\",\"Multics\",\"Mup\",\"NASA-1.3\",\"Naumen\",\"NBPL-1.0\",\"NetCDF\",\"NGPL\",\"NOSL\",\"NPL-1.0\",\"NPL-1.1\",\"Newsletr\",\"NLPL\",\"Nokia\",\"NPOSL-3.0\",\"NLOD-1.0\",\"Noweb\",\"NRL\",\"NTP\",\"Nunit\",\"OCLC-2.0\",\"ODbL-1.0\",\"PDDL-1.0\",\"OCCT-PL\",\"OGTSL\",\"OLDAP-2.2.2\",\"OLDAP-1.1\",\"OLDAP-1.2\",\"OLDAP-1.3\",\"OLDAP-1.4\",\"OLDAP-2.0\",\"OLDAP-2.0.1\",\"OLDAP-2.1\",\"OLDAP-2.2\",\"OLDAP-2.2.1\",\"OLDAP-2.3\",\"OLDAP-2.4\",\"OLDAP-2.5\",\"OLDAP-2.6\",\"OLDAP-2.7\",\"OLDAP-2.8\",\"OML\",\"OPL-1.0\",\"OSL-1.0\",\"OSL-1.1\",\"OSL-2.0\",\"OSL-2.1\",\"OSL-3.0\",\"OpenSSL\",\"OSET-PL-2.1\",\"PHP-3.0\",\"PHP-3.01\",\"Plexus\",\"PostgreSQL\",\"psfrag\",\"psutils\",\"Python-2.0\",\"QPL-1.0\",\"Qhull\",\"Rdisc\",\"RPSL-1.0\",\"RPL-1.1\",\"RPL-1.5\",\"RHeCos-1.1\",\"RSCPL\",\"RSA-MD\",\"Ruby\",\"SAX-PD\",\"Saxpath\",\"SCEA\",\"SWL\",\"SMPPL\",\"Sendmail\",\"SGI-B-1.0\",\"SGI-B-1.1\",\"SGI-B-2.0\",\"OFL-1.0\",\"OFL-1.1\",\"SimPL-2.0\",\"Sleepycat\",\"SNIA\",\"Spencer-86\",\"Spencer-94\",\"Spencer-99\",\"SMLNJ\",\"SugarCRM-1.1.3\",\"SISSL\",\"SISSL-1.2\",\"SPL-1.0\",\"Watcom-1.0\",\"TCL\",\"Unlicense\",\"TMate\",\"TORQUE-1.1\",\"TOSL\",\"Unicode-TOU\",\"UPL-1.0\",\"NCSA\",\"Vim\",\"VOSTROM\",\"VSL-1.0\",\"W3C-19980720\",\"W3C\",\"Wsuipa\",\"Xnet\",\"X11\",\"Xerox\",\"XFree86-1.1\",\"xinetd\",\"xpp\",\"XSkat\",\"YPL-1.0\",\"YPL-1.1\",\"Zed\",\"Zend-2.0\",\"Zimbra-1.3\",\"Zimbra-1.4\",\"Zlib\",\"zlib-acknowledgement\",\"ZPL-1.1\",\"ZPL-2.0\",\"ZPL-2.1\",\"BSD-3-Clause-No-Nuclear-License\",\"BSD-3-Clause-No-Nuclear-Warranty\",\"BSD-3-Clause-No-Nuclear-License-2014\",\"eCos-2.0\",\"GPL-2.0-with-autoconf-exception\",\"GPL-2.0-with-bison-exception\",\"GPL-2.0-with-classpath-exception\",\"GPL-2.0-with-font-exception\",\"GPL-2.0-with-GCC-exception\",\"GPL-3.0-with-autoconf-exception\",\"GPL-3.0-with-GCC-exception\",\"StandardML-NJ\",\"WXwindows\"]");
+function replaceXRange (comp, options) {
+ comp = comp.trim()
+ var r = options.loose ? re[XRANGELOOSE] : re[XRANGE]
+ return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
+ debug('xRange', comp, ret, gtlt, M, m, p, pr)
+ var xM = isX(M)
+ var xm = xM || isX(m)
+ var xp = xm || isX(p)
+ var anyX = xp
-/***/ }),
-/* 529 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (gtlt === '=' && anyX) {
+ gtlt = ''
+ }
-"use strict";
+ if (xM) {
+ if (gtlt === '>' || gtlt === '<') {
+ // nothing is allowed
+ ret = '<0.0.0'
+ } else {
+ // nothing is forbidden
+ ret = '*'
+ }
+ } else if (gtlt && anyX) {
+ // we know patch is an x, because we have any x at all.
+ // replace X with 0
+ if (xm) {
+ m = 0
+ }
+ p = 0
-var url = __webpack_require__(452)
-var gitHosts = __webpack_require__(530)
-var GitHost = module.exports = __webpack_require__(531)
+ if (gtlt === '>') {
+ // >1 => >=2.0.0
+ // >1.2 => >=1.3.0
+ // >1.2.3 => >= 1.2.4
+ gtlt = '>='
+ if (xm) {
+ M = +M + 1
+ m = 0
+ p = 0
+ } else {
+ m = +m + 1
+ p = 0
+ }
+ } else if (gtlt === '<=') {
+ // <=0.7.x is actually <0.8.0, since any 0.7.x should
+ // pass. Similarly, <=7.x is actually <8.0.0, etc.
+ gtlt = '<'
+ if (xm) {
+ M = +M + 1
+ } else {
+ m = +m + 1
+ }
+ }
-var protocolToRepresentationMap = {
- 'git+ssh': 'sshurl',
- 'git+https': 'https',
- 'ssh': 'sshurl',
- 'git': 'git'
-}
+ ret = gtlt + M + '.' + m + '.' + p
+ } else if (xm) {
+ ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'
+ } else if (xp) {
+ ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'
+ }
-function protocolToRepresentation (protocol) {
- if (protocol.substr(-1) === ':') protocol = protocol.slice(0, -1)
- return protocolToRepresentationMap[protocol] || protocol
-}
+ debug('xRange return', ret)
-var authProtocols = {
- 'git:': true,
- 'https:': true,
- 'git+https:': true,
- 'http:': true,
- 'git+http:': true
+ return ret
+ })
}
-var cache = {}
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+function replaceStars (comp, options) {
+ debug('replaceStars', comp, options)
+ // Looseness is ignored here. star is always as loose as it gets!
+ return comp.trim().replace(re[STAR], '')
+}
-module.exports.fromUrl = function (giturl, opts) {
- var key = giturl + JSON.stringify(opts || {})
+// This function is passed to string.replace(re[HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0
+function hyphenReplace ($0,
+ from, fM, fm, fp, fpr, fb,
+ to, tM, tm, tp, tpr, tb) {
+ if (isX(fM)) {
+ from = ''
+ } else if (isX(fm)) {
+ from = '>=' + fM + '.0.0'
+ } else if (isX(fp)) {
+ from = '>=' + fM + '.' + fm + '.0'
+ } else {
+ from = '>=' + from
+ }
- if (!(key in cache)) {
- cache[key] = fromUrl(giturl, opts)
+ if (isX(tM)) {
+ to = ''
+ } else if (isX(tm)) {
+ to = '<' + (+tM + 1) + '.0.0'
+ } else if (isX(tp)) {
+ to = '<' + tM + '.' + (+tm + 1) + '.0'
+ } else if (tpr) {
+ to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr
+ } else {
+ to = '<=' + to
}
- return cache[key]
+ return (from + ' ' + to).trim()
}
-function fromUrl (giturl, opts) {
- if (giturl == null || giturl === '') return
- var url = fixupUnqualifiedGist(
- isGitHubShorthand(giturl) ? 'github:' + giturl : giturl
- )
- var parsed = parseGitUrl(url)
- var shortcutMatch = url.match(new RegExp('^([^:]+):(?:(?:[^@:]+(?:[^@]+)?@)?([^/]*))[/](.+?)(?:[.]git)?($|#)'))
- var matches = Object.keys(gitHosts).map(function (gitHostName) {
- try {
- var gitHostInfo = gitHosts[gitHostName]
- var auth = null
- if (parsed.auth && authProtocols[parsed.protocol]) {
- auth = decodeURIComponent(parsed.auth)
- }
- var committish = parsed.hash ? decodeURIComponent(parsed.hash.substr(1)) : null
- var user = null
- var project = null
- var defaultRepresentation = null
- if (shortcutMatch && shortcutMatch[1] === gitHostName) {
- user = shortcutMatch[2] && decodeURIComponent(shortcutMatch[2])
- project = decodeURIComponent(shortcutMatch[3])
- defaultRepresentation = 'shortcut'
- } else {
- if (parsed.host !== gitHostInfo.domain) return
- if (!gitHostInfo.protocols_re.test(parsed.protocol)) return
- if (!parsed.path) return
- var pathmatch = gitHostInfo.pathmatch
- var matched = parsed.path.match(pathmatch)
- if (!matched) return
- if (matched[1] != null) user = decodeURIComponent(matched[1].replace(/^:/, ''))
- if (matched[2] != null) project = decodeURIComponent(matched[2])
- defaultRepresentation = protocolToRepresentation(parsed.protocol)
- }
- return new GitHost(gitHostName, user, auth, project, committish, defaultRepresentation, opts)
- } catch (ex) {
- if (!(ex instanceof URIError)) throw ex
- }
- }).filter(function (gitHostInfo) { return gitHostInfo })
- if (matches.length !== 1) return
- return matches[0]
-}
+// if ANY of the sets match ALL of its comparators, then pass
+Range.prototype.test = function (version) {
+ if (!version) {
+ return false
+ }
-function isGitHubShorthand (arg) {
- // Note: This does not fully test the git ref format.
- // See https://www.kernel.org/pub/software/scm/git/docs/git-check-ref-format.html
- //
- // The only way to do this properly would be to shell out to
- // git-check-ref-format, and as this is a fast sync function,
- // we don't want to do that. Just let git fail if it turns
- // out that the commit-ish is invalid.
- // GH usernames cannot start with . or -
- return /^[^:@%/\s.-][^:@%/\s]*[/][^:@\s/%]+(?:#.*)?$/.test(arg)
-}
+ if (typeof version === 'string') {
+ version = new SemVer(version, this.options)
+ }
-function fixupUnqualifiedGist (giturl) {
- // necessary for round-tripping gists
- var parsed = url.parse(giturl)
- if (parsed.protocol === 'gist:' && parsed.host && !parsed.path) {
- return parsed.protocol + '/' + parsed.host
- } else {
- return giturl
+ for (var i = 0; i < this.set.length; i++) {
+ if (testSet(this.set[i], version, this.options)) {
+ return true
+ }
}
+ return false
}
-function parseGitUrl (giturl) {
- if (typeof giturl !== 'string') giturl = '' + giturl
- var matched = giturl.match(/^([^@]+)@([^:/]+):[/]?((?:[^/]+[/])?[^/]+?)(?:[.]git)?(#.*)?$/)
- if (!matched) return url.parse(giturl)
- return {
- protocol: 'git+ssh:',
- slashes: true,
- auth: matched[1],
- host: matched[2],
- port: null,
- hostname: matched[2],
- hash: matched[4],
- search: null,
- query: null,
- pathname: '/' + matched[3],
- path: '/' + matched[3],
- href: 'git+ssh://' + matched[1] + '@' + matched[2] +
- '/' + matched[3] + (matched[4] || '')
+function testSet (set, version, options) {
+ for (var i = 0; i < set.length; i++) {
+ if (!set[i].test(version)) {
+ return false
+ }
}
-}
+ if (version.prerelease.length && !options.includePrerelease) {
+ // Find the set of versions that are allowed to have prereleases
+ // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+ // That should allow `1.2.3-pr.2` to pass.
+ // However, `1.2.4-alpha.notready` should NOT be allowed,
+ // even though it's within the range set by the comparators.
+ for (i = 0; i < set.length; i++) {
+ debug(set[i].semver)
+ if (set[i].semver === ANY) {
+ continue
+ }
-/***/ }),
-/* 530 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (set[i].semver.prerelease.length > 0) {
+ var allowed = set[i].semver
+ if (allowed.major === version.major &&
+ allowed.minor === version.minor &&
+ allowed.patch === version.patch) {
+ return true
+ }
+ }
+ }
-"use strict";
+ // Version has a -pre, but it's not one of the ones we like.
+ return false
+ }
+ return true
+}
-var gitHosts = module.exports = {
- github: {
- // First two are insecure and generally shouldn't be used any more, but
- // they are still supported.
- 'protocols': [ 'git', 'http', 'git+ssh', 'git+https', 'ssh', 'https' ],
- 'domain': 'github.com',
- 'treepath': 'tree',
- 'filetemplate': 'https://{auth@}raw.githubusercontent.com/{user}/{project}/{committish}/{path}',
- 'bugstemplate': 'https://{domain}/{user}/{project}/issues',
- 'gittemplate': 'git://{auth@}{domain}/{user}/{project}.git{#committish}',
- 'tarballtemplate': 'https://{domain}/{user}/{project}/archive/{committish}.tar.gz'
- },
- bitbucket: {
- 'protocols': [ 'git+ssh', 'git+https', 'ssh', 'https' ],
- 'domain': 'bitbucket.org',
- 'treepath': 'src',
- 'tarballtemplate': 'https://{domain}/{user}/{project}/get/{committish}.tar.gz'
- },
- gitlab: {
- 'protocols': [ 'git+ssh', 'git+https', 'ssh', 'https' ],
- 'domain': 'gitlab.com',
- 'treepath': 'tree',
- 'docstemplate': 'https://{domain}/{user}/{project}{/tree/committish}#README',
- 'bugstemplate': 'https://{domain}/{user}/{project}/issues',
- 'tarballtemplate': 'https://{domain}/{user}/{project}/repository/archive.tar.gz?ref={committish}'
- },
- gist: {
- 'protocols': [ 'git', 'git+ssh', 'git+https', 'ssh', 'https' ],
- 'domain': 'gist.github.com',
- 'pathmatch': /^[/](?:([^/]+)[/])?([a-z0-9]+)(?:[.]git)?$/,
- 'filetemplate': 'https://gist.githubusercontent.com/{user}/{project}/raw{/committish}/{path}',
- 'bugstemplate': 'https://{domain}/{project}',
- 'gittemplate': 'git://{domain}/{project}.git{#committish}',
- 'sshtemplate': 'git@{domain}:/{project}.git{#committish}',
- 'sshurltemplate': 'git+ssh://git@{domain}/{project}.git{#committish}',
- 'browsetemplate': 'https://{domain}/{project}{/committish}',
- 'docstemplate': 'https://{domain}/{project}{/committish}',
- 'httpstemplate': 'git+https://{domain}/{project}.git{#committish}',
- 'shortcuttemplate': '{type}:{project}{#committish}',
- 'pathtemplate': '{project}{#committish}',
- 'tarballtemplate': 'https://{domain}/{user}/{project}/archive/{committish}.tar.gz'
+exports.satisfies = satisfies
+function satisfies (version, range, options) {
+ try {
+ range = new Range(range, options)
+ } catch (er) {
+ return false
}
+ return range.test(version)
}
-var gitHostDefaults = {
- 'sshtemplate': 'git@{domain}:{user}/{project}.git{#committish}',
- 'sshurltemplate': 'git+ssh://git@{domain}/{user}/{project}.git{#committish}',
- 'browsetemplate': 'https://{domain}/{user}/{project}{/tree/committish}',
- 'docstemplate': 'https://{domain}/{user}/{project}{/tree/committish}#readme',
- 'httpstemplate': 'git+https://{auth@}{domain}/{user}/{project}.git{#committish}',
- 'filetemplate': 'https://{domain}/{user}/{project}/raw/{committish}/{path}',
- 'shortcuttemplate': '{type}:{user}/{project}{#committish}',
- 'pathtemplate': '{user}/{project}{#committish}',
- 'pathmatch': /^[/]([^/]+)[/]([^/]+?)(?:[.]git|[/])?$/
+exports.maxSatisfying = maxSatisfying
+function maxSatisfying (versions, range, options) {
+ var max = null
+ var maxSV = null
+ try {
+ var rangeObj = new Range(range, options)
+ } catch (er) {
+ return null
+ }
+ versions.forEach(function (v) {
+ if (rangeObj.test(v)) {
+ // satisfies(v, range, options)
+ if (!max || maxSV.compare(v) === -1) {
+ // compare(max, v, true)
+ max = v
+ maxSV = new SemVer(max, options)
+ }
+ }
+ })
+ return max
}
-Object.keys(gitHosts).forEach(function (name) {
- Object.keys(gitHostDefaults).forEach(function (key) {
- if (gitHosts[name][key]) return
- gitHosts[name][key] = gitHostDefaults[key]
+exports.minSatisfying = minSatisfying
+function minSatisfying (versions, range, options) {
+ var min = null
+ var minSV = null
+ try {
+ var rangeObj = new Range(range, options)
+ } catch (er) {
+ return null
+ }
+ versions.forEach(function (v) {
+ if (rangeObj.test(v)) {
+ // satisfies(v, range, options)
+ if (!min || minSV.compare(v) === 1) {
+ // compare(min, v, true)
+ min = v
+ minSV = new SemVer(min, options)
+ }
+ }
})
- gitHosts[name].protocols_re = RegExp('^(' +
- gitHosts[name].protocols.map(function (protocol) {
- return protocol.replace(/([\\+*{}()[\]$^|])/g, '\\$1')
- }).join('|') + '):$')
-})
+ return min
+}
+exports.minVersion = minVersion
+function minVersion (range, loose) {
+ range = new Range(range, loose)
-/***/ }),
-/* 531 */
-/***/ (function(module, exports, __webpack_require__) {
+ var minver = new SemVer('0.0.0')
+ if (range.test(minver)) {
+ return minver
+ }
-"use strict";
+ minver = new SemVer('0.0.0-0')
+ if (range.test(minver)) {
+ return minver
+ }
-var gitHosts = __webpack_require__(530)
-var extend = Object.assign || __webpack_require__(29)._extend
+ minver = null
+ for (var i = 0; i < range.set.length; ++i) {
+ var comparators = range.set[i]
-var GitHost = module.exports = function (type, user, auth, project, committish, defaultRepresentation, opts) {
- var gitHostInfo = this
- gitHostInfo.type = type
- Object.keys(gitHosts[type]).forEach(function (key) {
- gitHostInfo[key] = gitHosts[type][key]
- })
- gitHostInfo.user = user
- gitHostInfo.auth = auth
- gitHostInfo.project = project
- gitHostInfo.committish = committish
- gitHostInfo.default = defaultRepresentation
- gitHostInfo.opts = opts || {}
-}
-GitHost.prototype = {}
+ comparators.forEach(function (comparator) {
+ // Clone to avoid manipulating the comparator's semver object.
+ var compver = new SemVer(comparator.semver.version)
+ switch (comparator.operator) {
+ case '>':
+ if (compver.prerelease.length === 0) {
+ compver.patch++
+ } else {
+ compver.prerelease.push(0)
+ }
+ compver.raw = compver.format()
+ /* fallthrough */
+ case '':
+ case '>=':
+ if (!minver || gt(minver, compver)) {
+ minver = compver
+ }
+ break
+ case '<':
+ case '<=':
+ /* Ignore maximum versions */
+ break
+ /* istanbul ignore next */
+ default:
+ throw new Error('Unexpected operation: ' + comparator.operator)
+ }
+ })
+ }
-GitHost.prototype.hash = function () {
- return this.committish ? '#' + this.committish : ''
+ if (minver && range.test(minver)) {
+ return minver
+ }
+
+ return null
}
-GitHost.prototype._fill = function (template, opts) {
- if (!template) return
- var vars = extend({}, opts)
- opts = extend(extend({}, this.opts), opts)
- var self = this
- Object.keys(this).forEach(function (key) {
- if (self[key] != null && vars[key] == null) vars[key] = self[key]
- })
- var rawAuth = vars.auth
- var rawComittish = vars.committish
- Object.keys(vars).forEach(function (key) {
- vars[key] = encodeURIComponent(vars[key])
- })
- vars['auth@'] = rawAuth ? rawAuth + '@' : ''
- if (opts.noCommittish) {
- vars['#committish'] = ''
- vars['/tree/committish'] = ''
- vars['/comittish'] = ''
- vars.comittish = ''
- } else {
- vars['#committish'] = rawComittish ? '#' + rawComittish : ''
- vars['/tree/committish'] = vars.committish
- ? '/' + vars.treepath + '/' + vars.committish
- : ''
- vars['/committish'] = vars.committish ? '/' + vars.committish : ''
- vars.committish = vars.committish || 'master'
- }
- var res = template
- Object.keys(vars).forEach(function (key) {
- res = res.replace(new RegExp('[{]' + key + '[}]', 'g'), vars[key])
- })
- if (opts.noGitPlus) {
- return res.replace(/^git[+]/, '')
- } else {
- return res
+exports.validRange = validRange
+function validRange (range, options) {
+ try {
+ // Return '*' instead of '' so that truthiness works.
+ // This will throw if it's invalid anyway
+ return new Range(range, options).range || '*'
+ } catch (er) {
+ return null
}
}
-GitHost.prototype.ssh = function (opts) {
- return this._fill(this.sshtemplate, opts)
+// Determine if version is less than all the versions possible in the range
+exports.ltr = ltr
+function ltr (version, range, options) {
+ return outside(version, range, '<', options)
}
-GitHost.prototype.sshurl = function (opts) {
- return this._fill(this.sshurltemplate, opts)
+// Determine if version is greater than all the versions possible in the range.
+exports.gtr = gtr
+function gtr (version, range, options) {
+ return outside(version, range, '>', options)
}
-GitHost.prototype.browse = function (opts) {
- return this._fill(this.browsetemplate, opts)
-}
+exports.outside = outside
+function outside (version, range, hilo, options) {
+ version = new SemVer(version, options)
+ range = new Range(range, options)
-GitHost.prototype.docs = function (opts) {
- return this._fill(this.docstemplate, opts)
-}
+ var gtfn, ltefn, ltfn, comp, ecomp
+ switch (hilo) {
+ case '>':
+ gtfn = gt
+ ltefn = lte
+ ltfn = lt
+ comp = '>'
+ ecomp = '>='
+ break
+ case '<':
+ gtfn = lt
+ ltefn = gte
+ ltfn = gt
+ comp = '<'
+ ecomp = '<='
+ break
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"')
+ }
-GitHost.prototype.bugs = function (opts) {
- return this._fill(this.bugstemplate, opts)
-}
+ // If it satisifes the range it is not outside
+ if (satisfies(version, range, options)) {
+ return false
+ }
-GitHost.prototype.https = function (opts) {
- return this._fill(this.httpstemplate, opts)
-}
+ // From now on, variable terms are as if we're in "gtr" mode.
+ // but note that everything is flipped for the "ltr" function.
-GitHost.prototype.git = function (opts) {
- return this._fill(this.gittemplate, opts)
-}
+ for (var i = 0; i < range.set.length; ++i) {
+ var comparators = range.set[i]
-GitHost.prototype.shortcut = function (opts) {
- return this._fill(this.shortcuttemplate, opts)
-}
+ var high = null
+ var low = null
-GitHost.prototype.path = function (opts) {
- return this._fill(this.pathtemplate, opts)
-}
+ comparators.forEach(function (comparator) {
+ if (comparator.semver === ANY) {
+ comparator = new Comparator('>=0.0.0')
+ }
+ high = high || comparator
+ low = low || comparator
+ if (gtfn(comparator.semver, high.semver, options)) {
+ high = comparator
+ } else if (ltfn(comparator.semver, low.semver, options)) {
+ low = comparator
+ }
+ })
-GitHost.prototype.tarball = function (opts) {
- return this._fill(this.tarballtemplate, opts)
+ // If the edge version comparator has a operator then our version
+ // isn't outside it
+ if (high.operator === comp || high.operator === ecomp) {
+ return false
+ }
+
+ // If the lowest version comparator has an operator and our version
+ // is less than it then it isn't higher than the range
+ if ((!low.operator || low.operator === comp) &&
+ ltefn(version, low.semver)) {
+ return false
+ } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+ return false
+ }
+ }
+ return true
}
-GitHost.prototype.file = function (P, opts) {
- return this._fill(this.filetemplate, extend({
- path: P.replace(/^[/]+/g, '')
- }, opts))
+exports.prerelease = prerelease
+function prerelease (version, options) {
+ var parsed = parse(version, options)
+ return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
}
-GitHost.prototype.getDefaultRepresentation = function () {
- return this.default
+exports.intersects = intersects
+function intersects (r1, r2, options) {
+ r1 = new Range(r1, options)
+ r2 = new Range(r2, options)
+ return r1.intersects(r2)
}
-GitHost.prototype.toString = function (opts) {
- return (this[this.default] || this.sshurl).call(this, opts)
-}
+exports.coerce = coerce
+function coerce (version) {
+ if (version instanceof SemVer) {
+ return version
+ }
+ if (typeof version !== 'string') {
+ return null
+ }
-/***/ }),
-/* 532 */
-/***/ (function(module, exports, __webpack_require__) {
+ var match = version.match(re[COERCE])
-var core = __webpack_require__(533);
-var async = __webpack_require__(535);
-async.core = core;
-async.isCore = function isCore(x) { return core[x]; };
-async.sync = __webpack_require__(540);
+ if (match == null) {
+ return null
+ }
-exports = async;
-module.exports = async;
+ return parse(match[1] +
+ '.' + (match[2] || '0') +
+ '.' + (match[3] || '0'))
+}
/***/ }),
-/* 533 */
+/* 524 */
/***/ (function(module, exports, __webpack_require__) {
-var current = (process.versions && process.versions.node && process.versions.node.split('.')) || [];
+var parse = __webpack_require__(525);
+var correct = __webpack_require__(527);
-function specifierIncluded(specifier) {
- var parts = specifier.split(' ');
- var op = parts.length > 1 ? parts[0] : '=';
- var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split('.');
+var genericWarning = (
+ 'license should be ' +
+ 'a valid SPDX license expression (without "LicenseRef"), ' +
+ '"UNLICENSED", or ' +
+ '"SEE LICENSE IN "'
+);
- for (var i = 0; i < 3; ++i) {
- var cur = Number(current[i] || 0);
- var ver = Number(versionParts[i] || 0);
- if (cur === ver) {
- continue; // eslint-disable-line no-restricted-syntax, no-continue
- }
- if (op === '<') {
- return cur < ver;
- } else if (op === '>=') {
- return cur >= ver;
- } else {
- return false;
- }
- }
- return op === '>=';
-}
+var fileReferenceRE = /^SEE LICEN[CS]E IN (.+)$/;
-function matchesRange(range) {
- var specifiers = range.split(/ ?&& ?/);
- if (specifiers.length === 0) { return false; }
- for (var i = 0; i < specifiers.length; ++i) {
- if (!specifierIncluded(specifiers[i])) { return false; }
- }
- return true;
+function startsWith(prefix, string) {
+ return string.slice(0, prefix.length) === prefix;
}
-function versionIncluded(specifierValue) {
- if (typeof specifierValue === 'boolean') { return specifierValue; }
- if (specifierValue && typeof specifierValue === 'object') {
- for (var i = 0; i < specifierValue.length; ++i) {
- if (matchesRange(specifierValue[i])) { return true; }
- }
- return false;
- }
- return matchesRange(specifierValue);
+function usesLicenseRef(ast) {
+ if (ast.hasOwnProperty('license')) {
+ var license = ast.license;
+ return (
+ startsWith('LicenseRef', license) ||
+ startsWith('DocumentRef', license)
+ );
+ } else {
+ return (
+ usesLicenseRef(ast.left) ||
+ usesLicenseRef(ast.right)
+ );
+ }
}
-var data = __webpack_require__(534);
+module.exports = function(argument) {
+ var ast;
-var core = {};
-for (var mod in data) { // eslint-disable-line no-restricted-syntax
- if (Object.prototype.hasOwnProperty.call(data, mod)) {
- core[mod] = versionIncluded(data[mod]);
+ try {
+ ast = parse(argument);
+ } catch (e) {
+ var match
+ if (
+ argument === 'UNLICENSED' ||
+ argument === 'UNLICENCED'
+ ) {
+ return {
+ validForOldPackages: true,
+ validForNewPackages: true,
+ unlicensed: true
+ };
+ } else if (match = fileReferenceRE.exec(argument)) {
+ return {
+ validForOldPackages: true,
+ validForNewPackages: true,
+ inFile: match[1]
+ };
+ } else {
+ var result = {
+ validForOldPackages: false,
+ validForNewPackages: false,
+ warnings: [genericWarning]
+ };
+ var corrected = correct(argument);
+ if (corrected) {
+ result.warnings.push(
+ 'license is similar to the valid expression "' + corrected + '"'
+ );
+ }
+ return result;
}
-}
-module.exports = core;
+ }
+
+ if (usesLicenseRef(ast)) {
+ return {
+ validForNewPackages: false,
+ validForOldPackages: false,
+ spdx: true,
+ warnings: [genericWarning]
+ };
+ } else {
+ return {
+ validForNewPackages: true,
+ validForOldPackages: true,
+ spdx: true
+ };
+ }
+};
/***/ }),
-/* 534 */
-/***/ (function(module) {
+/* 525 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var parser = __webpack_require__(526).parser
+
+module.exports = function (argument) {
+ return parser.parse(argument)
+}
-module.exports = JSON.parse("{\"assert\":true,\"async_hooks\":\">= 8\",\"buffer_ieee754\":\"< 0.9.7\",\"buffer\":true,\"child_process\":true,\"cluster\":true,\"console\":true,\"constants\":true,\"crypto\":true,\"_debugger\":\"< 8\",\"dgram\":true,\"dns\":true,\"domain\":true,\"events\":true,\"freelist\":\"< 6\",\"fs\":true,\"fs/promises\":\">= 10 && < 10.1\",\"_http_agent\":\">= 0.11.1\",\"_http_client\":\">= 0.11.1\",\"_http_common\":\">= 0.11.1\",\"_http_incoming\":\">= 0.11.1\",\"_http_outgoing\":\">= 0.11.1\",\"_http_server\":\">= 0.11.1\",\"http\":true,\"http2\":\">= 8.8\",\"https\":true,\"inspector\":\">= 8.0.0\",\"_linklist\":\"< 8\",\"module\":true,\"net\":true,\"node-inspect/lib/_inspect\":\">= 7.6.0\",\"node-inspect/lib/internal/inspect_client\":\">= 7.6.0\",\"node-inspect/lib/internal/inspect_repl\":\">= 7.6.0\",\"os\":true,\"path\":true,\"perf_hooks\":\">= 8.5\",\"process\":\">= 1\",\"punycode\":true,\"querystring\":true,\"readline\":true,\"repl\":true,\"smalloc\":\">= 0.11.5 && < 3\",\"_stream_duplex\":\">= 0.9.4\",\"_stream_transform\":\">= 0.9.4\",\"_stream_wrap\":\">= 1.4.1\",\"_stream_passthrough\":\">= 0.9.4\",\"_stream_readable\":\">= 0.9.4\",\"_stream_writable\":\">= 0.9.4\",\"stream\":true,\"string_decoder\":true,\"sys\":true,\"timers\":true,\"_tls_common\":\">= 0.11.13\",\"_tls_legacy\":\">= 0.11.3 && < 10\",\"_tls_wrap\":\">= 0.11.3\",\"tls\":true,\"trace_events\":\">= 10\",\"tty\":true,\"url\":true,\"util\":true,\"v8/tools/arguments\":\">= 10\",\"v8/tools/codemap\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8/tools/consarray\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8/tools/csvparser\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8/tools/logreader\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8/tools/profile_view\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8/tools/splaytree\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8\":\">= 1\",\"vm\":true,\"worker_threads\":\">= 11.7\",\"zlib\":true}");
/***/ }),
-/* 535 */
+/* 526 */
/***/ (function(module, exports, __webpack_require__) {
-var core = __webpack_require__(533);
-var fs = __webpack_require__(23);
-var path = __webpack_require__(16);
-var caller = __webpack_require__(536);
-var nodeModulesPaths = __webpack_require__(537);
-var normalizeOptions = __webpack_require__(539);
+/* WEBPACK VAR INJECTION */(function(module) {/* parser generated by jison 0.4.17 */
+/*
+ Returns a Parser object of the following structure:
-var defaultIsFile = function isFile(file, cb) {
- fs.stat(file, function (err, stat) {
- if (!err) {
- return cb(null, stat.isFile() || stat.isFIFO());
- }
- if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
- return cb(err);
- });
-};
+ Parser: {
+ yy: {}
+ }
-module.exports = function resolve(x, options, callback) {
- var cb = callback;
- var opts = options;
- if (typeof options === 'function') {
- cb = opts;
- opts = {};
- }
- if (typeof x !== 'string') {
- var err = new TypeError('Path must be a string.');
- return process.nextTick(function () {
- cb(err);
- });
+ Parser.prototype: {
+ yy: {},
+ trace: function(),
+ symbols_: {associative list: name ==> number},
+ terminals_: {associative list: number ==> name},
+ productions_: [...],
+ performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
+ table: [...],
+ defaultActions: {...},
+ parseError: function(str, hash),
+ parse: function(input),
+
+ lexer: {
+ EOF: 1,
+ parseError: function(str, hash),
+ setInput: function(input),
+ input: function(),
+ unput: function(str),
+ more: function(),
+ less: function(n),
+ pastInput: function(),
+ upcomingInput: function(),
+ showPosition: function(),
+ test_match: function(regex_match_array, rule_index),
+ next: function(),
+ lex: function(),
+ begin: function(condition),
+ popState: function(),
+ _currentRules: function(),
+ topState: function(),
+ pushState: function(condition),
+
+ options: {
+ ranges: boolean (optional: true ==> token location info will include a .range[] member)
+ flex: boolean (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
+ backtrack_lexer: boolean (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
+ },
+
+ performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
+ rules: [...],
+ conditions: {associative list: name ==> set},
}
+ }
- opts = normalizeOptions(x, opts);
- var isFile = opts.isFile || defaultIsFile;
- var readFile = opts.readFile || fs.readFile;
+ token location info (@$, _$, etc.): {
+ first_line: n,
+ last_line: n,
+ first_column: n,
+ last_column: n,
+ range: [start_number, end_number] (where the numbers are indexes into the input string, regular zero-based)
+ }
- var extensions = opts.extensions || ['.js'];
- var basedir = opts.basedir || path.dirname(caller());
- var parent = opts.filename || basedir;
- opts.paths = opts.paths || [];
+ the parseError function receives a 'hash' object with these members for lexer and parser errors: {
+ text: (matched text)
+ token: (the produced terminal token, if any)
+ line: (yylineno)
+ }
+ while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
+ loc: (yylloc)
+ expected: (string describing the set of expected tokens)
+ recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
+ }
+*/
+var spdxparse = (function(){
+var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[1,5],$V1=[1,6],$V2=[1,7],$V3=[1,4],$V4=[1,9],$V5=[1,10],$V6=[5,14,15,17],$V7=[5,12,14,15,17];
+var parser = {trace: function trace() { },
+yy: {},
+symbols_: {"error":2,"start":3,"expression":4,"EOS":5,"simpleExpression":6,"LICENSE":7,"PLUS":8,"LICENSEREF":9,"DOCUMENTREF":10,"COLON":11,"WITH":12,"EXCEPTION":13,"AND":14,"OR":15,"OPEN":16,"CLOSE":17,"$accept":0,"$end":1},
+terminals_: {2:"error",5:"EOS",7:"LICENSE",8:"PLUS",9:"LICENSEREF",10:"DOCUMENTREF",11:"COLON",12:"WITH",13:"EXCEPTION",14:"AND",15:"OR",16:"OPEN",17:"CLOSE"},
+productions_: [0,[3,2],[6,1],[6,2],[6,1],[6,3],[4,1],[4,3],[4,3],[4,3],[4,3]],
+performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
+/* this == yyval */
- // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
- var absoluteStart = path.resolve(basedir);
+var $0 = $$.length - 1;
+switch (yystate) {
+case 1:
+return this.$ = $$[$0-1]
+break;
+case 2: case 4: case 5:
+this.$ = {license: yytext}
+break;
+case 3:
+this.$ = {license: $$[$0-1], plus: true}
+break;
+case 6:
+this.$ = $$[$0]
+break;
+case 7:
+this.$ = {exception: $$[$0]}
+this.$.license = $$[$0-2].license
+if ($$[$0-2].hasOwnProperty('plus')) {
+ this.$.plus = $$[$0-2].plus
+}
+break;
+case 8:
+this.$ = {conjunction: 'and', left: $$[$0-2], right: $$[$0]}
+break;
+case 9:
+this.$ = {conjunction: 'or', left: $$[$0-2], right: $$[$0]}
+break;
+case 10:
+this.$ = $$[$0-1]
+break;
+}
+},
+table: [{3:1,4:2,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{1:[3]},{5:[1,8],14:$V4,15:$V5},o($V6,[2,6],{12:[1,11]}),{4:12,6:3,7:$V0,9:$V1,10:$V2,16:$V3},o($V7,[2,2],{8:[1,13]}),o($V7,[2,4]),{11:[1,14]},{1:[2,1]},{4:15,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{4:16,6:3,7:$V0,9:$V1,10:$V2,16:$V3},{13:[1,17]},{14:$V4,15:$V5,17:[1,18]},o($V7,[2,3]),{9:[1,19]},o($V6,[2,8]),o([5,15,17],[2,9],{14:$V4}),o($V6,[2,7]),o($V6,[2,10]),o($V7,[2,5])],
+defaultActions: {8:[2,1]},
+parseError: function parseError(str, hash) {
+ if (hash.recoverable) {
+ this.trace(str);
+ } else {
+ function _parseError (msg, hash) {
+ this.message = msg;
+ this.hash = hash;
+ }
+ _parseError.prototype = Error;
- if (opts.preserveSymlinks === false) {
- fs.realpath(absoluteStart, function (realPathErr, realStart) {
- if (realPathErr && realPathErr.code !== 'ENOENT') cb(err);
- else init(realPathErr ? absoluteStart : realStart);
- });
+ throw new _parseError(str, hash);
+ }
+},
+parse: function parse(input) {
+ var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = '', yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
+ var args = lstack.slice.call(arguments, 1);
+ var lexer = Object.create(this.lexer);
+ var sharedState = { yy: {} };
+ for (var k in this.yy) {
+ if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
+ sharedState.yy[k] = this.yy[k];
+ }
+ }
+ lexer.setInput(input, sharedState.yy);
+ sharedState.yy.lexer = lexer;
+ sharedState.yy.parser = this;
+ if (typeof lexer.yylloc == 'undefined') {
+ lexer.yylloc = {};
+ }
+ var yyloc = lexer.yylloc;
+ lstack.push(yyloc);
+ var ranges = lexer.options && lexer.options.ranges;
+ if (typeof sharedState.yy.parseError === 'function') {
+ this.parseError = sharedState.yy.parseError;
} else {
- init(absoluteStart);
+ this.parseError = Object.getPrototypeOf(this).parseError;
}
-
- var res;
- function init(basedir) {
- if ((/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/).test(x)) {
- res = path.resolve(basedir, x);
- if (x === '..' || x.slice(-1) === '/') res += '/';
- if ((/\/$/).test(x) && res === basedir) {
- loadAsDirectory(res, opts.package, onfile);
- } else loadAsFile(res, opts.package, onfile);
- } else loadNodeModules(x, basedir, function (err, n, pkg) {
- if (err) cb(err);
- else if (n) cb(null, n, pkg);
- else if (core[x]) return cb(null, x);
- else {
- var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
- moduleError.code = 'MODULE_NOT_FOUND';
- cb(moduleError);
- }
- });
+ function popStack(n) {
+ stack.length = stack.length - 2 * n;
+ vstack.length = vstack.length - n;
+ lstack.length = lstack.length - n;
}
-
- function onfile(err, m, pkg) {
- if (err) cb(err);
- else if (m) cb(null, m, pkg);
- else loadAsDirectory(res, function (err, d, pkg) {
- if (err) cb(err);
- else if (d) cb(null, d, pkg);
- else {
- var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
- moduleError.code = 'MODULE_NOT_FOUND';
- cb(moduleError);
+ _token_stack:
+ var lex = function () {
+ var token;
+ token = lexer.lex() || EOF;
+ if (typeof token !== 'number') {
+ token = self.symbols_[token] || token;
}
- });
+ return token;
+ };
+ var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
+ while (true) {
+ state = stack[stack.length - 1];
+ if (this.defaultActions[state]) {
+ action = this.defaultActions[state];
+ } else {
+ if (symbol === null || typeof symbol == 'undefined') {
+ symbol = lex();
+ }
+ action = table[state] && table[state][symbol];
+ }
+ if (typeof action === 'undefined' || !action.length || !action[0]) {
+ var errStr = '';
+ expected = [];
+ for (p in table[state]) {
+ if (this.terminals_[p] && p > TERROR) {
+ expected.push('\'' + this.terminals_[p] + '\'');
+ }
+ }
+ if (lexer.showPosition) {
+ errStr = 'Parse error on line ' + (yylineno + 1) + ':\n' + lexer.showPosition() + '\nExpecting ' + expected.join(', ') + ', got \'' + (this.terminals_[symbol] || symbol) + '\'';
+ } else {
+ errStr = 'Parse error on line ' + (yylineno + 1) + ': Unexpected ' + (symbol == EOF ? 'end of input' : '\'' + (this.terminals_[symbol] || symbol) + '\'');
+ }
+ this.parseError(errStr, {
+ text: lexer.match,
+ token: this.terminals_[symbol] || symbol,
+ line: lexer.yylineno,
+ loc: yyloc,
+ expected: expected
+ });
+ }
+ if (action[0] instanceof Array && action.length > 1) {
+ throw new Error('Parse Error: multiple actions possible at state: ' + state + ', token: ' + symbol);
+ }
+ switch (action[0]) {
+ case 1:
+ stack.push(symbol);
+ vstack.push(lexer.yytext);
+ lstack.push(lexer.yylloc);
+ stack.push(action[1]);
+ symbol = null;
+ if (!preErrorSymbol) {
+ yyleng = lexer.yyleng;
+ yytext = lexer.yytext;
+ yylineno = lexer.yylineno;
+ yyloc = lexer.yylloc;
+ if (recovering > 0) {
+ recovering--;
+ }
+ } else {
+ symbol = preErrorSymbol;
+ preErrorSymbol = null;
+ }
+ break;
+ case 2:
+ len = this.productions_[action[1]][1];
+ yyval.$ = vstack[vstack.length - len];
+ yyval._$ = {
+ first_line: lstack[lstack.length - (len || 1)].first_line,
+ last_line: lstack[lstack.length - 1].last_line,
+ first_column: lstack[lstack.length - (len || 1)].first_column,
+ last_column: lstack[lstack.length - 1].last_column
+ };
+ if (ranges) {
+ yyval._$.range = [
+ lstack[lstack.length - (len || 1)].range[0],
+ lstack[lstack.length - 1].range[1]
+ ];
+ }
+ r = this.performAction.apply(yyval, [
+ yytext,
+ yyleng,
+ yylineno,
+ sharedState.yy,
+ action[1],
+ vstack,
+ lstack
+ ].concat(args));
+ if (typeof r !== 'undefined') {
+ return r;
+ }
+ if (len) {
+ stack = stack.slice(0, -1 * len * 2);
+ vstack = vstack.slice(0, -1 * len);
+ lstack = lstack.slice(0, -1 * len);
+ }
+ stack.push(this.productions_[action[1]][0]);
+ vstack.push(yyval.$);
+ lstack.push(yyval._$);
+ newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+ stack.push(newState);
+ break;
+ case 3:
+ return true;
+ }
}
+ return true;
+}};
+/* generated by jison-lex 0.3.4 */
+var lexer = (function(){
+var lexer = ({
+
+EOF:1,
+
+parseError:function parseError(str, hash) {
+ if (this.yy.parser) {
+ this.yy.parser.parseError(str, hash);
+ } else {
+ throw new Error(str);
+ }
+ },
+
+// resets the lexer, sets new input
+setInput:function (input, yy) {
+ this.yy = yy || this.yy || {};
+ this._input = input;
+ this._more = this._backtrack = this.done = false;
+ this.yylineno = this.yyleng = 0;
+ this.yytext = this.matched = this.match = '';
+ this.conditionStack = ['INITIAL'];
+ this.yylloc = {
+ first_line: 1,
+ first_column: 0,
+ last_line: 1,
+ last_column: 0
+ };
+ if (this.options.ranges) {
+ this.yylloc.range = [0,0];
+ }
+ this.offset = 0;
+ return this;
+ },
- function loadAsFile(x, thePackage, callback) {
- var loadAsFilePackage = thePackage;
- var cb = callback;
- if (typeof loadAsFilePackage === 'function') {
- cb = loadAsFilePackage;
- loadAsFilePackage = undefined;
+// consumes and returns one char from the input
+input:function () {
+ var ch = this._input[0];
+ this.yytext += ch;
+ this.yyleng++;
+ this.offset++;
+ this.match += ch;
+ this.matched += ch;
+ var lines = ch.match(/(?:\r\n?|\n).*/g);
+ if (lines) {
+ this.yylineno++;
+ this.yylloc.last_line++;
+ } else {
+ this.yylloc.last_column++;
+ }
+ if (this.options.ranges) {
+ this.yylloc.range[1]++;
}
- var exts = [''].concat(extensions);
- load(exts, x, loadAsFilePackage);
+ this._input = this._input.slice(1);
+ return ch;
+ },
- function load(exts, x, loadPackage) {
- if (exts.length === 0) return cb(null, undefined, loadPackage);
- var file = x + exts[0];
+// unshifts one char (or a string) into the input
+unput:function (ch) {
+ var len = ch.length;
+ var lines = ch.split(/(?:\r\n?|\n)/g);
- var pkg = loadPackage;
- if (pkg) onpkg(null, pkg);
- else loadpkg(path.dirname(file), onpkg);
+ this._input = ch + this._input;
+ this.yytext = this.yytext.substr(0, this.yytext.length - len);
+ //this.yyleng -= len;
+ this.offset -= len;
+ var oldLines = this.match.split(/(?:\r\n?|\n)/g);
+ this.match = this.match.substr(0, this.match.length - 1);
+ this.matched = this.matched.substr(0, this.matched.length - 1);
- function onpkg(err, pkg_, dir) {
- pkg = pkg_;
- if (err) return cb(err);
- if (dir && pkg && opts.pathFilter) {
- var rfile = path.relative(dir, file);
- var rel = rfile.slice(0, rfile.length - exts[0].length);
- var r = opts.pathFilter(pkg, x, rel);
- if (r) return load(
- [''].concat(extensions.slice()),
- path.resolve(dir, r),
- pkg
- );
- }
- isFile(file, onex);
- }
- function onex(err, ex) {
- if (err) return cb(err);
- if (ex) return cb(null, file, pkg);
- load(exts.slice(1), x, pkg);
- }
+ if (lines.length - 1) {
+ this.yylineno -= lines.length - 1;
}
- }
+ var r = this.yylloc.range;
- function loadpkg(dir, cb) {
- if (dir === '' || dir === '/') return cb(null);
- if (process.platform === 'win32' && (/^\w:[/\\]*$/).test(dir)) {
- return cb(null);
- }
- if ((/[/\\]node_modules[/\\]*$/).test(dir)) return cb(null);
+ this.yylloc = {
+ first_line: this.yylloc.first_line,
+ last_line: this.yylineno + 1,
+ first_column: this.yylloc.first_column,
+ last_column: lines ?
+ (lines.length === oldLines.length ? this.yylloc.first_column : 0)
+ + oldLines[oldLines.length - lines.length].length - lines[0].length :
+ this.yylloc.first_column - len
+ };
- var pkgfile = path.join(dir, 'package.json');
- isFile(pkgfile, function (err, ex) {
- // on err, ex is false
- if (!ex) return loadpkg(path.dirname(dir), cb);
+ if (this.options.ranges) {
+ this.yylloc.range = [r[0], r[0] + this.yyleng - len];
+ }
+ this.yyleng = this.yytext.length;
+ return this;
+ },
- readFile(pkgfile, function (err, body) {
- if (err) cb(err);
- try { var pkg = JSON.parse(body); } catch (jsonErr) {}
+// When called from action, caches matched text and appends it on next action
+more:function () {
+ this._more = true;
+ return this;
+ },
- if (pkg && opts.packageFilter) {
- pkg = opts.packageFilter(pkg, pkgfile);
- }
- cb(null, pkg, dir);
+// When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
+reject:function () {
+ if (this.options.backtrack_lexer) {
+ this._backtrack = true;
+ } else {
+ return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n' + this.showPosition(), {
+ text: "",
+ token: null,
+ line: this.yylineno
});
- });
- }
- function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
- var cb = callback;
- var fpkg = loadAsDirectoryPackage;
- if (typeof fpkg === 'function') {
- cb = fpkg;
- fpkg = opts.package;
}
+ return this;
+ },
- var pkgfile = path.join(x, 'package.json');
- isFile(pkgfile, function (err, ex) {
- if (err) return cb(err);
- if (!ex) return loadAsFile(path.join(x, 'index'), fpkg, cb);
-
- readFile(pkgfile, function (err, body) {
- if (err) return cb(err);
- try {
- var pkg = JSON.parse(body);
- } catch (jsonErr) {}
-
- if (opts.packageFilter) {
- pkg = opts.packageFilter(pkg, pkgfile);
- }
-
- if (pkg.main) {
- if (typeof pkg.main !== 'string') {
- var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
- mainError.code = 'INVALID_PACKAGE_MAIN';
- return cb(mainError);
- }
- if (pkg.main === '.' || pkg.main === './') {
- pkg.main = 'index';
- }
- loadAsFile(path.resolve(x, pkg.main), pkg, function (err, m, pkg) {
- if (err) return cb(err);
- if (m) return cb(null, m, pkg);
- if (!pkg) return loadAsFile(path.join(x, 'index'), pkg, cb);
+// retain first n characters of the match
+less:function (n) {
+ this.unput(this.match.slice(n));
+ },
- var dir = path.resolve(x, pkg.main);
- loadAsDirectory(dir, pkg, function (err, n, pkg) {
- if (err) return cb(err);
- if (n) return cb(null, n, pkg);
- loadAsFile(path.join(x, 'index'), pkg, cb);
- });
- });
- return;
- }
+// displays already matched input, i.e. for error messages
+pastInput:function () {
+ var past = this.matched.substr(0, this.matched.length - this.match.length);
+ return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
+ },
- loadAsFile(path.join(x, '/index'), pkg, cb);
- });
- });
- }
+// displays upcoming input, i.e. for error messages
+upcomingInput:function () {
+ var next = this.match;
+ if (next.length < 20) {
+ next += this._input.substr(0, 20-next.length);
+ }
+ return (next.substr(0,20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
+ },
- function processDirs(cb, dirs) {
- if (dirs.length === 0) return cb(null, undefined);
- var dir = dirs[0];
+// displays the character position where the lexing error occurred, i.e. for error messages
+showPosition:function () {
+ var pre = this.pastInput();
+ var c = new Array(pre.length + 1).join("-");
+ return pre + this.upcomingInput() + "\n" + c + "^";
+ },
- var file = path.join(dir, x);
- loadAsFile(file, opts.package, onfile);
+// test the lexed token: return FALSE when not a match, otherwise return token
+test_match:function (match, indexed_rule) {
+ var token,
+ lines,
+ backup;
- function onfile(err, m, pkg) {
- if (err) return cb(err);
- if (m) return cb(null, m, pkg);
- loadAsDirectory(path.join(dir, x), opts.package, ondir);
+ if (this.options.backtrack_lexer) {
+ // save context
+ backup = {
+ yylineno: this.yylineno,
+ yylloc: {
+ first_line: this.yylloc.first_line,
+ last_line: this.last_line,
+ first_column: this.yylloc.first_column,
+ last_column: this.yylloc.last_column
+ },
+ yytext: this.yytext,
+ match: this.match,
+ matches: this.matches,
+ matched: this.matched,
+ yyleng: this.yyleng,
+ offset: this.offset,
+ _more: this._more,
+ _input: this._input,
+ yy: this.yy,
+ conditionStack: this.conditionStack.slice(0),
+ done: this.done
+ };
+ if (this.options.ranges) {
+ backup.yylloc.range = this.yylloc.range.slice(0);
+ }
}
- function ondir(err, n, pkg) {
- if (err) return cb(err);
- if (n) return cb(null, n, pkg);
- processDirs(cb, dirs.slice(1));
+ lines = match[0].match(/(?:\r\n?|\n).*/g);
+ if (lines) {
+ this.yylineno += lines.length;
}
- }
- function loadNodeModules(x, start, cb) {
- processDirs(cb, nodeModulesPaths(start, opts, x));
- }
-};
+ this.yylloc = {
+ first_line: this.yylloc.last_line,
+ last_line: this.yylineno + 1,
+ first_column: this.yylloc.last_column,
+ last_column: lines ?
+ lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length :
+ this.yylloc.last_column + match[0].length
+ };
+ this.yytext += match[0];
+ this.match += match[0];
+ this.matches = match;
+ this.yyleng = this.yytext.length;
+ if (this.options.ranges) {
+ this.yylloc.range = [this.offset, this.offset += this.yyleng];
+ }
+ this._more = false;
+ this._backtrack = false;
+ this._input = this._input.slice(match[0].length);
+ this.matched += match[0];
+ token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
+ if (this.done && this._input) {
+ this.done = false;
+ }
+ if (token) {
+ return token;
+ } else if (this._backtrack) {
+ // recover context
+ for (var k in backup) {
+ this[k] = backup[k];
+ }
+ return false; // rule action called reject() implying the next rule should be tested instead.
+ }
+ return false;
+ },
+// return next match in input
+next:function () {
+ if (this.done) {
+ return this.EOF;
+ }
+ if (!this._input) {
+ this.done = true;
+ }
-/***/ }),
-/* 536 */
-/***/ (function(module, exports) {
+ var token,
+ match,
+ tempMatch,
+ index;
+ if (!this._more) {
+ this.yytext = '';
+ this.match = '';
+ }
+ var rules = this._currentRules();
+ for (var i = 0; i < rules.length; i++) {
+ tempMatch = this._input.match(this.rules[rules[i]]);
+ if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+ match = tempMatch;
+ index = i;
+ if (this.options.backtrack_lexer) {
+ token = this.test_match(tempMatch, rules[i]);
+ if (token !== false) {
+ return token;
+ } else if (this._backtrack) {
+ match = false;
+ continue; // rule action called reject() implying a rule MISmatch.
+ } else {
+ // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
+ return false;
+ }
+ } else if (!this.options.flex) {
+ break;
+ }
+ }
+ }
+ if (match) {
+ token = this.test_match(match, rules[index]);
+ if (token !== false) {
+ return token;
+ }
+ // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
+ return false;
+ }
+ if (this._input === "") {
+ return this.EOF;
+ } else {
+ return this.parseError('Lexical error on line ' + (this.yylineno + 1) + '. Unrecognized text.\n' + this.showPosition(), {
+ text: "",
+ token: null,
+ line: this.yylineno
+ });
+ }
+ },
-module.exports = function () {
- // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
- var origPrepareStackTrace = Error.prepareStackTrace;
- Error.prepareStackTrace = function (_, stack) { return stack; };
- var stack = (new Error()).stack;
- Error.prepareStackTrace = origPrepareStackTrace;
- return stack[2].getFileName();
-};
+// return next match that has a token
+lex:function lex() {
+ var r = this.next();
+ if (r) {
+ return r;
+ } else {
+ return this.lex();
+ }
+ },
+// activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+begin:function begin(condition) {
+ this.conditionStack.push(condition);
+ },
-/***/ }),
-/* 537 */
-/***/ (function(module, exports, __webpack_require__) {
+// pop the previously active lexer condition state off the condition stack
+popState:function popState() {
+ var n = this.conditionStack.length - 1;
+ if (n > 0) {
+ return this.conditionStack.pop();
+ } else {
+ return this.conditionStack[0];
+ }
+ },
-var path = __webpack_require__(16);
-var parse = path.parse || __webpack_require__(538);
+// produce the lexer rule set which is active for the currently active lexer condition state
+_currentRules:function _currentRules() {
+ if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
+ return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
+ } else {
+ return this.conditions["INITIAL"].rules;
+ }
+ },
-var getNodeModulesDirs = function getNodeModulesDirs(absoluteStart, modules) {
- var prefix = '/';
- if ((/^([A-Za-z]:)/).test(absoluteStart)) {
- prefix = '';
- } else if ((/^\\\\/).test(absoluteStart)) {
- prefix = '\\\\';
- }
+// return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+topState:function topState(n) {
+ n = this.conditionStack.length - 1 - Math.abs(n || 0);
+ if (n >= 0) {
+ return this.conditionStack[n];
+ } else {
+ return "INITIAL";
+ }
+ },
- var paths = [absoluteStart];
- var parsed = parse(absoluteStart);
- while (parsed.dir !== paths[paths.length - 1]) {
- paths.push(parsed.dir);
- parsed = parse(parsed.dir);
- }
+// alias for begin(condition)
+pushState:function pushState(condition) {
+ this.begin(condition);
+ },
- return paths.reduce(function (dirs, aPath) {
- return dirs.concat(modules.map(function (moduleDir) {
- return path.join(prefix, aPath, moduleDir);
- }));
- }, []);
-};
+// return the number of states currently on the stack
+stateStackSize:function stateStackSize() {
+ return this.conditionStack.length;
+ },
+options: {},
+performAction: function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
+var YYSTATE=YY_START;
+switch($avoiding_name_collisions) {
+case 0:return 5
+break;
+case 1:/* skip whitespace */
+break;
+case 2:return 8
+break;
+case 3:return 16
+break;
+case 4:return 17
+break;
+case 5:return 11
+break;
+case 6:return 10
+break;
+case 7:return 9
+break;
+case 8:return 14
+break;
+case 9:return 15
+break;
+case 10:return 12
+break;
+case 11:return 7
+break;
+case 12:return 7
+break;
+case 13:return 7
+break;
+case 14:return 7
+break;
+case 15:return 7
+break;
+case 16:return 7
+break;
+case 17:return 7
+break;
+case 18:return 7
+break;
+case 19:return 7
+break;
+case 20:return 7
+break;
+case 21:return 7
+break;
+case 22:return 7
+break;
+case 23:return 7
+break;
+case 24:return 13
+break;
+case 25:return 13
+break;
+case 26:return 13
+break;
+case 27:return 13
+break;
+case 28:return 13
+break;
+case 29:return 13
+break;
+case 30:return 13
+break;
+case 31:return 13
+break;
+case 32:return 7
+break;
+case 33:return 13
+break;
+case 34:return 7
+break;
+case 35:return 13
+break;
+case 36:return 7
+break;
+case 37:return 13
+break;
+case 38:return 13
+break;
+case 39:return 7
+break;
+case 40:return 13
+break;
+case 41:return 13
+break;
+case 42:return 13
+break;
+case 43:return 13
+break;
+case 44:return 13
+break;
+case 45:return 7
+break;
+case 46:return 13
+break;
+case 47:return 7
+break;
+case 48:return 7
+break;
+case 49:return 7
+break;
+case 50:return 7
+break;
+case 51:return 7
+break;
+case 52:return 7
+break;
+case 53:return 7
+break;
+case 54:return 7
+break;
+case 55:return 7
+break;
+case 56:return 7
+break;
+case 57:return 7
+break;
+case 58:return 7
+break;
+case 59:return 7
+break;
+case 60:return 7
+break;
+case 61:return 7
+break;
+case 62:return 7
+break;
+case 63:return 13
+break;
+case 64:return 7
+break;
+case 65:return 7
+break;
+case 66:return 13
+break;
+case 67:return 7
+break;
+case 68:return 7
+break;
+case 69:return 7
+break;
+case 70:return 7
+break;
+case 71:return 7
+break;
+case 72:return 7
+break;
+case 73:return 13
+break;
+case 74:return 7
+break;
+case 75:return 13
+break;
+case 76:return 7
+break;
+case 77:return 7
+break;
+case 78:return 7
+break;
+case 79:return 7
+break;
+case 80:return 7
+break;
+case 81:return 7
+break;
+case 82:return 7
+break;
+case 83:return 7
+break;
+case 84:return 7
+break;
+case 85:return 7
+break;
+case 86:return 7
+break;
+case 87:return 7
+break;
+case 88:return 7
+break;
+case 89:return 7
+break;
+case 90:return 7
+break;
+case 91:return 7
+break;
+case 92:return 7
+break;
+case 93:return 7
+break;
+case 94:return 7
+break;
+case 95:return 7
+break;
+case 96:return 7
+break;
+case 97:return 7
+break;
+case 98:return 7
+break;
+case 99:return 7
+break;
+case 100:return 7
+break;
+case 101:return 7
+break;
+case 102:return 7
+break;
+case 103:return 7
+break;
+case 104:return 7
+break;
+case 105:return 7
+break;
+case 106:return 7
+break;
+case 107:return 7
+break;
+case 108:return 7
+break;
+case 109:return 7
+break;
+case 110:return 7
+break;
+case 111:return 7
+break;
+case 112:return 7
+break;
+case 113:return 7
+break;
+case 114:return 7
+break;
+case 115:return 7
+break;
+case 116:return 7
+break;
+case 117:return 7
+break;
+case 118:return 7
+break;
+case 119:return 7
+break;
+case 120:return 7
+break;
+case 121:return 7
+break;
+case 122:return 7
+break;
+case 123:return 7
+break;
+case 124:return 7
+break;
+case 125:return 7
+break;
+case 126:return 7
+break;
+case 127:return 7
+break;
+case 128:return 7
+break;
+case 129:return 7
+break;
+case 130:return 7
+break;
+case 131:return 7
+break;
+case 132:return 7
+break;
+case 133:return 7
+break;
+case 134:return 7
+break;
+case 135:return 7
+break;
+case 136:return 7
+break;
+case 137:return 7
+break;
+case 138:return 7
+break;
+case 139:return 7
+break;
+case 140:return 7
+break;
+case 141:return 7
+break;
+case 142:return 7
+break;
+case 143:return 7
+break;
+case 144:return 7
+break;
+case 145:return 7
+break;
+case 146:return 7
+break;
+case 147:return 7
+break;
+case 148:return 7
+break;
+case 149:return 7
+break;
+case 150:return 7
+break;
+case 151:return 7
+break;
+case 152:return 7
+break;
+case 153:return 7
+break;
+case 154:return 7
+break;
+case 155:return 7
+break;
+case 156:return 7
+break;
+case 157:return 7
+break;
+case 158:return 7
+break;
+case 159:return 7
+break;
+case 160:return 7
+break;
+case 161:return 7
+break;
+case 162:return 7
+break;
+case 163:return 7
+break;
+case 164:return 7
+break;
+case 165:return 7
+break;
+case 166:return 7
+break;
+case 167:return 7
+break;
+case 168:return 7
+break;
+case 169:return 7
+break;
+case 170:return 7
+break;
+case 171:return 7
+break;
+case 172:return 7
+break;
+case 173:return 7
+break;
+case 174:return 7
+break;
+case 175:return 7
+break;
+case 176:return 7
+break;
+case 177:return 7
+break;
+case 178:return 7
+break;
+case 179:return 7
+break;
+case 180:return 7
+break;
+case 181:return 7
+break;
+case 182:return 7
+break;
+case 183:return 7
+break;
+case 184:return 7
+break;
+case 185:return 7
+break;
+case 186:return 7
+break;
+case 187:return 7
+break;
+case 188:return 7
+break;
+case 189:return 7
+break;
+case 190:return 7
+break;
+case 191:return 7
+break;
+case 192:return 7
+break;
+case 193:return 7
+break;
+case 194:return 7
+break;
+case 195:return 7
+break;
+case 196:return 7
+break;
+case 197:return 7
+break;
+case 198:return 7
+break;
+case 199:return 7
+break;
+case 200:return 7
+break;
+case 201:return 7
+break;
+case 202:return 7
+break;
+case 203:return 7
+break;
+case 204:return 7
+break;
+case 205:return 7
+break;
+case 206:return 7
+break;
+case 207:return 7
+break;
+case 208:return 7
+break;
+case 209:return 7
+break;
+case 210:return 7
+break;
+case 211:return 7
+break;
+case 212:return 7
+break;
+case 213:return 7
+break;
+case 214:return 7
+break;
+case 215:return 7
+break;
+case 216:return 7
+break;
+case 217:return 7
+break;
+case 218:return 7
+break;
+case 219:return 7
+break;
+case 220:return 7
+break;
+case 221:return 7
+break;
+case 222:return 7
+break;
+case 223:return 7
+break;
+case 224:return 7
+break;
+case 225:return 7
+break;
+case 226:return 7
+break;
+case 227:return 7
+break;
+case 228:return 7
+break;
+case 229:return 7
+break;
+case 230:return 7
+break;
+case 231:return 7
+break;
+case 232:return 7
+break;
+case 233:return 7
+break;
+case 234:return 7
+break;
+case 235:return 7
+break;
+case 236:return 7
+break;
+case 237:return 7
+break;
+case 238:return 7
+break;
+case 239:return 7
+break;
+case 240:return 7
+break;
+case 241:return 7
+break;
+case 242:return 7
+break;
+case 243:return 7
+break;
+case 244:return 7
+break;
+case 245:return 7
+break;
+case 246:return 7
+break;
+case 247:return 7
+break;
+case 248:return 7
+break;
+case 249:return 7
+break;
+case 250:return 7
+break;
+case 251:return 7
+break;
+case 252:return 7
+break;
+case 253:return 7
+break;
+case 254:return 7
+break;
+case 255:return 7
+break;
+case 256:return 7
+break;
+case 257:return 7
+break;
+case 258:return 7
+break;
+case 259:return 7
+break;
+case 260:return 7
+break;
+case 261:return 7
+break;
+case 262:return 7
+break;
+case 263:return 7
+break;
+case 264:return 7
+break;
+case 265:return 7
+break;
+case 266:return 7
+break;
+case 267:return 7
+break;
+case 268:return 7
+break;
+case 269:return 7
+break;
+case 270:return 7
+break;
+case 271:return 7
+break;
+case 272:return 7
+break;
+case 273:return 7
+break;
+case 274:return 7
+break;
+case 275:return 7
+break;
+case 276:return 7
+break;
+case 277:return 7
+break;
+case 278:return 7
+break;
+case 279:return 7
+break;
+case 280:return 7
+break;
+case 281:return 7
+break;
+case 282:return 7
+break;
+case 283:return 7
+break;
+case 284:return 7
+break;
+case 285:return 7
+break;
+case 286:return 7
+break;
+case 287:return 7
+break;
+case 288:return 7
+break;
+case 289:return 7
+break;
+case 290:return 7
+break;
+case 291:return 7
+break;
+case 292:return 7
+break;
+case 293:return 7
+break;
+case 294:return 7
+break;
+case 295:return 7
+break;
+case 296:return 7
+break;
+case 297:return 7
+break;
+case 298:return 7
+break;
+case 299:return 7
+break;
+case 300:return 7
+break;
+case 301:return 7
+break;
+case 302:return 7
+break;
+case 303:return 7
+break;
+case 304:return 7
+break;
+case 305:return 7
+break;
+case 306:return 7
+break;
+case 307:return 7
+break;
+case 308:return 7
+break;
+case 309:return 7
+break;
+case 310:return 7
+break;
+case 311:return 7
+break;
+case 312:return 7
+break;
+case 313:return 7
+break;
+case 314:return 7
+break;
+case 315:return 7
+break;
+case 316:return 7
+break;
+case 317:return 7
+break;
+case 318:return 7
+break;
+case 319:return 7
+break;
+case 320:return 7
+break;
+case 321:return 7
+break;
+case 322:return 7
+break;
+case 323:return 7
+break;
+case 324:return 7
+break;
+case 325:return 7
+break;
+case 326:return 7
+break;
+case 327:return 7
+break;
+case 328:return 7
+break;
+case 329:return 7
+break;
+case 330:return 7
+break;
+case 331:return 7
+break;
+case 332:return 7
+break;
+case 333:return 7
+break;
+case 334:return 7
+break;
+case 335:return 7
+break;
+case 336:return 7
+break;
+case 337:return 7
+break;
+case 338:return 7
+break;
+case 339:return 7
+break;
+case 340:return 7
+break;
+case 341:return 7
+break;
+case 342:return 7
+break;
+case 343:return 7
+break;
+case 344:return 7
+break;
+case 345:return 7
+break;
+case 346:return 7
+break;
+case 347:return 7
+break;
+case 348:return 7
+break;
+case 349:return 7
+break;
+case 350:return 7
+break;
+case 351:return 7
+break;
+case 352:return 7
+break;
+case 353:return 7
+break;
+case 354:return 7
+break;
+case 355:return 7
+break;
+case 356:return 7
+break;
+case 357:return 7
+break;
+case 358:return 7
+break;
+case 359:return 7
+break;
+case 360:return 7
+break;
+case 361:return 7
+break;
+case 362:return 7
+break;
+case 363:return 7
+break;
+case 364:return 7
+break;
+}
+},
+rules: [/^(?:$)/,/^(?:\s+)/,/^(?:\+)/,/^(?:\()/,/^(?:\))/,/^(?::)/,/^(?:DocumentRef-([0-9A-Za-z-+.]+))/,/^(?:LicenseRef-([0-9A-Za-z-+.]+))/,/^(?:AND)/,/^(?:OR)/,/^(?:WITH)/,/^(?:BSD-3-Clause-No-Nuclear-License-2014)/,/^(?:BSD-3-Clause-No-Nuclear-Warranty)/,/^(?:GPL-2\.0-with-classpath-exception)/,/^(?:GPL-3\.0-with-autoconf-exception)/,/^(?:GPL-2\.0-with-autoconf-exception)/,/^(?:BSD-3-Clause-No-Nuclear-License)/,/^(?:MPL-2\.0-no-copyleft-exception)/,/^(?:GPL-2\.0-with-bison-exception)/,/^(?:GPL-2\.0-with-font-exception)/,/^(?:GPL-2\.0-with-GCC-exception)/,/^(?:CNRI-Python-GPL-Compatible)/,/^(?:GPL-3\.0-with-GCC-exception)/,/^(?:BSD-3-Clause-Attribution)/,/^(?:Classpath-exception-2\.0)/,/^(?:WxWindows-exception-3\.1)/,/^(?:freertos-exception-2\.0)/,/^(?:Autoconf-exception-3\.0)/,/^(?:i2p-gpl-java-exception)/,/^(?:gnu-javamail-exception)/,/^(?:Nokia-Qt-exception-1\.1)/,/^(?:Autoconf-exception-2\.0)/,/^(?:BSD-2-Clause-FreeBSD)/,/^(?:u-boot-exception-2\.0)/,/^(?:zlib-acknowledgement)/,/^(?:Bison-exception-2\.2)/,/^(?:BSD-2-Clause-NetBSD)/,/^(?:CLISP-exception-2\.0)/,/^(?:eCos-exception-2\.0)/,/^(?:BSD-3-Clause-Clear)/,/^(?:Font-exception-2\.0)/,/^(?:FLTK-exception-2\.0)/,/^(?:GCC-exception-2\.0)/,/^(?:Qwt-exception-1\.0)/,/^(?:Libtool-exception)/,/^(?:BSD-3-Clause-LBNL)/,/^(?:GCC-exception-3\.1)/,/^(?:Artistic-1\.0-Perl)/,/^(?:Artistic-1\.0-cl8)/,/^(?:CC-BY-NC-SA-2\.5)/,/^(?:MIT-advertising)/,/^(?:BSD-Source-Code)/,/^(?:CC-BY-NC-SA-4\.0)/,/^(?:LiLiQ-Rplus-1\.1)/,/^(?:CC-BY-NC-SA-3\.0)/,/^(?:BSD-4-Clause-UC)/,/^(?:CC-BY-NC-SA-2\.0)/,/^(?:CC-BY-NC-SA-1\.0)/,/^(?:CC-BY-NC-ND-4\.0)/,/^(?:CC-BY-NC-ND-3\.0)/,/^(?:CC-BY-NC-ND-2\.5)/,/^(?:CC-BY-NC-ND-2\.0)/,/^(?:CC-BY-NC-ND-1\.0)/,/^(?:LZMA-exception)/,/^(?:BitTorrent-1\.1)/,/^(?:CrystalStacker)/,/^(?:FLTK-exception)/,/^(?:SugarCRM-1\.1\.3)/,/^(?:BSD-Protection)/,/^(?:BitTorrent-1\.0)/,/^(?:HaskellReport)/,/^(?:Interbase-1\.0)/,/^(?:StandardML-NJ)/,/^(?:mif-exception)/,/^(?:Frameworx-1\.0)/,/^(?:389-exception)/,/^(?:CC-BY-NC-2\.0)/,/^(?:CC-BY-NC-2\.5)/,/^(?:CC-BY-NC-3\.0)/,/^(?:CC-BY-NC-4\.0)/,/^(?:W3C-19980720)/,/^(?:CC-BY-SA-1\.0)/,/^(?:CC-BY-SA-2\.0)/,/^(?:CC-BY-SA-2\.5)/,/^(?:CC-BY-ND-2\.0)/,/^(?:CC-BY-SA-4\.0)/,/^(?:CC-BY-SA-3\.0)/,/^(?:Artistic-1\.0)/,/^(?:Artistic-2\.0)/,/^(?:CC-BY-ND-2\.5)/,/^(?:CC-BY-ND-3\.0)/,/^(?:CC-BY-ND-4\.0)/,/^(?:CC-BY-ND-1\.0)/,/^(?:BSD-4-Clause)/,/^(?:BSD-3-Clause)/,/^(?:BSD-2-Clause)/,/^(?:CC-BY-NC-1\.0)/,/^(?:bzip2-1\.0\.6)/,/^(?:Unicode-TOU)/,/^(?:CNRI-Jython)/,/^(?:ImageMagick)/,/^(?:Adobe-Glyph)/,/^(?:CUA-OPL-1\.0)/,/^(?:OLDAP-2\.2\.2)/,/^(?:LiLiQ-R-1\.1)/,/^(?:bzip2-1\.0\.5)/,/^(?:LiLiQ-P-1\.1)/,/^(?:OLDAP-2\.0\.1)/,/^(?:OLDAP-2\.2\.1)/,/^(?:CNRI-Python)/,/^(?:XFree86-1\.1)/,/^(?:OSET-PL-2\.1)/,/^(?:Apache-2\.0)/,/^(?:Watcom-1\.0)/,/^(?:PostgreSQL)/,/^(?:Python-2\.0)/,/^(?:RHeCos-1\.1)/,/^(?:EUDatagrid)/,/^(?:Spencer-99)/,/^(?:Intel-ACPI)/,/^(?:CECILL-1\.0)/,/^(?:CECILL-1\.1)/,/^(?:JasPer-2\.0)/,/^(?:CECILL-2\.0)/,/^(?:CECILL-2\.1)/,/^(?:gSOAP-1\.3b)/,/^(?:Spencer-94)/,/^(?:Apache-1\.1)/,/^(?:Spencer-86)/,/^(?:Apache-1\.0)/,/^(?:ClArtistic)/,/^(?:TORQUE-1\.1)/,/^(?:CATOSL-1\.1)/,/^(?:Adobe-2006)/,/^(?:Zimbra-1\.4)/,/^(?:Zimbra-1\.3)/,/^(?:Condor-1\.1)/,/^(?:CC-BY-3\.0)/,/^(?:CC-BY-2\.5)/,/^(?:OLDAP-2\.4)/,/^(?:SGI-B-1\.1)/,/^(?:SISSL-1\.2)/,/^(?:SGI-B-1\.0)/,/^(?:OLDAP-2\.3)/,/^(?:CC-BY-4\.0)/,/^(?:Crossword)/,/^(?:SimPL-2\.0)/,/^(?:OLDAP-2\.2)/,/^(?:OLDAP-2\.1)/,/^(?:ErlPL-1\.1)/,/^(?:LPPL-1\.3a)/,/^(?:LPPL-1\.3c)/,/^(?:OLDAP-2\.0)/,/^(?:Leptonica)/,/^(?:CPOL-1\.02)/,/^(?:OLDAP-1\.4)/,/^(?:OLDAP-1\.3)/,/^(?:CC-BY-2\.0)/,/^(?:Unlicense)/,/^(?:OLDAP-2\.8)/,/^(?:OLDAP-1\.2)/,/^(?:MakeIndex)/,/^(?:OLDAP-2\.7)/,/^(?:OLDAP-1\.1)/,/^(?:Sleepycat)/,/^(?:D-FSL-1\.0)/,/^(?:CC-BY-1\.0)/,/^(?:OLDAP-2\.6)/,/^(?:WXwindows)/,/^(?:NPOSL-3\.0)/,/^(?:FreeImage)/,/^(?:SGI-B-2\.0)/,/^(?:OLDAP-2\.5)/,/^(?:Beerware)/,/^(?:Newsletr)/,/^(?:NBPL-1\.0)/,/^(?:NASA-1\.3)/,/^(?:NLOD-1\.0)/,/^(?:AGPL-1\.0)/,/^(?:OCLC-2\.0)/,/^(?:ODbL-1\.0)/,/^(?:PDDL-1\.0)/,/^(?:Motosoto)/,/^(?:Afmparse)/,/^(?:ANTLR-PD)/,/^(?:LPL-1\.02)/,/^(?:Abstyles)/,/^(?:eCos-2\.0)/,/^(?:APSL-1\.0)/,/^(?:LPPL-1\.2)/,/^(?:LPPL-1\.1)/,/^(?:LPPL-1\.0)/,/^(?:APSL-1\.1)/,/^(?:APSL-2\.0)/,/^(?:Info-ZIP)/,/^(?:Zend-2\.0)/,/^(?:IBM-pibs)/,/^(?:LGPL-2\.0)/,/^(?:LGPL-3\.0)/,/^(?:LGPL-2\.1)/,/^(?:GFDL-1\.3)/,/^(?:PHP-3\.01)/,/^(?:GFDL-1\.2)/,/^(?:GFDL-1\.1)/,/^(?:AGPL-3\.0)/,/^(?:Giftware)/,/^(?:EUPL-1\.1)/,/^(?:RPSL-1\.0)/,/^(?:EUPL-1\.0)/,/^(?:MIT-enna)/,/^(?:CECILL-B)/,/^(?:diffmark)/,/^(?:CECILL-C)/,/^(?:CDDL-1\.0)/,/^(?:Sendmail)/,/^(?:CDDL-1\.1)/,/^(?:CPAL-1\.0)/,/^(?:APSL-1\.2)/,/^(?:NPL-1\.1)/,/^(?:AFL-1\.2)/,/^(?:Caldera)/,/^(?:AFL-2\.0)/,/^(?:FSFULLR)/,/^(?:AFL-2\.1)/,/^(?:VSL-1\.0)/,/^(?:VOSTROM)/,/^(?:UPL-1\.0)/,/^(?:Dotseqn)/,/^(?:CPL-1\.0)/,/^(?:dvipdfm)/,/^(?:EPL-1\.0)/,/^(?:OCCT-PL)/,/^(?:ECL-1\.0)/,/^(?:Latex2e)/,/^(?:ECL-2\.0)/,/^(?:GPL-1\.0)/,/^(?:GPL-2\.0)/,/^(?:GPL-3\.0)/,/^(?:AFL-3\.0)/,/^(?:LAL-1\.2)/,/^(?:LAL-1\.3)/,/^(?:EFL-1\.0)/,/^(?:EFL-2\.0)/,/^(?:gnuplot)/,/^(?:Aladdin)/,/^(?:LPL-1\.0)/,/^(?:libtiff)/,/^(?:Entessa)/,/^(?:AMDPLPA)/,/^(?:IPL-1\.0)/,/^(?:OPL-1\.0)/,/^(?:OSL-1\.0)/,/^(?:OSL-1\.1)/,/^(?:OSL-2\.0)/,/^(?:OSL-2\.1)/,/^(?:OSL-3\.0)/,/^(?:OpenSSL)/,/^(?:ZPL-2\.1)/,/^(?:PHP-3\.0)/,/^(?:ZPL-2\.0)/,/^(?:ZPL-1\.1)/,/^(?:CC0-1\.0)/,/^(?:SPL-1\.0)/,/^(?:psutils)/,/^(?:MPL-1\.0)/,/^(?:QPL-1\.0)/,/^(?:MPL-1\.1)/,/^(?:MPL-2\.0)/,/^(?:APL-1\.0)/,/^(?:RPL-1\.1)/,/^(?:RPL-1\.5)/,/^(?:MIT-CMU)/,/^(?:Multics)/,/^(?:Eurosym)/,/^(?:BSL-1\.0)/,/^(?:MIT-feh)/,/^(?:Saxpath)/,/^(?:Borceux)/,/^(?:OFL-1\.1)/,/^(?:OFL-1\.0)/,/^(?:AFL-1\.1)/,/^(?:YPL-1\.1)/,/^(?:YPL-1\.0)/,/^(?:NPL-1\.0)/,/^(?:iMatix)/,/^(?:mpich2)/,/^(?:APAFML)/,/^(?:Bahyph)/,/^(?:RSA-MD)/,/^(?:psfrag)/,/^(?:Plexus)/,/^(?:eGenix)/,/^(?:Glulxe)/,/^(?:SAX-PD)/,/^(?:Imlib2)/,/^(?:Wsuipa)/,/^(?:LGPLLR)/,/^(?:Libpng)/,/^(?:xinetd)/,/^(?:MITNFA)/,/^(?:NetCDF)/,/^(?:Naumen)/,/^(?:SMPPL)/,/^(?:Nunit)/,/^(?:FSFUL)/,/^(?:GL2PS)/,/^(?:SMLNJ)/,/^(?:Rdisc)/,/^(?:Noweb)/,/^(?:Nokia)/,/^(?:SISSL)/,/^(?:Qhull)/,/^(?:Intel)/,/^(?:Glide)/,/^(?:Xerox)/,/^(?:AMPAS)/,/^(?:WTFPL)/,/^(?:MS-PL)/,/^(?:XSkat)/,/^(?:MS-RL)/,/^(?:MirOS)/,/^(?:RSCPL)/,/^(?:TMate)/,/^(?:OGTSL)/,/^(?:FSFAP)/,/^(?:NCSA)/,/^(?:Zlib)/,/^(?:SCEA)/,/^(?:SNIA)/,/^(?:NGPL)/,/^(?:NOSL)/,/^(?:ADSL)/,/^(?:MTLL)/,/^(?:NLPL)/,/^(?:Ruby)/,/^(?:JSON)/,/^(?:Barr)/,/^(?:0BSD)/,/^(?:Xnet)/,/^(?:Cube)/,/^(?:curl)/,/^(?:DSDP)/,/^(?:Fair)/,/^(?:HPND)/,/^(?:TOSL)/,/^(?:IJG)/,/^(?:SWL)/,/^(?:Vim)/,/^(?:FTL)/,/^(?:ICU)/,/^(?:OML)/,/^(?:NRL)/,/^(?:DOC)/,/^(?:TCL)/,/^(?:W3C)/,/^(?:NTP)/,/^(?:IPA)/,/^(?:ISC)/,/^(?:X11)/,/^(?:AAL)/,/^(?:AML)/,/^(?:xpp)/,/^(?:Zed)/,/^(?:MIT)/,/^(?:Mup)/],
+conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364],"inclusive":true}}
+});
+return lexer;
+})();
+parser.lexer = lexer;
+function Parser () {
+ this.yy = {};
+}
+Parser.prototype = parser;parser.Parser = Parser;
+return new Parser;
+})();
-module.exports = function nodeModulesPaths(start, opts, request) {
- var modules = opts && opts.moduleDirectory
- ? [].concat(opts.moduleDirectory)
- : ['node_modules'];
- if (opts && typeof opts.paths === 'function') {
- return opts.paths(
- request,
- start,
- function () { return getNodeModulesDirs(start, modules); },
- opts
- );
+if (true) {
+exports.parser = spdxparse;
+exports.Parser = spdxparse.Parser;
+exports.parse = function () { return spdxparse.parse.apply(spdxparse, arguments); };
+exports.main = function commonjsMain(args) {
+ if (!args[1]) {
+ console.log('Usage: '+args[0]+' FILE');
+ process.exit(1);
}
-
- var dirs = getNodeModulesDirs(start, modules);
- return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+ var source = __webpack_require__(349).readFileSync(__webpack_require__(4).normalize(args[1]), "utf8");
+ return exports.parser.parse(source);
};
-
-
-/***/ }),
-/* 538 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-
-var isWindows = process.platform === 'win32';
-
-// Regex to split a windows path into three parts: [*, device, slash,
-// tail] windows-only
-var splitDeviceRe =
- /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
-
-// Regex to split the tail part of the above into [*, dir, basename, ext]
-var splitTailRe =
- /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
-
-var win32 = {};
-
-// Function to split a filename into [root, dir, basename, ext]
-function win32SplitPath(filename) {
- // Separate device+slash from tail
- var result = splitDeviceRe.exec(filename),
- device = (result[1] || '') + (result[2] || ''),
- tail = result[3] || '';
- // Split the tail into dir, basename and extension
- var result2 = splitTailRe.exec(tail),
- dir = result2[1],
- basename = result2[2],
- ext = result2[3];
- return [device, dir, basename, ext];
+if ( true && __webpack_require__.c[__webpack_require__.s] === module) {
+ exports.main(process.argv.slice(1));
}
-
-win32.parse = function(pathString) {
- if (typeof pathString !== 'string') {
- throw new TypeError(
- "Parameter 'pathString' must be a string, not " + typeof pathString
- );
- }
- var allParts = win32SplitPath(pathString);
- if (!allParts || allParts.length !== 4) {
- throw new TypeError("Invalid path '" + pathString + "'");
- }
- return {
- root: allParts[0],
- dir: allParts[0] + allParts[1].slice(0, -1),
- base: allParts[2],
- ext: allParts[3],
- name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
- };
-};
-
-
-
-// Split a filename into [root, dir, basename, ext], unix version
-// 'root' is just a slash, or nothing.
-var splitPathRe =
- /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
-var posix = {};
-
-
-function posixSplitPath(filename) {
- return splitPathRe.exec(filename).slice(1);
}
-
-posix.parse = function(pathString) {
- if (typeof pathString !== 'string') {
- throw new TypeError(
- "Parameter 'pathString' must be a string, not " + typeof pathString
- );
- }
- var allParts = posixSplitPath(pathString);
- if (!allParts || allParts.length !== 4) {
- throw new TypeError("Invalid path '" + pathString + "'");
- }
- allParts[1] = allParts[1] || '';
- allParts[2] = allParts[2] || '';
- allParts[3] = allParts[3] || '';
-
- return {
- root: allParts[0],
- dir: allParts[0] + allParts[1].slice(0, -1),
- base: allParts[2],
- ext: allParts[3],
- name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
- };
-};
-
-
-if (isWindows)
- module.exports = win32.parse;
-else /* posix */
- module.exports = posix.parse;
-
-module.exports.posix = posix.parse;
-module.exports.win32 = win32.parse;
-
-
-/***/ }),
-/* 539 */
-/***/ (function(module, exports) {
-
-module.exports = function (x, opts) {
- /**
- * This file is purposefully a passthrough. It's expected that third-party
- * environments will override it at runtime in order to inject special logic
- * into `resolve` (by manipulating the options). One such example is the PnP
- * code path in Yarn.
- */
-
- return opts || {};
-};
-
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(11)(module)))
/***/ }),
-/* 540 */
+/* 527 */
/***/ (function(module, exports, __webpack_require__) {
-var core = __webpack_require__(533);
-var fs = __webpack_require__(23);
-var path = __webpack_require__(16);
-var caller = __webpack_require__(536);
-var nodeModulesPaths = __webpack_require__(537);
-var normalizeOptions = __webpack_require__(539);
-
-var defaultIsFile = function isFile(file) {
- try {
- var stat = fs.statSync(file);
- } catch (e) {
- if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
- throw e;
- }
- return stat.isFile() || stat.isFIFO();
-};
-
-module.exports = function (x, options) {
- if (typeof x !== 'string') {
- throw new TypeError('Path must be a string.');
- }
- var opts = normalizeOptions(x, options);
-
- var isFile = opts.isFile || defaultIsFile;
- var readFileSync = opts.readFileSync || fs.readFileSync;
-
- var extensions = opts.extensions || ['.js'];
- var basedir = opts.basedir || path.dirname(caller());
- var parent = opts.filename || basedir;
-
- opts.paths = opts.paths || [];
+var licenseIDs = __webpack_require__(528);
- // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
- var absoluteStart = path.resolve(basedir);
+function valid(string) {
+ return licenseIDs.indexOf(string) > -1;
+}
- if (opts.preserveSymlinks === false) {
- try {
- absoluteStart = fs.realpathSync(absoluteStart);
- } catch (realPathErr) {
- if (realPathErr.code !== 'ENOENT') {
- throw realPathErr;
- }
- }
- }
+// Common transpositions of license identifier acronyms
+var transpositions = [
+ ['APGL', 'AGPL'],
+ ['Gpl', 'GPL'],
+ ['GLP', 'GPL'],
+ ['APL', 'Apache'],
+ ['ISD', 'ISC'],
+ ['GLP', 'GPL'],
+ ['IST', 'ISC'],
+ ['Claude', 'Clause'],
+ [' or later', '+'],
+ [' International', ''],
+ ['GNU', 'GPL'],
+ ['GUN', 'GPL'],
+ ['+', ''],
+ ['GNU GPL', 'GPL'],
+ ['GNU/GPL', 'GPL'],
+ ['GNU GLP', 'GPL'],
+ ['GNU General Public License', 'GPL'],
+ ['Gnu public license', 'GPL'],
+ ['GNU Public License', 'GPL'],
+ ['GNU GENERAL PUBLIC LICENSE', 'GPL'],
+ ['MTI', 'MIT'],
+ ['Mozilla Public License', 'MPL'],
+ ['WTH', 'WTF'],
+ ['-License', '']
+];
- if ((/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/).test(x)) {
- var res = path.resolve(absoluteStart, x);
- if (x === '..' || x.slice(-1) === '/') res += '/';
- var m = loadAsFileSync(res) || loadAsDirectorySync(res);
- if (m) return m;
- } else {
- var n = loadNodeModulesSync(x, absoluteStart);
- if (n) return n;
- }
+var TRANSPOSED = 0;
+var CORRECT = 1;
- if (core[x]) return x;
+// Simple corrections to nearly valid identifiers.
+var transforms = [
+ // e.g. 'mit'
+ function(argument) {
+ return argument.toUpperCase();
+ },
+ // e.g. 'MIT '
+ function(argument) {
+ return argument.trim();
+ },
+ // e.g. 'M.I.T.'
+ function(argument) {
+ return argument.replace(/\./g, '');
+ },
+ // e.g. 'Apache- 2.0'
+ function(argument) {
+ return argument.replace(/\s+/g, '');
+ },
+ // e.g. 'CC BY 4.0''
+ function(argument) {
+ return argument.replace(/\s+/g, '-');
+ },
+ // e.g. 'LGPLv2.1'
+ function(argument) {
+ return argument.replace('v', '-');
+ },
+ // e.g. 'Apache 2.0'
+ function(argument) {
+ return argument.replace(/,?\s*(\d)/, '-$1');
+ },
+ // e.g. 'GPL 2'
+ function(argument) {
+ return argument.replace(/,?\s*(\d)/, '-$1.0');
+ },
+ // e.g. 'Apache Version 2.0'
+ function(argument) {
+ return argument.replace(/,?\s*(V\.|v\.|V|v|Version|version)\s*(\d)/, '-$2');
+ },
+ // e.g. 'Apache Version 2'
+ function(argument) {
+ return argument.replace(/,?\s*(V\.|v\.|V|v|Version|version)\s*(\d)/, '-$2.0');
+ },
+ // e.g. 'ZLIB'
+ function(argument) {
+ return argument[0].toUpperCase() + argument.slice(1);
+ },
+ // e.g. 'MPL/2.0'
+ function(argument) {
+ return argument.replace('/', '-');
+ },
+ // e.g. 'Apache 2'
+ function(argument) {
+ return argument
+ .replace(/\s*V\s*(\d)/, '-$1')
+ .replace(/(\d)$/, '$1.0');
+ },
+ // e.g. 'GPL-2.0-'
+ function(argument) {
+ return argument.slice(0, argument.length - 1);
+ },
+ // e.g. 'GPL2'
+ function(argument) {
+ return argument.replace(/(\d)$/, '-$1.0');
+ },
+ // e.g. 'BSD 3'
+ function(argument) {
+ return argument.replace(/(-| )?(\d)$/, '-$2-Clause');
+ },
+ // e.g. 'BSD clause 3'
+ function(argument) {
+ return argument.replace(/(-| )clause(-| )(\d)/, '-$3-Clause');
+ },
+ // e.g. 'BY-NC-4.0'
+ function(argument) {
+ return 'CC-' + argument;
+ },
+ // e.g. 'BY-NC'
+ function(argument) {
+ return 'CC-' + argument + '-4.0';
+ },
+ // e.g. 'Attribution-NonCommercial'
+ function(argument) {
+ return argument
+ .replace('Attribution', 'BY')
+ .replace('NonCommercial', 'NC')
+ .replace('NoDerivatives', 'ND')
+ .replace(/ (\d)/, '-$1')
+ .replace(/ ?International/, '');
+ },
+ // e.g. 'Attribution-NonCommercial'
+ function(argument) {
+ return 'CC-' +
+ argument
+ .replace('Attribution', 'BY')
+ .replace('NonCommercial', 'NC')
+ .replace('NoDerivatives', 'ND')
+ .replace(/ (\d)/, '-$1')
+ .replace(/ ?International/, '') +
+ '-4.0';
+ }
+];
- var err = new Error("Cannot find module '" + x + "' from '" + parent + "'");
- err.code = 'MODULE_NOT_FOUND';
- throw err;
+// If all else fails, guess that strings containing certain substrings
+// meant to identify certain licenses.
+var lastResorts = [
+ ['UNLI', 'Unlicense'],
+ ['WTF', 'WTFPL'],
+ ['2 CLAUSE', 'BSD-2-Clause'],
+ ['2-CLAUSE', 'BSD-2-Clause'],
+ ['3 CLAUSE', 'BSD-3-Clause'],
+ ['3-CLAUSE', 'BSD-3-Clause'],
+ ['AFFERO', 'AGPL-3.0'],
+ ['AGPL', 'AGPL-3.0'],
+ ['APACHE', 'Apache-2.0'],
+ ['ARTISTIC', 'Artistic-2.0'],
+ ['Affero', 'AGPL-3.0'],
+ ['BEER', 'Beerware'],
+ ['BOOST', 'BSL-1.0'],
+ ['BSD', 'BSD-2-Clause'],
+ ['ECLIPSE', 'EPL-1.0'],
+ ['FUCK', 'WTFPL'],
+ ['GNU', 'GPL-3.0'],
+ ['LGPL', 'LGPL-3.0'],
+ ['GPL', 'GPL-3.0'],
+ ['MIT', 'MIT'],
+ ['MPL', 'MPL-2.0'],
+ ['X11', 'X11'],
+ ['ZLIB', 'Zlib']
+];
- function loadAsFileSync(x) {
- var pkg = loadpkg(path.dirname(x));
+var SUBSTRING = 0;
+var IDENTIFIER = 1;
- if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
- var rfile = path.relative(pkg.dir, x);
- var r = opts.pathFilter(pkg.pkg, x, rfile);
- if (r) {
- x = path.resolve(pkg.dir, r); // eslint-disable-line no-param-reassign
- }
- }
+var validTransformation = function(identifier) {
+ for (var i = 0; i < transforms.length; i++) {
+ var transformed = transforms[i](identifier);
+ if (transformed !== identifier && valid(transformed)) {
+ return transformed;
+ }
+ }
+ return null;
+};
- if (isFile(x)) {
- return x;
- }
+var validLastResort = function(identifier) {
+ var upperCased = identifier.toUpperCase();
+ for (var i = 0; i < lastResorts.length; i++) {
+ var lastResort = lastResorts[i];
+ if (upperCased.indexOf(lastResort[SUBSTRING]) > -1) {
+ return lastResort[IDENTIFIER];
+ }
+ }
+ return null;
+};
- for (var i = 0; i < extensions.length; i++) {
- var file = x + extensions[i];
- if (isFile(file)) {
- return file;
- }
- }
+var anyCorrection = function(identifier, check) {
+ for (var i = 0; i < transpositions.length; i++) {
+ var transposition = transpositions[i];
+ var transposed = transposition[TRANSPOSED];
+ if (identifier.indexOf(transposed) > -1) {
+ var corrected = identifier.replace(
+ transposed,
+ transposition[CORRECT]
+ );
+ var checked = check(corrected);
+ if (checked !== null) {
+ return checked;
+ }
}
+ }
+ return null;
+};
- function loadpkg(dir) {
- if (dir === '' || dir === '/') return;
- if (process.platform === 'win32' && (/^\w:[/\\]*$/).test(dir)) {
- return;
- }
- if ((/[/\\]node_modules[/\\]*$/).test(dir)) return;
+module.exports = function(identifier) {
+ identifier = identifier.replace(/\+$/, '');
+ if (valid(identifier)) {
+ return identifier;
+ }
+ var transformed = validTransformation(identifier);
+ if (transformed !== null) {
+ return transformed;
+ }
+ transformed = anyCorrection(identifier, function(argument) {
+ if (valid(argument)) {
+ return argument;
+ }
+ return validTransformation(argument);
+ });
+ if (transformed !== null) {
+ return transformed;
+ }
+ transformed = validLastResort(identifier);
+ if (transformed !== null) {
+ return transformed;
+ }
+ transformed = anyCorrection(identifier, validLastResort);
+ if (transformed !== null) {
+ return transformed;
+ }
+ return null;
+};
- var pkgfile = path.join(dir, 'package.json');
- if (!isFile(pkgfile)) {
- return loadpkg(path.dirname(dir));
- }
+/***/ }),
+/* 528 */
+/***/ (function(module) {
- var body = readFileSync(pkgfile);
+module.exports = JSON.parse("[\"Glide\",\"Abstyles\",\"AFL-1.1\",\"AFL-1.2\",\"AFL-2.0\",\"AFL-2.1\",\"AFL-3.0\",\"AMPAS\",\"APL-1.0\",\"Adobe-Glyph\",\"APAFML\",\"Adobe-2006\",\"AGPL-1.0\",\"Afmparse\",\"Aladdin\",\"ADSL\",\"AMDPLPA\",\"ANTLR-PD\",\"Apache-1.0\",\"Apache-1.1\",\"Apache-2.0\",\"AML\",\"APSL-1.0\",\"APSL-1.1\",\"APSL-1.2\",\"APSL-2.0\",\"Artistic-1.0\",\"Artistic-1.0-Perl\",\"Artistic-1.0-cl8\",\"Artistic-2.0\",\"AAL\",\"Bahyph\",\"Barr\",\"Beerware\",\"BitTorrent-1.0\",\"BitTorrent-1.1\",\"BSL-1.0\",\"Borceux\",\"BSD-2-Clause\",\"BSD-2-Clause-FreeBSD\",\"BSD-2-Clause-NetBSD\",\"BSD-3-Clause\",\"BSD-3-Clause-Clear\",\"BSD-4-Clause\",\"BSD-Protection\",\"BSD-Source-Code\",\"BSD-3-Clause-Attribution\",\"0BSD\",\"BSD-4-Clause-UC\",\"bzip2-1.0.5\",\"bzip2-1.0.6\",\"Caldera\",\"CECILL-1.0\",\"CECILL-1.1\",\"CECILL-2.0\",\"CECILL-2.1\",\"CECILL-B\",\"CECILL-C\",\"ClArtistic\",\"MIT-CMU\",\"CNRI-Jython\",\"CNRI-Python\",\"CNRI-Python-GPL-Compatible\",\"CPOL-1.02\",\"CDDL-1.0\",\"CDDL-1.1\",\"CPAL-1.0\",\"CPL-1.0\",\"CATOSL-1.1\",\"Condor-1.1\",\"CC-BY-1.0\",\"CC-BY-2.0\",\"CC-BY-2.5\",\"CC-BY-3.0\",\"CC-BY-4.0\",\"CC-BY-ND-1.0\",\"CC-BY-ND-2.0\",\"CC-BY-ND-2.5\",\"CC-BY-ND-3.0\",\"CC-BY-ND-4.0\",\"CC-BY-NC-1.0\",\"CC-BY-NC-2.0\",\"CC-BY-NC-2.5\",\"CC-BY-NC-3.0\",\"CC-BY-NC-4.0\",\"CC-BY-NC-ND-1.0\",\"CC-BY-NC-ND-2.0\",\"CC-BY-NC-ND-2.5\",\"CC-BY-NC-ND-3.0\",\"CC-BY-NC-ND-4.0\",\"CC-BY-NC-SA-1.0\",\"CC-BY-NC-SA-2.0\",\"CC-BY-NC-SA-2.5\",\"CC-BY-NC-SA-3.0\",\"CC-BY-NC-SA-4.0\",\"CC-BY-SA-1.0\",\"CC-BY-SA-2.0\",\"CC-BY-SA-2.5\",\"CC-BY-SA-3.0\",\"CC-BY-SA-4.0\",\"CC0-1.0\",\"Crossword\",\"CrystalStacker\",\"CUA-OPL-1.0\",\"Cube\",\"curl\",\"D-FSL-1.0\",\"diffmark\",\"WTFPL\",\"DOC\",\"Dotseqn\",\"DSDP\",\"dvipdfm\",\"EPL-1.0\",\"ECL-1.0\",\"ECL-2.0\",\"eGenix\",\"EFL-1.0\",\"EFL-2.0\",\"MIT-advertising\",\"MIT-enna\",\"Entessa\",\"ErlPL-1.1\",\"EUDatagrid\",\"EUPL-1.0\",\"EUPL-1.1\",\"Eurosym\",\"Fair\",\"MIT-feh\",\"Frameworx-1.0\",\"FreeImage\",\"FTL\",\"FSFAP\",\"FSFUL\",\"FSFULLR\",\"Giftware\",\"GL2PS\",\"Glulxe\",\"AGPL-3.0\",\"GFDL-1.1\",\"GFDL-1.2\",\"GFDL-1.3\",\"GPL-1.0\",\"GPL-2.0\",\"GPL-3.0\",\"LGPL-2.1\",\"LGPL-3.0\",\"LGPL-2.0\",\"gnuplot\",\"gSOAP-1.3b\",\"HaskellReport\",\"HPND\",\"IBM-pibs\",\"IPL-1.0\",\"ICU\",\"ImageMagick\",\"iMatix\",\"Imlib2\",\"IJG\",\"Info-ZIP\",\"Intel-ACPI\",\"Intel\",\"Interbase-1.0\",\"IPA\",\"ISC\",\"JasPer-2.0\",\"JSON\",\"LPPL-1.0\",\"LPPL-1.1\",\"LPPL-1.2\",\"LPPL-1.3a\",\"LPPL-1.3c\",\"Latex2e\",\"BSD-3-Clause-LBNL\",\"Leptonica\",\"LGPLLR\",\"Libpng\",\"libtiff\",\"LAL-1.2\",\"LAL-1.3\",\"LiLiQ-P-1.1\",\"LiLiQ-Rplus-1.1\",\"LiLiQ-R-1.1\",\"LPL-1.02\",\"LPL-1.0\",\"MakeIndex\",\"MTLL\",\"MS-PL\",\"MS-RL\",\"MirOS\",\"MITNFA\",\"MIT\",\"Motosoto\",\"MPL-1.0\",\"MPL-1.1\",\"MPL-2.0\",\"MPL-2.0-no-copyleft-exception\",\"mpich2\",\"Multics\",\"Mup\",\"NASA-1.3\",\"Naumen\",\"NBPL-1.0\",\"NetCDF\",\"NGPL\",\"NOSL\",\"NPL-1.0\",\"NPL-1.1\",\"Newsletr\",\"NLPL\",\"Nokia\",\"NPOSL-3.0\",\"NLOD-1.0\",\"Noweb\",\"NRL\",\"NTP\",\"Nunit\",\"OCLC-2.0\",\"ODbL-1.0\",\"PDDL-1.0\",\"OCCT-PL\",\"OGTSL\",\"OLDAP-2.2.2\",\"OLDAP-1.1\",\"OLDAP-1.2\",\"OLDAP-1.3\",\"OLDAP-1.4\",\"OLDAP-2.0\",\"OLDAP-2.0.1\",\"OLDAP-2.1\",\"OLDAP-2.2\",\"OLDAP-2.2.1\",\"OLDAP-2.3\",\"OLDAP-2.4\",\"OLDAP-2.5\",\"OLDAP-2.6\",\"OLDAP-2.7\",\"OLDAP-2.8\",\"OML\",\"OPL-1.0\",\"OSL-1.0\",\"OSL-1.1\",\"OSL-2.0\",\"OSL-2.1\",\"OSL-3.0\",\"OpenSSL\",\"OSET-PL-2.1\",\"PHP-3.0\",\"PHP-3.01\",\"Plexus\",\"PostgreSQL\",\"psfrag\",\"psutils\",\"Python-2.0\",\"QPL-1.0\",\"Qhull\",\"Rdisc\",\"RPSL-1.0\",\"RPL-1.1\",\"RPL-1.5\",\"RHeCos-1.1\",\"RSCPL\",\"RSA-MD\",\"Ruby\",\"SAX-PD\",\"Saxpath\",\"SCEA\",\"SWL\",\"SMPPL\",\"Sendmail\",\"SGI-B-1.0\",\"SGI-B-1.1\",\"SGI-B-2.0\",\"OFL-1.0\",\"OFL-1.1\",\"SimPL-2.0\",\"Sleepycat\",\"SNIA\",\"Spencer-86\",\"Spencer-94\",\"Spencer-99\",\"SMLNJ\",\"SugarCRM-1.1.3\",\"SISSL\",\"SISSL-1.2\",\"SPL-1.0\",\"Watcom-1.0\",\"TCL\",\"Unlicense\",\"TMate\",\"TORQUE-1.1\",\"TOSL\",\"Unicode-TOU\",\"UPL-1.0\",\"NCSA\",\"Vim\",\"VOSTROM\",\"VSL-1.0\",\"W3C-19980720\",\"W3C\",\"Wsuipa\",\"Xnet\",\"X11\",\"Xerox\",\"XFree86-1.1\",\"xinetd\",\"xpp\",\"XSkat\",\"YPL-1.0\",\"YPL-1.1\",\"Zed\",\"Zend-2.0\",\"Zimbra-1.3\",\"Zimbra-1.4\",\"Zlib\",\"zlib-acknowledgement\",\"ZPL-1.1\",\"ZPL-2.0\",\"ZPL-2.1\",\"BSD-3-Clause-No-Nuclear-License\",\"BSD-3-Clause-No-Nuclear-Warranty\",\"BSD-3-Clause-No-Nuclear-License-2014\",\"eCos-2.0\",\"GPL-2.0-with-autoconf-exception\",\"GPL-2.0-with-bison-exception\",\"GPL-2.0-with-classpath-exception\",\"GPL-2.0-with-font-exception\",\"GPL-2.0-with-GCC-exception\",\"GPL-3.0-with-autoconf-exception\",\"GPL-3.0-with-GCC-exception\",\"StandardML-NJ\",\"WXwindows\"]");
- try {
- var pkg = JSON.parse(body);
- } catch (jsonErr) {}
+/***/ }),
+/* 529 */
+/***/ (function(module, exports, __webpack_require__) {
- if (pkg && opts.packageFilter) {
- pkg = opts.packageFilter(pkg, dir);
- }
+"use strict";
- return { pkg: pkg, dir: dir };
- }
+var url = __webpack_require__(439)
+var gitHosts = __webpack_require__(530)
+var GitHost = module.exports = __webpack_require__(531)
- function loadAsDirectorySync(x) {
- var pkgfile = path.join(x, '/package.json');
- if (isFile(pkgfile)) {
- try {
- var body = readFileSync(pkgfile, 'UTF8');
- var pkg = JSON.parse(body);
- } catch (e) {}
+var protocolToRepresentationMap = {
+ 'git+ssh': 'sshurl',
+ 'git+https': 'https',
+ 'ssh': 'sshurl',
+ 'git': 'git'
+}
- if (opts.packageFilter) {
- pkg = opts.packageFilter(pkg, x);
- }
+function protocolToRepresentation (protocol) {
+ if (protocol.substr(-1) === ':') protocol = protocol.slice(0, -1)
+ return protocolToRepresentationMap[protocol] || protocol
+}
- if (pkg.main) {
- if (typeof pkg.main !== 'string') {
- var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
- mainError.code = 'INVALID_PACKAGE_MAIN';
- throw mainError;
- }
- if (pkg.main === '.' || pkg.main === './') {
- pkg.main = 'index';
- }
- try {
- var m = loadAsFileSync(path.resolve(x, pkg.main));
- if (m) return m;
- var n = loadAsDirectorySync(path.resolve(x, pkg.main));
- if (n) return n;
- } catch (e) {}
- }
- }
+var authProtocols = {
+ 'git:': true,
+ 'https:': true,
+ 'git+https:': true,
+ 'http:': true,
+ 'git+http:': true
+}
- return loadAsFileSync(path.join(x, '/index'));
- }
+var cache = {}
- function loadNodeModulesSync(x, start) {
- var dirs = nodeModulesPaths(start, opts, x);
- for (var i = 0; i < dirs.length; i++) {
- var dir = dirs[i];
- var m = loadAsFileSync(path.join(dir, '/', x));
- if (m) return m;
- var n = loadAsDirectorySync(path.join(dir, '/', x));
- if (n) return n;
- }
- }
-};
+module.exports.fromUrl = function (giturl, opts) {
+ var key = giturl + JSON.stringify(opts || {})
+ if (!(key in cache)) {
+ cache[key] = fromUrl(giturl, opts)
+ }
-/***/ }),
-/* 541 */
-/***/ (function(module, exports) {
+ return cache[key]
+}
-module.exports = extractDescription
+function fromUrl (giturl, opts) {
+ if (giturl == null || giturl === '') return
+ var url = fixupUnqualifiedGist(
+ isGitHubShorthand(giturl) ? 'github:' + giturl : giturl
+ )
+ var parsed = parseGitUrl(url)
+ var shortcutMatch = url.match(new RegExp('^([^:]+):(?:(?:[^@:]+(?:[^@]+)?@)?([^/]*))[/](.+?)(?:[.]git)?($|#)'))
+ var matches = Object.keys(gitHosts).map(function (gitHostName) {
+ try {
+ var gitHostInfo = gitHosts[gitHostName]
+ var auth = null
+ if (parsed.auth && authProtocols[parsed.protocol]) {
+ auth = decodeURIComponent(parsed.auth)
+ }
+ var committish = parsed.hash ? decodeURIComponent(parsed.hash.substr(1)) : null
+ var user = null
+ var project = null
+ var defaultRepresentation = null
+ if (shortcutMatch && shortcutMatch[1] === gitHostName) {
+ user = shortcutMatch[2] && decodeURIComponent(shortcutMatch[2])
+ project = decodeURIComponent(shortcutMatch[3])
+ defaultRepresentation = 'shortcut'
+ } else {
+ if (parsed.host !== gitHostInfo.domain) return
+ if (!gitHostInfo.protocols_re.test(parsed.protocol)) return
+ if (!parsed.path) return
+ var pathmatch = gitHostInfo.pathmatch
+ var matched = parsed.path.match(pathmatch)
+ if (!matched) return
+ if (matched[1] != null) user = decodeURIComponent(matched[1].replace(/^:/, ''))
+ if (matched[2] != null) project = decodeURIComponent(matched[2])
+ defaultRepresentation = protocolToRepresentation(parsed.protocol)
+ }
+ return new GitHost(gitHostName, user, auth, project, committish, defaultRepresentation, opts)
+ } catch (ex) {
+ if (!(ex instanceof URIError)) throw ex
+ }
+ }).filter(function (gitHostInfo) { return gitHostInfo })
+ if (matches.length !== 1) return
+ return matches[0]
+}
-// Extracts description from contents of a readme file in markdown format
-function extractDescription (d) {
- if (!d) return;
- if (d === "ERROR: No README data found!") return;
- // the first block of text before the first heading
- // that isn't the first line heading
- d = d.trim().split('\n')
- for (var s = 0; d[s] && d[s].trim().match(/^(#|$)/); s ++);
- var l = d.length
- for (var e = s + 1; e < l && d[e].trim(); e ++);
- return d.slice(s, e).join(' ').trim()
+function isGitHubShorthand (arg) {
+ // Note: This does not fully test the git ref format.
+ // See https://www.kernel.org/pub/software/scm/git/docs/git-check-ref-format.html
+ //
+ // The only way to do this properly would be to shell out to
+ // git-check-ref-format, and as this is a fast sync function,
+ // we don't want to do that. Just let git fail if it turns
+ // out that the commit-ish is invalid.
+ // GH usernames cannot start with . or -
+ return /^[^:@%/\s.-][^:@%/\s]*[/][^:@\s/%]+(?:#.*)?$/.test(arg)
}
+function fixupUnqualifiedGist (giturl) {
+ // necessary for round-tripping gists
+ var parsed = url.parse(giturl)
+ if (parsed.protocol === 'gist:' && parsed.host && !parsed.path) {
+ return parsed.protocol + '/' + parsed.host
+ } else {
+ return giturl
+ }
+}
-/***/ }),
-/* 542 */
-/***/ (function(module) {
+function parseGitUrl (giturl) {
+ if (typeof giturl !== 'string') giturl = '' + giturl
+ var matched = giturl.match(/^([^@]+)@([^:/]+):[/]?((?:[^/]+[/])?[^/]+?)(?:[.]git)?(#.*)?$/)
+ if (!matched) return url.parse(giturl)
+ return {
+ protocol: 'git+ssh:',
+ slashes: true,
+ auth: matched[1],
+ host: matched[2],
+ port: null,
+ hostname: matched[2],
+ hash: matched[4],
+ search: null,
+ query: null,
+ pathname: '/' + matched[3],
+ path: '/' + matched[3],
+ href: 'git+ssh://' + matched[1] + '@' + matched[2] +
+ '/' + matched[3] + (matched[4] || '')
+ }
+}
-module.exports = JSON.parse("{\"topLevel\":{\"dependancies\":\"dependencies\",\"dependecies\":\"dependencies\",\"depdenencies\":\"dependencies\",\"devEependencies\":\"devDependencies\",\"depends\":\"dependencies\",\"dev-dependencies\":\"devDependencies\",\"devDependences\":\"devDependencies\",\"devDepenencies\":\"devDependencies\",\"devdependencies\":\"devDependencies\",\"repostitory\":\"repository\",\"repo\":\"repository\",\"prefereGlobal\":\"preferGlobal\",\"hompage\":\"homepage\",\"hampage\":\"homepage\",\"autohr\":\"author\",\"autor\":\"author\",\"contributers\":\"contributors\",\"publicationConfig\":\"publishConfig\",\"script\":\"scripts\"},\"bugs\":{\"web\":\"url\",\"name\":\"url\"},\"script\":{\"server\":\"start\",\"tests\":\"test\"}}");
/***/ }),
-/* 543 */
+/* 530 */
/***/ (function(module, exports, __webpack_require__) {
-var util = __webpack_require__(29)
-var messages = __webpack_require__(544)
+"use strict";
-module.exports = function() {
- var args = Array.prototype.slice.call(arguments, 0)
- var warningName = args.shift()
- if (warningName == "typo") {
- return makeTypoWarning.apply(null,args)
- }
- else {
- var msgTemplate = messages[warningName] ? messages[warningName] : warningName + ": '%s'"
- args.unshift(msgTemplate)
- return util.format.apply(null, args)
- }
-}
-function makeTypoWarning (providedName, probableName, field) {
- if (field) {
- providedName = field + "['" + providedName + "']"
- probableName = field + "['" + probableName + "']"
+var gitHosts = module.exports = {
+ github: {
+ // First two are insecure and generally shouldn't be used any more, but
+ // they are still supported.
+ 'protocols': [ 'git', 'http', 'git+ssh', 'git+https', 'ssh', 'https' ],
+ 'domain': 'github.com',
+ 'treepath': 'tree',
+ 'filetemplate': 'https://{auth@}raw.githubusercontent.com/{user}/{project}/{committish}/{path}',
+ 'bugstemplate': 'https://{domain}/{user}/{project}/issues',
+ 'gittemplate': 'git://{auth@}{domain}/{user}/{project}.git{#committish}',
+ 'tarballtemplate': 'https://{domain}/{user}/{project}/archive/{committish}.tar.gz'
+ },
+ bitbucket: {
+ 'protocols': [ 'git+ssh', 'git+https', 'ssh', 'https' ],
+ 'domain': 'bitbucket.org',
+ 'treepath': 'src',
+ 'tarballtemplate': 'https://{domain}/{user}/{project}/get/{committish}.tar.gz'
+ },
+ gitlab: {
+ 'protocols': [ 'git+ssh', 'git+https', 'ssh', 'https' ],
+ 'domain': 'gitlab.com',
+ 'treepath': 'tree',
+ 'docstemplate': 'https://{domain}/{user}/{project}{/tree/committish}#README',
+ 'bugstemplate': 'https://{domain}/{user}/{project}/issues',
+ 'tarballtemplate': 'https://{domain}/{user}/{project}/repository/archive.tar.gz?ref={committish}'
+ },
+ gist: {
+ 'protocols': [ 'git', 'git+ssh', 'git+https', 'ssh', 'https' ],
+ 'domain': 'gist.github.com',
+ 'pathmatch': /^[/](?:([^/]+)[/])?([a-z0-9]+)(?:[.]git)?$/,
+ 'filetemplate': 'https://gist.githubusercontent.com/{user}/{project}/raw{/committish}/{path}',
+ 'bugstemplate': 'https://{domain}/{project}',
+ 'gittemplate': 'git://{domain}/{project}.git{#committish}',
+ 'sshtemplate': 'git@{domain}:/{project}.git{#committish}',
+ 'sshurltemplate': 'git+ssh://git@{domain}/{project}.git{#committish}',
+ 'browsetemplate': 'https://{domain}/{project}{/committish}',
+ 'docstemplate': 'https://{domain}/{project}{/committish}',
+ 'httpstemplate': 'git+https://{domain}/{project}.git{#committish}',
+ 'shortcuttemplate': '{type}:{project}{#committish}',
+ 'pathtemplate': '{project}{#committish}',
+ 'tarballtemplate': 'https://{domain}/{user}/{project}/archive/{committish}.tar.gz'
}
- return util.format(messages.typo, providedName, probableName)
}
+var gitHostDefaults = {
+ 'sshtemplate': 'git@{domain}:{user}/{project}.git{#committish}',
+ 'sshurltemplate': 'git+ssh://git@{domain}/{user}/{project}.git{#committish}',
+ 'browsetemplate': 'https://{domain}/{user}/{project}{/tree/committish}',
+ 'docstemplate': 'https://{domain}/{user}/{project}{/tree/committish}#readme',
+ 'httpstemplate': 'git+https://{auth@}{domain}/{user}/{project}.git{#committish}',
+ 'filetemplate': 'https://{domain}/{user}/{project}/raw/{committish}/{path}',
+ 'shortcuttemplate': '{type}:{user}/{project}{#committish}',
+ 'pathtemplate': '{user}/{project}{#committish}',
+ 'pathmatch': /^[/]([^/]+)[/]([^/]+?)(?:[.]git|[/])?$/
+}
-/***/ }),
-/* 544 */
-/***/ (function(module) {
+Object.keys(gitHosts).forEach(function (name) {
+ Object.keys(gitHostDefaults).forEach(function (key) {
+ if (gitHosts[name][key]) return
+ gitHosts[name][key] = gitHostDefaults[key]
+ })
+ gitHosts[name].protocols_re = RegExp('^(' +
+ gitHosts[name].protocols.map(function (protocol) {
+ return protocol.replace(/([\\+*{}()[\]$^|])/g, '\\$1')
+ }).join('|') + '):$')
+})
-module.exports = JSON.parse("{\"repositories\":\"'repositories' (plural) Not supported. Please pick one as the 'repository' field\",\"missingRepository\":\"No repository field.\",\"brokenGitUrl\":\"Probably broken git url: %s\",\"nonObjectScripts\":\"scripts must be an object\",\"nonStringScript\":\"script values must be string commands\",\"nonArrayFiles\":\"Invalid 'files' member\",\"invalidFilename\":\"Invalid filename in 'files' list: %s\",\"nonArrayBundleDependencies\":\"Invalid 'bundleDependencies' list. Must be array of package names\",\"nonStringBundleDependency\":\"Invalid bundleDependencies member: %s\",\"nonDependencyBundleDependency\":\"Non-dependency in bundleDependencies: %s\",\"nonObjectDependencies\":\"%s field must be an object\",\"nonStringDependency\":\"Invalid dependency: %s %s\",\"deprecatedArrayDependencies\":\"specifying %s as array is deprecated\",\"deprecatedModules\":\"modules field is deprecated\",\"nonArrayKeywords\":\"keywords should be an array of strings\",\"nonStringKeyword\":\"keywords should be an array of strings\",\"conflictingName\":\"%s is also the name of a node core module.\",\"nonStringDescription\":\"'description' field should be a string\",\"missingDescription\":\"No description\",\"missingReadme\":\"No README data\",\"missingLicense\":\"No license field.\",\"nonEmailUrlBugsString\":\"Bug string field must be url, email, or {email,url}\",\"nonUrlBugsUrlField\":\"bugs.url field must be a string url. Deleted.\",\"nonEmailBugsEmailField\":\"bugs.email field must be a string email. Deleted.\",\"emptyNormalizedBugs\":\"Normalized value of bugs field is an empty object. Deleted.\",\"nonUrlHomepage\":\"homepage field must be a string url. Deleted.\",\"invalidLicense\":\"license should be a valid SPDX license expression\",\"typo\":\"%s should probably be %s.\"}");
/***/ }),
-/* 545 */
+/* 531 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const path = __webpack_require__(16);
-const writeJsonFile = __webpack_require__(546);
-const sortKeys = __webpack_require__(558);
-
-const dependencyKeys = new Set([
- 'dependencies',
- 'devDependencies',
- 'optionalDependencies',
- 'peerDependencies'
-]);
-
-function normalize(packageJson) {
- const result = {};
-
- for (const key of Object.keys(packageJson)) {
- if (!dependencyKeys.has(key)) {
- result[key] = packageJson[key];
- } else if (Object.keys(packageJson[key]).length !== 0) {
- result[key] = sortKeys(packageJson[key]);
- }
- }
+var gitHosts = __webpack_require__(530)
+var extend = Object.assign || __webpack_require__(397)._extend
- return result;
+var GitHost = module.exports = function (type, user, auth, project, committish, defaultRepresentation, opts) {
+ var gitHostInfo = this
+ gitHostInfo.type = type
+ Object.keys(gitHosts[type]).forEach(function (key) {
+ gitHostInfo[key] = gitHosts[type][key]
+ })
+ gitHostInfo.user = user
+ gitHostInfo.auth = auth
+ gitHostInfo.project = project
+ gitHostInfo.committish = committish
+ gitHostInfo.default = defaultRepresentation
+ gitHostInfo.opts = opts || {}
}
+GitHost.prototype = {}
-module.exports = async (filePath, data, options) => {
- if (typeof filePath !== 'string') {
- options = data;
- data = filePath;
- filePath = '.';
- }
+GitHost.prototype.hash = function () {
+ return this.committish ? '#' + this.committish : ''
+}
- options = {
- normalize: true,
- ...options,
- detectIndent: true
- };
+GitHost.prototype._fill = function (template, opts) {
+ if (!template) return
+ var vars = extend({}, opts)
+ opts = extend(extend({}, this.opts), opts)
+ var self = this
+ Object.keys(this).forEach(function (key) {
+ if (self[key] != null && vars[key] == null) vars[key] = self[key]
+ })
+ var rawAuth = vars.auth
+ var rawComittish = vars.committish
+ Object.keys(vars).forEach(function (key) {
+ vars[key] = encodeURIComponent(vars[key])
+ })
+ vars['auth@'] = rawAuth ? rawAuth + '@' : ''
+ if (opts.noCommittish) {
+ vars['#committish'] = ''
+ vars['/tree/committish'] = ''
+ vars['/comittish'] = ''
+ vars.comittish = ''
+ } else {
+ vars['#committish'] = rawComittish ? '#' + rawComittish : ''
+ vars['/tree/committish'] = vars.committish
+ ? '/' + vars.treepath + '/' + vars.committish
+ : ''
+ vars['/committish'] = vars.committish ? '/' + vars.committish : ''
+ vars.committish = vars.committish || 'master'
+ }
+ var res = template
+ Object.keys(vars).forEach(function (key) {
+ res = res.replace(new RegExp('[{]' + key + '[}]', 'g'), vars[key])
+ })
+ if (opts.noGitPlus) {
+ return res.replace(/^git[+]/, '')
+ } else {
+ return res
+ }
+}
- filePath = path.basename(filePath) === 'package.json' ? filePath : path.join(filePath, 'package.json');
+GitHost.prototype.ssh = function (opts) {
+ return this._fill(this.sshtemplate, opts)
+}
- data = options.normalize ? normalize(data) : data;
+GitHost.prototype.sshurl = function (opts) {
+ return this._fill(this.sshurltemplate, opts)
+}
- return writeJsonFile(filePath, data, options);
-};
+GitHost.prototype.browse = function (opts) {
+ return this._fill(this.browsetemplate, opts)
+}
-module.exports.sync = (filePath, data, options) => {
- if (typeof filePath !== 'string') {
- options = data;
- data = filePath;
- filePath = '.';
- }
+GitHost.prototype.docs = function (opts) {
+ return this._fill(this.docstemplate, opts)
+}
- options = {
- normalize: true,
- ...options,
- detectIndent: true
- };
+GitHost.prototype.bugs = function (opts) {
+ return this._fill(this.bugstemplate, opts)
+}
- filePath = path.basename(filePath) === 'package.json' ? filePath : path.join(filePath, 'package.json');
+GitHost.prototype.https = function (opts) {
+ return this._fill(this.httpstemplate, opts)
+}
- data = options.normalize ? normalize(data) : data;
+GitHost.prototype.git = function (opts) {
+ return this._fill(this.gittemplate, opts)
+}
- writeJsonFile.sync(filePath, data, options);
-};
+GitHost.prototype.shortcut = function (opts) {
+ return this._fill(this.shortcuttemplate, opts)
+}
+GitHost.prototype.path = function (opts) {
+ return this._fill(this.pathtemplate, opts)
+}
-/***/ }),
-/* 546 */
-/***/ (function(module, exports, __webpack_require__) {
+GitHost.prototype.tarball = function (opts) {
+ return this._fill(this.tarballtemplate, opts)
+}
-"use strict";
+GitHost.prototype.file = function (P, opts) {
+ return this._fill(this.filetemplate, extend({
+ path: P.replace(/^[/]+/g, '')
+ }, opts))
+}
-const path = __webpack_require__(16);
-const fs = __webpack_require__(547);
-const writeFileAtomic = __webpack_require__(551);
-const sortKeys = __webpack_require__(558);
-const makeDir = __webpack_require__(560);
-const pify = __webpack_require__(561);
-const detectIndent = __webpack_require__(562);
+GitHost.prototype.getDefaultRepresentation = function () {
+ return this.default
+}
-const init = (fn, filePath, data, options) => {
- if (!filePath) {
- throw new TypeError('Expected a filepath');
- }
+GitHost.prototype.toString = function (opts) {
+ return (this[this.default] || this.sshurl).call(this, opts)
+}
- if (data === undefined) {
- throw new TypeError('Expected data to stringify');
- }
- options = Object.assign({
- indent: '\t',
- sortKeys: false
- }, options);
+/***/ }),
+/* 532 */
+/***/ (function(module, exports, __webpack_require__) {
- if (options.sortKeys) {
- data = sortKeys(data, {
- deep: true,
- compare: typeof options.sortKeys === 'function' ? options.sortKeys : undefined
- });
- }
+var core = __webpack_require__(533);
+var async = __webpack_require__(535);
+async.core = core;
+async.isCore = function isCore(x) { return core[x]; };
+async.sync = __webpack_require__(540);
- return fn(filePath, data, options);
-};
+exports = async;
+module.exports = async;
-const readFile = filePath => pify(fs.readFile)(filePath, 'utf8').catch(() => {});
-const main = (filePath, data, options) => {
- return (options.detectIndent ? readFile(filePath) : Promise.resolve())
- .then(string => {
- const indent = string ? detectIndent(string).indent : options.indent;
- const json = JSON.stringify(data, options.replacer, indent);
+/***/ }),
+/* 533 */
+/***/ (function(module, exports, __webpack_require__) {
- return pify(writeFileAtomic)(filePath, `${json}\n`, {mode: options.mode});
- });
-};
+var current = (process.versions && process.versions.node && process.versions.node.split('.')) || [];
-const mainSync = (filePath, data, options) => {
- let {indent} = options;
+function specifierIncluded(specifier) {
+ var parts = specifier.split(' ');
+ var op = parts.length > 1 ? parts[0] : '=';
+ var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split('.');
- if (options.detectIndent) {
- try {
- const file = fs.readFileSync(filePath, 'utf8');
- indent = detectIndent(file).indent;
- } catch (error) {
- if (error.code !== 'ENOENT') {
- throw error;
- }
- }
- }
+ for (var i = 0; i < 3; ++i) {
+ var cur = Number(current[i] || 0);
+ var ver = Number(versionParts[i] || 0);
+ if (cur === ver) {
+ continue; // eslint-disable-line no-restricted-syntax, no-continue
+ }
+ if (op === '<') {
+ return cur < ver;
+ } else if (op === '>=') {
+ return cur >= ver;
+ } else {
+ return false;
+ }
+ }
+ return op === '>=';
+}
- const json = JSON.stringify(data, options.replacer, indent);
+function matchesRange(range) {
+ var specifiers = range.split(/ ?&& ?/);
+ if (specifiers.length === 0) { return false; }
+ for (var i = 0; i < specifiers.length; ++i) {
+ if (!specifierIncluded(specifiers[i])) { return false; }
+ }
+ return true;
+}
- return writeFileAtomic.sync(filePath, `${json}\n`, {mode: options.mode});
-};
+function versionIncluded(specifierValue) {
+ if (typeof specifierValue === 'boolean') { return specifierValue; }
+ if (specifierValue && typeof specifierValue === 'object') {
+ for (var i = 0; i < specifierValue.length; ++i) {
+ if (matchesRange(specifierValue[i])) { return true; }
+ }
+ return false;
+ }
+ return matchesRange(specifierValue);
+}
-const writeJsonFile = (filePath, data, options) => {
- return makeDir(path.dirname(filePath), {fs})
- .then(() => init(main, filePath, data, options));
-};
+var data = __webpack_require__(534);
-module.exports = writeJsonFile;
-// TODO: Remove this for the next major release
-module.exports.default = writeJsonFile;
-module.exports.sync = (filePath, data, options) => {
- makeDir.sync(path.dirname(filePath), {fs});
- init(mainSync, filePath, data, options);
-};
+var core = {};
+for (var mod in data) { // eslint-disable-line no-restricted-syntax
+ if (Object.prototype.hasOwnProperty.call(data, mod)) {
+ core[mod] = versionIncluded(data[mod]);
+ }
+}
+module.exports = core;
/***/ }),
-/* 547 */
-/***/ (function(module, exports, __webpack_require__) {
+/* 534 */
+/***/ (function(module) {
-var fs = __webpack_require__(23)
-var polyfills = __webpack_require__(548)
-var legacy = __webpack_require__(549)
-var clone = __webpack_require__(550)
+module.exports = JSON.parse("{\"assert\":true,\"async_hooks\":\">= 8\",\"buffer_ieee754\":\"< 0.9.7\",\"buffer\":true,\"child_process\":true,\"cluster\":true,\"console\":true,\"constants\":true,\"crypto\":true,\"_debugger\":\"< 8\",\"dgram\":true,\"dns\":true,\"domain\":true,\"events\":true,\"freelist\":\"< 6\",\"fs\":true,\"fs/promises\":\">= 10 && < 10.1\",\"_http_agent\":\">= 0.11.1\",\"_http_client\":\">= 0.11.1\",\"_http_common\":\">= 0.11.1\",\"_http_incoming\":\">= 0.11.1\",\"_http_outgoing\":\">= 0.11.1\",\"_http_server\":\">= 0.11.1\",\"http\":true,\"http2\":\">= 8.8\",\"https\":true,\"inspector\":\">= 8.0.0\",\"_linklist\":\"< 8\",\"module\":true,\"net\":true,\"node-inspect/lib/_inspect\":\">= 7.6.0\",\"node-inspect/lib/internal/inspect_client\":\">= 7.6.0\",\"node-inspect/lib/internal/inspect_repl\":\">= 7.6.0\",\"os\":true,\"path\":true,\"perf_hooks\":\">= 8.5\",\"process\":\">= 1\",\"punycode\":true,\"querystring\":true,\"readline\":true,\"repl\":true,\"smalloc\":\">= 0.11.5 && < 3\",\"_stream_duplex\":\">= 0.9.4\",\"_stream_transform\":\">= 0.9.4\",\"_stream_wrap\":\">= 1.4.1\",\"_stream_passthrough\":\">= 0.9.4\",\"_stream_readable\":\">= 0.9.4\",\"_stream_writable\":\">= 0.9.4\",\"stream\":true,\"string_decoder\":true,\"sys\":true,\"timers\":true,\"_tls_common\":\">= 0.11.13\",\"_tls_legacy\":\">= 0.11.3 && < 10\",\"_tls_wrap\":\">= 0.11.3\",\"tls\":true,\"trace_events\":\">= 10\",\"tty\":true,\"url\":true,\"util\":true,\"v8/tools/arguments\":\">= 10\",\"v8/tools/codemap\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8/tools/consarray\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8/tools/csvparser\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8/tools/logreader\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8/tools/profile_view\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8/tools/splaytree\":[\">= 4.4.0 && < 5\",\">= 5.2.0\"],\"v8\":\">= 1\",\"vm\":true,\"worker_threads\":\">= 11.7\",\"zlib\":true}");
-var queue = []
+/***/ }),
+/* 535 */
+/***/ (function(module, exports, __webpack_require__) {
-var util = __webpack_require__(29)
+var core = __webpack_require__(533);
+var fs = __webpack_require__(349);
+var path = __webpack_require__(4);
+var caller = __webpack_require__(536);
+var nodeModulesPaths = __webpack_require__(537);
+var normalizeOptions = __webpack_require__(539);
-function noop () {}
+var defaultIsFile = function isFile(file, cb) {
+ fs.stat(file, function (err, stat) {
+ if (!err) {
+ return cb(null, stat.isFile() || stat.isFIFO());
+ }
+ if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+ return cb(err);
+ });
+};
-var debug = noop
-if (util.debuglog)
- debug = util.debuglog('gfs4')
-else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
- debug = function() {
- var m = util.format.apply(util, arguments)
- m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
- console.error(m)
- }
+module.exports = function resolve(x, options, callback) {
+ var cb = callback;
+ var opts = options;
+ if (typeof options === 'function') {
+ cb = opts;
+ opts = {};
+ }
+ if (typeof x !== 'string') {
+ var err = new TypeError('Path must be a string.');
+ return process.nextTick(function () {
+ cb(err);
+ });
+ }
-if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
- process.on('exit', function() {
- debug(queue)
- __webpack_require__(30).equal(queue.length, 0)
- })
-}
+ opts = normalizeOptions(x, opts);
-module.exports = patch(clone(fs))
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
- module.exports = patch(fs)
- fs.__patched = true;
-}
+ var isFile = opts.isFile || defaultIsFile;
+ var readFile = opts.readFile || fs.readFile;
-// Always patch fs.close/closeSync, because we want to
-// retry() whenever a close happens *anywhere* in the program.
-// This is essential when multiple graceful-fs instances are
-// in play at the same time.
-module.exports.close = (function (fs$close) { return function (fd, cb) {
- return fs$close.call(fs, fd, function (err) {
- if (!err)
- retry()
+ var extensions = opts.extensions || ['.js'];
+ var basedir = opts.basedir || path.dirname(caller());
+ var parent = opts.filename || basedir;
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- })
-}})(fs.close)
+ opts.paths = opts.paths || [];
-module.exports.closeSync = (function (fs$closeSync) { return function (fd) {
- // Note that graceful-fs also retries when fs.closeSync() fails.
- // Looks like a bug to me, although it's probably a harmless one.
- var rval = fs$closeSync.apply(fs, arguments)
- retry()
- return rval
-}})(fs.closeSync)
+ // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+ var absoluteStart = path.resolve(basedir);
-// Only patch fs once, otherwise we'll run into a memory leak if
-// graceful-fs is loaded multiple times, such as in test environments that
-// reset the loaded modules between tests.
-// We look for the string `graceful-fs` from the comment above. This
-// way we are not adding any extra properties and it will detect if older
-// versions of graceful-fs are installed.
-if (!/\bgraceful-fs\b/.test(fs.closeSync.toString())) {
- fs.closeSync = module.exports.closeSync;
- fs.close = module.exports.close;
-}
+ if (opts.preserveSymlinks === false) {
+ fs.realpath(absoluteStart, function (realPathErr, realStart) {
+ if (realPathErr && realPathErr.code !== 'ENOENT') cb(err);
+ else init(realPathErr ? absoluteStart : realStart);
+ });
+ } else {
+ init(absoluteStart);
+ }
-function patch (fs) {
- // Everything that references the open() function needs to be in here
- polyfills(fs)
- fs.gracefulify = patch
- fs.FileReadStream = ReadStream; // Legacy name.
- fs.FileWriteStream = WriteStream; // Legacy name.
- fs.createReadStream = createReadStream
- fs.createWriteStream = createWriteStream
- var fs$readFile = fs.readFile
- fs.readFile = readFile
- function readFile (path, options, cb) {
- if (typeof options === 'function')
- cb = options, options = null
+ var res;
+ function init(basedir) {
+ if ((/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/).test(x)) {
+ res = path.resolve(basedir, x);
+ if (x === '..' || x.slice(-1) === '/') res += '/';
+ if ((/\/$/).test(x) && res === basedir) {
+ loadAsDirectory(res, opts.package, onfile);
+ } else loadAsFile(res, opts.package, onfile);
+ } else loadNodeModules(x, basedir, function (err, n, pkg) {
+ if (err) cb(err);
+ else if (n) cb(null, n, pkg);
+ else if (core[x]) return cb(null, x);
+ else {
+ var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+ moduleError.code = 'MODULE_NOT_FOUND';
+ cb(moduleError);
+ }
+ });
+ }
- return go$readFile(path, options, cb)
+ function onfile(err, m, pkg) {
+ if (err) cb(err);
+ else if (m) cb(null, m, pkg);
+ else loadAsDirectory(res, function (err, d, pkg) {
+ if (err) cb(err);
+ else if (d) cb(null, d, pkg);
+ else {
+ var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+ moduleError.code = 'MODULE_NOT_FOUND';
+ cb(moduleError);
+ }
+ });
+ }
- function go$readFile (path, options, cb) {
- return fs$readFile(path, options, function (err) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$readFile, [path, options, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
+ function loadAsFile(x, thePackage, callback) {
+ var loadAsFilePackage = thePackage;
+ var cb = callback;
+ if (typeof loadAsFilePackage === 'function') {
+ cb = loadAsFilePackage;
+ loadAsFilePackage = undefined;
}
- })
- }
- }
- var fs$writeFile = fs.writeFile
- fs.writeFile = writeFile
- function writeFile (path, data, options, cb) {
- if (typeof options === 'function')
- cb = options, options = null
+ var exts = [''].concat(extensions);
+ load(exts, x, loadAsFilePackage);
- return go$writeFile(path, data, options, cb)
+ function load(exts, x, loadPackage) {
+ if (exts.length === 0) return cb(null, undefined, loadPackage);
+ var file = x + exts[0];
- function go$writeFile (path, data, options, cb) {
- return fs$writeFile(path, data, options, function (err) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$writeFile, [path, data, options, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
+ var pkg = loadPackage;
+ if (pkg) onpkg(null, pkg);
+ else loadpkg(path.dirname(file), onpkg);
+
+ function onpkg(err, pkg_, dir) {
+ pkg = pkg_;
+ if (err) return cb(err);
+ if (dir && pkg && opts.pathFilter) {
+ var rfile = path.relative(dir, file);
+ var rel = rfile.slice(0, rfile.length - exts[0].length);
+ var r = opts.pathFilter(pkg, x, rel);
+ if (r) return load(
+ [''].concat(extensions.slice()),
+ path.resolve(dir, r),
+ pkg
+ );
+ }
+ isFile(file, onex);
+ }
+ function onex(err, ex) {
+ if (err) return cb(err);
+ if (ex) return cb(null, file, pkg);
+ load(exts.slice(1), x, pkg);
+ }
}
- })
}
- }
- var fs$appendFile = fs.appendFile
- if (fs$appendFile)
- fs.appendFile = appendFile
- function appendFile (path, data, options, cb) {
- if (typeof options === 'function')
- cb = options, options = null
+ function loadpkg(dir, cb) {
+ if (dir === '' || dir === '/') return cb(null);
+ if (process.platform === 'win32' && (/^\w:[/\\]*$/).test(dir)) {
+ return cb(null);
+ }
+ if ((/[/\\]node_modules[/\\]*$/).test(dir)) return cb(null);
- return go$appendFile(path, data, options, cb)
+ var pkgfile = path.join(dir, 'package.json');
+ isFile(pkgfile, function (err, ex) {
+ // on err, ex is false
+ if (!ex) return loadpkg(path.dirname(dir), cb);
- function go$appendFile (path, data, options, cb) {
- return fs$appendFile(path, data, options, function (err) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$appendFile, [path, data, options, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
- }
- })
- }
- }
+ readFile(pkgfile, function (err, body) {
+ if (err) cb(err);
+ try { var pkg = JSON.parse(body); } catch (jsonErr) {}
- var fs$readdir = fs.readdir
- fs.readdir = readdir
- function readdir (path, options, cb) {
- var args = [path]
- if (typeof options !== 'function') {
- args.push(options)
- } else {
- cb = options
+ if (pkg && opts.packageFilter) {
+ pkg = opts.packageFilter(pkg, pkgfile);
+ }
+ cb(null, pkg, dir);
+ });
+ });
}
- args.push(go$readdir$cb)
- return go$readdir(args)
+ function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
+ var cb = callback;
+ var fpkg = loadAsDirectoryPackage;
+ if (typeof fpkg === 'function') {
+ cb = fpkg;
+ fpkg = opts.package;
+ }
- function go$readdir$cb (err, files) {
- if (files && files.sort)
- files.sort()
+ var pkgfile = path.join(x, 'package.json');
+ isFile(pkgfile, function (err, ex) {
+ if (err) return cb(err);
+ if (!ex) return loadAsFile(path.join(x, 'index'), fpkg, cb);
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$readdir, [args]])
+ readFile(pkgfile, function (err, body) {
+ if (err) return cb(err);
+ try {
+ var pkg = JSON.parse(body);
+ } catch (jsonErr) {}
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
- }
- }
- }
+ if (opts.packageFilter) {
+ pkg = opts.packageFilter(pkg, pkgfile);
+ }
- function go$readdir (args) {
- return fs$readdir.apply(fs, args)
- }
+ if (pkg.main) {
+ if (typeof pkg.main !== 'string') {
+ var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+ mainError.code = 'INVALID_PACKAGE_MAIN';
+ return cb(mainError);
+ }
+ if (pkg.main === '.' || pkg.main === './') {
+ pkg.main = 'index';
+ }
+ loadAsFile(path.resolve(x, pkg.main), pkg, function (err, m, pkg) {
+ if (err) return cb(err);
+ if (m) return cb(null, m, pkg);
+ if (!pkg) return loadAsFile(path.join(x, 'index'), pkg, cb);
- if (process.version.substr(0, 4) === 'v0.8') {
- var legStreams = legacy(fs)
- ReadStream = legStreams.ReadStream
- WriteStream = legStreams.WriteStream
- }
+ var dir = path.resolve(x, pkg.main);
+ loadAsDirectory(dir, pkg, function (err, n, pkg) {
+ if (err) return cb(err);
+ if (n) return cb(null, n, pkg);
+ loadAsFile(path.join(x, 'index'), pkg, cb);
+ });
+ });
+ return;
+ }
- var fs$ReadStream = fs.ReadStream
- if (fs$ReadStream) {
- ReadStream.prototype = Object.create(fs$ReadStream.prototype)
- ReadStream.prototype.open = ReadStream$open
- }
+ loadAsFile(path.join(x, '/index'), pkg, cb);
+ });
+ });
+ }
- var fs$WriteStream = fs.WriteStream
- if (fs$WriteStream) {
- WriteStream.prototype = Object.create(fs$WriteStream.prototype)
- WriteStream.prototype.open = WriteStream$open
- }
+ function processDirs(cb, dirs) {
+ if (dirs.length === 0) return cb(null, undefined);
+ var dir = dirs[0];
- fs.ReadStream = ReadStream
- fs.WriteStream = WriteStream
+ var file = path.join(dir, x);
+ loadAsFile(file, opts.package, onfile);
- function ReadStream (path, options) {
- if (this instanceof ReadStream)
- return fs$ReadStream.apply(this, arguments), this
- else
- return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
- }
+ function onfile(err, m, pkg) {
+ if (err) return cb(err);
+ if (m) return cb(null, m, pkg);
+ loadAsDirectory(path.join(dir, x), opts.package, ondir);
+ }
- function ReadStream$open () {
- var that = this
- open(that.path, that.flags, that.mode, function (err, fd) {
- if (err) {
- if (that.autoClose)
- that.destroy()
+ function ondir(err, n, pkg) {
+ if (err) return cb(err);
+ if (n) return cb(null, n, pkg);
+ processDirs(cb, dirs.slice(1));
+ }
+ }
+ function loadNodeModules(x, start, cb) {
+ processDirs(cb, nodeModulesPaths(start, opts, x));
+ }
+};
- that.emit('error', err)
- } else {
- that.fd = fd
- that.emit('open', fd)
- that.read()
- }
- })
- }
- function WriteStream (path, options) {
- if (this instanceof WriteStream)
- return fs$WriteStream.apply(this, arguments), this
- else
- return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
- }
+/***/ }),
+/* 536 */
+/***/ (function(module, exports) {
- function WriteStream$open () {
- var that = this
- open(that.path, that.flags, that.mode, function (err, fd) {
- if (err) {
- that.destroy()
- that.emit('error', err)
- } else {
- that.fd = fd
- that.emit('open', fd)
- }
- })
- }
+module.exports = function () {
+ // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+ var origPrepareStackTrace = Error.prepareStackTrace;
+ Error.prepareStackTrace = function (_, stack) { return stack; };
+ var stack = (new Error()).stack;
+ Error.prepareStackTrace = origPrepareStackTrace;
+ return stack[2].getFileName();
+};
- function createReadStream (path, options) {
- return new ReadStream(path, options)
- }
- function createWriteStream (path, options) {
- return new WriteStream(path, options)
- }
+/***/ }),
+/* 537 */
+/***/ (function(module, exports, __webpack_require__) {
- var fs$open = fs.open
- fs.open = open
- function open (path, flags, mode, cb) {
- if (typeof mode === 'function')
- cb = mode, mode = null
+var path = __webpack_require__(4);
+var parse = path.parse || __webpack_require__(538);
- return go$open(path, flags, mode, cb)
+var getNodeModulesDirs = function getNodeModulesDirs(absoluteStart, modules) {
+ var prefix = '/';
+ if ((/^([A-Za-z]:)/).test(absoluteStart)) {
+ prefix = '';
+ } else if ((/^\\\\/).test(absoluteStart)) {
+ prefix = '\\\\';
+ }
- function go$open (path, flags, mode, cb) {
- return fs$open(path, flags, mode, function (err, fd) {
- if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
- enqueue([go$open, [path, flags, mode, cb]])
- else {
- if (typeof cb === 'function')
- cb.apply(this, arguments)
- retry()
- }
- })
+ var paths = [absoluteStart];
+ var parsed = parse(absoluteStart);
+ while (parsed.dir !== paths[paths.length - 1]) {
+ paths.push(parsed.dir);
+ parsed = parse(parsed.dir);
}
- }
- return fs
-}
+ return paths.reduce(function (dirs, aPath) {
+ return dirs.concat(modules.map(function (moduleDir) {
+ return path.join(prefix, aPath, moduleDir);
+ }));
+ }, []);
+};
-function enqueue (elem) {
- debug('ENQUEUE', elem[0].name, elem[1])
- queue.push(elem)
-}
+module.exports = function nodeModulesPaths(start, opts, request) {
+ var modules = opts && opts.moduleDirectory
+ ? [].concat(opts.moduleDirectory)
+ : ['node_modules'];
-function retry () {
- var elem = queue.shift()
- if (elem) {
- debug('RETRY', elem[0].name, elem[1])
- elem[0].apply(null, elem[1])
- }
-}
+ if (opts && typeof opts.paths === 'function') {
+ return opts.paths(
+ request,
+ start,
+ function () { return getNodeModulesDirs(start, modules); },
+ opts
+ );
+ }
+
+ var dirs = getNodeModulesDirs(start, modules);
+ return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+};
/***/ }),
-/* 548 */
+/* 538 */
/***/ (function(module, exports, __webpack_require__) {
-var constants = __webpack_require__(25)
+"use strict";
-var origCwd = process.cwd
-var cwd = null
-var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
+var isWindows = process.platform === 'win32';
-process.cwd = function() {
- if (!cwd)
- cwd = origCwd.call(process)
- return cwd
-}
-try {
- process.cwd()
-} catch (er) {}
+// Regex to split a windows path into three parts: [*, device, slash,
+// tail] windows-only
+var splitDeviceRe =
+ /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
-var chdir = process.chdir
-process.chdir = function(d) {
- cwd = null
- chdir.call(process, d)
-}
+// Regex to split the tail part of the above into [*, dir, basename, ext]
+var splitTailRe =
+ /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
-module.exports = patch
+var win32 = {};
-function patch (fs) {
- // (re-)implement some things that are known busted or missing.
+// Function to split a filename into [root, dir, basename, ext]
+function win32SplitPath(filename) {
+ // Separate device+slash from tail
+ var result = splitDeviceRe.exec(filename),
+ device = (result[1] || '') + (result[2] || ''),
+ tail = result[3] || '';
+ // Split the tail into dir, basename and extension
+ var result2 = splitTailRe.exec(tail),
+ dir = result2[1],
+ basename = result2[2],
+ ext = result2[3];
+ return [device, dir, basename, ext];
+}
- // lchmod, broken prior to 0.6.2
- // back-port the fix here.
- if (constants.hasOwnProperty('O_SYMLINK') &&
- process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
- patchLchmod(fs)
+win32.parse = function(pathString) {
+ if (typeof pathString !== 'string') {
+ throw new TypeError(
+ "Parameter 'pathString' must be a string, not " + typeof pathString
+ );
}
-
- // lutimes implementation, or no-op
- if (!fs.lutimes) {
- patchLutimes(fs)
+ var allParts = win32SplitPath(pathString);
+ if (!allParts || allParts.length !== 4) {
+ throw new TypeError("Invalid path '" + pathString + "'");
}
+ return {
+ root: allParts[0],
+ dir: allParts[0] + allParts[1].slice(0, -1),
+ base: allParts[2],
+ ext: allParts[3],
+ name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
+ };
+};
- // https://github.com/isaacs/node-graceful-fs/issues/4
- // Chown should not fail on einval or eperm if non-root.
- // It should not fail on enosys ever, as this just indicates
- // that a fs doesn't support the intended operation.
-
- fs.chown = chownFix(fs.chown)
- fs.fchown = chownFix(fs.fchown)
- fs.lchown = chownFix(fs.lchown)
- fs.chmod = chmodFix(fs.chmod)
- fs.fchmod = chmodFix(fs.fchmod)
- fs.lchmod = chmodFix(fs.lchmod)
- fs.chownSync = chownFixSync(fs.chownSync)
- fs.fchownSync = chownFixSync(fs.fchownSync)
- fs.lchownSync = chownFixSync(fs.lchownSync)
+// Split a filename into [root, dir, basename, ext], unix version
+// 'root' is just a slash, or nothing.
+var splitPathRe =
+ /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+var posix = {};
- fs.chmodSync = chmodFixSync(fs.chmodSync)
- fs.fchmodSync = chmodFixSync(fs.fchmodSync)
- fs.lchmodSync = chmodFixSync(fs.lchmodSync)
- fs.stat = statFix(fs.stat)
- fs.fstat = statFix(fs.fstat)
- fs.lstat = statFix(fs.lstat)
+function posixSplitPath(filename) {
+ return splitPathRe.exec(filename).slice(1);
+}
- fs.statSync = statFixSync(fs.statSync)
- fs.fstatSync = statFixSync(fs.fstatSync)
- fs.lstatSync = statFixSync(fs.lstatSync)
- // if lchmod/lchown do not exist, then make them no-ops
- if (!fs.lchmod) {
- fs.lchmod = function (path, mode, cb) {
- if (cb) process.nextTick(cb)
- }
- fs.lchmodSync = function () {}
+posix.parse = function(pathString) {
+ if (typeof pathString !== 'string') {
+ throw new TypeError(
+ "Parameter 'pathString' must be a string, not " + typeof pathString
+ );
}
- if (!fs.lchown) {
- fs.lchown = function (path, uid, gid, cb) {
- if (cb) process.nextTick(cb)
- }
- fs.lchownSync = function () {}
+ var allParts = posixSplitPath(pathString);
+ if (!allParts || allParts.length !== 4) {
+ throw new TypeError("Invalid path '" + pathString + "'");
}
+ allParts[1] = allParts[1] || '';
+ allParts[2] = allParts[2] || '';
+ allParts[3] = allParts[3] || '';
- // on Windows, A/V software can lock the directory, causing this
- // to fail with an EACCES or EPERM if the directory contains newly
- // created files. Try again on failure, for up to 60 seconds.
+ return {
+ root: allParts[0],
+ dir: allParts[0] + allParts[1].slice(0, -1),
+ base: allParts[2],
+ ext: allParts[3],
+ name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
+ };
+};
- // Set the timeout this long because some Windows Anti-Virus, such as Parity
- // bit9, may lock files for up to a minute, causing npm package install
- // failures. Also, take care to yield the scheduler. Windows scheduling gives
- // CPU to a busy looping process, which can cause the program causing the lock
- // contention to be starved of CPU by node, so the contention doesn't resolve.
- if (platform === "win32") {
- fs.rename = (function (fs$rename) { return function (from, to, cb) {
- var start = Date.now()
- var backoff = 0;
- fs$rename(from, to, function CB (er) {
- if (er
- && (er.code === "EACCES" || er.code === "EPERM")
- && Date.now() - start < 60000) {
- setTimeout(function() {
- fs.stat(to, function (stater, st) {
- if (stater && stater.code === "ENOENT")
- fs$rename(from, to, CB);
- else
- cb(er)
- })
- }, backoff)
- if (backoff < 100)
- backoff += 10;
- return;
- }
- if (cb) cb(er)
- })
- }})(fs.rename)
- }
- // if read() returns EAGAIN, then just try it again.
- fs.read = (function (fs$read) { return function (fd, buffer, offset, length, position, callback_) {
- var callback
- if (callback_ && typeof callback_ === 'function') {
- var eagCounter = 0
- callback = function (er, _, __) {
- if (er && er.code === 'EAGAIN' && eagCounter < 10) {
- eagCounter ++
- return fs$read.call(fs, fd, buffer, offset, length, position, callback)
- }
- callback_.apply(this, arguments)
- }
- }
- return fs$read.call(fs, fd, buffer, offset, length, position, callback)
- }})(fs.read)
+if (isWindows)
+ module.exports = win32.parse;
+else /* posix */
+ module.exports = posix.parse;
- fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
- var eagCounter = 0
- while (true) {
- try {
- return fs$readSync.call(fs, fd, buffer, offset, length, position)
- } catch (er) {
- if (er.code === 'EAGAIN' && eagCounter < 10) {
- eagCounter ++
- continue
- }
- throw er
- }
- }
- }})(fs.readSync)
+module.exports.posix = posix.parse;
+module.exports.win32 = win32.parse;
- function patchLchmod (fs) {
- fs.lchmod = function (path, mode, callback) {
- fs.open( path
- , constants.O_WRONLY | constants.O_SYMLINK
- , mode
- , function (err, fd) {
- if (err) {
- if (callback) callback(err)
- return
- }
- // prefer to return the chmod error, if one occurs,
- // but still try to close, and report closing errors if they occur.
- fs.fchmod(fd, mode, function (err) {
- fs.close(fd, function(err2) {
- if (callback) callback(err || err2)
- })
- })
- })
- }
- fs.lchmodSync = function (path, mode) {
- var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
+/***/ }),
+/* 539 */
+/***/ (function(module, exports) {
- // prefer to return the chmod error, if one occurs,
- // but still try to close, and report closing errors if they occur.
- var threw = true
- var ret
- try {
- ret = fs.fchmodSync(fd, mode)
- threw = false
- } finally {
- if (threw) {
- try {
- fs.closeSync(fd)
- } catch (er) {}
- } else {
- fs.closeSync(fd)
- }
- }
- return ret
- }
- }
+module.exports = function (x, opts) {
+ /**
+ * This file is purposefully a passthrough. It's expected that third-party
+ * environments will override it at runtime in order to inject special logic
+ * into `resolve` (by manipulating the options). One such example is the PnP
+ * code path in Yarn.
+ */
- function patchLutimes (fs) {
- if (constants.hasOwnProperty("O_SYMLINK")) {
- fs.lutimes = function (path, at, mt, cb) {
- fs.open(path, constants.O_SYMLINK, function (er, fd) {
- if (er) {
- if (cb) cb(er)
- return
- }
- fs.futimes(fd, at, mt, function (er) {
- fs.close(fd, function (er2) {
- if (cb) cb(er || er2)
- })
- })
- })
- }
+ return opts || {};
+};
- fs.lutimesSync = function (path, at, mt) {
- var fd = fs.openSync(path, constants.O_SYMLINK)
- var ret
- var threw = true
- try {
- ret = fs.futimesSync(fd, at, mt)
- threw = false
- } finally {
- if (threw) {
- try {
- fs.closeSync(fd)
- } catch (er) {}
- } else {
- fs.closeSync(fd)
- }
- }
- return ret
- }
- } else {
- fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
- fs.lutimesSync = function () {}
- }
- }
+/***/ }),
+/* 540 */
+/***/ (function(module, exports, __webpack_require__) {
- function chmodFix (orig) {
- if (!orig) return orig
- return function (target, mode, cb) {
- return orig.call(fs, target, mode, function (er) {
- if (chownErOk(er)) er = null
- if (cb) cb.apply(this, arguments)
- })
+var core = __webpack_require__(533);
+var fs = __webpack_require__(349);
+var path = __webpack_require__(4);
+var caller = __webpack_require__(536);
+var nodeModulesPaths = __webpack_require__(537);
+var normalizeOptions = __webpack_require__(539);
+
+var defaultIsFile = function isFile(file) {
+ try {
+ var stat = fs.statSync(file);
+ } catch (e) {
+ if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+ throw e;
}
- }
+ return stat.isFile() || stat.isFIFO();
+};
- function chmodFixSync (orig) {
- if (!orig) return orig
- return function (target, mode) {
- try {
- return orig.call(fs, target, mode)
- } catch (er) {
- if (!chownErOk(er)) throw er
- }
+module.exports = function (x, options) {
+ if (typeof x !== 'string') {
+ throw new TypeError('Path must be a string.');
}
- }
+ var opts = normalizeOptions(x, options);
+ var isFile = opts.isFile || defaultIsFile;
+ var readFileSync = opts.readFileSync || fs.readFileSync;
- function chownFix (orig) {
- if (!orig) return orig
- return function (target, uid, gid, cb) {
- return orig.call(fs, target, uid, gid, function (er) {
- if (chownErOk(er)) er = null
- if (cb) cb.apply(this, arguments)
- })
+ var extensions = opts.extensions || ['.js'];
+ var basedir = opts.basedir || path.dirname(caller());
+ var parent = opts.filename || basedir;
+
+ opts.paths = opts.paths || [];
+
+ // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+ var absoluteStart = path.resolve(basedir);
+
+ if (opts.preserveSymlinks === false) {
+ try {
+ absoluteStart = fs.realpathSync(absoluteStart);
+ } catch (realPathErr) {
+ if (realPathErr.code !== 'ENOENT') {
+ throw realPathErr;
+ }
+ }
}
- }
- function chownFixSync (orig) {
- if (!orig) return orig
- return function (target, uid, gid) {
- try {
- return orig.call(fs, target, uid, gid)
- } catch (er) {
- if (!chownErOk(er)) throw er
- }
+ if ((/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/).test(x)) {
+ var res = path.resolve(absoluteStart, x);
+ if (x === '..' || x.slice(-1) === '/') res += '/';
+ var m = loadAsFileSync(res) || loadAsDirectorySync(res);
+ if (m) return m;
+ } else {
+ var n = loadNodeModulesSync(x, absoluteStart);
+ if (n) return n;
}
- }
+ if (core[x]) return x;
- function statFix (orig) {
- if (!orig) return orig
- // Older versions of Node erroneously returned signed integers for
- // uid + gid.
- return function (target, cb) {
- return orig.call(fs, target, function (er, stats) {
- if (!stats) return cb.apply(this, arguments)
- if (stats.uid < 0) stats.uid += 0x100000000
- if (stats.gid < 0) stats.gid += 0x100000000
- if (cb) cb.apply(this, arguments)
- })
- }
- }
+ var err = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+ err.code = 'MODULE_NOT_FOUND';
+ throw err;
- function statFixSync (orig) {
- if (!orig) return orig
- // Older versions of Node erroneously returned signed integers for
- // uid + gid.
- return function (target) {
- var stats = orig.call(fs, target)
- if (stats.uid < 0) stats.uid += 0x100000000
- if (stats.gid < 0) stats.gid += 0x100000000
- return stats;
+ function loadAsFileSync(x) {
+ var pkg = loadpkg(path.dirname(x));
+
+ if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
+ var rfile = path.relative(pkg.dir, x);
+ var r = opts.pathFilter(pkg.pkg, x, rfile);
+ if (r) {
+ x = path.resolve(pkg.dir, r); // eslint-disable-line no-param-reassign
+ }
+ }
+
+ if (isFile(x)) {
+ return x;
+ }
+
+ for (var i = 0; i < extensions.length; i++) {
+ var file = x + extensions[i];
+ if (isFile(file)) {
+ return file;
+ }
+ }
}
- }
- // ENOSYS means that the fs doesn't support the op. Just ignore
- // that, because it doesn't matter.
- //
- // if there's no getuid, or if getuid() is something other
- // than 0, and the error is EINVAL or EPERM, then just ignore
- // it.
- //
- // This specific case is a silent failure in cp, install, tar,
- // and most other unix tools that manage permissions.
- //
- // When running as root, or if other types of errors are
- // encountered, then it's strict.
- function chownErOk (er) {
- if (!er)
- return true
+ function loadpkg(dir) {
+ if (dir === '' || dir === '/') return;
+ if (process.platform === 'win32' && (/^\w:[/\\]*$/).test(dir)) {
+ return;
+ }
+ if ((/[/\\]node_modules[/\\]*$/).test(dir)) return;
- if (er.code === "ENOSYS")
- return true
+ var pkgfile = path.join(dir, 'package.json');
- var nonroot = !process.getuid || process.getuid() !== 0
- if (nonroot) {
- if (er.code === "EINVAL" || er.code === "EPERM")
- return true
- }
+ if (!isFile(pkgfile)) {
+ return loadpkg(path.dirname(dir));
+ }
- return false
- }
-}
+ var body = readFileSync(pkgfile);
+ try {
+ var pkg = JSON.parse(body);
+ } catch (jsonErr) {}
-/***/ }),
-/* 549 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (pkg && opts.packageFilter) {
+ pkg = opts.packageFilter(pkg, dir);
+ }
-var Stream = __webpack_require__(27).Stream
+ return { pkg: pkg, dir: dir };
+ }
-module.exports = legacy
+ function loadAsDirectorySync(x) {
+ var pkgfile = path.join(x, '/package.json');
+ if (isFile(pkgfile)) {
+ try {
+ var body = readFileSync(pkgfile, 'UTF8');
+ var pkg = JSON.parse(body);
+ } catch (e) {}
-function legacy (fs) {
- return {
- ReadStream: ReadStream,
- WriteStream: WriteStream
- }
+ if (opts.packageFilter) {
+ pkg = opts.packageFilter(pkg, x);
+ }
- function ReadStream (path, options) {
- if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+ if (pkg.main) {
+ if (typeof pkg.main !== 'string') {
+ var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+ mainError.code = 'INVALID_PACKAGE_MAIN';
+ throw mainError;
+ }
+ if (pkg.main === '.' || pkg.main === './') {
+ pkg.main = 'index';
+ }
+ try {
+ var m = loadAsFileSync(path.resolve(x, pkg.main));
+ if (m) return m;
+ var n = loadAsDirectorySync(path.resolve(x, pkg.main));
+ if (n) return n;
+ } catch (e) {}
+ }
+ }
- Stream.call(this);
+ return loadAsFileSync(path.join(x, '/index'));
+ }
- var self = this;
+ function loadNodeModulesSync(x, start) {
+ var dirs = nodeModulesPaths(start, opts, x);
+ for (var i = 0; i < dirs.length; i++) {
+ var dir = dirs[i];
+ var m = loadAsFileSync(path.join(dir, '/', x));
+ if (m) return m;
+ var n = loadAsDirectorySync(path.join(dir, '/', x));
+ if (n) return n;
+ }
+ }
+};
- this.path = path;
- this.fd = null;
- this.readable = true;
- this.paused = false;
- this.flags = 'r';
- this.mode = 438; /*=0666*/
- this.bufferSize = 64 * 1024;
+/***/ }),
+/* 541 */
+/***/ (function(module, exports) {
- options = options || {};
+module.exports = extractDescription
- // Mixin options into this
- var keys = Object.keys(options);
- for (var index = 0, length = keys.length; index < length; index++) {
- var key = keys[index];
- this[key] = options[key];
- }
+// Extracts description from contents of a readme file in markdown format
+function extractDescription (d) {
+ if (!d) return;
+ if (d === "ERROR: No README data found!") return;
+ // the first block of text before the first heading
+ // that isn't the first line heading
+ d = d.trim().split('\n')
+ for (var s = 0; d[s] && d[s].trim().match(/^(#|$)/); s ++);
+ var l = d.length
+ for (var e = s + 1; e < l && d[e].trim(); e ++);
+ return d.slice(s, e).join(' ').trim()
+}
- if (this.encoding) this.setEncoding(this.encoding);
- if (this.start !== undefined) {
- if ('number' !== typeof this.start) {
- throw TypeError('start must be a Number');
- }
- if (this.end === undefined) {
- this.end = Infinity;
- } else if ('number' !== typeof this.end) {
- throw TypeError('end must be a Number');
- }
+/***/ }),
+/* 542 */
+/***/ (function(module) {
- if (this.start > this.end) {
- throw new Error('start must be <= end');
- }
+module.exports = JSON.parse("{\"topLevel\":{\"dependancies\":\"dependencies\",\"dependecies\":\"dependencies\",\"depdenencies\":\"dependencies\",\"devEependencies\":\"devDependencies\",\"depends\":\"dependencies\",\"dev-dependencies\":\"devDependencies\",\"devDependences\":\"devDependencies\",\"devDepenencies\":\"devDependencies\",\"devdependencies\":\"devDependencies\",\"repostitory\":\"repository\",\"repo\":\"repository\",\"prefereGlobal\":\"preferGlobal\",\"hompage\":\"homepage\",\"hampage\":\"homepage\",\"autohr\":\"author\",\"autor\":\"author\",\"contributers\":\"contributors\",\"publicationConfig\":\"publishConfig\",\"script\":\"scripts\"},\"bugs\":{\"web\":\"url\",\"name\":\"url\"},\"script\":{\"server\":\"start\",\"tests\":\"test\"}}");
- this.pos = this.start;
- }
+/***/ }),
+/* 543 */
+/***/ (function(module, exports, __webpack_require__) {
- if (this.fd !== null) {
- process.nextTick(function() {
- self._read();
- });
- return;
- }
+var util = __webpack_require__(397)
+var messages = __webpack_require__(544)
- fs.open(this.path, this.flags, this.mode, function (err, fd) {
- if (err) {
- self.emit('error', err);
- self.readable = false;
- return;
- }
+module.exports = function() {
+ var args = Array.prototype.slice.call(arguments, 0)
+ var warningName = args.shift()
+ if (warningName == "typo") {
+ return makeTypoWarning.apply(null,args)
+ }
+ else {
+ var msgTemplate = messages[warningName] ? messages[warningName] : warningName + ": '%s'"
+ args.unshift(msgTemplate)
+ return util.format.apply(null, args)
+ }
+}
- self.fd = fd;
- self.emit('open', fd);
- self._read();
- })
+function makeTypoWarning (providedName, probableName, field) {
+ if (field) {
+ providedName = field + "['" + providedName + "']"
+ probableName = field + "['" + probableName + "']"
}
+ return util.format(messages.typo, providedName, probableName)
+}
- function WriteStream (path, options) {
- if (!(this instanceof WriteStream)) return new WriteStream(path, options);
- Stream.call(this);
+/***/ }),
+/* 544 */
+/***/ (function(module) {
- this.path = path;
- this.fd = null;
- this.writable = true;
+module.exports = JSON.parse("{\"repositories\":\"'repositories' (plural) Not supported. Please pick one as the 'repository' field\",\"missingRepository\":\"No repository field.\",\"brokenGitUrl\":\"Probably broken git url: %s\",\"nonObjectScripts\":\"scripts must be an object\",\"nonStringScript\":\"script values must be string commands\",\"nonArrayFiles\":\"Invalid 'files' member\",\"invalidFilename\":\"Invalid filename in 'files' list: %s\",\"nonArrayBundleDependencies\":\"Invalid 'bundleDependencies' list. Must be array of package names\",\"nonStringBundleDependency\":\"Invalid bundleDependencies member: %s\",\"nonDependencyBundleDependency\":\"Non-dependency in bundleDependencies: %s\",\"nonObjectDependencies\":\"%s field must be an object\",\"nonStringDependency\":\"Invalid dependency: %s %s\",\"deprecatedArrayDependencies\":\"specifying %s as array is deprecated\",\"deprecatedModules\":\"modules field is deprecated\",\"nonArrayKeywords\":\"keywords should be an array of strings\",\"nonStringKeyword\":\"keywords should be an array of strings\",\"conflictingName\":\"%s is also the name of a node core module.\",\"nonStringDescription\":\"'description' field should be a string\",\"missingDescription\":\"No description\",\"missingReadme\":\"No README data\",\"missingLicense\":\"No license field.\",\"nonEmailUrlBugsString\":\"Bug string field must be url, email, or {email,url}\",\"nonUrlBugsUrlField\":\"bugs.url field must be a string url. Deleted.\",\"nonEmailBugsEmailField\":\"bugs.email field must be a string email. Deleted.\",\"emptyNormalizedBugs\":\"Normalized value of bugs field is an empty object. Deleted.\",\"nonUrlHomepage\":\"homepage field must be a string url. Deleted.\",\"invalidLicense\":\"license should be a valid SPDX license expression\",\"typo\":\"%s should probably be %s.\"}");
- this.flags = 'w';
- this.encoding = 'binary';
- this.mode = 438; /*=0666*/
- this.bytesWritten = 0;
+/***/ }),
+/* 545 */
+/***/ (function(module, exports, __webpack_require__) {
- options = options || {};
+"use strict";
- // Mixin options into this
- var keys = Object.keys(options);
- for (var index = 0, length = keys.length; index < length; index++) {
- var key = keys[index];
- this[key] = options[key];
- }
+const path = __webpack_require__(4);
+const writeJsonFile = __webpack_require__(546);
+const sortKeys = __webpack_require__(558);
- if (this.start !== undefined) {
- if ('number' !== typeof this.start) {
- throw TypeError('start must be a Number');
- }
- if (this.start < 0) {
- throw new Error('start must be >= zero');
- }
+const dependencyKeys = new Set([
+ 'dependencies',
+ 'devDependencies',
+ 'optionalDependencies',
+ 'peerDependencies'
+]);
- this.pos = this.start;
- }
+function normalize(packageJson) {
+ const result = {};
- this.busy = false;
- this._queue = [];
+ for (const key of Object.keys(packageJson)) {
+ if (!dependencyKeys.has(key)) {
+ result[key] = packageJson[key];
+ } else if (Object.keys(packageJson[key]).length !== 0) {
+ result[key] = sortKeys(packageJson[key]);
+ }
+ }
- if (this.fd === null) {
- this._open = fs.open;
- this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
- this.flush();
- }
- }
+ return result;
}
+module.exports = async (filePath, data, options) => {
+ if (typeof filePath !== 'string') {
+ options = data;
+ data = filePath;
+ filePath = '.';
+ }
-/***/ }),
-/* 550 */
-/***/ (function(module, exports, __webpack_require__) {
+ options = {
+ normalize: true,
+ ...options,
+ detectIndent: true
+ };
-"use strict";
+ filePath = path.basename(filePath) === 'package.json' ? filePath : path.join(filePath, 'package.json');
+ data = options.normalize ? normalize(data) : data;
-module.exports = clone
+ return writeJsonFile(filePath, data, options);
+};
-function clone (obj) {
- if (obj === null || typeof obj !== 'object')
- return obj
+module.exports.sync = (filePath, data, options) => {
+ if (typeof filePath !== 'string') {
+ options = data;
+ data = filePath;
+ filePath = '.';
+ }
- if (obj instanceof Object)
- var copy = { __proto__: obj.__proto__ }
- else
- var copy = Object.create(null)
+ options = {
+ normalize: true,
+ ...options,
+ detectIndent: true
+ };
- Object.getOwnPropertyNames(obj).forEach(function (key) {
- Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
- })
+ filePath = path.basename(filePath) === 'package.json' ? filePath : path.join(filePath, 'package.json');
- return copy
-}
+ data = options.normalize ? normalize(data) : data;
+
+ writeJsonFile.sync(filePath, data, options);
+};
/***/ }),
-/* 551 */
+/* 546 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-module.exports = writeFile
-module.exports.sync = writeFileSync
-module.exports._getTmpname = getTmpname // for testing
-module.exports._cleanupOnExit = cleanupOnExit
-
-var fs = __webpack_require__(552)
-var MurmurHash3 = __webpack_require__(556)
-var onExit = __webpack_require__(397)
-var path = __webpack_require__(16)
-var activeFiles = {}
-
-// if we run inside of a worker_thread, `process.pid` is not unique
-/* istanbul ignore next */
-var threadId = (function getId () {
- try {
- var workerThreads = __webpack_require__(557)
+const path = __webpack_require__(4);
+const fs = __webpack_require__(547);
+const writeFileAtomic = __webpack_require__(551);
+const sortKeys = __webpack_require__(558);
+const makeDir = __webpack_require__(560);
+const pify = __webpack_require__(561);
+const detectIndent = __webpack_require__(562);
- /// if we are in main thread, this is set to `0`
- return workerThreads.threadId
- } catch (e) {
- // worker_threads are not available, fallback to 0
- return 0
- }
-})()
+const init = (fn, filePath, data, options) => {
+ if (!filePath) {
+ throw new TypeError('Expected a filepath');
+ }
-var invocations = 0
-function getTmpname (filename) {
- return filename + '.' +
- MurmurHash3(__filename)
- .hash(String(process.pid))
- .hash(String(threadId))
- .hash(String(++invocations))
- .result()
-}
+ if (data === undefined) {
+ throw new TypeError('Expected data to stringify');
+ }
-function cleanupOnExit (tmpfile) {
- return function () {
- try {
- fs.unlinkSync(typeof tmpfile === 'function' ? tmpfile() : tmpfile)
- } catch (_) {}
- }
-}
+ options = Object.assign({
+ indent: '\t',
+ sortKeys: false
+ }, options);
-function writeFile (filename, data, options, callback) {
- if (options) {
- if (options instanceof Function) {
- callback = options
- options = {}
- } else if (typeof options === 'string') {
- options = { encoding: options }
- }
- } else {
- options = {}
- }
+ if (options.sortKeys) {
+ data = sortKeys(data, {
+ deep: true,
+ compare: typeof options.sortKeys === 'function' ? options.sortKeys : undefined
+ });
+ }
- var Promise = options.Promise || global.Promise
- var truename
- var fd
- var tmpfile
- /* istanbul ignore next -- The closure only gets called when onExit triggers */
- var removeOnExitHandler = onExit(cleanupOnExit(() => tmpfile))
- var absoluteName = path.resolve(filename)
+ return fn(filePath, data, options);
+};
- new Promise(function serializeSameFile (resolve) {
- // make a queue if it doesn't already exist
- if (!activeFiles[absoluteName]) activeFiles[absoluteName] = []
+const readFile = filePath => pify(fs.readFile)(filePath, 'utf8').catch(() => {});
- activeFiles[absoluteName].push(resolve) // add this job to the queue
- if (activeFiles[absoluteName].length === 1) resolve() // kick off the first one
- }).then(function getRealPath () {
- return new Promise(function (resolve) {
- fs.realpath(filename, function (_, realname) {
- truename = realname || filename
- tmpfile = getTmpname(truename)
- resolve()
- })
- })
- }).then(function stat () {
- return new Promise(function stat (resolve) {
- if (options.mode && options.chown) resolve()
- else {
- // Either mode or chown is not explicitly set
- // Default behavior is to copy it from original file
- fs.stat(truename, function (err, stats) {
- if (err || !stats) resolve()
- else {
- options = Object.assign({}, options)
+const main = (filePath, data, options) => {
+ return (options.detectIndent ? readFile(filePath) : Promise.resolve())
+ .then(string => {
+ const indent = string ? detectIndent(string).indent : options.indent;
+ const json = JSON.stringify(data, options.replacer, indent);
- if (options.mode == null) {
- options.mode = stats.mode
- }
- if (options.chown == null && process.getuid) {
- options.chown = { uid: stats.uid, gid: stats.gid }
- }
- resolve()
- }
- })
- }
- })
- }).then(function thenWriteFile () {
- return new Promise(function (resolve, reject) {
- fs.open(tmpfile, 'w', options.mode, function (err, _fd) {
- fd = _fd
- if (err) reject(err)
- else resolve()
- })
- })
- }).then(function write () {
- return new Promise(function (resolve, reject) {
- if (Buffer.isBuffer(data)) {
- fs.write(fd, data, 0, data.length, 0, function (err) {
- if (err) reject(err)
- else resolve()
- })
- } else if (data != null) {
- fs.write(fd, String(data), 0, String(options.encoding || 'utf8'), function (err) {
- if (err) reject(err)
- else resolve()
- })
- } else resolve()
- })
- }).then(function syncAndClose () {
- return new Promise(function (resolve, reject) {
- if (options.fsync !== false) {
- fs.fsync(fd, function (err) {
- if (err) fs.close(fd, () => reject(err))
- else fs.close(fd, resolve)
- })
- } else {
- fs.close(fd, resolve)
- }
- })
- }).then(function chown () {
- fd = null
- if (options.chown) {
- return new Promise(function (resolve, reject) {
- fs.chown(tmpfile, options.chown.uid, options.chown.gid, function (err) {
- if (err) reject(err)
- else resolve()
- })
- })
- }
- }).then(function chmod () {
- if (options.mode) {
- return new Promise(function (resolve, reject) {
- fs.chmod(tmpfile, options.mode, function (err) {
- if (err) reject(err)
- else resolve()
- })
- })
- }
- }).then(function rename () {
- return new Promise(function (resolve, reject) {
- fs.rename(tmpfile, truename, function (err) {
- if (err) reject(err)
- else resolve()
- })
- })
- }).then(function success () {
- removeOnExitHandler()
- callback()
- }, function fail (err) {
- return new Promise(resolve => {
- return fd ? fs.close(fd, resolve) : resolve()
- }).then(() => {
- removeOnExitHandler()
- fs.unlink(tmpfile, function () {
- callback(err)
- })
- })
- }).then(function checkQueue () {
- activeFiles[absoluteName].shift() // remove the element added by serializeSameFile
- if (activeFiles[absoluteName].length > 0) {
- activeFiles[absoluteName][0]() // start next job if one is pending
- } else delete activeFiles[absoluteName]
- })
-}
+ return pify(writeFileAtomic)(filePath, `${json}\n`, {mode: options.mode});
+ });
+};
-function writeFileSync (filename, data, options) {
- if (typeof options === 'string') options = { encoding: options }
- else if (!options) options = {}
- try {
- filename = fs.realpathSync(filename)
- } catch (ex) {
- // it's ok, it'll happen on a not yet existing file
- }
- var tmpfile = getTmpname(filename)
+const mainSync = (filePath, data, options) => {
+ let {indent} = options;
- if (!options.mode || !options.chown) {
- // Either mode or chown is not explicitly set
- // Default behavior is to copy it from original file
- try {
- var stats = fs.statSync(filename)
- options = Object.assign({}, options)
- if (!options.mode) {
- options.mode = stats.mode
- }
- if (!options.chown && process.getuid) {
- options.chown = { uid: stats.uid, gid: stats.gid }
- }
- } catch (ex) {
- // ignore stat errors
- }
- }
+ if (options.detectIndent) {
+ try {
+ const file = fs.readFileSync(filePath, 'utf8');
+ indent = detectIndent(file).indent;
+ } catch (error) {
+ if (error.code !== 'ENOENT') {
+ throw error;
+ }
+ }
+ }
- var fd
- var cleanup = cleanupOnExit(tmpfile)
- var removeOnExitHandler = onExit(cleanup)
+ const json = JSON.stringify(data, options.replacer, indent);
- try {
- fd = fs.openSync(tmpfile, 'w', options.mode)
- if (Buffer.isBuffer(data)) {
- fs.writeSync(fd, data, 0, data.length, 0)
- } else if (data != null) {
- fs.writeSync(fd, String(data), 0, String(options.encoding || 'utf8'))
- }
- if (options.fsync !== false) {
- fs.fsyncSync(fd)
- }
- fs.closeSync(fd)
- if (options.chown) fs.chownSync(tmpfile, options.chown.uid, options.chown.gid)
- if (options.mode) fs.chmodSync(tmpfile, options.mode)
- fs.renameSync(tmpfile, filename)
- removeOnExitHandler()
- } catch (err) {
- if (fd) {
- try {
- fs.closeSync(fd)
- } catch (ex) {
- // ignore close errors at this stage, error may have closed fd already.
- }
- }
- removeOnExitHandler()
- cleanup()
- throw err
- }
-}
+ return writeFileAtomic.sync(filePath, `${json}\n`, {mode: options.mode});
+};
+
+const writeJsonFile = (filePath, data, options) => {
+ return makeDir(path.dirname(filePath), {fs})
+ .then(() => init(main, filePath, data, options));
+};
+
+module.exports = writeJsonFile;
+// TODO: Remove this for the next major release
+module.exports.default = writeJsonFile;
+module.exports.sync = (filePath, data, options) => {
+ makeDir.sync(path.dirname(filePath), {fs});
+ init(mainSync, filePath, data, options);
+};
/***/ }),
-/* 552 */
+/* 547 */
/***/ (function(module, exports, __webpack_require__) {
-var fs = __webpack_require__(23)
-var polyfills = __webpack_require__(553)
-var legacy = __webpack_require__(555)
+var fs = __webpack_require__(349)
+var polyfills = __webpack_require__(548)
+var legacy = __webpack_require__(549)
+var clone = __webpack_require__(550)
+
var queue = []
-var util = __webpack_require__(29)
+var util = __webpack_require__(397)
function noop () {}
@@ -53880,21 +52895,21 @@ else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
process.on('exit', function() {
debug(queue)
- __webpack_require__(30).equal(queue.length, 0)
+ __webpack_require__(371).equal(queue.length, 0)
})
}
-module.exports = patch(__webpack_require__(554))
-if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH) {
- module.exports = patch(fs)
+module.exports = patch(clone(fs))
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+ module.exports = patch(fs)
+ fs.__patched = true;
}
// Always patch fs.close/closeSync, because we want to
// retry() whenever a close happens *anywhere* in the program.
// This is essential when multiple graceful-fs instances are
// in play at the same time.
-module.exports.close =
-fs.close = (function (fs$close) { return function (fd, cb) {
+module.exports.close = (function (fs$close) { return function (fd, cb) {
return fs$close.call(fs, fd, function (err) {
if (!err)
retry()
@@ -53904,8 +52919,7 @@ fs.close = (function (fs$close) { return function (fd, cb) {
})
}})(fs.close)
-module.exports.closeSync =
-fs.closeSync = (function (fs$closeSync) { return function (fd) {
+module.exports.closeSync = (function (fs$closeSync) { return function (fd) {
// Note that graceful-fs also retries when fs.closeSync() fails.
// Looks like a bug to me, although it's probably a harmless one.
var rval = fs$closeSync.apply(fs, arguments)
@@ -53913,6 +52927,17 @@ fs.closeSync = (function (fs$closeSync) { return function (fd) {
return rval
}})(fs.closeSync)
+// Only patch fs once, otherwise we'll run into a memory leak if
+// graceful-fs is loaded multiple times, such as in test environments that
+// reset the loaded modules between tests.
+// We look for the string `graceful-fs` from the comment above. This
+// way we are not adding any extra properties and it will detect if older
+// versions of graceful-fs are installed.
+if (!/\bgraceful-fs\b/.test(fs.closeSync.toString())) {
+ fs.closeSync = module.exports.closeSync;
+ fs.close = module.exports.close;
+}
+
function patch (fs) {
// Everything that references the open() function needs to be in here
polyfills(fs)
@@ -54004,6 +53029,7 @@ function patch (fs) {
if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
enqueue([go$readdir, [args]])
+
else {
if (typeof cb === 'function')
cb.apply(this, arguments)
@@ -54023,12 +53049,16 @@ function patch (fs) {
}
var fs$ReadStream = fs.ReadStream
- ReadStream.prototype = Object.create(fs$ReadStream.prototype)
- ReadStream.prototype.open = ReadStream$open
+ if (fs$ReadStream) {
+ ReadStream.prototype = Object.create(fs$ReadStream.prototype)
+ ReadStream.prototype.open = ReadStream$open
+ }
var fs$WriteStream = fs.WriteStream
- WriteStream.prototype = Object.create(fs$WriteStream.prototype)
- WriteStream.prototype.open = WriteStream$open
+ if (fs$WriteStream) {
+ WriteStream.prototype = Object.create(fs$WriteStream.prototype)
+ WriteStream.prototype.open = WriteStream$open
+ }
fs.ReadStream = ReadStream
fs.WriteStream = WriteStream
@@ -54123,11 +53153,10 @@ function retry () {
/***/ }),
-/* 553 */
+/* 548 */
/***/ (function(module, exports, __webpack_require__) {
-var fs = __webpack_require__(554)
-var constants = __webpack_require__(25)
+var constants = __webpack_require__(411)
var origCwd = process.cwd
var cwd = null
@@ -54273,73 +53302,36 @@ function patch (fs) {
}
}
}})(fs.readSync)
-}
-
-function patchLchmod (fs) {
- fs.lchmod = function (path, mode, callback) {
- fs.open( path
- , constants.O_WRONLY | constants.O_SYMLINK
- , mode
- , function (err, fd) {
- if (err) {
- if (callback) callback(err)
- return
- }
- // prefer to return the chmod error, if one occurs,
- // but still try to close, and report closing errors if they occur.
- fs.fchmod(fd, mode, function (err) {
- fs.close(fd, function(err2) {
- if (callback) callback(err || err2)
- })
- })
- })
- }
-
- fs.lchmodSync = function (path, mode) {
- var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
-
- // prefer to return the chmod error, if one occurs,
- // but still try to close, and report closing errors if they occur.
- var threw = true
- var ret
- try {
- ret = fs.fchmodSync(fd, mode)
- threw = false
- } finally {
- if (threw) {
- try {
- fs.closeSync(fd)
- } catch (er) {}
- } else {
- fs.closeSync(fd)
- }
- }
- return ret
- }
-}
-function patchLutimes (fs) {
- if (constants.hasOwnProperty("O_SYMLINK")) {
- fs.lutimes = function (path, at, mt, cb) {
- fs.open(path, constants.O_SYMLINK, function (er, fd) {
- if (er) {
- if (cb) cb(er)
+ function patchLchmod (fs) {
+ fs.lchmod = function (path, mode, callback) {
+ fs.open( path
+ , constants.O_WRONLY | constants.O_SYMLINK
+ , mode
+ , function (err, fd) {
+ if (err) {
+ if (callback) callback(err)
return
}
- fs.futimes(fd, at, mt, function (er) {
- fs.close(fd, function (er2) {
- if (cb) cb(er || er2)
+ // prefer to return the chmod error, if one occurs,
+ // but still try to close, and report closing errors if they occur.
+ fs.fchmod(fd, mode, function (err) {
+ fs.close(fd, function(err2) {
+ if (callback) callback(err || err2)
})
})
})
}
- fs.lutimesSync = function (path, at, mt) {
- var fd = fs.openSync(path, constants.O_SYMLINK)
- var ret
+ fs.lchmodSync = function (path, mode) {
+ var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
+
+ // prefer to return the chmod error, if one occurs,
+ // but still try to close, and report closing errors if they occur.
var threw = true
+ var ret
try {
- ret = fs.futimesSync(fd, at, mt)
+ ret = fs.fchmodSync(fd, mode)
threw = false
} finally {
if (threw) {
@@ -54352,145 +53344,154 @@ function patchLutimes (fs) {
}
return ret
}
-
- } else {
- fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
- fs.lutimesSync = function () {}
}
-}
-function chmodFix (orig) {
- if (!orig) return orig
- return function (target, mode, cb) {
- return orig.call(fs, target, mode, function (er) {
- if (chownErOk(er)) er = null
- if (cb) cb.apply(this, arguments)
- })
- }
-}
+ function patchLutimes (fs) {
+ if (constants.hasOwnProperty("O_SYMLINK")) {
+ fs.lutimes = function (path, at, mt, cb) {
+ fs.open(path, constants.O_SYMLINK, function (er, fd) {
+ if (er) {
+ if (cb) cb(er)
+ return
+ }
+ fs.futimes(fd, at, mt, function (er) {
+ fs.close(fd, function (er2) {
+ if (cb) cb(er || er2)
+ })
+ })
+ })
+ }
-function chmodFixSync (orig) {
- if (!orig) return orig
- return function (target, mode) {
- try {
- return orig.call(fs, target, mode)
- } catch (er) {
- if (!chownErOk(er)) throw er
+ fs.lutimesSync = function (path, at, mt) {
+ var fd = fs.openSync(path, constants.O_SYMLINK)
+ var ret
+ var threw = true
+ try {
+ ret = fs.futimesSync(fd, at, mt)
+ threw = false
+ } finally {
+ if (threw) {
+ try {
+ fs.closeSync(fd)
+ } catch (er) {}
+ } else {
+ fs.closeSync(fd)
+ }
+ }
+ return ret
+ }
+
+ } else {
+ fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
+ fs.lutimesSync = function () {}
}
}
-}
-
-function chownFix (orig) {
- if (!orig) return orig
- return function (target, uid, gid, cb) {
- return orig.call(fs, target, uid, gid, function (er) {
- if (chownErOk(er)) er = null
- if (cb) cb.apply(this, arguments)
- })
+ function chmodFix (orig) {
+ if (!orig) return orig
+ return function (target, mode, cb) {
+ return orig.call(fs, target, mode, function (er) {
+ if (chownErOk(er)) er = null
+ if (cb) cb.apply(this, arguments)
+ })
+ }
}
-}
-function chownFixSync (orig) {
- if (!orig) return orig
- return function (target, uid, gid) {
- try {
- return orig.call(fs, target, uid, gid)
- } catch (er) {
- if (!chownErOk(er)) throw er
+ function chmodFixSync (orig) {
+ if (!orig) return orig
+ return function (target, mode) {
+ try {
+ return orig.call(fs, target, mode)
+ } catch (er) {
+ if (!chownErOk(er)) throw er
+ }
}
}
-}
-function statFix (orig) {
- if (!orig) return orig
- // Older versions of Node erroneously returned signed integers for
- // uid + gid.
- return function (target, cb) {
- return orig.call(fs, target, function (er, stats) {
- if (!stats) return cb.apply(this, arguments)
- if (stats.uid < 0) stats.uid += 0x100000000
- if (stats.gid < 0) stats.gid += 0x100000000
- if (cb) cb.apply(this, arguments)
- })
+ function chownFix (orig) {
+ if (!orig) return orig
+ return function (target, uid, gid, cb) {
+ return orig.call(fs, target, uid, gid, function (er) {
+ if (chownErOk(er)) er = null
+ if (cb) cb.apply(this, arguments)
+ })
+ }
}
-}
-function statFixSync (orig) {
- if (!orig) return orig
- // Older versions of Node erroneously returned signed integers for
- // uid + gid.
- return function (target) {
- var stats = orig.call(fs, target)
- if (stats.uid < 0) stats.uid += 0x100000000
- if (stats.gid < 0) stats.gid += 0x100000000
- return stats;
+ function chownFixSync (orig) {
+ if (!orig) return orig
+ return function (target, uid, gid) {
+ try {
+ return orig.call(fs, target, uid, gid)
+ } catch (er) {
+ if (!chownErOk(er)) throw er
+ }
+ }
}
-}
-
-// ENOSYS means that the fs doesn't support the op. Just ignore
-// that, because it doesn't matter.
-//
-// if there's no getuid, or if getuid() is something other
-// than 0, and the error is EINVAL or EPERM, then just ignore
-// it.
-//
-// This specific case is a silent failure in cp, install, tar,
-// and most other unix tools that manage permissions.
-//
-// When running as root, or if other types of errors are
-// encountered, then it's strict.
-function chownErOk (er) {
- if (!er)
- return true
- if (er.code === "ENOSYS")
- return true
- var nonroot = !process.getuid || process.getuid() !== 0
- if (nonroot) {
- if (er.code === "EINVAL" || er.code === "EPERM")
- return true
+ function statFix (orig) {
+ if (!orig) return orig
+ // Older versions of Node erroneously returned signed integers for
+ // uid + gid.
+ return function (target, cb) {
+ return orig.call(fs, target, function (er, stats) {
+ if (!stats) return cb.apply(this, arguments)
+ if (stats.uid < 0) stats.uid += 0x100000000
+ if (stats.gid < 0) stats.gid += 0x100000000
+ if (cb) cb.apply(this, arguments)
+ })
+ }
}
- return false
-}
-
-
-/***/ }),
-/* 554 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-
-var fs = __webpack_require__(23)
-
-module.exports = clone(fs)
+ function statFixSync (orig) {
+ if (!orig) return orig
+ // Older versions of Node erroneously returned signed integers for
+ // uid + gid.
+ return function (target) {
+ var stats = orig.call(fs, target)
+ if (stats.uid < 0) stats.uid += 0x100000000
+ if (stats.gid < 0) stats.gid += 0x100000000
+ return stats;
+ }
+ }
-function clone (obj) {
- if (obj === null || typeof obj !== 'object')
- return obj
+ // ENOSYS means that the fs doesn't support the op. Just ignore
+ // that, because it doesn't matter.
+ //
+ // if there's no getuid, or if getuid() is something other
+ // than 0, and the error is EINVAL or EPERM, then just ignore
+ // it.
+ //
+ // This specific case is a silent failure in cp, install, tar,
+ // and most other unix tools that manage permissions.
+ //
+ // When running as root, or if other types of errors are
+ // encountered, then it's strict.
+ function chownErOk (er) {
+ if (!er)
+ return true
- if (obj instanceof Object)
- var copy = { __proto__: obj.__proto__ }
- else
- var copy = Object.create(null)
+ if (er.code === "ENOSYS")
+ return true
- Object.getOwnPropertyNames(obj).forEach(function (key) {
- Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
- })
+ var nonroot = !process.getuid || process.getuid() !== 0
+ if (nonroot) {
+ if (er.code === "EINVAL" || er.code === "EPERM")
+ return true
+ }
- return copy
+ return false
+ }
}
/***/ }),
-/* 555 */
+/* 549 */
/***/ (function(module, exports, __webpack_require__) {
-var Stream = __webpack_require__(27).Stream
+var Stream = __webpack_require__(382).Stream
module.exports = legacy
@@ -54610,1452 +53611,1793 @@ function legacy (fs) {
}
-/***/ }),
-/* 556 */
-/***/ (function(module, exports, __webpack_require__) {
-
-/**
- * @preserve
- * JS Implementation of incremental MurmurHash3 (r150) (as of May 10, 2013)
- *
- * @author Jens Taylor
- * @see http://github.com/homebrewing/brauhaus-diff
- * @author Gary Court
- * @see http://github.com/garycourt/murmurhash-js
- * @author Austin Appleby
- * @see http://sites.google.com/site/murmurhash/
- */
-(function(){
- var cache;
-
- // Call this function without `new` to use the cached object (good for
- // single-threaded environments), or with `new` to create a new object.
- //
- // @param {string} key A UTF-16 or ASCII string
- // @param {number} seed An optional positive integer
- // @return {object} A MurmurHash3 object for incremental hashing
- function MurmurHash3(key, seed) {
- var m = this instanceof MurmurHash3 ? this : cache;
- m.reset(seed)
- if (typeof key === 'string' && key.length > 0) {
- m.hash(key);
- }
-
- if (m !== this) {
- return m;
- }
- };
-
- // Incrementally add a string to this hash
- //
- // @param {string} key A UTF-16 or ASCII string
- // @return {object} this
- MurmurHash3.prototype.hash = function(key) {
- var h1, k1, i, top, len;
-
- len = key.length;
- this.len += len;
-
- k1 = this.k1;
- i = 0;
- switch (this.rem) {
- case 0: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) : 0;
- case 1: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 8 : 0;
- case 2: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 16 : 0;
- case 3:
- k1 ^= len > i ? (key.charCodeAt(i) & 0xff) << 24 : 0;
- k1 ^= len > i ? (key.charCodeAt(i++) & 0xff00) >> 8 : 0;
- }
-
- this.rem = (len + this.rem) & 3; // & 3 is same as % 4
- len -= this.rem;
- if (len > 0) {
- h1 = this.h1;
- while (1) {
- k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff;
- k1 = (k1 << 15) | (k1 >>> 17);
- k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff;
-
- h1 ^= k1;
- h1 = (h1 << 13) | (h1 >>> 19);
- h1 = (h1 * 5 + 0xe6546b64) & 0xffffffff;
-
- if (i >= len) {
- break;
- }
-
- k1 = ((key.charCodeAt(i++) & 0xffff)) ^
- ((key.charCodeAt(i++) & 0xffff) << 8) ^
- ((key.charCodeAt(i++) & 0xffff) << 16);
- top = key.charCodeAt(i++);
- k1 ^= ((top & 0xff) << 24) ^
- ((top & 0xff00) >> 8);
- }
-
- k1 = 0;
- switch (this.rem) {
- case 3: k1 ^= (key.charCodeAt(i + 2) & 0xffff) << 16;
- case 2: k1 ^= (key.charCodeAt(i + 1) & 0xffff) << 8;
- case 1: k1 ^= (key.charCodeAt(i) & 0xffff);
- }
-
- this.h1 = h1;
- }
-
- this.k1 = k1;
- return this;
- };
-
- // Get the result of this hash
- //
- // @return {number} The 32-bit hash
- MurmurHash3.prototype.result = function() {
- var k1, h1;
-
- k1 = this.k1;
- h1 = this.h1;
-
- if (k1 > 0) {
- k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff;
- k1 = (k1 << 15) | (k1 >>> 17);
- k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff;
- h1 ^= k1;
- }
-
- h1 ^= this.len;
+/***/ }),
+/* 550 */
+/***/ (function(module, exports, __webpack_require__) {
- h1 ^= h1 >>> 16;
- h1 = (h1 * 0xca6b + (h1 & 0xffff) * 0x85eb0000) & 0xffffffff;
- h1 ^= h1 >>> 13;
- h1 = (h1 * 0xae35 + (h1 & 0xffff) * 0xc2b20000) & 0xffffffff;
- h1 ^= h1 >>> 16;
+"use strict";
- return h1 >>> 0;
- };
- // Reset the hash object for reuse
- //
- // @param {number} seed An optional positive integer
- MurmurHash3.prototype.reset = function(seed) {
- this.h1 = typeof seed === 'number' ? seed : 0;
- this.rem = this.k1 = this.len = 0;
- return this;
- };
+module.exports = clone
- // A cached object to use. This can be safely used if you're in a single-
- // threaded environment, otherwise you need to create new hashes to use.
- cache = new MurmurHash3();
+function clone (obj) {
+ if (obj === null || typeof obj !== 'object')
+ return obj
- if (true) {
- module.exports = MurmurHash3;
- } else {}
-}());
+ if (obj instanceof Object)
+ var copy = { __proto__: obj.__proto__ }
+ else
+ var copy = Object.create(null)
+ Object.getOwnPropertyNames(obj).forEach(function (key) {
+ Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
+ })
-/***/ }),
-/* 557 */
-/***/ (function(module, exports) {
+ return copy
+}
-module.exports = require(undefined);
/***/ }),
-/* 558 */
+/* 551 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const isPlainObj = __webpack_require__(559);
-
-module.exports = (obj, opts) => {
- if (!isPlainObj(obj)) {
- throw new TypeError('Expected a plain object');
- }
+module.exports = writeFile
+module.exports.sync = writeFileSync
+module.exports._getTmpname = getTmpname // for testing
+module.exports._cleanupOnExit = cleanupOnExit
- opts = opts || {};
+var fs = __webpack_require__(552)
+var MurmurHash3 = __webpack_require__(556)
+var onExit = __webpack_require__(370)
+var path = __webpack_require__(4)
+var activeFiles = {}
- // DEPRECATED
- if (typeof opts === 'function') {
- throw new TypeError('Specify the compare function as an option instead');
- }
+// if we run inside of a worker_thread, `process.pid` is not unique
+/* istanbul ignore next */
+var threadId = (function getId () {
+ try {
+ var workerThreads = __webpack_require__(557)
- const deep = opts.deep;
- const seenInput = [];
- const seenOutput = [];
+ /// if we are in main thread, this is set to `0`
+ return workerThreads.threadId
+ } catch (e) {
+ // worker_threads are not available, fallback to 0
+ return 0
+ }
+})()
- const sortKeys = x => {
- const seenIndex = seenInput.indexOf(x);
+var invocations = 0
+function getTmpname (filename) {
+ return filename + '.' +
+ MurmurHash3(__filename)
+ .hash(String(process.pid))
+ .hash(String(threadId))
+ .hash(String(++invocations))
+ .result()
+}
- if (seenIndex !== -1) {
- return seenOutput[seenIndex];
- }
+function cleanupOnExit (tmpfile) {
+ return function () {
+ try {
+ fs.unlinkSync(typeof tmpfile === 'function' ? tmpfile() : tmpfile)
+ } catch (_) {}
+ }
+}
- const ret = {};
- const keys = Object.keys(x).sort(opts.compare);
+function writeFile (filename, data, options, callback) {
+ if (options) {
+ if (options instanceof Function) {
+ callback = options
+ options = {}
+ } else if (typeof options === 'string') {
+ options = { encoding: options }
+ }
+ } else {
+ options = {}
+ }
- seenInput.push(x);
- seenOutput.push(ret);
+ var Promise = options.Promise || global.Promise
+ var truename
+ var fd
+ var tmpfile
+ /* istanbul ignore next -- The closure only gets called when onExit triggers */
+ var removeOnExitHandler = onExit(cleanupOnExit(() => tmpfile))
+ var absoluteName = path.resolve(filename)
- for (let i = 0; i < keys.length; i++) {
- const key = keys[i];
- const val = x[key];
+ new Promise(function serializeSameFile (resolve) {
+ // make a queue if it doesn't already exist
+ if (!activeFiles[absoluteName]) activeFiles[absoluteName] = []
- if (deep && Array.isArray(val)) {
- const retArr = [];
+ activeFiles[absoluteName].push(resolve) // add this job to the queue
+ if (activeFiles[absoluteName].length === 1) resolve() // kick off the first one
+ }).then(function getRealPath () {
+ return new Promise(function (resolve) {
+ fs.realpath(filename, function (_, realname) {
+ truename = realname || filename
+ tmpfile = getTmpname(truename)
+ resolve()
+ })
+ })
+ }).then(function stat () {
+ return new Promise(function stat (resolve) {
+ if (options.mode && options.chown) resolve()
+ else {
+ // Either mode or chown is not explicitly set
+ // Default behavior is to copy it from original file
+ fs.stat(truename, function (err, stats) {
+ if (err || !stats) resolve()
+ else {
+ options = Object.assign({}, options)
- for (let j = 0; j < val.length; j++) {
- retArr[j] = isPlainObj(val[j]) ? sortKeys(val[j]) : val[j];
- }
+ if (options.mode == null) {
+ options.mode = stats.mode
+ }
+ if (options.chown == null && process.getuid) {
+ options.chown = { uid: stats.uid, gid: stats.gid }
+ }
+ resolve()
+ }
+ })
+ }
+ })
+ }).then(function thenWriteFile () {
+ return new Promise(function (resolve, reject) {
+ fs.open(tmpfile, 'w', options.mode, function (err, _fd) {
+ fd = _fd
+ if (err) reject(err)
+ else resolve()
+ })
+ })
+ }).then(function write () {
+ return new Promise(function (resolve, reject) {
+ if (Buffer.isBuffer(data)) {
+ fs.write(fd, data, 0, data.length, 0, function (err) {
+ if (err) reject(err)
+ else resolve()
+ })
+ } else if (data != null) {
+ fs.write(fd, String(data), 0, String(options.encoding || 'utf8'), function (err) {
+ if (err) reject(err)
+ else resolve()
+ })
+ } else resolve()
+ })
+ }).then(function syncAndClose () {
+ return new Promise(function (resolve, reject) {
+ if (options.fsync !== false) {
+ fs.fsync(fd, function (err) {
+ if (err) fs.close(fd, () => reject(err))
+ else fs.close(fd, resolve)
+ })
+ } else {
+ fs.close(fd, resolve)
+ }
+ })
+ }).then(function chown () {
+ fd = null
+ if (options.chown) {
+ return new Promise(function (resolve, reject) {
+ fs.chown(tmpfile, options.chown.uid, options.chown.gid, function (err) {
+ if (err) reject(err)
+ else resolve()
+ })
+ })
+ }
+ }).then(function chmod () {
+ if (options.mode) {
+ return new Promise(function (resolve, reject) {
+ fs.chmod(tmpfile, options.mode, function (err) {
+ if (err) reject(err)
+ else resolve()
+ })
+ })
+ }
+ }).then(function rename () {
+ return new Promise(function (resolve, reject) {
+ fs.rename(tmpfile, truename, function (err) {
+ if (err) reject(err)
+ else resolve()
+ })
+ })
+ }).then(function success () {
+ removeOnExitHandler()
+ callback()
+ }, function fail (err) {
+ return new Promise(resolve => {
+ return fd ? fs.close(fd, resolve) : resolve()
+ }).then(() => {
+ removeOnExitHandler()
+ fs.unlink(tmpfile, function () {
+ callback(err)
+ })
+ })
+ }).then(function checkQueue () {
+ activeFiles[absoluteName].shift() // remove the element added by serializeSameFile
+ if (activeFiles[absoluteName].length > 0) {
+ activeFiles[absoluteName][0]() // start next job if one is pending
+ } else delete activeFiles[absoluteName]
+ })
+}
- ret[key] = retArr;
- continue;
- }
+function writeFileSync (filename, data, options) {
+ if (typeof options === 'string') options = { encoding: options }
+ else if (!options) options = {}
+ try {
+ filename = fs.realpathSync(filename)
+ } catch (ex) {
+ // it's ok, it'll happen on a not yet existing file
+ }
+ var tmpfile = getTmpname(filename)
- ret[key] = deep && isPlainObj(val) ? sortKeys(val) : val;
- }
+ if (!options.mode || !options.chown) {
+ // Either mode or chown is not explicitly set
+ // Default behavior is to copy it from original file
+ try {
+ var stats = fs.statSync(filename)
+ options = Object.assign({}, options)
+ if (!options.mode) {
+ options.mode = stats.mode
+ }
+ if (!options.chown && process.getuid) {
+ options.chown = { uid: stats.uid, gid: stats.gid }
+ }
+ } catch (ex) {
+ // ignore stat errors
+ }
+ }
- return ret;
- };
+ var fd
+ var cleanup = cleanupOnExit(tmpfile)
+ var removeOnExitHandler = onExit(cleanup)
- return sortKeys(obj);
-};
+ try {
+ fd = fs.openSync(tmpfile, 'w', options.mode)
+ if (Buffer.isBuffer(data)) {
+ fs.writeSync(fd, data, 0, data.length, 0)
+ } else if (data != null) {
+ fs.writeSync(fd, String(data), 0, String(options.encoding || 'utf8'))
+ }
+ if (options.fsync !== false) {
+ fs.fsyncSync(fd)
+ }
+ fs.closeSync(fd)
+ if (options.chown) fs.chownSync(tmpfile, options.chown.uid, options.chown.gid)
+ if (options.mode) fs.chmodSync(tmpfile, options.mode)
+ fs.renameSync(tmpfile, filename)
+ removeOnExitHandler()
+ } catch (err) {
+ if (fd) {
+ try {
+ fs.closeSync(fd)
+ } catch (ex) {
+ // ignore close errors at this stage, error may have closed fd already.
+ }
+ }
+ removeOnExitHandler()
+ cleanup()
+ throw err
+ }
+}
/***/ }),
-/* 559 */
+/* 552 */
/***/ (function(module, exports, __webpack_require__) {
-"use strict";
+var fs = __webpack_require__(349)
+var polyfills = __webpack_require__(553)
+var legacy = __webpack_require__(555)
+var queue = []
-var toString = Object.prototype.toString;
+var util = __webpack_require__(397)
-module.exports = function (x) {
- var prototype;
- return toString.call(x) === '[object Object]' && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({}));
-};
+function noop () {}
+var debug = noop
+if (util.debuglog)
+ debug = util.debuglog('gfs4')
+else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+ debug = function() {
+ var m = util.format.apply(util, arguments)
+ m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
+ console.error(m)
+ }
-/***/ }),
-/* 560 */
-/***/ (function(module, exports, __webpack_require__) {
+if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+ process.on('exit', function() {
+ debug(queue)
+ __webpack_require__(371).equal(queue.length, 0)
+ })
+}
-"use strict";
+module.exports = patch(__webpack_require__(554))
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH) {
+ module.exports = patch(fs)
+}
-const fs = __webpack_require__(23);
-const path = __webpack_require__(16);
-const pify = __webpack_require__(561);
-const semver = __webpack_require__(523);
+// Always patch fs.close/closeSync, because we want to
+// retry() whenever a close happens *anywhere* in the program.
+// This is essential when multiple graceful-fs instances are
+// in play at the same time.
+module.exports.close =
+fs.close = (function (fs$close) { return function (fd, cb) {
+ return fs$close.call(fs, fd, function (err) {
+ if (!err)
+ retry()
-const defaults = {
- mode: 0o777 & (~process.umask()),
- fs
-};
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ })
+}})(fs.close)
-const useNativeRecursiveOption = semver.satisfies(process.version, '>=10.12.0');
+module.exports.closeSync =
+fs.closeSync = (function (fs$closeSync) { return function (fd) {
+ // Note that graceful-fs also retries when fs.closeSync() fails.
+ // Looks like a bug to me, although it's probably a harmless one.
+ var rval = fs$closeSync.apply(fs, arguments)
+ retry()
+ return rval
+}})(fs.closeSync)
-// https://github.com/nodejs/node/issues/8987
-// https://github.com/libuv/libuv/pull/1088
-const checkPath = pth => {
- if (process.platform === 'win32') {
- const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ''));
+function patch (fs) {
+ // Everything that references the open() function needs to be in here
+ polyfills(fs)
+ fs.gracefulify = patch
+ fs.FileReadStream = ReadStream; // Legacy name.
+ fs.FileWriteStream = WriteStream; // Legacy name.
+ fs.createReadStream = createReadStream
+ fs.createWriteStream = createWriteStream
+ var fs$readFile = fs.readFile
+ fs.readFile = readFile
+ function readFile (path, options, cb) {
+ if (typeof options === 'function')
+ cb = options, options = null
- if (pathHasInvalidWinCharacters) {
- const error = new Error(`Path contains invalid characters: ${pth}`);
- error.code = 'EINVAL';
- throw error;
- }
- }
-};
+ return go$readFile(path, options, cb)
-const permissionError = pth => {
- // This replicates the exception of `fs.mkdir` with native the
- // `recusive` option when run on an invalid drive under Windows.
- const error = new Error(`operation not permitted, mkdir '${pth}'`);
- error.code = 'EPERM';
- error.errno = -4048;
- error.path = pth;
- error.syscall = 'mkdir';
- return error;
-};
+ function go$readFile (path, options, cb) {
+ return fs$readFile(path, options, function (err) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$readFile, [path, options, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ })
+ }
+ }
-const makeDir = (input, options) => Promise.resolve().then(() => {
- checkPath(input);
- options = Object.assign({}, defaults, options);
+ var fs$writeFile = fs.writeFile
+ fs.writeFile = writeFile
+ function writeFile (path, data, options, cb) {
+ if (typeof options === 'function')
+ cb = options, options = null
- // TODO: Use util.promisify when targeting Node.js 8
- const mkdir = pify(options.fs.mkdir);
- const stat = pify(options.fs.stat);
+ return go$writeFile(path, data, options, cb)
- if (useNativeRecursiveOption && options.fs.mkdir === fs.mkdir) {
- const pth = path.resolve(input);
+ function go$writeFile (path, data, options, cb) {
+ return fs$writeFile(path, data, options, function (err) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$writeFile, [path, data, options, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ })
+ }
+ }
+
+ var fs$appendFile = fs.appendFile
+ if (fs$appendFile)
+ fs.appendFile = appendFile
+ function appendFile (path, data, options, cb) {
+ if (typeof options === 'function')
+ cb = options, options = null
+
+ return go$appendFile(path, data, options, cb)
+
+ function go$appendFile (path, data, options, cb) {
+ return fs$appendFile(path, data, options, function (err) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$appendFile, [path, data, options, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ })
+ }
+ }
+
+ var fs$readdir = fs.readdir
+ fs.readdir = readdir
+ function readdir (path, options, cb) {
+ var args = [path]
+ if (typeof options !== 'function') {
+ args.push(options)
+ } else {
+ cb = options
+ }
+ args.push(go$readdir$cb)
+
+ return go$readdir(args)
+
+ function go$readdir$cb (err, files) {
+ if (files && files.sort)
+ files.sort()
+
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$readdir, [args]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ }
+ }
+
+ function go$readdir (args) {
+ return fs$readdir.apply(fs, args)
+ }
+
+ if (process.version.substr(0, 4) === 'v0.8') {
+ var legStreams = legacy(fs)
+ ReadStream = legStreams.ReadStream
+ WriteStream = legStreams.WriteStream
+ }
+
+ var fs$ReadStream = fs.ReadStream
+ ReadStream.prototype = Object.create(fs$ReadStream.prototype)
+ ReadStream.prototype.open = ReadStream$open
+
+ var fs$WriteStream = fs.WriteStream
+ WriteStream.prototype = Object.create(fs$WriteStream.prototype)
+ WriteStream.prototype.open = WriteStream$open
+
+ fs.ReadStream = ReadStream
+ fs.WriteStream = WriteStream
- return mkdir(pth, {
- mode: options.mode,
- recursive: true
- }).then(() => pth);
- }
+ function ReadStream (path, options) {
+ if (this instanceof ReadStream)
+ return fs$ReadStream.apply(this, arguments), this
+ else
+ return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
+ }
- const make = pth => {
- return mkdir(pth, options.mode)
- .then(() => pth)
- .catch(error => {
- if (error.code === 'EPERM') {
- throw error;
- }
+ function ReadStream$open () {
+ var that = this
+ open(that.path, that.flags, that.mode, function (err, fd) {
+ if (err) {
+ if (that.autoClose)
+ that.destroy()
- if (error.code === 'ENOENT') {
- if (path.dirname(pth) === pth) {
- throw permissionError(pth);
- }
+ that.emit('error', err)
+ } else {
+ that.fd = fd
+ that.emit('open', fd)
+ that.read()
+ }
+ })
+ }
- if (error.message.includes('null bytes')) {
- throw error;
- }
+ function WriteStream (path, options) {
+ if (this instanceof WriteStream)
+ return fs$WriteStream.apply(this, arguments), this
+ else
+ return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
+ }
- return make(path.dirname(pth)).then(() => make(pth));
- }
+ function WriteStream$open () {
+ var that = this
+ open(that.path, that.flags, that.mode, function (err, fd) {
+ if (err) {
+ that.destroy()
+ that.emit('error', err)
+ } else {
+ that.fd = fd
+ that.emit('open', fd)
+ }
+ })
+ }
- return stat(pth)
- .then(stats => stats.isDirectory() ? pth : Promise.reject())
- .catch(() => {
- throw error;
- });
- });
- };
+ function createReadStream (path, options) {
+ return new ReadStream(path, options)
+ }
- return make(path.resolve(input));
-});
+ function createWriteStream (path, options) {
+ return new WriteStream(path, options)
+ }
-module.exports = makeDir;
-module.exports.default = makeDir;
+ var fs$open = fs.open
+ fs.open = open
+ function open (path, flags, mode, cb) {
+ if (typeof mode === 'function')
+ cb = mode, mode = null
-module.exports.sync = (input, options) => {
- checkPath(input);
- options = Object.assign({}, defaults, options);
+ return go$open(path, flags, mode, cb)
- if (useNativeRecursiveOption && options.fs.mkdirSync === fs.mkdirSync) {
- const pth = path.resolve(input);
+ function go$open (path, flags, mode, cb) {
+ return fs$open(path, flags, mode, function (err, fd) {
+ if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+ enqueue([go$open, [path, flags, mode, cb]])
+ else {
+ if (typeof cb === 'function')
+ cb.apply(this, arguments)
+ retry()
+ }
+ })
+ }
+ }
- fs.mkdirSync(pth, {
- mode: options.mode,
- recursive: true
- });
+ return fs
+}
- return pth;
- }
+function enqueue (elem) {
+ debug('ENQUEUE', elem[0].name, elem[1])
+ queue.push(elem)
+}
- const make = pth => {
- try {
- options.fs.mkdirSync(pth, options.mode);
- } catch (error) {
- if (error.code === 'EPERM') {
- throw error;
- }
+function retry () {
+ var elem = queue.shift()
+ if (elem) {
+ debug('RETRY', elem[0].name, elem[1])
+ elem[0].apply(null, elem[1])
+ }
+}
- if (error.code === 'ENOENT') {
- if (path.dirname(pth) === pth) {
- throw permissionError(pth);
- }
- if (error.message.includes('null bytes')) {
- throw error;
- }
+/***/ }),
+/* 553 */
+/***/ (function(module, exports, __webpack_require__) {
- make(path.dirname(pth));
- return make(pth);
- }
+var fs = __webpack_require__(554)
+var constants = __webpack_require__(411)
- try {
- if (!options.fs.statSync(pth).isDirectory()) {
- throw new Error('The path is not a directory');
- }
- } catch (_) {
- throw error;
- }
- }
+var origCwd = process.cwd
+var cwd = null
- return pth;
- };
+var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
- return make(path.resolve(input));
-};
+process.cwd = function() {
+ if (!cwd)
+ cwd = origCwd.call(process)
+ return cwd
+}
+try {
+ process.cwd()
+} catch (er) {}
+var chdir = process.chdir
+process.chdir = function(d) {
+ cwd = null
+ chdir.call(process, d)
+}
-/***/ }),
-/* 561 */
-/***/ (function(module, exports, __webpack_require__) {
+module.exports = patch
-"use strict";
+function patch (fs) {
+ // (re-)implement some things that are known busted or missing.
+ // lchmod, broken prior to 0.6.2
+ // back-port the fix here.
+ if (constants.hasOwnProperty('O_SYMLINK') &&
+ process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+ patchLchmod(fs)
+ }
-const processFn = (fn, options) => function (...args) {
- const P = options.promiseModule;
+ // lutimes implementation, or no-op
+ if (!fs.lutimes) {
+ patchLutimes(fs)
+ }
- return new P((resolve, reject) => {
- if (options.multiArgs) {
- args.push((...result) => {
- if (options.errorFirst) {
- if (result[0]) {
- reject(result);
- } else {
- result.shift();
- resolve(result);
- }
- } else {
- resolve(result);
- }
- });
- } else if (options.errorFirst) {
- args.push((error, result) => {
- if (error) {
- reject(error);
- } else {
- resolve(result);
- }
- });
- } else {
- args.push(resolve);
- }
+ // https://github.com/isaacs/node-graceful-fs/issues/4
+ // Chown should not fail on einval or eperm if non-root.
+ // It should not fail on enosys ever, as this just indicates
+ // that a fs doesn't support the intended operation.
- fn.apply(this, args);
- });
-};
+ fs.chown = chownFix(fs.chown)
+ fs.fchown = chownFix(fs.fchown)
+ fs.lchown = chownFix(fs.lchown)
-module.exports = (input, options) => {
- options = Object.assign({
- exclude: [/.+(Sync|Stream)$/],
- errorFirst: true,
- promiseModule: Promise
- }, options);
+ fs.chmod = chmodFix(fs.chmod)
+ fs.fchmod = chmodFix(fs.fchmod)
+ fs.lchmod = chmodFix(fs.lchmod)
- const objType = typeof input;
- if (!(input !== null && (objType === 'object' || objType === 'function'))) {
- throw new TypeError(`Expected \`input\` to be a \`Function\` or \`Object\`, got \`${input === null ? 'null' : objType}\``);
- }
+ fs.chownSync = chownFixSync(fs.chownSync)
+ fs.fchownSync = chownFixSync(fs.fchownSync)
+ fs.lchownSync = chownFixSync(fs.lchownSync)
- const filter = key => {
- const match = pattern => typeof pattern === 'string' ? key === pattern : pattern.test(key);
- return options.include ? options.include.some(match) : !options.exclude.some(match);
- };
+ fs.chmodSync = chmodFixSync(fs.chmodSync)
+ fs.fchmodSync = chmodFixSync(fs.fchmodSync)
+ fs.lchmodSync = chmodFixSync(fs.lchmodSync)
- let ret;
- if (objType === 'function') {
- ret = function (...args) {
- return options.excludeMain ? input(...args) : processFn(input, options).apply(this, args);
- };
- } else {
- ret = Object.create(Object.getPrototypeOf(input));
- }
+ fs.stat = statFix(fs.stat)
+ fs.fstat = statFix(fs.fstat)
+ fs.lstat = statFix(fs.lstat)
- for (const key in input) { // eslint-disable-line guard-for-in
- const property = input[key];
- ret[key] = typeof property === 'function' && filter(key) ? processFn(property, options) : property;
- }
+ fs.statSync = statFixSync(fs.statSync)
+ fs.fstatSync = statFixSync(fs.fstatSync)
+ fs.lstatSync = statFixSync(fs.lstatSync)
- return ret;
-};
+ // if lchmod/lchown do not exist, then make them no-ops
+ if (!fs.lchmod) {
+ fs.lchmod = function (path, mode, cb) {
+ if (cb) process.nextTick(cb)
+ }
+ fs.lchmodSync = function () {}
+ }
+ if (!fs.lchown) {
+ fs.lchown = function (path, uid, gid, cb) {
+ if (cb) process.nextTick(cb)
+ }
+ fs.lchownSync = function () {}
+ }
+ // on Windows, A/V software can lock the directory, causing this
+ // to fail with an EACCES or EPERM if the directory contains newly
+ // created files. Try again on failure, for up to 60 seconds.
-/***/ }),
-/* 562 */
-/***/ (function(module, exports, __webpack_require__) {
+ // Set the timeout this long because some Windows Anti-Virus, such as Parity
+ // bit9, may lock files for up to a minute, causing npm package install
+ // failures. Also, take care to yield the scheduler. Windows scheduling gives
+ // CPU to a busy looping process, which can cause the program causing the lock
+ // contention to be starved of CPU by node, so the contention doesn't resolve.
+ if (platform === "win32") {
+ fs.rename = (function (fs$rename) { return function (from, to, cb) {
+ var start = Date.now()
+ var backoff = 0;
+ fs$rename(from, to, function CB (er) {
+ if (er
+ && (er.code === "EACCES" || er.code === "EPERM")
+ && Date.now() - start < 60000) {
+ setTimeout(function() {
+ fs.stat(to, function (stater, st) {
+ if (stater && stater.code === "ENOENT")
+ fs$rename(from, to, CB);
+ else
+ cb(er)
+ })
+ }, backoff)
+ if (backoff < 100)
+ backoff += 10;
+ return;
+ }
+ if (cb) cb(er)
+ })
+ }})(fs.rename)
+ }
-"use strict";
+ // if read() returns EAGAIN, then just try it again.
+ fs.read = (function (fs$read) { return function (fd, buffer, offset, length, position, callback_) {
+ var callback
+ if (callback_ && typeof callback_ === 'function') {
+ var eagCounter = 0
+ callback = function (er, _, __) {
+ if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+ eagCounter ++
+ return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+ }
+ callback_.apply(this, arguments)
+ }
+ }
+ return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+ }})(fs.read)
+ fs.readSync = (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+ var eagCounter = 0
+ while (true) {
+ try {
+ return fs$readSync.call(fs, fd, buffer, offset, length, position)
+ } catch (er) {
+ if (er.code === 'EAGAIN' && eagCounter < 10) {
+ eagCounter ++
+ continue
+ }
+ throw er
+ }
+ }
+ }})(fs.readSync)
+}
-// detect either spaces or tabs but not both to properly handle tabs
-// for indentation and spaces for alignment
-const INDENT_RE = /^(?:( )+|\t+)/;
+function patchLchmod (fs) {
+ fs.lchmod = function (path, mode, callback) {
+ fs.open( path
+ , constants.O_WRONLY | constants.O_SYMLINK
+ , mode
+ , function (err, fd) {
+ if (err) {
+ if (callback) callback(err)
+ return
+ }
+ // prefer to return the chmod error, if one occurs,
+ // but still try to close, and report closing errors if they occur.
+ fs.fchmod(fd, mode, function (err) {
+ fs.close(fd, function(err2) {
+ if (callback) callback(err || err2)
+ })
+ })
+ })
+ }
-function getMostUsed(indents) {
- let result = 0;
- let maxUsed = 0;
- let maxWeight = 0;
+ fs.lchmodSync = function (path, mode) {
+ var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
- for (const entry of indents) {
- // TODO: use destructuring when targeting Node.js 6
- const key = entry[0];
- const val = entry[1];
+ // prefer to return the chmod error, if one occurs,
+ // but still try to close, and report closing errors if they occur.
+ var threw = true
+ var ret
+ try {
+ ret = fs.fchmodSync(fd, mode)
+ threw = false
+ } finally {
+ if (threw) {
+ try {
+ fs.closeSync(fd)
+ } catch (er) {}
+ } else {
+ fs.closeSync(fd)
+ }
+ }
+ return ret
+ }
+}
- const u = val[0];
- const w = val[1];
+function patchLutimes (fs) {
+ if (constants.hasOwnProperty("O_SYMLINK")) {
+ fs.lutimes = function (path, at, mt, cb) {
+ fs.open(path, constants.O_SYMLINK, function (er, fd) {
+ if (er) {
+ if (cb) cb(er)
+ return
+ }
+ fs.futimes(fd, at, mt, function (er) {
+ fs.close(fd, function (er2) {
+ if (cb) cb(er || er2)
+ })
+ })
+ })
+ }
- if (u > maxUsed || (u === maxUsed && w > maxWeight)) {
- maxUsed = u;
- maxWeight = w;
- result = Number(key);
- }
- }
+ fs.lutimesSync = function (path, at, mt) {
+ var fd = fs.openSync(path, constants.O_SYMLINK)
+ var ret
+ var threw = true
+ try {
+ ret = fs.futimesSync(fd, at, mt)
+ threw = false
+ } finally {
+ if (threw) {
+ try {
+ fs.closeSync(fd)
+ } catch (er) {}
+ } else {
+ fs.closeSync(fd)
+ }
+ }
+ return ret
+ }
- return result;
+ } else {
+ fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
+ fs.lutimesSync = function () {}
+ }
}
-module.exports = str => {
- if (typeof str !== 'string') {
- throw new TypeError('Expected a string');
- }
+function chmodFix (orig) {
+ if (!orig) return orig
+ return function (target, mode, cb) {
+ return orig.call(fs, target, mode, function (er) {
+ if (chownErOk(er)) er = null
+ if (cb) cb.apply(this, arguments)
+ })
+ }
+}
- // used to see if tabs or spaces are the most used
- let tabs = 0;
- let spaces = 0;
+function chmodFixSync (orig) {
+ if (!orig) return orig
+ return function (target, mode) {
+ try {
+ return orig.call(fs, target, mode)
+ } catch (er) {
+ if (!chownErOk(er)) throw er
+ }
+ }
+}
- // remember the size of previous line's indentation
- let prev = 0;
- // remember how many indents/unindents as occurred for a given size
- // and how much lines follow a given indentation
- //
- // indents = {
- // 3: [1, 0],
- // 4: [1, 5],
- // 5: [1, 0],
- // 12: [1, 0],
- // }
- const indents = new Map();
+function chownFix (orig) {
+ if (!orig) return orig
+ return function (target, uid, gid, cb) {
+ return orig.call(fs, target, uid, gid, function (er) {
+ if (chownErOk(er)) er = null
+ if (cb) cb.apply(this, arguments)
+ })
+ }
+}
- // pointer to the array of last used indent
- let current;
+function chownFixSync (orig) {
+ if (!orig) return orig
+ return function (target, uid, gid) {
+ try {
+ return orig.call(fs, target, uid, gid)
+ } catch (er) {
+ if (!chownErOk(er)) throw er
+ }
+ }
+}
- // whether the last action was an indent (opposed to an unindent)
- let isIndent;
- for (const line of str.split(/\n/g)) {
- if (!line) {
- // ignore empty lines
- continue;
- }
+function statFix (orig) {
+ if (!orig) return orig
+ // Older versions of Node erroneously returned signed integers for
+ // uid + gid.
+ return function (target, cb) {
+ return orig.call(fs, target, function (er, stats) {
+ if (!stats) return cb.apply(this, arguments)
+ if (stats.uid < 0) stats.uid += 0x100000000
+ if (stats.gid < 0) stats.gid += 0x100000000
+ if (cb) cb.apply(this, arguments)
+ })
+ }
+}
- let indent;
- const matches = line.match(INDENT_RE);
+function statFixSync (orig) {
+ if (!orig) return orig
+ // Older versions of Node erroneously returned signed integers for
+ // uid + gid.
+ return function (target) {
+ var stats = orig.call(fs, target)
+ if (stats.uid < 0) stats.uid += 0x100000000
+ if (stats.gid < 0) stats.gid += 0x100000000
+ return stats;
+ }
+}
- if (matches) {
- indent = matches[0].length;
+// ENOSYS means that the fs doesn't support the op. Just ignore
+// that, because it doesn't matter.
+//
+// if there's no getuid, or if getuid() is something other
+// than 0, and the error is EINVAL or EPERM, then just ignore
+// it.
+//
+// This specific case is a silent failure in cp, install, tar,
+// and most other unix tools that manage permissions.
+//
+// When running as root, or if other types of errors are
+// encountered, then it's strict.
+function chownErOk (er) {
+ if (!er)
+ return true
- if (matches[1]) {
- spaces++;
- } else {
- tabs++;
- }
- } else {
- indent = 0;
- }
+ if (er.code === "ENOSYS")
+ return true
- const diff = indent - prev;
- prev = indent;
+ var nonroot = !process.getuid || process.getuid() !== 0
+ if (nonroot) {
+ if (er.code === "EINVAL" || er.code === "EPERM")
+ return true
+ }
- if (diff) {
- // an indent or unindent has been detected
+ return false
+}
- isIndent = diff > 0;
- current = indents.get(isIndent ? diff : -diff);
+/***/ }),
+/* 554 */
+/***/ (function(module, exports, __webpack_require__) {
- if (current) {
- current[0]++;
- } else {
- current = [1, 0];
- indents.set(diff, current);
- }
- } else if (current) {
- // if the last action was an indent, increment the weight
- current[1] += Number(isIndent);
- }
- }
+"use strict";
- const amount = getMostUsed(indents);
- let type;
- let indent;
- if (!amount) {
- type = null;
- indent = '';
- } else if (spaces >= tabs) {
- type = 'space';
- indent = ' '.repeat(amount);
- } else {
- type = 'tab';
- indent = '\t'.repeat(amount);
- }
+var fs = __webpack_require__(349)
- return {
- amount,
- type,
- indent
- };
-};
+module.exports = clone(fs)
+function clone (obj) {
+ if (obj === null || typeof obj !== 'object')
+ return obj
-/***/ }),
-/* 563 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ if (obj instanceof Object)
+ var copy = { __proto__: obj.__proto__ }
+ else
+ var copy = Object.create(null)
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "installInDir", function() { return installInDir; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "runScriptInPackage", function() { return runScriptInPackage; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "runScriptInPackageStreaming", function() { return runScriptInPackageStreaming; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "yarnWorkspacesInfo", function() { return yarnWorkspacesInfo; });
-/* harmony import */ var _child_process__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(564);
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
+ Object.getOwnPropertyNames(obj).forEach(function (key) {
+ Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
+ })
+ return copy
+}
-/**
- * Install all dependencies in the given directory
- */
-async function installInDir(directory, extraArgs = []) {
- const options = ['install', '--non-interactive', ...extraArgs]; // We pass the mutex flag to ensure only one instance of yarn runs at any
- // given time (e.g. to avoid conflicts).
- await Object(_child_process__WEBPACK_IMPORTED_MODULE_0__["spawn"])('yarn', options, {
- cwd: directory
- });
-}
-/**
- * Run script in the given directory
- */
+/***/ }),
+/* 555 */
+/***/ (function(module, exports, __webpack_require__) {
-async function runScriptInPackage(script, args, pkg) {
- const execOpts = {
- cwd: pkg.path
- };
- await Object(_child_process__WEBPACK_IMPORTED_MODULE_0__["spawn"])('yarn', ['run', script, ...args], execOpts);
-}
-/**
- * Run script in the given directory
- */
+var Stream = __webpack_require__(382).Stream
-function runScriptInPackageStreaming(script, args, pkg) {
- const execOpts = {
- cwd: pkg.path
- };
- return Object(_child_process__WEBPACK_IMPORTED_MODULE_0__["spawnStreaming"])('yarn', ['run', script, ...args], execOpts, {
- prefix: pkg.name
- });
-}
-async function yarnWorkspacesInfo(directory) {
- const {
- stdout
- } = await Object(_child_process__WEBPACK_IMPORTED_MODULE_0__["spawn"])('yarn', ['--json', 'workspaces', 'info'], {
- cwd: directory,
- stdio: 'pipe'
- });
+module.exports = legacy
- try {
- return JSON.parse(JSON.parse(stdout).data);
- } catch (error) {
- throw new Error(`'yarn workspaces info --json' produced unexpected output: \n${stdout}`);
+function legacy (fs) {
+ return {
+ ReadStream: ReadStream,
+ WriteStream: WriteStream
}
-}
-/***/ }),
-/* 564 */
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
+ function ReadStream (path, options) {
+ if (!(this instanceof ReadStream)) return new ReadStream(path, options);
-"use strict";
-__webpack_require__.r(__webpack_exports__);
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "spawn", function() { return spawn; });
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "spawnStreaming", function() { return spawnStreaming; });
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var execa__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(371);
-/* harmony import */ var execa__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(execa__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var log_symbols__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(565);
-/* harmony import */ var log_symbols__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(log_symbols__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var strong_log_transformer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(570);
-/* harmony import */ var strong_log_transformer__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(strong_log_transformer__WEBPACK_IMPORTED_MODULE_3__);
-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; }
+ Stream.call(this);
-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; }
+ var self = this;
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+ this.path = path;
+ this.fd = null;
+ this.readable = true;
+ this.paused = false;
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
+ this.flags = 'r';
+ this.mode = 438; /*=0666*/
+ this.bufferSize = 64 * 1024;
+ options = options || {};
+ // Mixin options into this
+ var keys = Object.keys(options);
+ for (var index = 0, length = keys.length; index < length; index++) {
+ var key = keys[index];
+ this[key] = options[key];
+ }
+ if (this.encoding) this.setEncoding(this.encoding);
+ if (this.start !== undefined) {
+ if ('number' !== typeof this.start) {
+ throw TypeError('start must be a Number');
+ }
+ if (this.end === undefined) {
+ this.end = Infinity;
+ } else if ('number' !== typeof this.end) {
+ throw TypeError('end must be a Number');
+ }
-function generateColors() {
- const colorWheel = [chalk__WEBPACK_IMPORTED_MODULE_0___default.a.cyan, chalk__WEBPACK_IMPORTED_MODULE_0___default.a.magenta, chalk__WEBPACK_IMPORTED_MODULE_0___default.a.blue, chalk__WEBPACK_IMPORTED_MODULE_0___default.a.yellow, chalk__WEBPACK_IMPORTED_MODULE_0___default.a.green];
- const count = colorWheel.length;
- let children = 0;
- return () => colorWheel[children++ % count];
-}
+ if (this.start > this.end) {
+ throw new Error('start must be <= end');
+ }
-function spawn(command, args, opts) {
- return execa__WEBPACK_IMPORTED_MODULE_1___default()(command, args, _objectSpread({
- stdio: 'inherit',
- preferLocal: true
- }, opts));
-}
-const nextColor = generateColors();
-function spawnStreaming(command, args, opts, {
- prefix
-}) {
- const spawned = execa__WEBPACK_IMPORTED_MODULE_1___default()(command, args, _objectSpread({
- stdio: ['ignore', 'pipe', 'pipe'],
- preferLocal: true
- }, opts));
- const color = nextColor();
- const prefixedStdout = strong_log_transformer__WEBPACK_IMPORTED_MODULE_3___default()({
- tag: `${color.bold(prefix)}:`
- });
- const prefixedStderr = strong_log_transformer__WEBPACK_IMPORTED_MODULE_3___default()({
- mergeMultiline: true,
- tag: `${log_symbols__WEBPACK_IMPORTED_MODULE_2___default.a.error} ${color.bold(prefix)}:`
- });
- spawned.stdout.pipe(prefixedStdout).pipe(process.stdout);
- spawned.stderr.pipe(prefixedStderr).pipe(process.stderr);
- return spawned;
-}
+ this.pos = this.start;
+ }
-/***/ }),
-/* 565 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (this.fd !== null) {
+ process.nextTick(function() {
+ self._read();
+ });
+ return;
+ }
-"use strict";
+ fs.open(this.path, this.flags, this.mode, function (err, fd) {
+ if (err) {
+ self.emit('error', err);
+ self.readable = false;
+ return;
+ }
-const chalk = __webpack_require__(566);
+ self.fd = fd;
+ self.emit('open', fd);
+ self._read();
+ })
+ }
-const isSupported = process.platform !== 'win32' || process.env.CI || process.env.TERM === 'xterm-256color';
+ function WriteStream (path, options) {
+ if (!(this instanceof WriteStream)) return new WriteStream(path, options);
-const main = {
- info: chalk.blue('ℹ'),
- success: chalk.green('✔'),
- warning: chalk.yellow('⚠'),
- error: chalk.red('✖')
-};
+ Stream.call(this);
-const fallbacks = {
- info: chalk.blue('i'),
- success: chalk.green('√'),
- warning: chalk.yellow('‼'),
- error: chalk.red('×')
-};
+ this.path = path;
+ this.fd = null;
+ this.writable = true;
-module.exports = isSupported ? main : fallbacks;
+ this.flags = 'w';
+ this.encoding = 'binary';
+ this.mode = 438; /*=0666*/
+ this.bytesWritten = 0;
+ options = options || {};
-/***/ }),
-/* 566 */
-/***/ (function(module, exports, __webpack_require__) {
+ // Mixin options into this
+ var keys = Object.keys(options);
+ for (var index = 0, length = keys.length; index < length; index++) {
+ var key = keys[index];
+ this[key] = options[key];
+ }
-"use strict";
+ if (this.start !== undefined) {
+ if ('number' !== typeof this.start) {
+ throw TypeError('start must be a Number');
+ }
+ if (this.start < 0) {
+ throw new Error('start must be >= zero');
+ }
-const escapeStringRegexp = __webpack_require__(3);
-const ansiStyles = __webpack_require__(567);
-const stdoutColor = __webpack_require__(568).stdout;
+ this.pos = this.start;
+ }
-const template = __webpack_require__(569);
+ this.busy = false;
+ this._queue = [];
-const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
+ if (this.fd === null) {
+ this._open = fs.open;
+ this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+ this.flush();
+ }
+ }
+}
-// `supportsColor.level` → `ansiStyles.color[name]` mapping
-const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
-// `color-convert` models to exclude from the Chalk API due to conflicts and such
-const skipModels = new Set(['gray']);
+/***/ }),
+/* 556 */
+/***/ (function(module, exports, __webpack_require__) {
-const styles = Object.create(null);
+/**
+ * @preserve
+ * JS Implementation of incremental MurmurHash3 (r150) (as of May 10, 2013)
+ *
+ * @author Jens Taylor
+ * @see http://github.com/homebrewing/brauhaus-diff
+ * @author Gary Court
+ * @see http://github.com/garycourt/murmurhash-js
+ * @author Austin Appleby
+ * @see http://sites.google.com/site/murmurhash/
+ */
+(function(){
+ var cache;
-function applyOptions(obj, options) {
- options = options || {};
+ // Call this function without `new` to use the cached object (good for
+ // single-threaded environments), or with `new` to create a new object.
+ //
+ // @param {string} key A UTF-16 or ASCII string
+ // @param {number} seed An optional positive integer
+ // @return {object} A MurmurHash3 object for incremental hashing
+ function MurmurHash3(key, seed) {
+ var m = this instanceof MurmurHash3 ? this : cache;
+ m.reset(seed)
+ if (typeof key === 'string' && key.length > 0) {
+ m.hash(key);
+ }
- // Detect level if not set manually
- const scLevel = stdoutColor ? stdoutColor.level : 0;
- obj.level = options.level === undefined ? scLevel : options.level;
- obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
-}
+ if (m !== this) {
+ return m;
+ }
+ };
-function Chalk(options) {
- // We check for this.template here since calling `chalk.constructor()`
- // by itself will have a `this` of a previously constructed chalk object
- if (!this || !(this instanceof Chalk) || this.template) {
- const chalk = {};
- applyOptions(chalk, options);
+ // Incrementally add a string to this hash
+ //
+ // @param {string} key A UTF-16 or ASCII string
+ // @return {object} this
+ MurmurHash3.prototype.hash = function(key) {
+ var h1, k1, i, top, len;
- chalk.template = function () {
- const args = [].slice.call(arguments);
- return chalkTag.apply(null, [chalk.template].concat(args));
- };
+ len = key.length;
+ this.len += len;
- Object.setPrototypeOf(chalk, Chalk.prototype);
- Object.setPrototypeOf(chalk.template, chalk);
+ k1 = this.k1;
+ i = 0;
+ switch (this.rem) {
+ case 0: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) : 0;
+ case 1: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 8 : 0;
+ case 2: k1 ^= len > i ? (key.charCodeAt(i++) & 0xffff) << 16 : 0;
+ case 3:
+ k1 ^= len > i ? (key.charCodeAt(i) & 0xff) << 24 : 0;
+ k1 ^= len > i ? (key.charCodeAt(i++) & 0xff00) >> 8 : 0;
+ }
- chalk.template.constructor = Chalk;
+ this.rem = (len + this.rem) & 3; // & 3 is same as % 4
+ len -= this.rem;
+ if (len > 0) {
+ h1 = this.h1;
+ while (1) {
+ k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff;
+ k1 = (k1 << 15) | (k1 >>> 17);
+ k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff;
- return chalk.template;
- }
+ h1 ^= k1;
+ h1 = (h1 << 13) | (h1 >>> 19);
+ h1 = (h1 * 5 + 0xe6546b64) & 0xffffffff;
- applyOptions(this, options);
-}
+ if (i >= len) {
+ break;
+ }
-// Use bright blue on Windows as the normal blue color is illegible
-if (isSimpleWindowsTerm) {
- ansiStyles.blue.open = '\u001B[94m';
-}
+ k1 = ((key.charCodeAt(i++) & 0xffff)) ^
+ ((key.charCodeAt(i++) & 0xffff) << 8) ^
+ ((key.charCodeAt(i++) & 0xffff) << 16);
+ top = key.charCodeAt(i++);
+ k1 ^= ((top & 0xff) << 24) ^
+ ((top & 0xff00) >> 8);
+ }
-for (const key of Object.keys(ansiStyles)) {
- ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
+ k1 = 0;
+ switch (this.rem) {
+ case 3: k1 ^= (key.charCodeAt(i + 2) & 0xffff) << 16;
+ case 2: k1 ^= (key.charCodeAt(i + 1) & 0xffff) << 8;
+ case 1: k1 ^= (key.charCodeAt(i) & 0xffff);
+ }
- styles[key] = {
- get() {
- const codes = ansiStyles[key];
- return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
- }
- };
-}
+ this.h1 = h1;
+ }
-styles.visible = {
- get() {
- return build.call(this, this._styles || [], true, 'visible');
- }
-};
+ this.k1 = k1;
+ return this;
+ };
-ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
-for (const model of Object.keys(ansiStyles.color.ansi)) {
- if (skipModels.has(model)) {
- continue;
- }
+ // Get the result of this hash
+ //
+ // @return {number} The 32-bit hash
+ MurmurHash3.prototype.result = function() {
+ var k1, h1;
+
+ k1 = this.k1;
+ h1 = this.h1;
- styles[model] = {
- get() {
- const level = this.level;
- return function () {
- const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
- const codes = {
- open,
- close: ansiStyles.color.close,
- closeRe: ansiStyles.color.closeRe
- };
- return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
- };
- }
- };
-}
+ if (k1 > 0) {
+ k1 = (k1 * 0x2d51 + (k1 & 0xffff) * 0xcc9e0000) & 0xffffffff;
+ k1 = (k1 << 15) | (k1 >>> 17);
+ k1 = (k1 * 0x3593 + (k1 & 0xffff) * 0x1b870000) & 0xffffffff;
+ h1 ^= k1;
+ }
-ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
-for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
- if (skipModels.has(model)) {
- continue;
- }
+ h1 ^= this.len;
+
+ h1 ^= h1 >>> 16;
+ h1 = (h1 * 0xca6b + (h1 & 0xffff) * 0x85eb0000) & 0xffffffff;
+ h1 ^= h1 >>> 13;
+ h1 = (h1 * 0xae35 + (h1 & 0xffff) * 0xc2b20000) & 0xffffffff;
+ h1 ^= h1 >>> 16;
- const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
- styles[bgModel] = {
- get() {
- const level = this.level;
- return function () {
- const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
- const codes = {
- open,
- close: ansiStyles.bgColor.close,
- closeRe: ansiStyles.bgColor.closeRe
- };
- return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
- };
- }
- };
-}
+ return h1 >>> 0;
+ };
-const proto = Object.defineProperties(() => {}, styles);
+ // Reset the hash object for reuse
+ //
+ // @param {number} seed An optional positive integer
+ MurmurHash3.prototype.reset = function(seed) {
+ this.h1 = typeof seed === 'number' ? seed : 0;
+ this.rem = this.k1 = this.len = 0;
+ return this;
+ };
-function build(_styles, _empty, key) {
- const builder = function () {
- return applyStyle.apply(builder, arguments);
- };
+ // A cached object to use. This can be safely used if you're in a single-
+ // threaded environment, otherwise you need to create new hashes to use.
+ cache = new MurmurHash3();
- builder._styles = _styles;
- builder._empty = _empty;
+ if (true) {
+ module.exports = MurmurHash3;
+ } else {}
+}());
- const self = this;
- Object.defineProperty(builder, 'level', {
- enumerable: true,
- get() {
- return self.level;
- },
- set(level) {
- self.level = level;
- }
- });
+/***/ }),
+/* 557 */
+/***/ (function(module, exports) {
- Object.defineProperty(builder, 'enabled', {
- enumerable: true,
- get() {
- return self.enabled;
- },
- set(enabled) {
- self.enabled = enabled;
- }
- });
+module.exports = require(undefined);
- // See below for fix regarding invisible grey/dim combination on Windows
- builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
+/***/ }),
+/* 558 */
+/***/ (function(module, exports, __webpack_require__) {
- // `__proto__` is used because we must return a function, but there is
- // no way to create a function with a different prototype
- builder.__proto__ = proto; // eslint-disable-line no-proto
+"use strict";
- return builder;
-}
+const isPlainObj = __webpack_require__(559);
-function applyStyle() {
- // Support varags, but simply cast to string in case there's only one arg
- const args = arguments;
- const argsLen = args.length;
- let str = String(arguments[0]);
+module.exports = (obj, opts) => {
+ if (!isPlainObj(obj)) {
+ throw new TypeError('Expected a plain object');
+ }
- if (argsLen === 0) {
- return '';
+ opts = opts || {};
+
+ // DEPRECATED
+ if (typeof opts === 'function') {
+ throw new TypeError('Specify the compare function as an option instead');
}
- if (argsLen > 1) {
- // Don't slice `arguments`, it prevents V8 optimizations
- for (let a = 1; a < argsLen; a++) {
- str += ' ' + args[a];
+ const deep = opts.deep;
+ const seenInput = [];
+ const seenOutput = [];
+
+ const sortKeys = x => {
+ const seenIndex = seenInput.indexOf(x);
+
+ if (seenIndex !== -1) {
+ return seenOutput[seenIndex];
}
- }
- if (!this.enabled || this.level <= 0 || !str) {
- return this._empty ? '' : str;
- }
+ const ret = {};
+ const keys = Object.keys(x).sort(opts.compare);
- // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
- // see https://github.com/chalk/chalk/issues/58
- // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
- const originalDim = ansiStyles.dim.open;
- if (isSimpleWindowsTerm && this.hasGrey) {
- ansiStyles.dim.open = '';
- }
+ seenInput.push(x);
+ seenOutput.push(ret);
- for (const code of this._styles.slice().reverse()) {
- // Replace any instances already present with a re-opening code
- // otherwise only the part of the string until said closing code
- // will be colored, and the rest will simply be 'plain'.
- str = code.open + str.replace(code.closeRe, code.open) + code.close;
+ for (let i = 0; i < keys.length; i++) {
+ const key = keys[i];
+ const val = x[key];
- // Close the styling before a linebreak and reopen
- // after next line to fix a bleed issue on macOS
- // https://github.com/chalk/chalk/pull/92
- str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
- }
+ if (deep && Array.isArray(val)) {
+ const retArr = [];
- // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
- ansiStyles.dim.open = originalDim;
+ for (let j = 0; j < val.length; j++) {
+ retArr[j] = isPlainObj(val[j]) ? sortKeys(val[j]) : val[j];
+ }
- return str;
-}
+ ret[key] = retArr;
+ continue;
+ }
-function chalkTag(chalk, strings) {
- if (!Array.isArray(strings)) {
- // If chalk() was called by itself or with a string,
- // return the string itself as a string.
- return [].slice.call(arguments, 1).join(' ');
- }
+ ret[key] = deep && isPlainObj(val) ? sortKeys(val) : val;
+ }
- const args = [].slice.call(arguments, 2);
- const parts = [strings.raw[0]];
+ return ret;
+ };
- for (let i = 1; i < strings.length; i++) {
- parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
- parts.push(String(strings.raw[i]));
- }
+ return sortKeys(obj);
+};
- return template(chalk, parts.join(''));
-}
-Object.defineProperties(Chalk.prototype, styles);
+/***/ }),
+/* 559 */
+/***/ (function(module, exports, __webpack_require__) {
-module.exports = Chalk(); // eslint-disable-line new-cap
-module.exports.supportsColor = stdoutColor;
-module.exports.default = module.exports; // For TypeScript
+"use strict";
+
+var toString = Object.prototype.toString;
+
+module.exports = function (x) {
+ var prototype;
+ return toString.call(x) === '[object Object]' && (prototype = Object.getPrototypeOf(x), prototype === null || prototype === Object.getPrototypeOf({}));
+};
/***/ }),
-/* 567 */
+/* 560 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-/* WEBPACK VAR INJECTION */(function(module) {
-const colorConvert = __webpack_require__(6);
-const wrapAnsi16 = (fn, offset) => function () {
- const code = fn.apply(colorConvert, arguments);
- return `\u001B[${code + offset}m`;
+const fs = __webpack_require__(349);
+const path = __webpack_require__(4);
+const pify = __webpack_require__(561);
+const semver = __webpack_require__(523);
+
+const defaults = {
+ mode: 0o777 & (~process.umask()),
+ fs
};
-const wrapAnsi256 = (fn, offset) => function () {
- const code = fn.apply(colorConvert, arguments);
- return `\u001B[${38 + offset};5;${code}m`;
+const useNativeRecursiveOption = semver.satisfies(process.version, '>=10.12.0');
+
+// https://github.com/nodejs/node/issues/8987
+// https://github.com/libuv/libuv/pull/1088
+const checkPath = pth => {
+ if (process.platform === 'win32') {
+ const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, ''));
+
+ if (pathHasInvalidWinCharacters) {
+ const error = new Error(`Path contains invalid characters: ${pth}`);
+ error.code = 'EINVAL';
+ throw error;
+ }
+ }
};
-const wrapAnsi16m = (fn, offset) => function () {
- const rgb = fn.apply(colorConvert, arguments);
- return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+const permissionError = pth => {
+ // This replicates the exception of `fs.mkdir` with native the
+ // `recusive` option when run on an invalid drive under Windows.
+ const error = new Error(`operation not permitted, mkdir '${pth}'`);
+ error.code = 'EPERM';
+ error.errno = -4048;
+ error.path = pth;
+ error.syscall = 'mkdir';
+ return error;
};
-function assembleStyles() {
- const codes = new Map();
- const styles = {
- modifier: {
- reset: [0, 0],
- // 21 isn't widely supported and 22 does the same thing
- bold: [1, 22],
- dim: [2, 22],
- italic: [3, 23],
- underline: [4, 24],
- inverse: [7, 27],
- hidden: [8, 28],
- strikethrough: [9, 29]
- },
- color: {
- black: [30, 39],
- red: [31, 39],
- green: [32, 39],
- yellow: [33, 39],
- blue: [34, 39],
- magenta: [35, 39],
- cyan: [36, 39],
- white: [37, 39],
- gray: [90, 39],
+const makeDir = (input, options) => Promise.resolve().then(() => {
+ checkPath(input);
+ options = Object.assign({}, defaults, options);
- // Bright color
- redBright: [91, 39],
- greenBright: [92, 39],
- yellowBright: [93, 39],
- blueBright: [94, 39],
- magentaBright: [95, 39],
- cyanBright: [96, 39],
- whiteBright: [97, 39]
- },
- bgColor: {
- bgBlack: [40, 49],
- bgRed: [41, 49],
- bgGreen: [42, 49],
- bgYellow: [43, 49],
- bgBlue: [44, 49],
- bgMagenta: [45, 49],
- bgCyan: [46, 49],
- bgWhite: [47, 49],
+ // TODO: Use util.promisify when targeting Node.js 8
+ const mkdir = pify(options.fs.mkdir);
+ const stat = pify(options.fs.stat);
- // Bright color
- bgBlackBright: [100, 49],
- bgRedBright: [101, 49],
- bgGreenBright: [102, 49],
- bgYellowBright: [103, 49],
- bgBlueBright: [104, 49],
- bgMagentaBright: [105, 49],
- bgCyanBright: [106, 49],
- bgWhiteBright: [107, 49]
- }
- };
+ if (useNativeRecursiveOption && options.fs.mkdir === fs.mkdir) {
+ const pth = path.resolve(input);
- // Fix humans
- styles.color.grey = styles.color.gray;
+ return mkdir(pth, {
+ mode: options.mode,
+ recursive: true
+ }).then(() => pth);
+ }
- for (const groupName of Object.keys(styles)) {
- const group = styles[groupName];
+ const make = pth => {
+ return mkdir(pth, options.mode)
+ .then(() => pth)
+ .catch(error => {
+ if (error.code === 'EPERM') {
+ throw error;
+ }
- for (const styleName of Object.keys(group)) {
- const style = group[styleName];
+ if (error.code === 'ENOENT') {
+ if (path.dirname(pth) === pth) {
+ throw permissionError(pth);
+ }
- styles[styleName] = {
- open: `\u001B[${style[0]}m`,
- close: `\u001B[${style[1]}m`
- };
+ if (error.message.includes('null bytes')) {
+ throw error;
+ }
- group[styleName] = styles[styleName];
+ return make(path.dirname(pth)).then(() => make(pth));
+ }
- codes.set(style[0], style[1]);
- }
+ return stat(pth)
+ .then(stats => stats.isDirectory() ? pth : Promise.reject())
+ .catch(() => {
+ throw error;
+ });
+ });
+ };
- Object.defineProperty(styles, groupName, {
- value: group,
- enumerable: false
- });
+ return make(path.resolve(input));
+});
- Object.defineProperty(styles, 'codes', {
- value: codes,
- enumerable: false
+module.exports = makeDir;
+module.exports.default = makeDir;
+
+module.exports.sync = (input, options) => {
+ checkPath(input);
+ options = Object.assign({}, defaults, options);
+
+ if (useNativeRecursiveOption && options.fs.mkdirSync === fs.mkdirSync) {
+ const pth = path.resolve(input);
+
+ fs.mkdirSync(pth, {
+ mode: options.mode,
+ recursive: true
});
+
+ return pth;
}
- const ansi2ansi = n => n;
- const rgb2rgb = (r, g, b) => [r, g, b];
+ const make = pth => {
+ try {
+ options.fs.mkdirSync(pth, options.mode);
+ } catch (error) {
+ if (error.code === 'EPERM') {
+ throw error;
+ }
- styles.color.close = '\u001B[39m';
- styles.bgColor.close = '\u001B[49m';
+ if (error.code === 'ENOENT') {
+ if (path.dirname(pth) === pth) {
+ throw permissionError(pth);
+ }
- styles.color.ansi = {
- ansi: wrapAnsi16(ansi2ansi, 0)
- };
- styles.color.ansi256 = {
- ansi256: wrapAnsi256(ansi2ansi, 0)
- };
- styles.color.ansi16m = {
- rgb: wrapAnsi16m(rgb2rgb, 0)
- };
+ if (error.message.includes('null bytes')) {
+ throw error;
+ }
- styles.bgColor.ansi = {
- ansi: wrapAnsi16(ansi2ansi, 10)
- };
- styles.bgColor.ansi256 = {
- ansi256: wrapAnsi256(ansi2ansi, 10)
- };
- styles.bgColor.ansi16m = {
- rgb: wrapAnsi16m(rgb2rgb, 10)
- };
+ make(path.dirname(pth));
+ return make(pth);
+ }
- for (let key of Object.keys(colorConvert)) {
- if (typeof colorConvert[key] !== 'object') {
- continue;
+ try {
+ if (!options.fs.statSync(pth).isDirectory()) {
+ throw new Error('The path is not a directory');
+ }
+ } catch (_) {
+ throw error;
+ }
}
- const suite = colorConvert[key];
+ return pth;
+ };
- if (key === 'ansi16') {
- key = 'ansi';
- }
+ return make(path.resolve(input));
+};
- if ('ansi16' in suite) {
- styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
- styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
- }
- if ('ansi256' in suite) {
- styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
- styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
- }
+/***/ }),
+/* 561 */
+/***/ (function(module, exports, __webpack_require__) {
- if ('rgb' in suite) {
- styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
- styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+"use strict";
+
+
+const processFn = (fn, options) => function (...args) {
+ const P = options.promiseModule;
+
+ return new P((resolve, reject) => {
+ if (options.multiArgs) {
+ args.push((...result) => {
+ if (options.errorFirst) {
+ if (result[0]) {
+ reject(result);
+ } else {
+ result.shift();
+ resolve(result);
+ }
+ } else {
+ resolve(result);
+ }
+ });
+ } else if (options.errorFirst) {
+ args.push((error, result) => {
+ if (error) {
+ reject(error);
+ } else {
+ resolve(result);
+ }
+ });
+ } else {
+ args.push(resolve);
}
+
+ fn.apply(this, args);
+ });
+};
+
+module.exports = (input, options) => {
+ options = Object.assign({
+ exclude: [/.+(Sync|Stream)$/],
+ errorFirst: true,
+ promiseModule: Promise
+ }, options);
+
+ const objType = typeof input;
+ if (!(input !== null && (objType === 'object' || objType === 'function'))) {
+ throw new TypeError(`Expected \`input\` to be a \`Function\` or \`Object\`, got \`${input === null ? 'null' : objType}\``);
}
- return styles;
-}
+ const filter = key => {
+ const match = pattern => typeof pattern === 'string' ? key === pattern : pattern.test(key);
+ return options.include ? options.include.some(match) : !options.exclude.some(match);
+ };
-// Make the export immutable
-Object.defineProperty(module, 'exports', {
- enumerable: true,
- get: assembleStyles
-});
+ let ret;
+ if (objType === 'function') {
+ ret = function (...args) {
+ return options.excludeMain ? input(...args) : processFn(input, options).apply(this, args);
+ };
+ } else {
+ ret = Object.create(Object.getPrototypeOf(input));
+ }
+
+ for (const key in input) { // eslint-disable-line guard-for-in
+ const property = input[key];
+ ret[key] = typeof property === 'function' && filter(key) ? processFn(property, options) : property;
+ }
+
+ return ret;
+};
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(5)(module)))
/***/ }),
-/* 568 */
+/* 562 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const os = __webpack_require__(11);
-const hasFlag = __webpack_require__(12);
-const env = process.env;
+// detect either spaces or tabs but not both to properly handle tabs
+// for indentation and spaces for alignment
+const INDENT_RE = /^(?:( )+|\t+)/;
-let forceColor;
-if (hasFlag('no-color') ||
- hasFlag('no-colors') ||
- hasFlag('color=false')) {
- forceColor = false;
-} else if (hasFlag('color') ||
- hasFlag('colors') ||
- hasFlag('color=true') ||
- hasFlag('color=always')) {
- forceColor = true;
-}
-if ('FORCE_COLOR' in env) {
- forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
-}
+function getMostUsed(indents) {
+ let result = 0;
+ let maxUsed = 0;
+ let maxWeight = 0;
-function translateLevel(level) {
- if (level === 0) {
- return false;
+ for (const entry of indents) {
+ // TODO: use destructuring when targeting Node.js 6
+ const key = entry[0];
+ const val = entry[1];
+
+ const u = val[0];
+ const w = val[1];
+
+ if (u > maxUsed || (u === maxUsed && w > maxWeight)) {
+ maxUsed = u;
+ maxWeight = w;
+ result = Number(key);
+ }
}
- return {
- level,
- hasBasic: true,
- has256: level >= 2,
- has16m: level >= 3
- };
+ return result;
}
-function supportsColor(stream) {
- if (forceColor === false) {
- return 0;
+module.exports = str => {
+ if (typeof str !== 'string') {
+ throw new TypeError('Expected a string');
}
- if (hasFlag('color=16m') ||
- hasFlag('color=full') ||
- hasFlag('color=truecolor')) {
- return 3;
- }
+ // used to see if tabs or spaces are the most used
+ let tabs = 0;
+ let spaces = 0;
- if (hasFlag('color=256')) {
- return 2;
- }
+ // remember the size of previous line's indentation
+ let prev = 0;
- if (stream && !stream.isTTY && forceColor !== true) {
- // VS code debugger doesn't have isTTY set
- if (env.VSCODE_PID) {
- return 1;
- }
- return 0;
- }
+ // remember how many indents/unindents as occurred for a given size
+ // and how much lines follow a given indentation
+ //
+ // indents = {
+ // 3: [1, 0],
+ // 4: [1, 5],
+ // 5: [1, 0],
+ // 12: [1, 0],
+ // }
+ const indents = new Map();
- const min = forceColor ? 1 : 0;
+ // pointer to the array of last used indent
+ let current;
- if (process.platform === 'win32') {
- // Node.js 7.5.0 is the first version of Node.js to include a patch to
- // libuv that enables 256 color output on Windows. Anything earlier and it
- // won't work. However, here we target Node.js 8 at minimum as it is an LTS
- // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
- // release that supports 256 colors. Windows 10 build 14931 is the first release
- // that supports 16m/TrueColor.
- const osRelease = os.release().split('.');
- if (
- Number(process.versions.node.split('.')[0]) >= 8 &&
- Number(osRelease[0]) >= 10 &&
- Number(osRelease[2]) >= 10586
- ) {
- return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ // whether the last action was an indent (opposed to an unindent)
+ let isIndent;
+
+ for (const line of str.split(/\n/g)) {
+ if (!line) {
+ // ignore empty lines
+ continue;
}
- return 1;
- }
+ let indent;
+ const matches = line.match(INDENT_RE);
- if ('CI' in env) {
- if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
- return 1;
+ if (matches) {
+ indent = matches[0].length;
+
+ if (matches[1]) {
+ spaces++;
+ } else {
+ tabs++;
+ }
+ } else {
+ indent = 0;
}
- return min;
- }
+ const diff = indent - prev;
+ prev = indent;
- if ('TEAMCITY_VERSION' in env) {
- return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
- }
+ if (diff) {
+ // an indent or unindent has been detected
- if (env.COLORTERM === 'truecolor') {
- return 3;
- }
+ isIndent = diff > 0;
- if ('TERM_PROGRAM' in env) {
- const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+ current = indents.get(isIndent ? diff : -diff);
- switch (env.TERM_PROGRAM) {
- case 'iTerm.app':
- return version >= 3 ? 3 : 2;
- case 'Apple_Terminal':
- return 2;
- // No default
+ if (current) {
+ current[0]++;
+ } else {
+ current = [1, 0];
+ indents.set(diff, current);
+ }
+ } else if (current) {
+ // if the last action was an indent, increment the weight
+ current[1] += Number(isIndent);
}
}
- if (/-256(color)?$/i.test(env.TERM)) {
- return 2;
- }
-
- if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
- return 1;
- }
-
- if ('COLORTERM' in env) {
- return 1;
- }
+ const amount = getMostUsed(indents);
- if (env.TERM === 'dumb') {
- return min;
+ let type;
+ let indent;
+ if (!amount) {
+ type = null;
+ indent = '';
+ } else if (spaces >= tabs) {
+ type = 'space';
+ indent = ' '.repeat(amount);
+ } else {
+ type = 'tab';
+ indent = '\t'.repeat(amount);
}
- return min;
-}
-
-function getSupportLevel(stream) {
- const level = supportsColor(stream);
- return translateLevel(level);
-}
-
-module.exports = {
- supportsColor: getSupportLevel,
- stdout: getSupportLevel(process.stdout),
- stderr: getSupportLevel(process.stderr)
+ return {
+ amount,
+ type,
+ indent
+ };
};
/***/ }),
-/* 569 */
-/***/ (function(module, exports, __webpack_require__) {
+/* 563 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "installInDir", function() { return installInDir; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "runScriptInPackage", function() { return runScriptInPackage; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "runScriptInPackageStreaming", function() { return runScriptInPackageStreaming; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "yarnWorkspacesInfo", function() { return yarnWorkspacesInfo; });
+/* harmony import */ var _child_process__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(564);
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
-const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
-const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
-const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
-const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
-
-const ESCAPES = new Map([
- ['n', '\n'],
- ['r', '\r'],
- ['t', '\t'],
- ['b', '\b'],
- ['f', '\f'],
- ['v', '\v'],
- ['0', '\0'],
- ['\\', '\\'],
- ['e', '\u001B'],
- ['a', '\u0007']
-]);
-function unescape(c) {
- if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
- return String.fromCharCode(parseInt(c.slice(1), 16));
- }
+/**
+ * Install all dependencies in the given directory
+ */
+async function installInDir(directory, extraArgs = []) {
+ const options = ['install', '--non-interactive', ...extraArgs]; // We pass the mutex flag to ensure only one instance of yarn runs at any
+ // given time (e.g. to avoid conflicts).
- return ESCAPES.get(c) || c;
+ await Object(_child_process__WEBPACK_IMPORTED_MODULE_0__["spawn"])('yarn', options, {
+ cwd: directory
+ });
}
+/**
+ * Run script in the given directory
+ */
-function parseArguments(name, args) {
- const results = [];
- const chunks = args.trim().split(/\s*,\s*/g);
- let matches;
+async function runScriptInPackage(script, args, pkg) {
+ const execOpts = {
+ cwd: pkg.path
+ };
+ await Object(_child_process__WEBPACK_IMPORTED_MODULE_0__["spawn"])('yarn', ['run', script, ...args], execOpts);
+}
+/**
+ * Run script in the given directory
+ */
- for (const chunk of chunks) {
- if (!isNaN(chunk)) {
- results.push(Number(chunk));
- } else if ((matches = chunk.match(STRING_REGEX))) {
- results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
- } else {
- throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
- }
- }
+function runScriptInPackageStreaming({
+ script,
+ args,
+ pkg,
+ debug
+}) {
+ const execOpts = {
+ cwd: pkg.path
+ };
+ return Object(_child_process__WEBPACK_IMPORTED_MODULE_0__["spawnStreaming"])('yarn', ['run', script, ...args], execOpts, {
+ prefix: pkg.name,
+ debug
+ });
+}
+async function yarnWorkspacesInfo(directory) {
+ const {
+ stdout
+ } = await Object(_child_process__WEBPACK_IMPORTED_MODULE_0__["spawn"])('yarn', ['--json', 'workspaces', 'info'], {
+ cwd: directory,
+ stdio: 'pipe'
+ });
- return results;
+ try {
+ return JSON.parse(JSON.parse(stdout).data);
+ } catch (error) {
+ throw new Error(`'yarn workspaces info --json' produced unexpected output: \n${stdout}`);
+ }
}
-function parseStyle(style) {
- STYLE_REGEX.lastIndex = 0;
+/***/ }),
+/* 564 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
- const results = [];
- let matches;
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "spawn", function() { return spawn; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "spawnStreaming", function() { return spawnStreaming; });
+/* harmony import */ var stream__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(382);
+/* harmony import */ var stream__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(stream__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(386);
+/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var execa__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(342);
+/* harmony import */ var execa__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(execa__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var strong_log_transformer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(565);
+/* harmony import */ var strong_log_transformer__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(strong_log_transformer__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _log__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(500);
+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; }
- while ((matches = STYLE_REGEX.exec(style)) !== null) {
- const name = matches[1];
+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; }
- if (matches[2]) {
- const args = parseArguments(name, matches[2]);
- results.push([name].concat(args));
- } else {
- results.push([name]);
- }
- }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
- return results;
-}
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
-function buildStyle(chalk, styles) {
- const enabled = {};
- for (const layer of styles) {
- for (const style of layer.styles) {
- enabled[style[0]] = layer.inverse ? null : style.slice(1);
- }
- }
- let current = chalk;
- for (const styleName of Object.keys(enabled)) {
- if (Array.isArray(enabled[styleName])) {
- if (!(styleName in current)) {
- throw new Error(`Unknown Chalk style: ${styleName}`);
- }
- if (enabled[styleName].length > 0) {
- current = current[styleName].apply(current, enabled[styleName]);
- } else {
- current = current[styleName];
- }
- }
- }
- return current;
-}
+const colorWheel = [chalk__WEBPACK_IMPORTED_MODULE_1___default.a.cyan, chalk__WEBPACK_IMPORTED_MODULE_1___default.a.magenta, chalk__WEBPACK_IMPORTED_MODULE_1___default.a.blue, chalk__WEBPACK_IMPORTED_MODULE_1___default.a.yellow, chalk__WEBPACK_IMPORTED_MODULE_1___default.a.green];
-module.exports = (chalk, tmp) => {
- const styles = [];
- const chunks = [];
- let chunk = [];
+const getColor = () => {
+ const color = colorWheel.shift();
+ colorWheel.push(color);
+ return color;
+};
- // eslint-disable-next-line max-params
- tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
- if (escapeChar) {
- chunk.push(unescape(escapeChar));
- } else if (style) {
- const str = chunk.join('');
- chunk = [];
- chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
- styles.push({inverse, styles: parseStyle(style)});
- } else if (close) {
- if (styles.length === 0) {
- throw new Error('Found extraneous } in Chalk template literal');
- }
+function spawn(command, args, opts) {
+ return execa__WEBPACK_IMPORTED_MODULE_2___default()(command, args, _objectSpread({
+ stdio: 'inherit',
+ preferLocal: true
+ }, opts));
+}
- chunks.push(buildStyle(chalk, styles)(chunk.join('')));
- chunk = [];
- styles.pop();
- } else {
- chunk.push(chr);
- }
- });
+function streamToLog(debug = true) {
+ return new stream__WEBPACK_IMPORTED_MODULE_0__["Writable"]({
+ objectMode: true,
- chunks.push(chunk.join(''));
+ write(line, _, cb) {
+ if (line.endsWith('\n')) {
+ _log__WEBPACK_IMPORTED_MODULE_4__["log"][debug ? 'debug' : 'write'](line.slice(0, -1));
+ } else {
+ _log__WEBPACK_IMPORTED_MODULE_4__["log"][debug ? 'debug' : 'write'](line);
+ }
- if (styles.length > 0) {
- const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
- throw new Error(errMsg);
- }
+ cb();
+ }
- return chunks.join('');
-};
+ });
+}
+function spawnStreaming(command, args, opts, {
+ prefix,
+ debug
+}) {
+ const spawned = execa__WEBPACK_IMPORTED_MODULE_2___default()(command, args, _objectSpread({
+ stdio: ['ignore', 'pipe', 'pipe'],
+ preferLocal: true
+ }, opts));
+ const color = getColor();
+ const prefixedStdout = strong_log_transformer__WEBPACK_IMPORTED_MODULE_3___default()({
+ tag: color.bold(prefix)
+ });
+ const prefixedStderr = strong_log_transformer__WEBPACK_IMPORTED_MODULE_3___default()({
+ mergeMultiline: true,
+ tag: color.bold(prefix)
+ });
+ spawned.stdout.pipe(prefixedStdout).pipe(streamToLog(debug));
+ spawned.stderr.pipe(prefixedStderr).pipe(streamToLog(debug));
+ return spawned;
+}
/***/ }),
-/* 570 */
+/* 565 */
/***/ (function(module, exports, __webpack_require__) {
// Copyright IBM Corp. 2014,2018. All Rights Reserved.
@@ -56063,12 +55405,12 @@ module.exports = (chalk, tmp) => {
// This file is licensed under the Apache License 2.0.
// License text available at https://opensource.org/licenses/Apache-2.0
-module.exports = __webpack_require__(571);
-module.exports.cli = __webpack_require__(575);
+module.exports = __webpack_require__(566);
+module.exports.cli = __webpack_require__(570);
/***/ }),
-/* 571 */
+/* 566 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -56079,13 +55421,13 @@ module.exports.cli = __webpack_require__(575);
-var stream = __webpack_require__(27);
-var util = __webpack_require__(29);
-var fs = __webpack_require__(23);
+var stream = __webpack_require__(382);
+var util = __webpack_require__(397);
+var fs = __webpack_require__(349);
-var through = __webpack_require__(572);
-var duplexer = __webpack_require__(573);
-var StringDecoder = __webpack_require__(574).StringDecoder;
+var through = __webpack_require__(567);
+var duplexer = __webpack_require__(568);
+var StringDecoder = __webpack_require__(569).StringDecoder;
module.exports = Logger;
@@ -56274,10 +55616,10 @@ function lineMerger(host) {
/***/ }),
-/* 572 */
+/* 567 */
/***/ (function(module, exports, __webpack_require__) {
-var Stream = __webpack_require__(27)
+var Stream = __webpack_require__(382)
// through
//
@@ -56388,10 +55730,10 @@ function through (write, end, opts) {
/***/ }),
-/* 573 */
+/* 568 */
/***/ (function(module, exports, __webpack_require__) {
-var Stream = __webpack_require__(27)
+var Stream = __webpack_require__(382)
var writeMethods = ["write", "end", "destroy"]
var readMethods = ["resume", "pause"]
var readEvents = ["data", "close"]
@@ -56481,13 +55823,13 @@ function duplex(writer, reader) {
/***/ }),
-/* 574 */
+/* 569 */
/***/ (function(module, exports) {
module.exports = require("string_decoder");
/***/ }),
-/* 575 */
+/* 570 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -56498,11 +55840,11 @@ module.exports = require("string_decoder");
-var minimist = __webpack_require__(576);
-var path = __webpack_require__(16);
+var minimist = __webpack_require__(571);
+var path = __webpack_require__(4);
-var Logger = __webpack_require__(571);
-var pkg = __webpack_require__(577);
+var Logger = __webpack_require__(566);
+var pkg = __webpack_require__(572);
module.exports = cli;
@@ -56556,7 +55898,7 @@ function usage($0, p) {
/***/ }),
-/* 576 */
+/* 571 */
/***/ (function(module, exports) {
module.exports = function (args, opts) {
@@ -56798,13 +56140,13 @@ function isNumber (x) {
/***/ }),
-/* 577 */
+/* 572 */
/***/ (function(module) {
module.exports = JSON.parse("{\"name\":\"strong-log-transformer\",\"version\":\"2.1.0\",\"description\":\"Stream transformer that prefixes lines with timestamps and other things.\",\"author\":\"Ryan Graham \",\"license\":\"Apache-2.0\",\"repository\":{\"type\":\"git\",\"url\":\"git://github.com/strongloop/strong-log-transformer\"},\"keywords\":[\"logging\",\"streams\"],\"bugs\":{\"url\":\"https://github.com/strongloop/strong-log-transformer/issues\"},\"homepage\":\"https://github.com/strongloop/strong-log-transformer\",\"directories\":{\"test\":\"test\"},\"bin\":{\"sl-log-transformer\":\"bin/sl-log-transformer.js\"},\"main\":\"index.js\",\"scripts\":{\"test\":\"tap --100 test/test-*\"},\"dependencies\":{\"duplexer\":\"^0.1.1\",\"minimist\":\"^1.2.0\",\"through\":\"^2.3.4\"},\"devDependencies\":{\"tap\":\"^12.0.1\"},\"engines\":{\"node\":\">=4\"}}");
/***/ }),
-/* 578 */
+/* 573 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
@@ -56813,12 +56155,12 @@ __webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copyWorkspacePackages", function() { return copyWorkspacePackages; });
/* harmony import */ var glob__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(503);
/* harmony import */ var glob__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(glob__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(16);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4);
/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(29);
+/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(397);
/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(util__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(579);
-/* harmony import */ var _fs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(20);
+/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(574);
+/* harmony import */ var _fs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(491);
/* harmony import */ var _package_json__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(518);
/* harmony import */ var _projects__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(502);
/*
@@ -56912,13 +56254,13 @@ function packagesFromGlobPattern({
}
/***/ }),
-/* 579 */
+/* 574 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getProjectPaths", function() { return getProjectPaths; });
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(16);
+/* 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__);
/*
* Licensed to Elasticsearch B.V. under one or more contributor
@@ -56982,21 +56324,21 @@ function getProjectPaths({
}
/***/ }),
-/* 580 */
+/* 575 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getAllChecksums", function() { return getAllChecksums; });
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(23);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(349);
/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(581);
+/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(576);
/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(crypto__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(29);
+/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(397);
/* harmony import */ var util__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(util__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var execa__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(371);
+/* harmony import */ var execa__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(342);
/* harmony import */ var execa__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(execa__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var _yarn_lock__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(582);
+/* harmony import */ var _yarn_lock__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(577);
/*
* Licensed to Elasticsearch B.V. under one or more contributor
* license agreements. See the NOTICE file distributed with
@@ -57225,21 +56567,21 @@ async function getAllChecksums(kbn, log) {
}
/***/ }),
-/* 581 */
+/* 576 */
/***/ (function(module, exports) {
module.exports = require("crypto");
/***/ }),
-/* 582 */
+/* 577 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "readYarnLock", function() { return readYarnLock; });
-/* harmony import */ var _yarnpkg_lockfile__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(583);
+/* harmony import */ var _yarnpkg_lockfile__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(578);
/* harmony import */ var _yarnpkg_lockfile__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_yarnpkg_lockfile__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _utils_fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(20);
+/* harmony import */ var _utils_fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(491);
/*
* Licensed to Elasticsearch B.V. under one or more contributor
* license agreements. See the NOTICE file distributed with
@@ -57281,7 +56623,7 @@ async function readYarnLock(kbn) {
}
/***/ }),
-/* 583 */
+/* 578 */
/***/ (function(module, exports, __webpack_require__) {
module.exports =
@@ -57357,7 +56699,7 @@ module.exports =
/* 0 */
/***/ (function(module, exports) {
-module.exports = __webpack_require__(16);
+module.exports = __webpack_require__(4);
/***/ }),
/* 1 */
@@ -57407,13 +56749,13 @@ exports.default = function (fn) {
/* 2 */
/***/ (function(module, exports) {
-module.exports = __webpack_require__(29);
+module.exports = __webpack_require__(397);
/***/ }),
/* 3 */
/***/ (function(module, exports) {
-module.exports = __webpack_require__(23);
+module.exports = __webpack_require__(349);
/***/ }),
/* 4 */
@@ -58840,7 +58182,7 @@ module.exports = invariant;
/* 9 */
/***/ (function(module, exports) {
-module.exports = __webpack_require__(581);
+module.exports = __webpack_require__(576);
/***/ }),
/* 10 */,
@@ -59266,7 +58608,7 @@ exports.default = Lockfile;
/* 17 */
/***/ (function(module, exports) {
-module.exports = __webpack_require__(27);
+module.exports = __webpack_require__(382);
/***/ }),
/* 18 */,
@@ -59318,7 +58660,7 @@ function nullify(obj = {}) {
/* 22 */
/***/ (function(module, exports) {
-module.exports = __webpack_require__(30);
+module.exports = __webpack_require__(371);
/***/ }),
/* 23 */
@@ -59505,7 +58847,7 @@ module.exports = {};
/* 36 */
/***/ (function(module, exports) {
-module.exports = __webpack_require__(11);
+module.exports = __webpack_require__(364);
/***/ }),
/* 37 */,
@@ -59790,7 +59132,7 @@ exports.f = __webpack_require__(33) ? Object.defineProperty : function definePro
/* 54 */
/***/ (function(module, exports) {
-module.exports = __webpack_require__(399);
+module.exports = __webpack_require__(373);
/***/ }),
/* 55 */
@@ -61164,7 +60506,7 @@ function onceStrict (fn) {
/* 63 */
/***/ (function(module, exports) {
-module.exports = __webpack_require__(584);
+module.exports = __webpack_require__(579);
/***/ }),
/* 64 */,
@@ -62102,7 +61444,7 @@ module.exports.win32 = win32;
/* 79 */
/***/ (function(module, exports) {
-module.exports = __webpack_require__(484);
+module.exports = __webpack_require__(471);
/***/ }),
/* 80 */,
@@ -67559,21 +66901,21 @@ module.exports = process && support(supportLevel);
/******/ ]);
/***/ }),
-/* 584 */
+/* 579 */
/***/ (function(module, exports) {
module.exports = require("buffer");
/***/ }),
-/* 585 */
+/* 580 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BootstrapCacheFile", function() { return BootstrapCacheFile; });
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(23);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(349);
/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(16);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4);
/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
@@ -67662,22 +67004,20 @@ class BootstrapCacheFile {
}
/***/ }),
-/* 586 */
+/* 581 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CleanCommand", function() { return CleanCommand; });
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var del__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(587);
-/* harmony import */ var del__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(del__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var ora__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(675);
-/* harmony import */ var ora__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(ora__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(16);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var _utils_fs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(20);
-/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(34);
+/* harmony import */ var del__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(582);
+/* harmony import */ var del__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(del__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var ora__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(670);
+/* harmony import */ var ora__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(ora__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 _utils_fs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(491);
+/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(500);
/*
* Licensed to Elasticsearch B.V. under one or more contributor
* license agreements. See the NOTICE file distributed with
@@ -67701,7 +67041,6 @@ __webpack_require__.r(__webpack_exports__);
-
const CleanCommand = {
description: 'Remove the node_modules and target directories from all projects.',
name: 'clean',
@@ -67710,17 +67049,17 @@ const CleanCommand = {
const toDelete = [];
for (const project of projects.values()) {
- if (await Object(_utils_fs__WEBPACK_IMPORTED_MODULE_4__["isDirectory"])(project.nodeModulesLocation)) {
+ if (await Object(_utils_fs__WEBPACK_IMPORTED_MODULE_3__["isDirectory"])(project.nodeModulesLocation)) {
toDelete.push({
cwd: project.path,
- pattern: Object(path__WEBPACK_IMPORTED_MODULE_3__["relative"])(project.path, project.nodeModulesLocation)
+ pattern: Object(path__WEBPACK_IMPORTED_MODULE_2__["relative"])(project.path, project.nodeModulesLocation)
});
}
- if (await Object(_utils_fs__WEBPACK_IMPORTED_MODULE_4__["isDirectory"])(project.targetLocation)) {
+ if (await Object(_utils_fs__WEBPACK_IMPORTED_MODULE_3__["isDirectory"])(project.targetLocation)) {
toDelete.push({
cwd: project.path,
- pattern: Object(path__WEBPACK_IMPORTED_MODULE_3__["relative"])(project.path, project.targetLocation)
+ pattern: Object(path__WEBPACK_IMPORTED_MODULE_2__["relative"])(project.path, project.targetLocation)
});
}
@@ -67737,9 +67076,8 @@ const CleanCommand = {
}
if (toDelete.length === 0) {
- _utils_log__WEBPACK_IMPORTED_MODULE_5__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold.green('\n\nNothing to delete'));
+ _utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].success('Nothing to delete');
} else {
- _utils_log__WEBPACK_IMPORTED_MODULE_5__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold.red('\n\nDeleting:\n'));
/**
* In order to avoid patterns like `/build` in packages from accidentally
* impacting files outside the package we use `process.chdir()` to change
@@ -67749,7 +67087,6 @@ const CleanCommand = {
* `del()` does support a `cwd` option, but it's only for resolving the
* patterns and does not impact the cwd check.
*/
-
const originalCwd = process.cwd();
try {
@@ -67758,8 +67095,12 @@ const CleanCommand = {
cwd
} of toDelete) {
process.chdir(cwd);
- const promise = del__WEBPACK_IMPORTED_MODULE_1___default()(pattern);
- ora__WEBPACK_IMPORTED_MODULE_2___default.a.promise(promise, Object(path__WEBPACK_IMPORTED_MODULE_3__["relative"])(originalCwd, Object(path__WEBPACK_IMPORTED_MODULE_3__["join"])(cwd, String(pattern))));
+ const promise = del__WEBPACK_IMPORTED_MODULE_0___default()(pattern);
+
+ if (_utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].wouldLogLevel('info')) {
+ ora__WEBPACK_IMPORTED_MODULE_1___default.a.promise(promise, Object(path__WEBPACK_IMPORTED_MODULE_2__["relative"])(originalCwd, Object(path__WEBPACK_IMPORTED_MODULE_2__["join"])(cwd, String(pattern))));
+ }
+
await promise;
}
} finally {
@@ -67771,21 +67112,21 @@ const CleanCommand = {
};
/***/ }),
-/* 587 */
+/* 582 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const {promisify} = __webpack_require__(29);
-const path = __webpack_require__(16);
-const globby = __webpack_require__(588);
-const isGlob = __webpack_require__(605);
-const slash = __webpack_require__(666);
-const gracefulFs = __webpack_require__(22);
-const isPathCwd = __webpack_require__(668);
-const isPathInside = __webpack_require__(669);
-const rimraf = __webpack_require__(670);
-const pMap = __webpack_require__(671);
+const {promisify} = __webpack_require__(397);
+const path = __webpack_require__(4);
+const globby = __webpack_require__(583);
+const isGlob = __webpack_require__(600);
+const slash = __webpack_require__(661);
+const gracefulFs = __webpack_require__(493);
+const isPathCwd = __webpack_require__(663);
+const isPathInside = __webpack_require__(664);
+const rimraf = __webpack_require__(665);
+const pMap = __webpack_require__(666);
const rimrafP = promisify(rimraf);
@@ -67899,19 +67240,19 @@ module.exports.sync = (patterns, {force, dryRun, cwd = process.cwd(), ...options
/***/ }),
-/* 588 */
+/* 583 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const fs = __webpack_require__(23);
-const arrayUnion = __webpack_require__(589);
-const merge2 = __webpack_require__(590);
-const glob = __webpack_require__(591);
-const fastGlob = __webpack_require__(596);
-const dirGlob = __webpack_require__(662);
-const gitignore = __webpack_require__(664);
-const {FilterStream, UniqueStream} = __webpack_require__(667);
+const fs = __webpack_require__(349);
+const arrayUnion = __webpack_require__(584);
+const merge2 = __webpack_require__(585);
+const glob = __webpack_require__(586);
+const fastGlob = __webpack_require__(591);
+const dirGlob = __webpack_require__(657);
+const gitignore = __webpack_require__(659);
+const {FilterStream, UniqueStream} = __webpack_require__(662);
const DEFAULT_FILTER = () => false;
@@ -68084,7 +67425,7 @@ module.exports.gitignore = gitignore;
/***/ }),
-/* 589 */
+/* 584 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -68096,7 +67437,7 @@ module.exports = (...arguments_) => {
/***/ }),
-/* 590 */
+/* 585 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -68108,7 +67449,7 @@ module.exports = (...arguments_) => {
* Copyright (c) 2014-2016 Teambition
* Licensed under the MIT license.
*/
-const Stream = __webpack_require__(27)
+const Stream = __webpack_require__(382)
const PassThrough = Stream.PassThrough
const slice = Array.prototype.slice
@@ -68210,7 +67551,7 @@ function pauseStreams (streams, options) {
/***/ }),
-/* 591 */
+/* 586 */
/***/ (function(module, exports, __webpack_require__) {
// Approach:
@@ -68255,27 +67596,27 @@ function pauseStreams (streams, options) {
module.exports = glob
-var fs = __webpack_require__(23)
+var fs = __webpack_require__(349)
var rp = __webpack_require__(504)
var minimatch = __webpack_require__(506)
var Minimatch = minimatch.Minimatch
-var inherits = __webpack_require__(592)
-var EE = __webpack_require__(399).EventEmitter
-var path = __webpack_require__(16)
-var assert = __webpack_require__(30)
+var inherits = __webpack_require__(587)
+var EE = __webpack_require__(373).EventEmitter
+var path = __webpack_require__(4)
+var assert = __webpack_require__(371)
var isAbsolute = __webpack_require__(512)
-var globSync = __webpack_require__(594)
-var common = __webpack_require__(595)
+var globSync = __webpack_require__(589)
+var common = __webpack_require__(590)
var alphasort = common.alphasort
var alphasorti = common.alphasorti
var setopts = common.setopts
var ownProp = common.ownProp
var inflight = __webpack_require__(515)
-var util = __webpack_require__(29)
+var util = __webpack_require__(397)
var childrenIgnored = common.childrenIgnored
var isIgnored = common.isIgnored
-var once = __webpack_require__(404)
+var once = __webpack_require__(378)
function glob (pattern, options, cb) {
if (typeof options === 'function') cb = options, options = {}
@@ -69006,22 +68347,22 @@ Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
/***/ }),
-/* 592 */
+/* 587 */
/***/ (function(module, exports, __webpack_require__) {
try {
- var util = __webpack_require__(29);
+ var util = __webpack_require__(397);
/* istanbul ignore next */
if (typeof util.inherits !== 'function') throw '';
module.exports = util.inherits;
} catch (e) {
/* istanbul ignore next */
- module.exports = __webpack_require__(593);
+ module.exports = __webpack_require__(588);
}
/***/ }),
-/* 593 */
+/* 588 */
/***/ (function(module, exports) {
if (typeof Object.create === 'function') {
@@ -69054,22 +68395,22 @@ if (typeof Object.create === 'function') {
/***/ }),
-/* 594 */
+/* 589 */
/***/ (function(module, exports, __webpack_require__) {
module.exports = globSync
globSync.GlobSync = GlobSync
-var fs = __webpack_require__(23)
+var fs = __webpack_require__(349)
var rp = __webpack_require__(504)
var minimatch = __webpack_require__(506)
var Minimatch = minimatch.Minimatch
-var Glob = __webpack_require__(591).Glob
-var util = __webpack_require__(29)
-var path = __webpack_require__(16)
-var assert = __webpack_require__(30)
+var Glob = __webpack_require__(586).Glob
+var util = __webpack_require__(397)
+var path = __webpack_require__(4)
+var assert = __webpack_require__(371)
var isAbsolute = __webpack_require__(512)
-var common = __webpack_require__(595)
+var common = __webpack_require__(590)
var alphasort = common.alphasort
var alphasorti = common.alphasorti
var setopts = common.setopts
@@ -69546,7 +68887,7 @@ GlobSync.prototype._makeAbs = function (f) {
/***/ }),
-/* 595 */
+/* 590 */
/***/ (function(module, exports, __webpack_require__) {
exports.alphasort = alphasort
@@ -69563,7 +68904,7 @@ function ownProp (obj, field) {
return Object.prototype.hasOwnProperty.call(obj, field)
}
-var path = __webpack_require__(16)
+var path = __webpack_require__(4)
var minimatch = __webpack_require__(506)
var isAbsolute = __webpack_require__(512)
var Minimatch = minimatch.Minimatch
@@ -69792,17 +69133,17 @@ function childrenIgnored (self, path) {
/***/ }),
-/* 596 */
+/* 591 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const taskManager = __webpack_require__(597);
-const async_1 = __webpack_require__(625);
-const stream_1 = __webpack_require__(658);
-const sync_1 = __webpack_require__(659);
-const settings_1 = __webpack_require__(661);
-const utils = __webpack_require__(598);
+const taskManager = __webpack_require__(592);
+const async_1 = __webpack_require__(620);
+const stream_1 = __webpack_require__(653);
+const sync_1 = __webpack_require__(654);
+const settings_1 = __webpack_require__(656);
+const utils = __webpack_require__(593);
function FastGlob(source, options) {
try {
assertPatternsInput(source);
@@ -69860,13 +69201,13 @@ module.exports = FastGlob;
/***/ }),
-/* 597 */
+/* 592 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const utils = __webpack_require__(598);
+const utils = __webpack_require__(593);
function generate(patterns, settings) {
const positivePatterns = getPositivePatterns(patterns);
const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);
@@ -69934,28 +69275,28 @@ exports.convertPatternGroupToTask = convertPatternGroupToTask;
/***/ }),
-/* 598 */
+/* 593 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const array = __webpack_require__(599);
+const array = __webpack_require__(594);
exports.array = array;
-const errno = __webpack_require__(600);
+const errno = __webpack_require__(595);
exports.errno = errno;
-const fs = __webpack_require__(601);
+const fs = __webpack_require__(596);
exports.fs = fs;
-const path = __webpack_require__(602);
+const path = __webpack_require__(597);
exports.path = path;
-const pattern = __webpack_require__(603);
+const pattern = __webpack_require__(598);
exports.pattern = pattern;
-const stream = __webpack_require__(624);
+const stream = __webpack_require__(619);
exports.stream = stream;
/***/ }),
-/* 599 */
+/* 594 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -69968,7 +69309,7 @@ exports.flatten = flatten;
/***/ }),
-/* 600 */
+/* 595 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -69981,7 +69322,7 @@ exports.isEnoentCodeError = isEnoentCodeError;
/***/ }),
-/* 601 */
+/* 596 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -70006,13 +69347,13 @@ exports.createDirentFromStats = createDirentFromStats;
/***/ }),
-/* 602 */
+/* 597 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const path = __webpack_require__(16);
+const path = __webpack_require__(4);
/**
* Designed to work only with simple paths: `dir\\file`.
*/
@@ -70027,16 +69368,16 @@ exports.makeAbsolute = makeAbsolute;
/***/ }),
-/* 603 */
+/* 598 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const path = __webpack_require__(16);
-const globParent = __webpack_require__(604);
-const isGlob = __webpack_require__(605);
-const micromatch = __webpack_require__(607);
+const path = __webpack_require__(4);
+const globParent = __webpack_require__(599);
+const isGlob = __webpack_require__(600);
+const micromatch = __webpack_require__(602);
const GLOBSTAR = '**';
function isStaticPattern(pattern) {
return !isDynamicPattern(pattern);
@@ -70125,15 +69466,15 @@ exports.matchAny = matchAny;
/***/ }),
-/* 604 */
+/* 599 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isGlob = __webpack_require__(605);
-var pathPosixDirname = __webpack_require__(16).posix.dirname;
-var isWin32 = __webpack_require__(11).platform() === 'win32';
+var isGlob = __webpack_require__(600);
+var pathPosixDirname = __webpack_require__(4).posix.dirname;
+var isWin32 = __webpack_require__(364).platform() === 'win32';
var slash = '/';
var backslash = /\\/g;
@@ -70166,7 +69507,7 @@ module.exports = function globParent(str) {
/***/ }),
-/* 605 */
+/* 600 */
/***/ (function(module, exports, __webpack_require__) {
/*!
@@ -70176,7 +69517,7 @@ module.exports = function globParent(str) {
* Released under the MIT License.
*/
-var isExtglob = __webpack_require__(606);
+var isExtglob = __webpack_require__(601);
var chars = { '{': '}', '(': ')', '[': ']'};
var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
@@ -70220,7 +69561,7 @@ module.exports = function isGlob(str, options) {
/***/ }),
-/* 606 */
+/* 601 */
/***/ (function(module, exports) {
/*!
@@ -70246,16 +69587,16 @@ module.exports = function isExtglob(str) {
/***/ }),
-/* 607 */
+/* 602 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const util = __webpack_require__(29);
-const braces = __webpack_require__(608);
-const picomatch = __webpack_require__(618);
-const utils = __webpack_require__(621);
+const util = __webpack_require__(397);
+const braces = __webpack_require__(603);
+const picomatch = __webpack_require__(613);
+const utils = __webpack_require__(616);
const isEmptyString = val => typeof val === 'string' && (val === '' || val === './');
/**
@@ -70720,16 +70061,16 @@ module.exports = micromatch;
/***/ }),
-/* 608 */
+/* 603 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const stringify = __webpack_require__(609);
-const compile = __webpack_require__(611);
-const expand = __webpack_require__(615);
-const parse = __webpack_require__(616);
+const stringify = __webpack_require__(604);
+const compile = __webpack_require__(606);
+const expand = __webpack_require__(610);
+const parse = __webpack_require__(611);
/**
* Expand the given pattern or create a regex-compatible string.
@@ -70897,13 +70238,13 @@ module.exports = braces;
/***/ }),
-/* 609 */
+/* 604 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const utils = __webpack_require__(610);
+const utils = __webpack_require__(605);
module.exports = (ast, options = {}) => {
let stringify = (node, parent = {}) => {
@@ -70936,7 +70277,7 @@ module.exports = (ast, options = {}) => {
/***/ }),
-/* 610 */
+/* 605 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -71055,14 +70396,14 @@ exports.flatten = (...args) => {
/***/ }),
-/* 611 */
+/* 606 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const fill = __webpack_require__(612);
-const utils = __webpack_require__(610);
+const fill = __webpack_require__(607);
+const utils = __webpack_require__(605);
const compile = (ast, options = {}) => {
let walk = (node, parent = {}) => {
@@ -71119,7 +70460,7 @@ module.exports = compile;
/***/ }),
-/* 612 */
+/* 607 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -71132,8 +70473,8 @@ module.exports = compile;
-const util = __webpack_require__(29);
-const toRegexRange = __webpack_require__(613);
+const util = __webpack_require__(397);
+const toRegexRange = __webpack_require__(608);
const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
@@ -71375,7 +70716,7 @@ module.exports = fill;
/***/ }),
-/* 613 */
+/* 608 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -71388,7 +70729,7 @@ module.exports = fill;
-const isNumber = __webpack_require__(614);
+const isNumber = __webpack_require__(609);
const toRegexRange = (min, max, options) => {
if (isNumber(min) === false) {
@@ -71670,7 +71011,7 @@ module.exports = toRegexRange;
/***/ }),
-/* 614 */
+/* 609 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -71695,15 +71036,15 @@ module.exports = function(num) {
/***/ }),
-/* 615 */
+/* 610 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const fill = __webpack_require__(612);
-const stringify = __webpack_require__(609);
-const utils = __webpack_require__(610);
+const fill = __webpack_require__(607);
+const stringify = __webpack_require__(604);
+const utils = __webpack_require__(605);
const append = (queue = '', stash = '', enclose = false) => {
let result = [];
@@ -71815,13 +71156,13 @@ module.exports = expand;
/***/ }),
-/* 616 */
+/* 611 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const stringify = __webpack_require__(609);
+const stringify = __webpack_require__(604);
/**
* Constants
@@ -71843,7 +71184,7 @@ const {
CHAR_SINGLE_QUOTE, /* ' */
CHAR_NO_BREAK_SPACE,
CHAR_ZERO_WIDTH_NOBREAK_SPACE
-} = __webpack_require__(617);
+} = __webpack_require__(612);
/**
* parse
@@ -72155,7 +71496,7 @@ module.exports = parse;
/***/ }),
-/* 617 */
+/* 612 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -72219,26 +71560,26 @@ module.exports = {
/***/ }),
-/* 618 */
+/* 613 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-module.exports = __webpack_require__(619);
+module.exports = __webpack_require__(614);
/***/ }),
-/* 619 */
+/* 614 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const path = __webpack_require__(16);
-const scan = __webpack_require__(620);
-const parse = __webpack_require__(623);
-const utils = __webpack_require__(621);
+const path = __webpack_require__(4);
+const scan = __webpack_require__(615);
+const parse = __webpack_require__(618);
+const utils = __webpack_require__(616);
/**
* Creates a matcher function from one or more glob patterns. The
@@ -72541,7 +71882,7 @@ picomatch.toRegex = (source, options) => {
* @return {Object}
*/
-picomatch.constants = __webpack_require__(622);
+picomatch.constants = __webpack_require__(617);
/**
* Expose "picomatch"
@@ -72551,13 +71892,13 @@ module.exports = picomatch;
/***/ }),
-/* 620 */
+/* 615 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const utils = __webpack_require__(621);
+const utils = __webpack_require__(616);
const {
CHAR_ASTERISK, /* * */
@@ -72575,7 +71916,7 @@ const {
CHAR_RIGHT_CURLY_BRACE, /* } */
CHAR_RIGHT_PARENTHESES, /* ) */
CHAR_RIGHT_SQUARE_BRACKET /* ] */
-} = __webpack_require__(622);
+} = __webpack_require__(617);
const isPathSeparator = code => {
return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
@@ -72777,19 +72118,19 @@ module.exports = (input, options) => {
/***/ }),
-/* 621 */
+/* 616 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const path = __webpack_require__(16);
+const path = __webpack_require__(4);
const win32 = process.platform === 'win32';
const {
REGEX_SPECIAL_CHARS,
REGEX_SPECIAL_CHARS_GLOBAL,
REGEX_REMOVE_BACKSLASH
-} = __webpack_require__(622);
+} = __webpack_require__(617);
exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
@@ -72827,13 +72168,13 @@ exports.escapeLast = (input, char, lastIdx) => {
/***/ }),
-/* 622 */
+/* 617 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const path = __webpack_require__(16);
+const path = __webpack_require__(4);
const WIN_SLASH = '\\\\/';
const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
@@ -73013,14 +72354,14 @@ module.exports = {
/***/ }),
-/* 623 */
+/* 618 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const utils = __webpack_require__(621);
-const constants = __webpack_require__(622);
+const utils = __webpack_require__(616);
+const constants = __webpack_require__(617);
/**
* Constants
@@ -73175,2463 +72516,3370 @@ const parse = (input, options) => {
state.consumed += token.value || '';
};
- const increment = type => {
- state[type]++;
- stack.push(type);
- };
+ const increment = type => {
+ state[type]++;
+ stack.push(type);
+ };
+
+ const decrement = type => {
+ state[type]--;
+ stack.pop();
+ };
+
+ /**
+ * Push tokens onto the tokens array. This helper speeds up
+ * tokenizing by 1) helping us avoid backtracking as much as possible,
+ * and 2) helping us avoid creating extra tokens when consecutive
+ * characters are plain text. This improves performance and simplifies
+ * lookbehinds.
+ */
+
+ const push = tok => {
+ if (prev.type === 'globstar') {
+ let isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
+ let isExtglob = extglobs.length && (tok.type === 'pipe' || tok.type === 'paren');
+ if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
+ state.output = state.output.slice(0, -prev.output.length);
+ prev.type = 'star';
+ prev.value = '*';
+ prev.output = star;
+ state.output += prev.output;
+ }
+ }
+
+ if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {
+ extglobs[extglobs.length - 1].inner += tok.value;
+ }
+
+ if (tok.value || tok.output) append(tok);
+ if (prev && prev.type === 'text' && tok.type === 'text') {
+ prev.value += tok.value;
+ return;
+ }
+
+ tok.prev = prev;
+ tokens.push(tok);
+ prev = tok;
+ };
+
+ const extglobOpen = (type, value) => {
+ let token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+
+ token.prev = prev;
+ token.parens = state.parens;
+ token.output = state.output;
+ let output = (opts.capture ? '(' : '') + token.open;
+
+ push({ type, value, output: state.output ? '' : ONE_CHAR });
+ push({ type: 'paren', extglob: true, value: advance(), output });
+ increment('parens');
+ extglobs.push(token);
+ };
+
+ const extglobClose = token => {
+ let output = token.close + (opts.capture ? ')' : '');
+
+ if (token.type === 'negate') {
+ let extglobStar = star;
+
+ if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
+ extglobStar = globstar(opts);
+ }
+
+ if (extglobStar !== star || eos() || /^\)+$/.test(input.slice(state.index + 1))) {
+ output = token.close = ')$))' + extglobStar;
+ }
+
+ if (token.prev.type === 'bos' && eos()) {
+ state.negatedExtglob = true;
+ }
+ }
+
+ push({ type: 'paren', extglob: true, value, output });
+ decrement('parens');
+ };
+
+ if (opts.fastpaths !== false && !/(^[*!]|[/{[()\]}"])/.test(input)) {
+ let backslashes = false;
+
+ let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+ if (first === '\\') {
+ backslashes = true;
+ return m;
+ }
+
+ if (first === '?') {
+ if (esc) {
+ return esc + first + (rest ? QMARK.repeat(rest.length) : '');
+ }
+ if (index === 0) {
+ return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
+ }
+ return QMARK.repeat(chars.length);
+ }
+
+ if (first === '.') {
+ return DOT_LITERAL.repeat(chars.length);
+ }
+
+ if (first === '*') {
+ if (esc) {
+ return esc + first + (rest ? star : '');
+ }
+ return star;
+ }
+ return esc ? m : '\\' + m;
+ });
+
+ if (backslashes === true) {
+ if (opts.unescape === true) {
+ output = output.replace(/\\/g, '');
+ } else {
+ output = output.replace(/\\+/g, m => {
+ return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
+ });
+ }
+ }
+
+ state.output = output;
+ return state;
+ }
+
+ /**
+ * Tokenize input until we reach end-of-string
+ */
+
+ while (!eos()) {
+ value = advance();
+
+ if (value === '\u0000') {
+ continue;
+ }
+
+ /**
+ * Escaped characters
+ */
+
+ if (value === '\\') {
+ let next = peek();
+
+ if (next === '/' && opts.bash !== true) {
+ continue;
+ }
+
+ if (next === '.' || next === ';') {
+ continue;
+ }
+
+ if (!next) {
+ value += '\\';
+ push({ type: 'text', value });
+ continue;
+ }
+
+ // collapse slashes to reduce potential for exploits
+ let match = /^\\+/.exec(input.slice(state.index + 1));
+ let slashes = 0;
+
+ if (match && match[0].length > 2) {
+ slashes = match[0].length;
+ state.index += slashes;
+ if (slashes % 2 !== 0) {
+ value += '\\';
+ }
+ }
+
+ if (opts.unescape === true) {
+ value = advance() || '';
+ } else {
+ value += advance() || '';
+ }
+
+ if (state.brackets === 0) {
+ push({ type: 'text', value });
+ continue;
+ }
+ }
+
+ /**
+ * If we're inside a regex character class, continue
+ * until we reach the closing bracket.
+ */
+
+ if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
+ if (opts.posix !== false && value === ':') {
+ let inner = prev.value.slice(1);
+ if (inner.includes('[')) {
+ prev.posix = true;
+
+ if (inner.includes(':')) {
+ let idx = prev.value.lastIndexOf('[');
+ let pre = prev.value.slice(0, idx);
+ let rest = prev.value.slice(idx + 2);
+ let posix = POSIX_REGEX_SOURCE[rest];
+ if (posix) {
+ prev.value = pre + posix;
+ state.backtrack = true;
+ advance();
+
+ if (!bos.output && tokens.indexOf(prev) === 1) {
+ bos.output = ONE_CHAR;
+ }
+ continue;
+ }
+ }
+ }
+ }
+
+ if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
+ value = '\\' + value;
+ }
+
+ if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
+ value = '\\' + value;
+ }
+
+ if (opts.posix === true && value === '!' && prev.value === '[') {
+ value = '^';
+ }
+
+ prev.value += value;
+ append({ value });
+ continue;
+ }
+
+ /**
+ * If we're inside a quoted string, continue
+ * until we reach the closing double quote.
+ */
+
+ if (state.quotes === 1 && value !== '"') {
+ value = utils.escapeRegex(value);
+ prev.value += value;
+ append({ value });
+ continue;
+ }
+
+ /**
+ * Double quotes
+ */
+
+ if (value === '"') {
+ state.quotes = state.quotes === 1 ? 0 : 1;
+ if (opts.keepQuotes === true) {
+ push({ type: 'text', value });
+ }
+ continue;
+ }
+
+ /**
+ * Parentheses
+ */
+
+ if (value === '(') {
+ push({ type: 'paren', value });
+ increment('parens');
+ continue;
+ }
+
+ if (value === ')') {
+ if (state.parens === 0 && opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError('opening', '('));
+ }
+
+ let extglob = extglobs[extglobs.length - 1];
+ if (extglob && state.parens === extglob.parens + 1) {
+ extglobClose(extglobs.pop());
+ continue;
+ }
+
+ push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
+ decrement('parens');
+ continue;
+ }
+
+ /**
+ * Brackets
+ */
+
+ if (value === '[') {
+ if (opts.nobracket === true || !input.slice(state.index + 1).includes(']')) {
+ if (opts.nobracket !== true && opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError('closing', ']'));
+ }
+
+ value = '\\' + value;
+ } else {
+ increment('brackets');
+ }
+
+ push({ type: 'bracket', value });
+ continue;
+ }
+
+ if (value === ']') {
+ if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
+ push({ type: 'text', value, output: '\\' + value });
+ continue;
+ }
+
+ if (state.brackets === 0) {
+ if (opts.strictBrackets === true) {
+ throw new SyntaxError(syntaxError('opening', '['));
+ }
+
+ push({ type: 'text', value, output: '\\' + value });
+ continue;
+ }
+
+ decrement('brackets');
+
+ let prevValue = prev.value.slice(1);
+ if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
+ value = '/' + value;
+ }
+
+ prev.value += value;
+ append({ value });
+
+ // when literal brackets are explicitly disabled
+ // assume we should match with a regex character class
+ if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+ continue;
+ }
+
+ let escaped = utils.escapeRegex(prev.value);
+ state.output = state.output.slice(0, -prev.value.length);
+
+ // when literal brackets are explicitly enabled
+ // assume we should escape the brackets to match literal characters
+ if (opts.literalBrackets === true) {
+ state.output += escaped;
+ prev.value = escaped;
+ continue;
+ }
+
+ // when the user specifies nothing, try to match both
+ prev.value = `(${capture}${escaped}|${prev.value})`;
+ state.output += prev.value;
+ continue;
+ }
+
+ /**
+ * Braces
+ */
+
+ if (value === '{' && opts.nobrace !== true) {
+ push({ type: 'brace', value, output: '(' });
+ increment('braces');
+ continue;
+ }
+
+ if (value === '}') {
+ if (opts.nobrace === true || state.braces === 0) {
+ push({ type: 'text', value, output: '\\' + value });
+ continue;
+ }
+
+ let output = ')';
+
+ if (state.dots === true) {
+ let arr = tokens.slice();
+ let range = [];
+
+ for (let i = arr.length - 1; i >= 0; i--) {
+ tokens.pop();
+ if (arr[i].type === 'brace') {
+ break;
+ }
+ if (arr[i].type !== 'dots') {
+ range.unshift(arr[i].value);
+ }
+ }
+
+ output = expandRange(range, opts);
+ state.backtrack = true;
+ }
+
+ push({ type: 'brace', value, output });
+ decrement('braces');
+ continue;
+ }
+
+ /**
+ * Pipes
+ */
+
+ if (value === '|') {
+ if (extglobs.length > 0) {
+ extglobs[extglobs.length - 1].conditions++;
+ }
+ push({ type: 'text', value });
+ continue;
+ }
- const decrement = type => {
- state[type]--;
- stack.pop();
- };
+ /**
+ * Commas
+ */
- /**
- * Push tokens onto the tokens array. This helper speeds up
- * tokenizing by 1) helping us avoid backtracking as much as possible,
- * and 2) helping us avoid creating extra tokens when consecutive
- * characters are plain text. This improves performance and simplifies
- * lookbehinds.
- */
+ if (value === ',') {
+ let output = value;
- const push = tok => {
- if (prev.type === 'globstar') {
- let isBrace = state.braces > 0 && (tok.type === 'comma' || tok.type === 'brace');
- let isExtglob = extglobs.length && (tok.type === 'pipe' || tok.type === 'paren');
- if (tok.type !== 'slash' && tok.type !== 'paren' && !isBrace && !isExtglob) {
- state.output = state.output.slice(0, -prev.output.length);
- prev.type = 'star';
- prev.value = '*';
- prev.output = star;
- state.output += prev.output;
+ if (state.braces > 0 && stack[stack.length - 1] === 'braces') {
+ output = '|';
}
- }
- if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {
- extglobs[extglobs.length - 1].inner += tok.value;
+ push({ type: 'comma', value, output });
+ continue;
}
- if (tok.value || tok.output) append(tok);
- if (prev && prev.type === 'text' && tok.type === 'text') {
- prev.value += tok.value;
- return;
+ /**
+ * Slashes
+ */
+
+ if (value === '/') {
+ // if the beginning of the glob is "./", advance the start
+ // to the current index, and don't add the "./" characters
+ // to the state. This greatly simplifies lookbehinds when
+ // checking for BOS characters like "!" and "." (not "./")
+ if (prev.type === 'dot' && state.index === 1) {
+ state.start = state.index + 1;
+ state.consumed = '';
+ state.output = '';
+ tokens.pop();
+ prev = bos; // reset "prev" to the first token
+ continue;
+ }
+
+ push({ type: 'slash', value, output: SLASH_LITERAL });
+ continue;
}
- tok.prev = prev;
- tokens.push(tok);
- prev = tok;
- };
+ /**
+ * Dots
+ */
- const extglobOpen = (type, value) => {
- let token = { ...EXTGLOB_CHARS[value], conditions: 1, inner: '' };
+ if (value === '.') {
+ if (state.braces > 0 && prev.type === 'dot') {
+ if (prev.value === '.') prev.output = DOT_LITERAL;
+ prev.type = 'dots';
+ prev.output += value;
+ prev.value += value;
+ state.dots = true;
+ continue;
+ }
- token.prev = prev;
- token.parens = state.parens;
- token.output = state.output;
- let output = (opts.capture ? '(' : '') + token.open;
+ push({ type: 'dot', value, output: DOT_LITERAL });
+ continue;
+ }
- push({ type, value, output: state.output ? '' : ONE_CHAR });
- push({ type: 'paren', extglob: true, value: advance(), output });
- increment('parens');
- extglobs.push(token);
- };
+ /**
+ * Question marks
+ */
- const extglobClose = token => {
- let output = token.close + (opts.capture ? ')' : '');
+ if (value === '?') {
+ if (prev && prev.type === 'paren') {
+ let next = peek();
+ let output = value;
- if (token.type === 'negate') {
- let extglobStar = star;
+ if (next === '<' && !utils.supportsLookbehinds()) {
+ throw new Error('Node.js v10 or higher is required for regex lookbehinds');
+ }
- if (token.inner && token.inner.length > 1 && token.inner.includes('/')) {
- extglobStar = globstar(opts);
+ if (prev.value === '(' && !/[!=<:]/.test(next) || (next === '<' && !/[!=]/.test(peek(2)))) {
+ output = '\\' + value;
+ }
+
+ push({ type: 'text', value, output });
+ continue;
}
- if (extglobStar !== star || eos() || /^\)+$/.test(input.slice(state.index + 1))) {
- output = token.close = ')$))' + extglobStar;
+ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ extglobOpen('qmark', value);
+ continue;
}
- if (token.prev.type === 'bos' && eos()) {
- state.negatedExtglob = true;
+ if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
+ push({ type: 'qmark', value, output: QMARK_NO_DOT });
+ continue;
}
+
+ push({ type: 'qmark', value, output: QMARK });
+ continue;
}
- push({ type: 'paren', extglob: true, value, output });
- decrement('parens');
- };
+ /**
+ * Exclamation
+ */
- if (opts.fastpaths !== false && !/(^[*!]|[/{[()\]}"])/.test(input)) {
- let backslashes = false;
+ if (value === '!') {
+ if (opts.noextglob !== true && peek() === '(') {
+ if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
+ extglobOpen('negate', value);
+ continue;
+ }
+ }
- let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
- if (first === '\\') {
- backslashes = true;
- return m;
+ if (opts.nonegate !== true && state.index === 0) {
+ negate(state);
+ continue;
}
+ }
- if (first === '?') {
- if (esc) {
- return esc + first + (rest ? QMARK.repeat(rest.length) : '');
- }
- if (index === 0) {
- return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : '');
- }
- return QMARK.repeat(chars.length);
+ /**
+ * Plus
+ */
+
+ if (value === '+') {
+ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ extglobOpen('plus', value);
+ continue;
}
- if (first === '.') {
- return DOT_LITERAL.repeat(chars.length);
+ if (prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) {
+ let output = prev.extglob === true ? '\\' + value : value;
+ push({ type: 'plus', value, output });
+ continue;
}
- if (first === '*') {
- if (esc) {
- return esc + first + (rest ? star : '');
- }
- return star;
+ // use regex behavior inside parens
+ if (state.parens > 0 && opts.regex !== false) {
+ push({ type: 'plus', value });
+ continue;
}
- return esc ? m : '\\' + m;
- });
- if (backslashes === true) {
- if (opts.unescape === true) {
- output = output.replace(/\\/g, '');
- } else {
- output = output.replace(/\\+/g, m => {
- return m.length % 2 === 0 ? '\\\\' : (m ? '\\' : '');
- });
+ push({ type: 'plus', value: PLUS_LITERAL });
+ continue;
+ }
+
+ /**
+ * Plain text
+ */
+
+ if (value === '@') {
+ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ push({ type: 'at', value, output: '' });
+ continue;
}
+
+ push({ type: 'text', value });
+ continue;
}
- state.output = output;
- return state;
- }
+ /**
+ * Plain text
+ */
- /**
- * Tokenize input until we reach end-of-string
- */
+ if (value !== '*') {
+ if (value === '$' || value === '^') {
+ value = '\\' + value;
+ }
- while (!eos()) {
- value = advance();
+ let match = REGEX_NON_SPECIAL_CHAR.exec(input.slice(state.index + 1));
+ if (match) {
+ value += match[0];
+ state.index += match[0].length;
+ }
- if (value === '\u0000') {
+ push({ type: 'text', value });
continue;
}
/**
- * Escaped characters
+ * Stars
*/
- if (value === '\\') {
- let next = peek();
+ if (prev && (prev.type === 'globstar' || prev.star === true)) {
+ prev.type = 'star';
+ prev.star = true;
+ prev.value += value;
+ prev.output = star;
+ state.backtrack = true;
+ state.consumed += value;
+ continue;
+ }
- if (next === '/' && opts.bash !== true) {
+ if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
+ extglobOpen('star', value);
+ continue;
+ }
+
+ if (prev.type === 'star') {
+ if (opts.noglobstar === true) {
+ state.consumed += value;
continue;
}
- if (next === '.' || next === ';') {
+ let prior = prev.prev;
+ let before = prior.prev;
+ let isStart = prior.type === 'slash' || prior.type === 'bos';
+ let afterStar = before && (before.type === 'star' || before.type === 'globstar');
+
+ if (opts.bash === true && (!isStart || (!eos() && peek() !== '/'))) {
+ push({ type: 'star', value, output: '' });
continue;
}
- if (!next) {
- value += '\\';
- push({ type: 'text', value });
+ let isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
+ let isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
+ if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
+ push({ type: 'star', value, output: '' });
continue;
}
- // collapse slashes to reduce potential for exploits
- let match = /^\\+/.exec(input.slice(state.index + 1));
- let slashes = 0;
-
- if (match && match[0].length > 2) {
- slashes = match[0].length;
- state.index += slashes;
- if (slashes % 2 !== 0) {
- value += '\\';
+ // strip consecutive `/**/`
+ while (input.slice(state.index + 1, state.index + 4) === '/**') {
+ let after = input[state.index + 4];
+ if (after && after !== '/') {
+ break;
}
+ state.consumed += '/**';
+ state.index += 3;
}
- if (opts.unescape === true) {
- value = advance() || '';
- } else {
- value += advance() || '';
+ if (prior.type === 'bos' && eos()) {
+ prev.type = 'globstar';
+ prev.value += value;
+ prev.output = globstar(opts);
+ state.output = prev.output;
+ state.consumed += value;
+ continue;
}
- if (state.brackets === 0) {
- push({ type: 'text', value });
+ if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
+ state.output = state.output.slice(0, -(prior.output + prev.output).length);
+ prior.output = '(?:' + prior.output;
+
+ prev.type = 'globstar';
+ prev.output = globstar(opts) + '|$)';
+ prev.value += value;
+
+ state.output += prior.output + prev.output;
+ state.consumed += value;
continue;
}
- }
- /**
- * If we're inside a regex character class, continue
- * until we reach the closing bracket.
- */
+ let next = peek();
+ if (prior.type === 'slash' && prior.prev.type !== 'bos' && next === '/') {
+ let end = peek(2) !== void 0 ? '|$' : '';
- if (state.brackets > 0 && (value !== ']' || prev.value === '[' || prev.value === '[^')) {
- if (opts.posix !== false && value === ':') {
- let inner = prev.value.slice(1);
- if (inner.includes('[')) {
- prev.posix = true;
+ state.output = state.output.slice(0, -(prior.output + prev.output).length);
+ prior.output = '(?:' + prior.output;
- if (inner.includes(':')) {
- let idx = prev.value.lastIndexOf('[');
- let pre = prev.value.slice(0, idx);
- let rest = prev.value.slice(idx + 2);
- let posix = POSIX_REGEX_SOURCE[rest];
- if (posix) {
- prev.value = pre + posix;
- state.backtrack = true;
- advance();
+ prev.type = 'globstar';
+ prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+ prev.value += value;
- if (!bos.output && tokens.indexOf(prev) === 1) {
- bos.output = ONE_CHAR;
- }
- continue;
- }
- }
- }
+ state.output += prior.output + prev.output;
+ state.consumed += value + advance();
+
+ push({ type: 'slash', value, output: '' });
+ continue;
}
- if ((value === '[' && peek() !== ':') || (value === '-' && peek() === ']')) {
- value = '\\' + value;
+ if (prior.type === 'bos' && next === '/') {
+ prev.type = 'globstar';
+ prev.value += value;
+ prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+ state.output = prev.output;
+ state.consumed += value + advance();
+ push({ type: 'slash', value, output: '' });
+ continue;
}
- if (value === ']' && (prev.value === '[' || prev.value === '[^')) {
- value = '\\' + value;
+ // remove single star from output
+ state.output = state.output.slice(0, -prev.output.length);
+
+ // reset previous token to globstar
+ prev.type = 'globstar';
+ prev.output = globstar(opts);
+ prev.value += value;
+
+ // reset output with globstar
+ state.output += prev.output;
+ state.consumed += value;
+ continue;
+ }
+
+ let token = { type: 'star', value, output: star };
+
+ if (opts.bash === true) {
+ token.output = '.*?';
+ if (prev.type === 'bos' || prev.type === 'slash') {
+ token.output = nodot + token.output;
+ }
+ push(token);
+ continue;
+ }
+
+ if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
+ token.output = value;
+ push(token);
+ continue;
+ }
+
+ if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
+ if (prev.type === 'dot') {
+ state.output += NO_DOT_SLASH;
+ prev.output += NO_DOT_SLASH;
+
+ } else if (opts.dot === true) {
+ state.output += NO_DOTS_SLASH;
+ prev.output += NO_DOTS_SLASH;
+
+ } else {
+ state.output += nodot;
+ prev.output += nodot;
}
- if (opts.posix === true && value === '!' && prev.value === '[') {
- value = '^';
+ if (peek() !== '*') {
+ state.output += ONE_CHAR;
+ prev.output += ONE_CHAR;
+ }
+ }
+
+ push(token);
+ }
+
+ while (state.brackets > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
+ state.output = utils.escapeLast(state.output, '[');
+ decrement('brackets');
+ }
+
+ while (state.parens > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
+ state.output = utils.escapeLast(state.output, '(');
+ decrement('parens');
+ }
+
+ while (state.braces > 0) {
+ if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
+ state.output = utils.escapeLast(state.output, '{');
+ decrement('braces');
+ }
+
+ if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
+ push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
+ }
+
+ // rebuild the output if we had to backtrack at any point
+ if (state.backtrack === true) {
+ state.output = '';
+
+ for (let token of state.tokens) {
+ state.output += token.output != null ? token.output : token.value;
+
+ if (token.suffix) {
+ state.output += token.suffix;
}
+ }
+ }
+
+ return state;
+};
+
+/**
+ * Fast paths for creating regular expressions for common glob patterns.
+ * This can significantly speed up processing and has very little downside
+ * impact when none of the fast paths match.
+ */
+
+parse.fastpaths = (input, options) => {
+ let opts = { ...options };
+ let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+ let len = input.length;
+ if (len > max) {
+ throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+ }
+
+ input = REPLACEMENTS[input] || input;
+ let win32 = utils.isWindows(options);
+
+ // create constants based on platform, for windows or posix
+ const {
+ DOT_LITERAL,
+ SLASH_LITERAL,
+ ONE_CHAR,
+ DOTS_SLASH,
+ NO_DOT,
+ NO_DOTS,
+ NO_DOTS_SLASH,
+ STAR,
+ START_ANCHOR
+ } = constants.globChars(win32);
+
+ let capture = opts.capture ? '' : '?:';
+ let star = opts.bash === true ? '.*?' : STAR;
+ let nodot = opts.dot ? NO_DOTS : NO_DOT;
+ let slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+
+ if (opts.capture) {
+ star = `(${star})`;
+ }
+
+ const globstar = (opts) => {
+ return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+ };
+
+ const create = str => {
+ switch (str) {
+ case '*':
+ return `${nodot}${ONE_CHAR}${star}`;
+
+ case '.*':
+ return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+ case '*.*':
+ return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+
+ case '*/*':
+ return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+
+ case '**':
+ return nodot + globstar(opts);
+
+ case '**/*':
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
- prev.value += value;
- append({ value });
- continue;
- }
+ case '**/*.*':
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
- /**
- * If we're inside a quoted string, continue
- * until we reach the closing double quote.
- */
+ case '**/.*':
+ return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
- if (state.quotes === 1 && value !== '"') {
- value = utils.escapeRegex(value);
- prev.value += value;
- append({ value });
- continue;
- }
+ default: {
+ let match = /^(.*?)\.(\w+)$/.exec(str);
+ if (!match) return;
- /**
- * Double quotes
- */
+ let source = create(match[1], options);
+ if (!source) return;
- if (value === '"') {
- state.quotes = state.quotes === 1 ? 0 : 1;
- if (opts.keepQuotes === true) {
- push({ type: 'text', value });
+ return source + DOT_LITERAL + match[2];
}
- continue;
}
+ };
- /**
- * Parentheses
- */
+ let output = create(input);
+ if (output && opts.strictSlashes !== true) {
+ output += `${SLASH_LITERAL}?`;
+ }
- if (value === '(') {
- push({ type: 'paren', value });
- increment('parens');
- continue;
- }
+ return output;
+};
- if (value === ')') {
- if (state.parens === 0 && opts.strictBrackets === true) {
- throw new SyntaxError(syntaxError('opening', '('));
- }
+module.exports = parse;
- let extglob = extglobs[extglobs.length - 1];
- if (extglob && state.parens === extglob.parens + 1) {
- extglobClose(extglobs.pop());
- continue;
- }
- push({ type: 'paren', value, output: state.parens ? ')' : '\\)' });
- decrement('parens');
- continue;
- }
+/***/ }),
+/* 619 */
+/***/ (function(module, exports, __webpack_require__) {
- /**
- * Brackets
- */
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const merge2 = __webpack_require__(585);
+function merge(streams) {
+ const mergedStream = merge2(streams);
+ streams.forEach((stream) => {
+ stream.once('error', (err) => mergedStream.emit('error', err));
+ });
+ return mergedStream;
+}
+exports.merge = merge;
- if (value === '[') {
- if (opts.nobracket === true || !input.slice(state.index + 1).includes(']')) {
- if (opts.nobracket !== true && opts.strictBrackets === true) {
- throw new SyntaxError(syntaxError('closing', ']'));
- }
- value = '\\' + value;
- } else {
- increment('brackets');
- }
+/***/ }),
+/* 620 */
+/***/ (function(module, exports, __webpack_require__) {
- push({ type: 'bracket', value });
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = __webpack_require__(621);
+const provider_1 = __webpack_require__(648);
+class ProviderAsync extends provider_1.default {
+ constructor() {
+ super(...arguments);
+ this._reader = new stream_1.default(this._settings);
+ }
+ read(task) {
+ const root = this._getRootDirectory(task);
+ const options = this._getReaderOptions(task);
+ const entries = [];
+ return new Promise((resolve, reject) => {
+ const stream = this.api(root, task, options);
+ stream.once('error', reject);
+ stream.on('data', (entry) => entries.push(options.transform(entry)));
+ stream.once('end', () => resolve(entries));
+ });
+ }
+ api(root, task, options) {
+ if (task.dynamic) {
+ return this._reader.dynamic(root, options);
+ }
+ return this._reader.static(task.patterns, options);
+ }
+}
+exports.default = ProviderAsync;
- if (value === ']') {
- if (opts.nobracket === true || (prev && prev.type === 'bracket' && prev.value.length === 1)) {
- push({ type: 'text', value, output: '\\' + value });
- continue;
- }
- if (state.brackets === 0) {
- if (opts.strictBrackets === true) {
- throw new SyntaxError(syntaxError('opening', '['));
- }
+/***/ }),
+/* 621 */
+/***/ (function(module, exports, __webpack_require__) {
- push({ type: 'text', value, output: '\\' + value });
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = __webpack_require__(382);
+const fsStat = __webpack_require__(622);
+const fsWalk = __webpack_require__(627);
+const reader_1 = __webpack_require__(647);
+class ReaderStream extends reader_1.default {
+ constructor() {
+ super(...arguments);
+ this._walkStream = fsWalk.walkStream;
+ this._stat = fsStat.stat;
+ }
+ dynamic(root, options) {
+ return this._walkStream(root, options);
+ }
+ static(patterns, options) {
+ const filepaths = patterns.map(this._getFullEntryPath, this);
+ const stream = new stream_1.PassThrough({ objectMode: true });
+ stream._write = (index, _enc, done) => {
+ return this._getEntry(filepaths[index], patterns[index], options)
+ .then((entry) => {
+ if (entry !== null && options.entryFilter(entry)) {
+ stream.push(entry);
+ }
+ if (index === filepaths.length - 1) {
+ stream.end();
+ }
+ done();
+ })
+ .catch(done);
+ };
+ for (let i = 0; i < filepaths.length; i++) {
+ stream.write(i);
+ }
+ return stream;
+ }
+ _getEntry(filepath, pattern, options) {
+ return this._getStat(filepath)
+ .then((stats) => this._makeEntry(stats, pattern))
+ .catch((error) => {
+ if (options.errorFilter(error)) {
+ return null;
+ }
+ throw error;
+ });
+ }
+ _getStat(filepath) {
+ return new Promise((resolve, reject) => {
+ this._stat(filepath, this._fsStatSettings, (error, stats) => {
+ error ? reject(error) : resolve(stats);
+ });
+ });
+ }
+}
+exports.default = ReaderStream;
- decrement('brackets');
- let prevValue = prev.value.slice(1);
- if (prev.posix !== true && prevValue[0] === '^' && !prevValue.includes('/')) {
- value = '/' + value;
- }
+/***/ }),
+/* 622 */
+/***/ (function(module, exports, __webpack_require__) {
- prev.value += value;
- append({ value });
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const async = __webpack_require__(623);
+const sync = __webpack_require__(624);
+const settings_1 = __webpack_require__(625);
+exports.Settings = settings_1.default;
+function stat(path, optionsOrSettingsOrCallback, callback) {
+ if (typeof optionsOrSettingsOrCallback === 'function') {
+ return async.read(path, getSettings(), optionsOrSettingsOrCallback);
+ }
+ async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
+}
+exports.stat = stat;
+function statSync(path, optionsOrSettings) {
+ const settings = getSettings(optionsOrSettings);
+ return sync.read(path, settings);
+}
+exports.statSync = statSync;
+function getSettings(settingsOrOptions = {}) {
+ if (settingsOrOptions instanceof settings_1.default) {
+ return settingsOrOptions;
+ }
+ return new settings_1.default(settingsOrOptions);
+}
- // when literal brackets are explicitly disabled
- // assume we should match with a regex character class
- if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
- continue;
- }
- let escaped = utils.escapeRegex(prev.value);
- state.output = state.output.slice(0, -prev.value.length);
+/***/ }),
+/* 623 */
+/***/ (function(module, exports, __webpack_require__) {
- // when literal brackets are explicitly enabled
- // assume we should escape the brackets to match literal characters
- if (opts.literalBrackets === true) {
- state.output += escaped;
- prev.value = escaped;
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+function read(path, settings, callback) {
+ settings.fs.lstat(path, (lstatError, lstat) => {
+ if (lstatError) {
+ return callFailureCallback(callback, lstatError);
+ }
+ if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+ return callSuccessCallback(callback, lstat);
+ }
+ settings.fs.stat(path, (statError, stat) => {
+ if (statError) {
+ if (settings.throwErrorOnBrokenSymbolicLink) {
+ return callFailureCallback(callback, statError);
+ }
+ return callSuccessCallback(callback, lstat);
+ }
+ if (settings.markSymbolicLink) {
+ stat.isSymbolicLink = () => true;
+ }
+ callSuccessCallback(callback, stat);
+ });
+ });
+}
+exports.read = read;
+function callFailureCallback(callback, error) {
+ callback(error);
+}
+function callSuccessCallback(callback, result) {
+ callback(null, result);
+}
- // when the user specifies nothing, try to match both
- prev.value = `(${capture}${escaped}|${prev.value})`;
- state.output += prev.value;
- continue;
- }
- /**
- * Braces
- */
+/***/ }),
+/* 624 */
+/***/ (function(module, exports, __webpack_require__) {
- if (value === '{' && opts.nobrace !== true) {
- push({ type: 'brace', value, output: '(' });
- increment('braces');
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+function read(path, settings) {
+ const lstat = settings.fs.lstatSync(path);
+ if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+ return lstat;
+ }
+ try {
+ const stat = settings.fs.statSync(path);
+ if (settings.markSymbolicLink) {
+ stat.isSymbolicLink = () => true;
+ }
+ return stat;
+ }
+ catch (error) {
+ if (!settings.throwErrorOnBrokenSymbolicLink) {
+ return lstat;
+ }
+ throw error;
+ }
+}
+exports.read = read;
- if (value === '}') {
- if (opts.nobrace === true || state.braces === 0) {
- push({ type: 'text', value, output: '\\' + value });
- continue;
- }
- let output = ')';
+/***/ }),
+/* 625 */
+/***/ (function(module, exports, __webpack_require__) {
- if (state.dots === true) {
- let arr = tokens.slice();
- let range = [];
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __webpack_require__(626);
+class Settings {
+ constructor(_options = {}) {
+ this._options = _options;
+ this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
+ this.fs = fs.createFileSystemAdapter(this._options.fs);
+ this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
+ this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+ }
+ _getValue(option, value) {
+ return option === undefined ? value : option;
+ }
+}
+exports.default = Settings;
- for (let i = arr.length - 1; i >= 0; i--) {
- tokens.pop();
- if (arr[i].type === 'brace') {
- break;
- }
- if (arr[i].type !== 'dots') {
- range.unshift(arr[i].value);
- }
- }
- output = expandRange(range, opts);
- state.backtrack = true;
- }
+/***/ }),
+/* 626 */
+/***/ (function(module, exports, __webpack_require__) {
- push({ type: 'brace', value, output });
- decrement('braces');
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __webpack_require__(349);
+exports.FILE_SYSTEM_ADAPTER = {
+ lstat: fs.lstat,
+ stat: fs.stat,
+ lstatSync: fs.lstatSync,
+ statSync: fs.statSync
+};
+function createFileSystemAdapter(fsMethods) {
+ if (!fsMethods) {
+ return exports.FILE_SYSTEM_ADAPTER;
+ }
+ return Object.assign({}, exports.FILE_SYSTEM_ADAPTER, fsMethods);
+}
+exports.createFileSystemAdapter = createFileSystemAdapter;
- /**
- * Pipes
- */
- if (value === '|') {
- if (extglobs.length > 0) {
- extglobs[extglobs.length - 1].conditions++;
- }
- push({ type: 'text', value });
- continue;
- }
+/***/ }),
+/* 627 */
+/***/ (function(module, exports, __webpack_require__) {
- /**
- * Commas
- */
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const async_1 = __webpack_require__(628);
+const stream_1 = __webpack_require__(643);
+const sync_1 = __webpack_require__(644);
+const settings_1 = __webpack_require__(646);
+exports.Settings = settings_1.default;
+function walk(dir, optionsOrSettingsOrCallback, callback) {
+ if (typeof optionsOrSettingsOrCallback === 'function') {
+ return new async_1.default(dir, getSettings()).read(optionsOrSettingsOrCallback);
+ }
+ new async_1.default(dir, getSettings(optionsOrSettingsOrCallback)).read(callback);
+}
+exports.walk = walk;
+function walkSync(dir, optionsOrSettings) {
+ const settings = getSettings(optionsOrSettings);
+ const provider = new sync_1.default(dir, settings);
+ return provider.read();
+}
+exports.walkSync = walkSync;
+function walkStream(dir, optionsOrSettings) {
+ const settings = getSettings(optionsOrSettings);
+ const provider = new stream_1.default(dir, settings);
+ return provider.read();
+}
+exports.walkStream = walkStream;
+function getSettings(settingsOrOptions = {}) {
+ if (settingsOrOptions instanceof settings_1.default) {
+ return settingsOrOptions;
+ }
+ return new settings_1.default(settingsOrOptions);
+}
- if (value === ',') {
- let output = value;
- if (state.braces > 0 && stack[stack.length - 1] === 'braces') {
- output = '|';
- }
+/***/ }),
+/* 628 */
+/***/ (function(module, exports, __webpack_require__) {
- push({ type: 'comma', value, output });
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const async_1 = __webpack_require__(629);
+class AsyncProvider {
+ constructor(_root, _settings) {
+ this._root = _root;
+ this._settings = _settings;
+ this._reader = new async_1.default(this._root, this._settings);
+ this._storage = new Set();
+ }
+ read(callback) {
+ this._reader.onError((error) => {
+ callFailureCallback(callback, error);
+ });
+ this._reader.onEntry((entry) => {
+ this._storage.add(entry);
+ });
+ this._reader.onEnd(() => {
+ callSuccessCallback(callback, Array.from(this._storage));
+ });
+ this._reader.read();
+ }
+}
+exports.default = AsyncProvider;
+function callFailureCallback(callback, error) {
+ callback(error);
+}
+function callSuccessCallback(callback, entries) {
+ callback(null, entries);
+}
- /**
- * Slashes
- */
- if (value === '/') {
- // if the beginning of the glob is "./", advance the start
- // to the current index, and don't add the "./" characters
- // to the state. This greatly simplifies lookbehinds when
- // checking for BOS characters like "!" and "." (not "./")
- if (prev.type === 'dot' && state.index === 1) {
- state.start = state.index + 1;
- state.consumed = '';
- state.output = '';
- tokens.pop();
- prev = bos; // reset "prev" to the first token
- continue;
- }
+/***/ }),
+/* 629 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = __webpack_require__(373);
+const fsScandir = __webpack_require__(630);
+const fastq = __webpack_require__(639);
+const common = __webpack_require__(641);
+const reader_1 = __webpack_require__(642);
+class AsyncReader extends reader_1.default {
+ constructor(_root, _settings) {
+ super(_root, _settings);
+ this._settings = _settings;
+ this._scandir = fsScandir.scandir;
+ this._emitter = new events_1.EventEmitter();
+ this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
+ this._isFatalError = false;
+ this._isDestroyed = false;
+ this._queue.drain = () => {
+ if (!this._isFatalError) {
+ this._emitter.emit('end');
+ }
+ };
+ }
+ read() {
+ this._isFatalError = false;
+ this._isDestroyed = false;
+ setImmediate(() => {
+ this._pushToQueue(this._root, this._settings.basePath);
+ });
+ return this._emitter;
+ }
+ destroy() {
+ if (this._isDestroyed) {
+ throw new Error('The reader is already destroyed');
+ }
+ this._isDestroyed = true;
+ this._queue.killAndDrain();
+ }
+ onEntry(callback) {
+ this._emitter.on('entry', callback);
+ }
+ onError(callback) {
+ this._emitter.once('error', callback);
+ }
+ onEnd(callback) {
+ this._emitter.once('end', callback);
+ }
+ _pushToQueue(dir, base) {
+ const queueItem = { dir, base };
+ this._queue.push(queueItem, (error) => {
+ if (error) {
+ this._handleError(error);
+ }
+ });
+ }
+ _worker(item, done) {
+ this._scandir(item.dir, this._settings.fsScandirSettings, (error, entries) => {
+ if (error) {
+ return done(error, undefined);
+ }
+ for (const entry of entries) {
+ this._handleEntry(entry, item.base);
+ }
+ done(null, undefined);
+ });
+ }
+ _handleError(error) {
+ if (!common.isFatalError(this._settings, error)) {
+ return;
+ }
+ this._isFatalError = true;
+ this._isDestroyed = true;
+ this._emitter.emit('error', error);
+ }
+ _handleEntry(entry, base) {
+ if (this._isDestroyed || this._isFatalError) {
+ return;
+ }
+ const fullpath = entry.path;
+ if (base !== undefined) {
+ entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+ }
+ if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
+ this._emitEntry(entry);
+ }
+ if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
+ this._pushToQueue(fullpath, entry.path);
+ }
+ }
+ _emitEntry(entry) {
+ this._emitter.emit('entry', entry);
+ }
+}
+exports.default = AsyncReader;
- push({ type: 'slash', value, output: SLASH_LITERAL });
- continue;
- }
- /**
- * Dots
- */
+/***/ }),
+/* 630 */
+/***/ (function(module, exports, __webpack_require__) {
- if (value === '.') {
- if (state.braces > 0 && prev.type === 'dot') {
- if (prev.value === '.') prev.output = DOT_LITERAL;
- prev.type = 'dots';
- prev.output += value;
- prev.value += value;
- state.dots = true;
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const async = __webpack_require__(631);
+const sync = __webpack_require__(636);
+const settings_1 = __webpack_require__(637);
+exports.Settings = settings_1.default;
+function scandir(path, optionsOrSettingsOrCallback, callback) {
+ if (typeof optionsOrSettingsOrCallback === 'function') {
+ return async.read(path, getSettings(), optionsOrSettingsOrCallback);
+ }
+ async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
+}
+exports.scandir = scandir;
+function scandirSync(path, optionsOrSettings) {
+ const settings = getSettings(optionsOrSettings);
+ return sync.read(path, settings);
+}
+exports.scandirSync = scandirSync;
+function getSettings(settingsOrOptions = {}) {
+ if (settingsOrOptions instanceof settings_1.default) {
+ return settingsOrOptions;
+ }
+ return new settings_1.default(settingsOrOptions);
+}
- push({ type: 'dot', value, output: DOT_LITERAL });
- continue;
- }
- /**
- * Question marks
- */
+/***/ }),
+/* 631 */
+/***/ (function(module, exports, __webpack_require__) {
- if (value === '?') {
- if (prev && prev.type === 'paren') {
- let next = peek();
- let output = value;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const fsStat = __webpack_require__(622);
+const rpl = __webpack_require__(632);
+const constants_1 = __webpack_require__(633);
+const utils = __webpack_require__(634);
+function read(dir, settings, callback) {
+ if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+ return readdirWithFileTypes(dir, settings, callback);
+ }
+ return readdir(dir, settings, callback);
+}
+exports.read = read;
+function readdirWithFileTypes(dir, settings, callback) {
+ settings.fs.readdir(dir, { withFileTypes: true }, (readdirError, dirents) => {
+ if (readdirError) {
+ return callFailureCallback(callback, readdirError);
+ }
+ const entries = dirents.map((dirent) => ({
+ dirent,
+ name: dirent.name,
+ path: `${dir}${settings.pathSegmentSeparator}${dirent.name}`
+ }));
+ if (!settings.followSymbolicLinks) {
+ return callSuccessCallback(callback, entries);
+ }
+ const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
+ rpl(tasks, (rplError, rplEntries) => {
+ if (rplError) {
+ return callFailureCallback(callback, rplError);
+ }
+ callSuccessCallback(callback, rplEntries);
+ });
+ });
+}
+exports.readdirWithFileTypes = readdirWithFileTypes;
+function makeRplTaskEntry(entry, settings) {
+ return (done) => {
+ if (!entry.dirent.isSymbolicLink()) {
+ return done(null, entry);
+ }
+ settings.fs.stat(entry.path, (statError, stats) => {
+ if (statError) {
+ if (settings.throwErrorOnBrokenSymbolicLink) {
+ return done(statError);
+ }
+ return done(null, entry);
+ }
+ entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
+ return done(null, entry);
+ });
+ };
+}
+function readdir(dir, settings, callback) {
+ settings.fs.readdir(dir, (readdirError, names) => {
+ if (readdirError) {
+ return callFailureCallback(callback, readdirError);
+ }
+ const filepaths = names.map((name) => `${dir}${settings.pathSegmentSeparator}${name}`);
+ const tasks = filepaths.map((filepath) => {
+ return (done) => fsStat.stat(filepath, settings.fsStatSettings, done);
+ });
+ rpl(tasks, (rplError, results) => {
+ if (rplError) {
+ return callFailureCallback(callback, rplError);
+ }
+ const entries = [];
+ for (let index = 0; index < names.length; index++) {
+ const name = names[index];
+ const stats = results[index];
+ const entry = {
+ name,
+ path: filepaths[index],
+ dirent: utils.fs.createDirentFromStats(name, stats)
+ };
+ if (settings.stats) {
+ entry.stats = stats;
+ }
+ entries.push(entry);
+ }
+ callSuccessCallback(callback, entries);
+ });
+ });
+}
+exports.readdir = readdir;
+function callFailureCallback(callback, error) {
+ callback(error);
+}
+function callSuccessCallback(callback, result) {
+ callback(null, result);
+}
- if (next === '<' && !utils.supportsLookbehinds()) {
- throw new Error('Node.js v10 or higher is required for regex lookbehinds');
- }
- if (prev.value === '(' && !/[!=<:]/.test(next) || (next === '<' && !/[!=]/.test(peek(2)))) {
- output = '\\' + value;
- }
+/***/ }),
+/* 632 */
+/***/ (function(module, exports) {
- push({ type: 'text', value, output });
- continue;
- }
+module.exports = runParallel
- if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
- extglobOpen('qmark', value);
- continue;
- }
+function runParallel (tasks, cb) {
+ var results, pending, keys
+ var isSync = true
- if (opts.dot !== true && (prev.type === 'slash' || prev.type === 'bos')) {
- push({ type: 'qmark', value, output: QMARK_NO_DOT });
- continue;
- }
+ if (Array.isArray(tasks)) {
+ results = []
+ pending = tasks.length
+ } else {
+ keys = Object.keys(tasks)
+ results = {}
+ pending = keys.length
+ }
- push({ type: 'qmark', value, output: QMARK });
- continue;
+ function done (err) {
+ function end () {
+ if (cb) cb(err, results)
+ cb = null
}
+ if (isSync) process.nextTick(end)
+ else end()
+ }
- /**
- * Exclamation
- */
-
- if (value === '!') {
- if (opts.noextglob !== true && peek() === '(') {
- if (peek(2) !== '?' || !/[!=<:]/.test(peek(3))) {
- extglobOpen('negate', value);
- continue;
- }
- }
-
- if (opts.nonegate !== true && state.index === 0) {
- negate(state);
- continue;
- }
+ function each (i, err, result) {
+ results[i] = result
+ if (--pending === 0 || err) {
+ done(err)
}
+ }
- /**
- * Plus
- */
-
- if (value === '+') {
- if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
- extglobOpen('plus', value);
- continue;
- }
+ if (!pending) {
+ // empty
+ done(null)
+ } else if (keys) {
+ // object
+ keys.forEach(function (key) {
+ tasks[key](function (err, result) { each(key, err, result) })
+ })
+ } else {
+ // array
+ tasks.forEach(function (task, i) {
+ task(function (err, result) { each(i, err, result) })
+ })
+ }
- if (prev && (prev.type === 'bracket' || prev.type === 'paren' || prev.type === 'brace')) {
- let output = prev.extglob === true ? '\\' + value : value;
- push({ type: 'plus', value, output });
- continue;
- }
+ isSync = false
+}
- // use regex behavior inside parens
- if (state.parens > 0 && opts.regex !== false) {
- push({ type: 'plus', value });
- continue;
- }
- push({ type: 'plus', value: PLUS_LITERAL });
- continue;
- }
+/***/ }),
+/* 633 */
+/***/ (function(module, exports, __webpack_require__) {
- /**
- * Plain text
- */
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
+const MAJOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
+const MINOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
+exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = MAJOR_VERSION > 10 || (MAJOR_VERSION === 10 && MINOR_VERSION >= 10);
- if (value === '@') {
- if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
- push({ type: 'at', value, output: '' });
- continue;
- }
- push({ type: 'text', value });
- continue;
- }
+/***/ }),
+/* 634 */
+/***/ (function(module, exports, __webpack_require__) {
- /**
- * Plain text
- */
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __webpack_require__(635);
+exports.fs = fs;
- if (value !== '*') {
- if (value === '$' || value === '^') {
- value = '\\' + value;
- }
- let match = REGEX_NON_SPECIAL_CHAR.exec(input.slice(state.index + 1));
- if (match) {
- value += match[0];
- state.index += match[0].length;
- }
+/***/ }),
+/* 635 */
+/***/ (function(module, exports, __webpack_require__) {
- push({ type: 'text', value });
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+class DirentFromStats {
+ constructor(name, stats) {
+ this.name = name;
+ this.isBlockDevice = stats.isBlockDevice.bind(stats);
+ this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+ this.isDirectory = stats.isDirectory.bind(stats);
+ this.isFIFO = stats.isFIFO.bind(stats);
+ this.isFile = stats.isFile.bind(stats);
+ this.isSocket = stats.isSocket.bind(stats);
+ this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+ }
+}
+function createDirentFromStats(name, stats) {
+ return new DirentFromStats(name, stats);
+}
+exports.createDirentFromStats = createDirentFromStats;
- /**
- * Stars
- */
- if (prev && (prev.type === 'globstar' || prev.star === true)) {
- prev.type = 'star';
- prev.star = true;
- prev.value += value;
- prev.output = star;
- state.backtrack = true;
- state.consumed += value;
- continue;
- }
+/***/ }),
+/* 636 */
+/***/ (function(module, exports, __webpack_require__) {
- if (opts.noextglob !== true && peek() === '(' && peek(2) !== '?') {
- extglobOpen('star', value);
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const fsStat = __webpack_require__(622);
+const constants_1 = __webpack_require__(633);
+const utils = __webpack_require__(634);
+function read(dir, settings) {
+ if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+ return readdirWithFileTypes(dir, settings);
+ }
+ return readdir(dir, settings);
+}
+exports.read = read;
+function readdirWithFileTypes(dir, settings) {
+ const dirents = settings.fs.readdirSync(dir, { withFileTypes: true });
+ return dirents.map((dirent) => {
+ const entry = {
+ dirent,
+ name: dirent.name,
+ path: `${dir}${settings.pathSegmentSeparator}${dirent.name}`
+ };
+ if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
+ try {
+ const stats = settings.fs.statSync(entry.path);
+ entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
+ }
+ catch (error) {
+ if (settings.throwErrorOnBrokenSymbolicLink) {
+ throw error;
+ }
+ }
+ }
+ return entry;
+ });
+}
+exports.readdirWithFileTypes = readdirWithFileTypes;
+function readdir(dir, settings) {
+ const names = settings.fs.readdirSync(dir);
+ return names.map((name) => {
+ const entryPath = `${dir}${settings.pathSegmentSeparator}${name}`;
+ const stats = fsStat.statSync(entryPath, settings.fsStatSettings);
+ const entry = {
+ name,
+ path: entryPath,
+ dirent: utils.fs.createDirentFromStats(name, stats)
+ };
+ if (settings.stats) {
+ entry.stats = stats;
+ }
+ return entry;
+ });
+}
+exports.readdir = readdir;
- if (prev.type === 'star') {
- if (opts.noglobstar === true) {
- state.consumed += value;
- continue;
- }
- let prior = prev.prev;
- let before = prior.prev;
- let isStart = prior.type === 'slash' || prior.type === 'bos';
- let afterStar = before && (before.type === 'star' || before.type === 'globstar');
+/***/ }),
+/* 637 */
+/***/ (function(module, exports, __webpack_require__) {
- if (opts.bash === true && (!isStart || (!eos() && peek() !== '/'))) {
- push({ type: 'star', value, output: '' });
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __webpack_require__(4);
+const fsStat = __webpack_require__(622);
+const fs = __webpack_require__(638);
+class Settings {
+ constructor(_options = {}) {
+ this._options = _options;
+ this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
+ this.fs = fs.createFileSystemAdapter(this._options.fs);
+ this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
+ this.stats = this._getValue(this._options.stats, false);
+ this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+ this.fsStatSettings = new fsStat.Settings({
+ followSymbolicLink: this.followSymbolicLinks,
+ fs: this.fs,
+ throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
+ });
+ }
+ _getValue(option, value) {
+ return option === undefined ? value : option;
+ }
+}
+exports.default = Settings;
- let isBrace = state.braces > 0 && (prior.type === 'comma' || prior.type === 'brace');
- let isExtglob = extglobs.length && (prior.type === 'pipe' || prior.type === 'paren');
- if (!isStart && prior.type !== 'paren' && !isBrace && !isExtglob) {
- push({ type: 'star', value, output: '' });
- continue;
- }
- // strip consecutive `/**/`
- while (input.slice(state.index + 1, state.index + 4) === '/**') {
- let after = input[state.index + 4];
- if (after && after !== '/') {
- break;
- }
- state.consumed += '/**';
- state.index += 3;
- }
+/***/ }),
+/* 638 */
+/***/ (function(module, exports, __webpack_require__) {
- if (prior.type === 'bos' && eos()) {
- prev.type = 'globstar';
- prev.value += value;
- prev.output = globstar(opts);
- state.output = prev.output;
- state.consumed += value;
- continue;
- }
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __webpack_require__(349);
+exports.FILE_SYSTEM_ADAPTER = {
+ lstat: fs.lstat,
+ stat: fs.stat,
+ lstatSync: fs.lstatSync,
+ statSync: fs.statSync,
+ readdir: fs.readdir,
+ readdirSync: fs.readdirSync
+};
+function createFileSystemAdapter(fsMethods) {
+ if (!fsMethods) {
+ return exports.FILE_SYSTEM_ADAPTER;
+ }
+ return Object.assign({}, exports.FILE_SYSTEM_ADAPTER, fsMethods);
+}
+exports.createFileSystemAdapter = createFileSystemAdapter;
- if (prior.type === 'slash' && prior.prev.type !== 'bos' && !afterStar && eos()) {
- state.output = state.output.slice(0, -(prior.output + prev.output).length);
- prior.output = '(?:' + prior.output;
- prev.type = 'globstar';
- prev.output = globstar(opts) + '|$)';
- prev.value += value;
+/***/ }),
+/* 639 */
+/***/ (function(module, exports, __webpack_require__) {
- state.output += prior.output + prev.output;
- state.consumed += value;
- continue;
- }
+"use strict";
- let next = peek();
- if (prior.type === 'slash' && prior.prev.type !== 'bos' && next === '/') {
- let end = peek(2) !== void 0 ? '|$' : '';
- state.output = state.output.slice(0, -(prior.output + prev.output).length);
- prior.output = '(?:' + prior.output;
+var reusify = __webpack_require__(640)
- prev.type = 'globstar';
- prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
- prev.value += value;
+function fastqueue (context, worker, concurrency) {
+ if (typeof context === 'function') {
+ concurrency = worker
+ worker = context
+ context = null
+ }
- state.output += prior.output + prev.output;
- state.consumed += value + advance();
+ var cache = reusify(Task)
+ var queueHead = null
+ var queueTail = null
+ var _running = 0
- push({ type: 'slash', value, output: '' });
- continue;
- }
+ var self = {
+ push: push,
+ drain: noop,
+ saturated: noop,
+ pause: pause,
+ paused: false,
+ concurrency: concurrency,
+ running: running,
+ resume: resume,
+ idle: idle,
+ length: length,
+ unshift: unshift,
+ empty: noop,
+ kill: kill,
+ killAndDrain: killAndDrain
+ }
- if (prior.type === 'bos' && next === '/') {
- prev.type = 'globstar';
- prev.value += value;
- prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
- state.output = prev.output;
- state.consumed += value + advance();
- push({ type: 'slash', value, output: '' });
- continue;
- }
+ return self
- // remove single star from output
- state.output = state.output.slice(0, -prev.output.length);
+ function running () {
+ return _running
+ }
- // reset previous token to globstar
- prev.type = 'globstar';
- prev.output = globstar(opts);
- prev.value += value;
+ function pause () {
+ self.paused = true
+ }
- // reset output with globstar
- state.output += prev.output;
- state.consumed += value;
- continue;
+ function length () {
+ var current = queueHead
+ var counter = 0
+
+ while (current) {
+ current = current.next
+ counter++
}
- let token = { type: 'star', value, output: star };
+ return counter
+ }
- if (opts.bash === true) {
- token.output = '.*?';
- if (prev.type === 'bos' || prev.type === 'slash') {
- token.output = nodot + token.output;
- }
- push(token);
- continue;
+ function resume () {
+ if (!self.paused) return
+ self.paused = false
+ for (var i = 0; i < self.concurrency; i++) {
+ _running++
+ release()
}
+ }
- if (prev && (prev.type === 'bracket' || prev.type === 'paren') && opts.regex === true) {
- token.output = value;
- push(token);
- continue;
- }
+ function idle () {
+ return _running === 0 && self.length() === 0
+ }
- if (state.index === state.start || prev.type === 'slash' || prev.type === 'dot') {
- if (prev.type === 'dot') {
- state.output += NO_DOT_SLASH;
- prev.output += NO_DOT_SLASH;
+ function push (value, done) {
+ var current = cache.get()
- } else if (opts.dot === true) {
- state.output += NO_DOTS_SLASH;
- prev.output += NO_DOTS_SLASH;
+ current.context = context
+ current.release = release
+ current.value = value
+ current.callback = done || noop
+ if (_running === self.concurrency || self.paused) {
+ if (queueTail) {
+ queueTail.next = current
+ queueTail = current
} else {
- state.output += nodot;
- prev.output += nodot;
+ queueHead = current
+ queueTail = current
+ self.saturated()
}
+ } else {
+ _running++
+ worker.call(context, current.value, current.worked)
+ }
+ }
- if (peek() !== '*') {
- state.output += ONE_CHAR;
- prev.output += ONE_CHAR;
+ function unshift (value, done) {
+ var current = cache.get()
+
+ current.context = context
+ current.release = release
+ current.value = value
+ current.callback = done || noop
+
+ if (_running === self.concurrency || self.paused) {
+ if (queueHead) {
+ current.next = queueHead
+ queueHead = current
+ } else {
+ queueHead = current
+ queueTail = current
+ self.saturated()
}
+ } else {
+ _running++
+ worker.call(context, current.value, current.worked)
}
-
- push(token);
}
- while (state.brackets > 0) {
- if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
- state.output = utils.escapeLast(state.output, '[');
- decrement('brackets');
+ function release (holder) {
+ if (holder) {
+ cache.release(holder)
+ }
+ var next = queueHead
+ if (next) {
+ if (!self.paused) {
+ if (queueTail === queueHead) {
+ queueTail = null
+ }
+ queueHead = next.next
+ next.next = null
+ worker.call(context, next.value, next.worked)
+ if (queueTail === null) {
+ self.empty()
+ }
+ } else {
+ _running--
+ }
+ } else if (--_running === 0) {
+ self.drain()
+ }
}
- while (state.parens > 0) {
- if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
- state.output = utils.escapeLast(state.output, '(');
- decrement('parens');
+ function kill () {
+ queueHead = null
+ queueTail = null
+ self.drain = noop
}
- while (state.braces > 0) {
- if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
- state.output = utils.escapeLast(state.output, '{');
- decrement('braces');
+ function killAndDrain () {
+ queueHead = null
+ queueTail = null
+ self.drain()
+ self.drain = noop
}
+}
- if (opts.strictSlashes !== true && (prev.type === 'star' || prev.type === 'bracket')) {
- push({ type: 'maybe_slash', value: '', output: `${SLASH_LITERAL}?` });
- }
+function noop () {}
- // rebuild the output if we had to backtrack at any point
- if (state.backtrack === true) {
- state.output = '';
+function Task () {
+ this.value = null
+ this.callback = noop
+ this.next = null
+ this.release = noop
+ this.context = null
- for (let token of state.tokens) {
- state.output += token.output != null ? token.output : token.value;
+ var self = this
- if (token.suffix) {
- state.output += token.suffix;
- }
- }
+ this.worked = function worked (err, result) {
+ var callback = self.callback
+ self.value = null
+ self.callback = noop
+ callback.call(self.context, err, result)
+ self.release(self)
}
+}
- return state;
-};
+module.exports = fastqueue
-/**
- * Fast paths for creating regular expressions for common glob patterns.
- * This can significantly speed up processing and has very little downside
- * impact when none of the fast paths match.
- */
-parse.fastpaths = (input, options) => {
- let opts = { ...options };
- let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
- let len = input.length;
- if (len > max) {
- throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
- }
+/***/ }),
+/* 640 */
+/***/ (function(module, exports, __webpack_require__) {
- input = REPLACEMENTS[input] || input;
- let win32 = utils.isWindows(options);
+"use strict";
- // create constants based on platform, for windows or posix
- const {
- DOT_LITERAL,
- SLASH_LITERAL,
- ONE_CHAR,
- DOTS_SLASH,
- NO_DOT,
- NO_DOTS,
- NO_DOTS_SLASH,
- STAR,
- START_ANCHOR
- } = constants.globChars(win32);
- let capture = opts.capture ? '' : '?:';
- let star = opts.bash === true ? '.*?' : STAR;
- let nodot = opts.dot ? NO_DOTS : NO_DOT;
- let slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+function reusify (Constructor) {
+ var head = new Constructor()
+ var tail = head
- if (opts.capture) {
- star = `(${star})`;
- }
+ function get () {
+ var current = head
- const globstar = (opts) => {
- return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
- };
+ if (current.next) {
+ head = current.next
+ } else {
+ head = new Constructor()
+ tail = head
+ }
- const create = str => {
- switch (str) {
- case '*':
- return `${nodot}${ONE_CHAR}${star}`;
+ current.next = null
- case '.*':
- return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+ return current
+ }
- case '*.*':
- return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+ function release (obj) {
+ tail.next = obj
+ tail = obj
+ }
- case '*/*':
- return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+ return {
+ get: get,
+ release: release
+ }
+}
- case '**':
- return nodot + globstar(opts);
+module.exports = reusify
- case '**/*':
- return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
- case '**/*.*':
- return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+/***/ }),
+/* 641 */
+/***/ (function(module, exports, __webpack_require__) {
- case '**/.*':
- return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+function isFatalError(settings, error) {
+ if (settings.errorFilter === null) {
+ return true;
+ }
+ return !settings.errorFilter(error);
+}
+exports.isFatalError = isFatalError;
+function isAppliedFilter(filter, value) {
+ return filter === null || filter(value);
+}
+exports.isAppliedFilter = isAppliedFilter;
+function replacePathSegmentSeparator(filepath, separator) {
+ return filepath.split(/[\\\/]/).join(separator);
+}
+exports.replacePathSegmentSeparator = replacePathSegmentSeparator;
+function joinPathSegments(a, b, separator) {
+ if (a === '') {
+ return b;
+ }
+ return a + separator + b;
+}
+exports.joinPathSegments = joinPathSegments;
- default: {
- let match = /^(.*?)\.(\w+)$/.exec(str);
- if (!match) return;
- let source = create(match[1], options);
- if (!source) return;
+/***/ }),
+/* 642 */
+/***/ (function(module, exports, __webpack_require__) {
- return source + DOT_LITERAL + match[2];
- }
- }
- };
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const common = __webpack_require__(641);
+class Reader {
+ constructor(_root, _settings) {
+ this._root = _root;
+ this._settings = _settings;
+ this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
+ }
+}
+exports.default = Reader;
- let output = create(input);
- if (output && opts.strictSlashes !== true) {
- output += `${SLASH_LITERAL}?`;
- }
- return output;
-};
+/***/ }),
+/* 643 */
+/***/ (function(module, exports, __webpack_require__) {
-module.exports = parse;
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = __webpack_require__(382);
+const async_1 = __webpack_require__(629);
+class StreamProvider {
+ constructor(_root, _settings) {
+ this._root = _root;
+ this._settings = _settings;
+ this._reader = new async_1.default(this._root, this._settings);
+ this._stream = new stream_1.Readable({
+ objectMode: true,
+ read: () => { },
+ destroy: this._reader.destroy.bind(this._reader)
+ });
+ }
+ read() {
+ this._reader.onError((error) => {
+ this._stream.emit('error', error);
+ });
+ this._reader.onEntry((entry) => {
+ this._stream.push(entry);
+ });
+ this._reader.onEnd(() => {
+ this._stream.push(null);
+ });
+ this._reader.read();
+ return this._stream;
+ }
+}
+exports.default = StreamProvider;
/***/ }),
-/* 624 */
+/* 644 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const merge2 = __webpack_require__(590);
-function merge(streams) {
- const mergedStream = merge2(streams);
- streams.forEach((stream) => {
- stream.once('error', (err) => mergedStream.emit('error', err));
- });
- return mergedStream;
+const sync_1 = __webpack_require__(645);
+class SyncProvider {
+ constructor(_root, _settings) {
+ this._root = _root;
+ this._settings = _settings;
+ this._reader = new sync_1.default(this._root, this._settings);
+ }
+ read() {
+ return this._reader.read();
+ }
}
-exports.merge = merge;
+exports.default = SyncProvider;
/***/ }),
-/* 625 */
+/* 645 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const stream_1 = __webpack_require__(626);
-const provider_1 = __webpack_require__(653);
-class ProviderAsync extends provider_1.default {
+const fsScandir = __webpack_require__(630);
+const common = __webpack_require__(641);
+const reader_1 = __webpack_require__(642);
+class SyncReader extends reader_1.default {
constructor() {
super(...arguments);
- this._reader = new stream_1.default(this._settings);
+ this._scandir = fsScandir.scandirSync;
+ this._storage = new Set();
+ this._queue = new Set();
}
- read(task) {
- const root = this._getRootDirectory(task);
- const options = this._getReaderOptions(task);
- const entries = [];
- return new Promise((resolve, reject) => {
- const stream = this.api(root, task, options);
- stream.once('error', reject);
- stream.on('data', (entry) => entries.push(options.transform(entry)));
- stream.once('end', () => resolve(entries));
+ read() {
+ this._pushToQueue(this._root, this._settings.basePath);
+ this._handleQueue();
+ return Array.from(this._storage);
+ }
+ _pushToQueue(dir, base) {
+ this._queue.add({ dir, base });
+ }
+ _handleQueue() {
+ for (const item of this._queue.values()) {
+ this._handleDirectory(item.dir, item.base);
+ }
+ }
+ _handleDirectory(dir, base) {
+ try {
+ const entries = this._scandir(dir, this._settings.fsScandirSettings);
+ for (const entry of entries) {
+ this._handleEntry(entry, base);
+ }
+ }
+ catch (error) {
+ this._handleError(error);
+ }
+ }
+ _handleError(error) {
+ if (!common.isFatalError(this._settings, error)) {
+ return;
+ }
+ throw error;
+ }
+ _handleEntry(entry, base) {
+ const fullpath = entry.path;
+ if (base !== undefined) {
+ entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+ }
+ if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
+ this._pushToStorage(entry);
+ }
+ if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
+ this._pushToQueue(fullpath, entry.path);
+ }
+ }
+ _pushToStorage(entry) {
+ this._storage.add(entry);
+ }
+}
+exports.default = SyncReader;
+
+
+/***/ }),
+/* 646 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __webpack_require__(4);
+const fsScandir = __webpack_require__(630);
+class Settings {
+ constructor(_options = {}) {
+ this._options = _options;
+ this.basePath = this._getValue(this._options.basePath, undefined);
+ this.concurrency = this._getValue(this._options.concurrency, Infinity);
+ this.deepFilter = this._getValue(this._options.deepFilter, null);
+ this.entryFilter = this._getValue(this._options.entryFilter, null);
+ this.errorFilter = this._getValue(this._options.errorFilter, null);
+ this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
+ this.fsScandirSettings = new fsScandir.Settings({
+ followSymbolicLinks: this._options.followSymbolicLinks,
+ fs: this._options.fs,
+ pathSegmentSeparator: this._options.pathSegmentSeparator,
+ stats: this._options.stats,
+ throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
});
}
- api(root, task, options) {
- if (task.dynamic) {
- return this._reader.dynamic(root, options);
- }
- return this._reader.static(task.patterns, options);
+ _getValue(option, value) {
+ return option === undefined ? value : option;
}
}
-exports.default = ProviderAsync;
+exports.default = Settings;
/***/ }),
-/* 626 */
+/* 647 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const stream_1 = __webpack_require__(27);
-const fsStat = __webpack_require__(627);
-const fsWalk = __webpack_require__(632);
-const reader_1 = __webpack_require__(652);
-class ReaderStream extends reader_1.default {
- constructor() {
- super(...arguments);
- this._walkStream = fsWalk.walkStream;
- this._stat = fsStat.stat;
+const path = __webpack_require__(4);
+const fsStat = __webpack_require__(622);
+const utils = __webpack_require__(593);
+class Reader {
+ constructor(_settings) {
+ this._settings = _settings;
+ this._fsStatSettings = new fsStat.Settings({
+ followSymbolicLink: this._settings.followSymbolicLinks,
+ fs: this._settings.fs,
+ throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+ });
}
- dynamic(root, options) {
- return this._walkStream(root, options);
+ _getFullEntryPath(filepath) {
+ return path.resolve(this._settings.cwd, filepath);
}
- static(patterns, options) {
- const filepaths = patterns.map(this._getFullEntryPath, this);
- const stream = new stream_1.PassThrough({ objectMode: true });
- stream._write = (index, _enc, done) => {
- return this._getEntry(filepaths[index], patterns[index], options)
- .then((entry) => {
- if (entry !== null && options.entryFilter(entry)) {
- stream.push(entry);
- }
- if (index === filepaths.length - 1) {
- stream.end();
- }
- done();
- })
- .catch(done);
+ _makeEntry(stats, pattern) {
+ const entry = {
+ name: pattern,
+ path: pattern,
+ dirent: utils.fs.createDirentFromStats(pattern, stats)
};
- for (let i = 0; i < filepaths.length; i++) {
- stream.write(i);
+ if (this._settings.stats) {
+ entry.stats = stats;
}
- return stream;
- }
- _getEntry(filepath, pattern, options) {
- return this._getStat(filepath)
- .then((stats) => this._makeEntry(stats, pattern))
- .catch((error) => {
- if (options.errorFilter(error)) {
- return null;
- }
- throw error;
- });
+ return entry;
}
- _getStat(filepath) {
- return new Promise((resolve, reject) => {
- this._stat(filepath, this._fsStatSettings, (error, stats) => {
- error ? reject(error) : resolve(stats);
- });
- });
+ _isFatalError(error) {
+ return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
}
}
-exports.default = ReaderStream;
+exports.default = Reader;
/***/ }),
-/* 627 */
+/* 648 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const async = __webpack_require__(628);
-const sync = __webpack_require__(629);
-const settings_1 = __webpack_require__(630);
-exports.Settings = settings_1.default;
-function stat(path, optionsOrSettingsOrCallback, callback) {
- if (typeof optionsOrSettingsOrCallback === 'function') {
- return async.read(path, getSettings(), optionsOrSettingsOrCallback);
+const path = __webpack_require__(4);
+const deep_1 = __webpack_require__(649);
+const entry_1 = __webpack_require__(650);
+const error_1 = __webpack_require__(651);
+const entry_2 = __webpack_require__(652);
+class Provider {
+ constructor(_settings) {
+ this._settings = _settings;
+ this.errorFilter = new error_1.default(this._settings);
+ this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
+ this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
+ this.entryTransformer = new entry_2.default(this._settings);
}
- async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
-}
-exports.stat = stat;
-function statSync(path, optionsOrSettings) {
- const settings = getSettings(optionsOrSettings);
- return sync.read(path, settings);
-}
-exports.statSync = statSync;
-function getSettings(settingsOrOptions = {}) {
- if (settingsOrOptions instanceof settings_1.default) {
- return settingsOrOptions;
+ _getRootDirectory(task) {
+ return path.resolve(this._settings.cwd, task.base);
+ }
+ _getReaderOptions(task) {
+ const basePath = task.base === '.' ? '' : task.base;
+ return {
+ basePath,
+ pathSegmentSeparator: '/',
+ concurrency: this._settings.concurrency,
+ deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+ entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+ errorFilter: this.errorFilter.getFilter(),
+ followSymbolicLinks: this._settings.followSymbolicLinks,
+ fs: this._settings.fs,
+ stats: this._settings.stats,
+ throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+ transform: this.entryTransformer.getTransformer()
+ };
+ }
+ _getMicromatchOptions() {
+ return {
+ dot: this._settings.dot,
+ matchBase: this._settings.baseNameMatch,
+ nobrace: !this._settings.braceExpansion,
+ nocase: !this._settings.caseSensitiveMatch,
+ noext: !this._settings.extglob,
+ noglobstar: !this._settings.globstar,
+ posix: true,
+ strictSlashes: false
+ };
}
- return new settings_1.default(settingsOrOptions);
}
+exports.default = Provider;
/***/ }),
-/* 628 */
+/* 649 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-function read(path, settings, callback) {
- settings.fs.lstat(path, (lstatError, lstat) => {
- if (lstatError) {
- return callFailureCallback(callback, lstatError);
+const utils = __webpack_require__(593);
+class DeepFilter {
+ constructor(_settings, _micromatchOptions) {
+ this._settings = _settings;
+ this._micromatchOptions = _micromatchOptions;
+ }
+ getFilter(basePath, positive, negative) {
+ const maxPatternDepth = this._getMaxPatternDepth(positive);
+ const negativeRe = this._getNegativePatternsRe(negative);
+ return (entry) => this._filter(basePath, entry, negativeRe, maxPatternDepth);
+ }
+ _getMaxPatternDepth(patterns) {
+ const globstar = patterns.some(utils.pattern.hasGlobStar);
+ return globstar ? Infinity : utils.pattern.getMaxNaivePatternsDepth(patterns);
+ }
+ _getNegativePatternsRe(patterns) {
+ const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
+ return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
+ }
+ _filter(basePath, entry, negativeRe, maxPatternDepth) {
+ const depth = this._getEntryDepth(basePath, entry.path);
+ if (this._isSkippedByDeep(depth)) {
+ return false;
}
- if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
- return callSuccessCallback(callback, lstat);
+ if (this._isSkippedByMaxPatternDepth(depth, maxPatternDepth)) {
+ return false;
}
- settings.fs.stat(path, (statError, stat) => {
- if (statError) {
- if (settings.throwErrorOnBrokenSymbolicLink) {
- return callFailureCallback(callback, statError);
- }
- return callSuccessCallback(callback, lstat);
- }
- if (settings.markSymbolicLink) {
- stat.isSymbolicLink = () => true;
- }
- callSuccessCallback(callback, stat);
- });
- });
-}
-exports.read = read;
-function callFailureCallback(callback, error) {
- callback(error);
-}
-function callSuccessCallback(callback, result) {
- callback(null, result);
+ if (this._isSkippedSymbolicLink(entry)) {
+ return false;
+ }
+ if (this._isSkippedDotDirectory(entry)) {
+ return false;
+ }
+ return this._isSkippedByNegativePatterns(entry, negativeRe);
+ }
+ _getEntryDepth(basePath, entryPath) {
+ const basePathDepth = basePath.split('/').length;
+ const entryPathDepth = entryPath.split('/').length;
+ return entryPathDepth - (basePath === '' ? 0 : basePathDepth);
+ }
+ _isSkippedByDeep(entryDepth) {
+ return entryDepth >= this._settings.deep;
+ }
+ _isSkippedByMaxPatternDepth(entryDepth, maxPatternDepth) {
+ return !this._settings.baseNameMatch && maxPatternDepth !== Infinity && entryDepth > maxPatternDepth;
+ }
+ _isSkippedSymbolicLink(entry) {
+ return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
+ }
+ _isSkippedDotDirectory(entry) {
+ return !this._settings.dot && entry.name.startsWith('.');
+ }
+ _isSkippedByNegativePatterns(entry, negativeRe) {
+ return !utils.pattern.matchAny(entry.path, negativeRe);
+ }
}
+exports.default = DeepFilter;
/***/ }),
-/* 629 */
+/* 650 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-function read(path, settings) {
- const lstat = settings.fs.lstatSync(path);
- if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
- return lstat;
+const utils = __webpack_require__(593);
+class EntryFilter {
+ constructor(_settings, _micromatchOptions) {
+ this._settings = _settings;
+ this._micromatchOptions = _micromatchOptions;
+ this.index = new Map();
}
- try {
- const stat = settings.fs.statSync(path);
- if (settings.markSymbolicLink) {
- stat.isSymbolicLink = () => true;
+ getFilter(positive, negative) {
+ const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
+ const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);
+ return (entry) => this._filter(entry, positiveRe, negativeRe);
+ }
+ _filter(entry, positiveRe, negativeRe) {
+ if (this._settings.unique) {
+ if (this._isDuplicateEntry(entry)) {
+ return false;
+ }
+ this._createIndexRecord(entry);
}
- return stat;
+ if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
+ return false;
+ }
+ if (this._isSkippedByAbsoluteNegativePatterns(entry, negativeRe)) {
+ return false;
+ }
+ const filepath = this._settings.baseNameMatch ? entry.name : entry.path;
+ return this._isMatchToPatterns(filepath, positiveRe) && !this._isMatchToPatterns(entry.path, negativeRe);
}
- catch (error) {
- if (!settings.throwErrorOnBrokenSymbolicLink) {
- return lstat;
+ _isDuplicateEntry(entry) {
+ return this.index.has(entry.path);
+ }
+ _createIndexRecord(entry) {
+ this.index.set(entry.path, undefined);
+ }
+ _onlyFileFilter(entry) {
+ return this._settings.onlyFiles && !entry.dirent.isFile();
+ }
+ _onlyDirectoryFilter(entry) {
+ return this._settings.onlyDirectories && !entry.dirent.isDirectory();
+ }
+ _isSkippedByAbsoluteNegativePatterns(entry, negativeRe) {
+ if (!this._settings.absolute) {
+ return false;
}
- throw error;
+ const fullpath = utils.path.makeAbsolute(this._settings.cwd, entry.path);
+ return this._isMatchToPatterns(fullpath, negativeRe);
+ }
+ _isMatchToPatterns(filepath, patternsRe) {
+ return utils.pattern.matchAny(filepath, patternsRe);
}
}
-exports.read = read;
+exports.default = EntryFilter;
/***/ }),
-/* 630 */
+/* 651 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __webpack_require__(631);
-class Settings {
- constructor(_options = {}) {
- this._options = _options;
- this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
- this.fs = fs.createFileSystemAdapter(this._options.fs);
- this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
- this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+const utils = __webpack_require__(593);
+class ErrorFilter {
+ constructor(_settings) {
+ this._settings = _settings;
}
- _getValue(option, value) {
- return option === undefined ? value : option;
+ getFilter() {
+ return (error) => this._isNonFatalError(error);
+ }
+ _isNonFatalError(error) {
+ return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
}
}
-exports.default = Settings;
+exports.default = ErrorFilter;
/***/ }),
-/* 631 */
+/* 652 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __webpack_require__(23);
-exports.FILE_SYSTEM_ADAPTER = {
- lstat: fs.lstat,
- stat: fs.stat,
- lstatSync: fs.lstatSync,
- statSync: fs.statSync
-};
-function createFileSystemAdapter(fsMethods) {
- if (!fsMethods) {
- return exports.FILE_SYSTEM_ADAPTER;
+const utils = __webpack_require__(593);
+class EntryTransformer {
+ constructor(_settings) {
+ this._settings = _settings;
+ }
+ getTransformer() {
+ return (entry) => this._transform(entry);
+ }
+ _transform(entry) {
+ let filepath = entry.path;
+ if (this._settings.absolute) {
+ filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
+ filepath = utils.path.unixify(filepath);
+ }
+ if (this._settings.markDirectories && entry.dirent.isDirectory()) {
+ filepath += '/';
+ }
+ if (!this._settings.objectMode) {
+ return filepath;
+ }
+ return Object.assign({}, entry, { path: filepath });
}
- return Object.assign({}, exports.FILE_SYSTEM_ADAPTER, fsMethods);
}
-exports.createFileSystemAdapter = createFileSystemAdapter;
+exports.default = EntryTransformer;
/***/ }),
-/* 632 */
+/* 653 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const async_1 = __webpack_require__(633);
-const stream_1 = __webpack_require__(648);
-const sync_1 = __webpack_require__(649);
-const settings_1 = __webpack_require__(651);
-exports.Settings = settings_1.default;
-function walk(dir, optionsOrSettingsOrCallback, callback) {
- if (typeof optionsOrSettingsOrCallback === 'function') {
- return new async_1.default(dir, getSettings()).read(optionsOrSettingsOrCallback);
+const stream_1 = __webpack_require__(382);
+const stream_2 = __webpack_require__(621);
+const provider_1 = __webpack_require__(648);
+class ProviderStream extends provider_1.default {
+ constructor() {
+ super(...arguments);
+ this._reader = new stream_2.default(this._settings);
}
- new async_1.default(dir, getSettings(optionsOrSettingsOrCallback)).read(callback);
-}
-exports.walk = walk;
-function walkSync(dir, optionsOrSettings) {
- const settings = getSettings(optionsOrSettings);
- const provider = new sync_1.default(dir, settings);
- return provider.read();
-}
-exports.walkSync = walkSync;
-function walkStream(dir, optionsOrSettings) {
- const settings = getSettings(optionsOrSettings);
- const provider = new stream_1.default(dir, settings);
- return provider.read();
-}
-exports.walkStream = walkStream;
-function getSettings(settingsOrOptions = {}) {
- if (settingsOrOptions instanceof settings_1.default) {
- return settingsOrOptions;
+ read(task) {
+ const root = this._getRootDirectory(task);
+ const options = this._getReaderOptions(task);
+ const source = this.api(root, task, options);
+ const dest = new stream_1.Readable({ objectMode: true, read: () => { } });
+ source
+ .once('error', (error) => dest.emit('error', error))
+ .on('data', (entry) => dest.emit('data', options.transform(entry)))
+ .once('end', () => dest.emit('end'));
+ return dest;
+ }
+ api(root, task, options) {
+ if (task.dynamic) {
+ return this._reader.dynamic(root, options);
+ }
+ return this._reader.static(task.patterns, options);
}
- return new settings_1.default(settingsOrOptions);
}
+exports.default = ProviderStream;
/***/ }),
-/* 633 */
+/* 654 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const async_1 = __webpack_require__(634);
-class AsyncProvider {
- constructor(_root, _settings) {
- this._root = _root;
- this._settings = _settings;
- this._reader = new async_1.default(this._root, this._settings);
- this._storage = new Set();
+const sync_1 = __webpack_require__(655);
+const provider_1 = __webpack_require__(648);
+class ProviderSync extends provider_1.default {
+ constructor() {
+ super(...arguments);
+ this._reader = new sync_1.default(this._settings);
}
- read(callback) {
- this._reader.onError((error) => {
- callFailureCallback(callback, error);
- });
- this._reader.onEntry((entry) => {
- this._storage.add(entry);
- });
- this._reader.onEnd(() => {
- callSuccessCallback(callback, Array.from(this._storage));
- });
- this._reader.read();
+ read(task) {
+ const root = this._getRootDirectory(task);
+ const options = this._getReaderOptions(task);
+ const entries = this.api(root, task, options);
+ return entries.map(options.transform);
+ }
+ api(root, task, options) {
+ if (task.dynamic) {
+ return this._reader.dynamic(root, options);
+ }
+ return this._reader.static(task.patterns, options);
}
}
-exports.default = AsyncProvider;
-function callFailureCallback(callback, error) {
- callback(error);
-}
-function callSuccessCallback(callback, entries) {
- callback(null, entries);
-}
+exports.default = ProviderSync;
/***/ }),
-/* 634 */
+/* 655 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const events_1 = __webpack_require__(399);
-const fsScandir = __webpack_require__(635);
-const fastq = __webpack_require__(644);
-const common = __webpack_require__(646);
+const fsStat = __webpack_require__(622);
+const fsWalk = __webpack_require__(627);
const reader_1 = __webpack_require__(647);
-class AsyncReader extends reader_1.default {
- constructor(_root, _settings) {
- super(_root, _settings);
- this._settings = _settings;
- this._scandir = fsScandir.scandir;
- this._emitter = new events_1.EventEmitter();
- this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
- this._isFatalError = false;
- this._isDestroyed = false;
- this._queue.drain = () => {
- if (!this._isFatalError) {
- this._emitter.emit('end');
- }
- };
- }
- read() {
- this._isFatalError = false;
- this._isDestroyed = false;
- setImmediate(() => {
- this._pushToQueue(this._root, this._settings.basePath);
- });
- return this._emitter;
- }
- destroy() {
- if (this._isDestroyed) {
- throw new Error('The reader is already destroyed');
- }
- this._isDestroyed = true;
- this._queue.killAndDrain();
- }
- onEntry(callback) {
- this._emitter.on('entry', callback);
- }
- onError(callback) {
- this._emitter.once('error', callback);
- }
- onEnd(callback) {
- this._emitter.once('end', callback);
+class ReaderSync extends reader_1.default {
+ constructor() {
+ super(...arguments);
+ this._walkSync = fsWalk.walkSync;
+ this._statSync = fsStat.statSync;
}
- _pushToQueue(dir, base) {
- const queueItem = { dir, base };
- this._queue.push(queueItem, (error) => {
- if (error) {
- this._handleError(error);
- }
- });
+ dynamic(root, options) {
+ return this._walkSync(root, options);
}
- _worker(item, done) {
- this._scandir(item.dir, this._settings.fsScandirSettings, (error, entries) => {
- if (error) {
- return done(error, undefined);
- }
- for (const entry of entries) {
- this._handleEntry(entry, item.base);
+ static(patterns, options) {
+ const entries = [];
+ for (const pattern of patterns) {
+ const filepath = this._getFullEntryPath(pattern);
+ const entry = this._getEntry(filepath, pattern, options);
+ if (entry === null || !options.entryFilter(entry)) {
+ continue;
}
- done(null, undefined);
- });
- }
- _handleError(error) {
- if (!common.isFatalError(this._settings, error)) {
- return;
- }
- this._isFatalError = true;
- this._isDestroyed = true;
- this._emitter.emit('error', error);
- }
- _handleEntry(entry, base) {
- if (this._isDestroyed || this._isFatalError) {
- return;
- }
- const fullpath = entry.path;
- if (base !== undefined) {
- entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+ entries.push(entry);
}
- if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
- this._emitEntry(entry);
+ return entries;
+ }
+ _getEntry(filepath, pattern, options) {
+ try {
+ const stats = this._getStat(filepath);
+ return this._makeEntry(stats, pattern);
}
- if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
- this._pushToQueue(fullpath, entry.path);
+ catch (error) {
+ if (options.errorFilter(error)) {
+ return null;
+ }
+ throw error;
}
}
- _emitEntry(entry) {
- this._emitter.emit('entry', entry);
+ _getStat(filepath) {
+ return this._statSync(filepath, this._fsStatSettings);
}
}
-exports.default = AsyncReader;
+exports.default = ReaderSync;
/***/ }),
-/* 635 */
+/* 656 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const async = __webpack_require__(636);
-const sync = __webpack_require__(641);
-const settings_1 = __webpack_require__(642);
-exports.Settings = settings_1.default;
-function scandir(path, optionsOrSettingsOrCallback, callback) {
- if (typeof optionsOrSettingsOrCallback === 'function') {
- return async.read(path, getSettings(), optionsOrSettingsOrCallback);
+const fs = __webpack_require__(349);
+const os = __webpack_require__(364);
+const CPU_COUNT = os.cpus().length;
+exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
+ lstat: fs.lstat,
+ lstatSync: fs.lstatSync,
+ stat: fs.stat,
+ statSync: fs.statSync,
+ readdir: fs.readdir,
+ readdirSync: fs.readdirSync
+};
+// tslint:enable no-redundant-jsdoc
+class Settings {
+ constructor(_options = {}) {
+ this._options = _options;
+ this.absolute = this._getValue(this._options.absolute, false);
+ this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
+ this.braceExpansion = this._getValue(this._options.braceExpansion, true);
+ this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
+ this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
+ this.cwd = this._getValue(this._options.cwd, process.cwd());
+ this.deep = this._getValue(this._options.deep, Infinity);
+ this.dot = this._getValue(this._options.dot, false);
+ this.extglob = this._getValue(this._options.extglob, true);
+ this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
+ this.fs = this._getFileSystemMethods(this._options.fs);
+ this.globstar = this._getValue(this._options.globstar, true);
+ this.ignore = this._getValue(this._options.ignore, []);
+ this.markDirectories = this._getValue(this._options.markDirectories, false);
+ this.objectMode = this._getValue(this._options.objectMode, false);
+ this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
+ this.onlyFiles = this._getValue(this._options.onlyFiles, true);
+ this.stats = this._getValue(this._options.stats, false);
+ this.suppressErrors = this._getValue(this._options.suppressErrors, false);
+ this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
+ this.unique = this._getValue(this._options.unique, true);
+ if (this.onlyDirectories) {
+ this.onlyFiles = false;
+ }
+ if (this.stats) {
+ this.objectMode = true;
+ }
}
- async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
-}
-exports.scandir = scandir;
-function scandirSync(path, optionsOrSettings) {
- const settings = getSettings(optionsOrSettings);
- return sync.read(path, settings);
-}
-exports.scandirSync = scandirSync;
-function getSettings(settingsOrOptions = {}) {
- if (settingsOrOptions instanceof settings_1.default) {
- return settingsOrOptions;
+ _getValue(option, value) {
+ return option === undefined ? value : option;
+ }
+ _getFileSystemMethods(methods = {}) {
+ return Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER, methods);
}
- return new settings_1.default(settingsOrOptions);
}
+exports.default = Settings;
/***/ }),
-/* 636 */
+/* 657 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const fsStat = __webpack_require__(627);
-const rpl = __webpack_require__(637);
-const constants_1 = __webpack_require__(638);
-const utils = __webpack_require__(639);
-function read(dir, settings, callback) {
- if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
- return readdirWithFileTypes(dir, settings, callback);
- }
- return readdir(dir, settings, callback);
-}
-exports.read = read;
-function readdirWithFileTypes(dir, settings, callback) {
- settings.fs.readdir(dir, { withFileTypes: true }, (readdirError, dirents) => {
- if (readdirError) {
- return callFailureCallback(callback, readdirError);
- }
- const entries = dirents.map((dirent) => ({
- dirent,
- name: dirent.name,
- path: `${dir}${settings.pathSegmentSeparator}${dirent.name}`
- }));
- if (!settings.followSymbolicLinks) {
- return callSuccessCallback(callback, entries);
- }
- const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
- rpl(tasks, (rplError, rplEntries) => {
- if (rplError) {
- return callFailureCallback(callback, rplError);
- }
- callSuccessCallback(callback, rplEntries);
- });
- });
-}
-exports.readdirWithFileTypes = readdirWithFileTypes;
-function makeRplTaskEntry(entry, settings) {
- return (done) => {
- if (!entry.dirent.isSymbolicLink()) {
- return done(null, entry);
- }
- settings.fs.stat(entry.path, (statError, stats) => {
- if (statError) {
- if (settings.throwErrorOnBrokenSymbolicLink) {
- return done(statError);
- }
- return done(null, entry);
- }
- entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
- return done(null, entry);
- });
- };
-}
-function readdir(dir, settings, callback) {
- settings.fs.readdir(dir, (readdirError, names) => {
- if (readdirError) {
- return callFailureCallback(callback, readdirError);
- }
- const filepaths = names.map((name) => `${dir}${settings.pathSegmentSeparator}${name}`);
- const tasks = filepaths.map((filepath) => {
- return (done) => fsStat.stat(filepath, settings.fsStatSettings, done);
- });
- rpl(tasks, (rplError, results) => {
- if (rplError) {
- return callFailureCallback(callback, rplError);
- }
- const entries = [];
- for (let index = 0; index < names.length; index++) {
- const name = names[index];
- const stats = results[index];
- const entry = {
- name,
- path: filepaths[index],
- dirent: utils.fs.createDirentFromStats(name, stats)
- };
- if (settings.stats) {
- entry.stats = stats;
- }
- entries.push(entry);
- }
- callSuccessCallback(callback, entries);
- });
- });
-}
-exports.readdir = readdir;
-function callFailureCallback(callback, error) {
- callback(error);
-}
-function callSuccessCallback(callback, result) {
- callback(null, result);
-}
+const path = __webpack_require__(4);
+const pathType = __webpack_require__(658);
-/***/ }),
-/* 637 */
-/***/ (function(module, exports) {
+const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
-module.exports = runParallel
+const getPath = (filepath, cwd) => {
+ const pth = filepath[0] === '!' ? filepath.slice(1) : filepath;
+ return path.isAbsolute(pth) ? pth : path.join(cwd, pth);
+};
-function runParallel (tasks, cb) {
- var results, pending, keys
- var isSync = true
+const addExtensions = (file, extensions) => {
+ if (path.extname(file)) {
+ return `**/${file}`;
+ }
- if (Array.isArray(tasks)) {
- results = []
- pending = tasks.length
- } else {
- keys = Object.keys(tasks)
- results = {}
- pending = keys.length
- }
+ return `**/${file}.${getExtensions(extensions)}`;
+};
- function done (err) {
- function end () {
- if (cb) cb(err, results)
- cb = null
- }
- if (isSync) process.nextTick(end)
- else end()
- }
+const getGlob = (directory, options) => {
+ if (options.files && !Array.isArray(options.files)) {
+ throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``);
+ }
- function each (i, err, result) {
- results[i] = result
- if (--pending === 0 || err) {
- done(err)
- }
- }
+ if (options.extensions && !Array.isArray(options.extensions)) {
+ throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
+ }
- if (!pending) {
- // empty
- done(null)
- } else if (keys) {
- // object
- keys.forEach(function (key) {
- tasks[key](function (err, result) { each(key, err, result) })
- })
- } else {
- // array
- tasks.forEach(function (task, i) {
- task(function (err, result) { each(i, err, result) })
- })
- }
+ if (options.files && options.extensions) {
+ return options.files.map(x => path.posix.join(directory, addExtensions(x, options.extensions)));
+ }
- isSync = false
-}
+ if (options.files) {
+ return options.files.map(x => path.posix.join(directory, `**/${x}`));
+ }
+ if (options.extensions) {
+ return [path.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
+ }
-/***/ }),
-/* 638 */
-/***/ (function(module, exports, __webpack_require__) {
+ return [path.posix.join(directory, '**')];
+};
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
-const MAJOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
-const MINOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
-/**
- * IS `true` for Node.js 10.10 and greater.
- */
-exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = MAJOR_VERSION > 10 || (MAJOR_VERSION === 10 && MINOR_VERSION >= 10);
+module.exports = async (input, options) => {
+ options = {
+ cwd: process.cwd(),
+ ...options
+ };
+ if (typeof options.cwd !== 'string') {
+ throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+ }
-/***/ }),
-/* 639 */
-/***/ (function(module, exports, __webpack_require__) {
+ const globs = await Promise.all([].concat(input).map(async x => {
+ const isDirectory = await pathType.isDirectory(getPath(x, options.cwd));
+ return isDirectory ? getGlob(x, options) : x;
+ }));
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __webpack_require__(640);
-exports.fs = fs;
+ return [].concat.apply([], globs); // eslint-disable-line prefer-spread
+};
+
+module.exports.sync = (input, options) => {
+ options = {
+ cwd: process.cwd(),
+ ...options
+ };
+
+ if (typeof options.cwd !== 'string') {
+ throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
+ }
+
+ const globs = [].concat(input).map(x => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x);
+
+ return [].concat.apply([], globs); // eslint-disable-line prefer-spread
+};
/***/ }),
-/* 640 */
+/* 658 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-class DirentFromStats {
- constructor(name, stats) {
- this.name = name;
- this.isBlockDevice = stats.isBlockDevice.bind(stats);
- this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
- this.isDirectory = stats.isDirectory.bind(stats);
- this.isFIFO = stats.isFIFO.bind(stats);
- this.isFile = stats.isFile.bind(stats);
- this.isSocket = stats.isSocket.bind(stats);
- this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
- }
-}
-function createDirentFromStats(name, stats) {
- return new DirentFromStats(name, stats);
-}
-exports.createDirentFromStats = createDirentFromStats;
+
+const {promisify} = __webpack_require__(397);
+const fs = __webpack_require__(349);
+
+async function isType(fsStatType, statsMethodName, filePath) {
+ if (typeof filePath !== 'string') {
+ throw new TypeError(`Expected a string, got ${typeof filePath}`);
+ }
+
+ try {
+ const stats = await promisify(fs[fsStatType])(filePath);
+ return stats[statsMethodName]();
+ } catch (error) {
+ if (error.code === 'ENOENT') {
+ return false;
+ }
+
+ throw error;
+ }
+}
+
+function isTypeSync(fsStatType, statsMethodName, filePath) {
+ if (typeof filePath !== 'string') {
+ throw new TypeError(`Expected a string, got ${typeof filePath}`);
+ }
+
+ try {
+ return fs[fsStatType](filePath)[statsMethodName]();
+ } catch (error) {
+ if (error.code === 'ENOENT') {
+ return false;
+ }
+
+ throw error;
+ }
+}
+
+exports.isFile = isType.bind(null, 'stat', 'isFile');
+exports.isDirectory = isType.bind(null, 'stat', 'isDirectory');
+exports.isSymlink = isType.bind(null, 'lstat', 'isSymbolicLink');
+exports.isFileSync = isTypeSync.bind(null, 'statSync', 'isFile');
+exports.isDirectorySync = isTypeSync.bind(null, 'statSync', 'isDirectory');
+exports.isSymlinkSync = isTypeSync.bind(null, 'lstatSync', 'isSymbolicLink');
/***/ }),
-/* 641 */
+/* 659 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const fsStat = __webpack_require__(627);
-const constants_1 = __webpack_require__(638);
-const utils = __webpack_require__(639);
-function read(dir, settings) {
- if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
- return readdirWithFileTypes(dir, settings);
- }
- return readdir(dir, settings);
-}
-exports.read = read;
-function readdirWithFileTypes(dir, settings) {
- const dirents = settings.fs.readdirSync(dir, { withFileTypes: true });
- return dirents.map((dirent) => {
- const entry = {
- dirent,
- name: dirent.name,
- path: `${dir}${settings.pathSegmentSeparator}${dirent.name}`
- };
- if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
- try {
- const stats = settings.fs.statSync(entry.path);
- entry.dirent = utils.fs.createDirentFromStats(entry.name, stats);
- }
- catch (error) {
- if (settings.throwErrorOnBrokenSymbolicLink) {
- throw error;
- }
- }
- }
- return entry;
- });
-}
-exports.readdirWithFileTypes = readdirWithFileTypes;
-function readdir(dir, settings) {
- const names = settings.fs.readdirSync(dir);
- return names.map((name) => {
- const entryPath = `${dir}${settings.pathSegmentSeparator}${name}`;
- const stats = fsStat.statSync(entryPath, settings.fsStatSettings);
- const entry = {
- name,
- path: entryPath,
- dirent: utils.fs.createDirentFromStats(name, stats)
- };
- if (settings.stats) {
- entry.stats = stats;
- }
- return entry;
- });
-}
-exports.readdir = readdir;
+
+const {promisify} = __webpack_require__(397);
+const fs = __webpack_require__(349);
+const path = __webpack_require__(4);
+const fastGlob = __webpack_require__(591);
+const gitIgnore = __webpack_require__(660);
+const slash = __webpack_require__(661);
+
+const DEFAULT_IGNORE = [
+ '**/node_modules/**',
+ '**/flow-typed/**',
+ '**/coverage/**',
+ '**/.git'
+];
+
+const readFileP = promisify(fs.readFile);
+
+const mapGitIgnorePatternTo = base => ignore => {
+ if (ignore.startsWith('!')) {
+ return '!' + path.posix.join(base, ignore.slice(1));
+ }
+
+ return path.posix.join(base, ignore);
+};
+
+const parseGitIgnore = (content, options) => {
+ const base = slash(path.relative(options.cwd, path.dirname(options.fileName)));
+
+ return content
+ .split(/\r?\n/)
+ .filter(Boolean)
+ .filter(line => !line.startsWith('#'))
+ .map(mapGitIgnorePatternTo(base));
+};
+
+const reduceIgnore = files => {
+ return files.reduce((ignores, file) => {
+ ignores.add(parseGitIgnore(file.content, {
+ cwd: file.cwd,
+ fileName: file.filePath
+ }));
+ return ignores;
+ }, gitIgnore());
+};
+
+const ensureAbsolutePathForCwd = (cwd, p) => {
+ if (path.isAbsolute(p)) {
+ if (p.startsWith(cwd)) {
+ return p;
+ }
+
+ throw new Error(`Path ${p} is not in cwd ${cwd}`);
+ }
+
+ return path.join(cwd, p);
+};
+
+const getIsIgnoredPredecate = (ignores, cwd) => {
+ return p => ignores.ignores(slash(path.relative(cwd, ensureAbsolutePathForCwd(cwd, p))));
+};
+
+const getFile = async (file, cwd) => {
+ const filePath = path.join(cwd, file);
+ const content = await readFileP(filePath, 'utf8');
+
+ return {
+ cwd,
+ filePath,
+ content
+ };
+};
+
+const getFileSync = (file, cwd) => {
+ const filePath = path.join(cwd, file);
+ const content = fs.readFileSync(filePath, 'utf8');
+
+ return {
+ cwd,
+ filePath,
+ content
+ };
+};
+
+const normalizeOptions = ({
+ ignore = [],
+ cwd = process.cwd()
+} = {}) => {
+ return {ignore, cwd};
+};
+
+module.exports = async options => {
+ options = normalizeOptions(options);
+
+ const paths = await fastGlob('**/.gitignore', {
+ ignore: DEFAULT_IGNORE.concat(options.ignore),
+ cwd: options.cwd
+ });
+
+ const files = await Promise.all(paths.map(file => getFile(file, options.cwd)));
+ const ignores = reduceIgnore(files);
+
+ return getIsIgnoredPredecate(ignores, options.cwd);
+};
+
+module.exports.sync = options => {
+ options = normalizeOptions(options);
+
+ const paths = fastGlob.sync('**/.gitignore', {
+ ignore: DEFAULT_IGNORE.concat(options.ignore),
+ cwd: options.cwd
+ });
+
+ const files = paths.map(file => getFileSync(file, options.cwd));
+ const ignores = reduceIgnore(files);
+
+ return getIsIgnoredPredecate(ignores, options.cwd);
+};
/***/ }),
-/* 642 */
-/***/ (function(module, exports, __webpack_require__) {
+/* 660 */
+/***/ (function(module, exports) {
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = __webpack_require__(16);
-const fsStat = __webpack_require__(627);
-const fs = __webpack_require__(643);
-class Settings {
- constructor(_options = {}) {
- this._options = _options;
- this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
- this.fs = fs.createFileSystemAdapter(this._options.fs);
- this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
- this.stats = this._getValue(this._options.stats, false);
- this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
- this.fsStatSettings = new fsStat.Settings({
- followSymbolicLink: this.followSymbolicLinks,
- fs: this.fs,
- throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
- });
- }
- _getValue(option, value) {
- return option === undefined ? value : option;
- }
-}
-exports.default = Settings;
+// A simple implementation of make-array
+function makeArray (subject) {
+ return Array.isArray(subject)
+ ? subject
+ : [subject]
+}
+const REGEX_TEST_BLANK_LINE = /^\s+$/
+const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/
+const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/
+const REGEX_SPLITALL_CRLF = /\r?\n/g
+// /foo,
+// ./foo,
+// ../foo,
+// .
+// ..
+const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/
-/***/ }),
-/* 643 */
-/***/ (function(module, exports, __webpack_require__) {
+const SLASH = '/'
+const KEY_IGNORE = typeof Symbol !== 'undefined'
+ ? Symbol.for('node-ignore')
+ /* istanbul ignore next */
+ : 'node-ignore'
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __webpack_require__(23);
-exports.FILE_SYSTEM_ADAPTER = {
- lstat: fs.lstat,
- stat: fs.stat,
- lstatSync: fs.lstatSync,
- statSync: fs.statSync,
- readdir: fs.readdir,
- readdirSync: fs.readdirSync
-};
-function createFileSystemAdapter(fsMethods) {
- if (!fsMethods) {
- return exports.FILE_SYSTEM_ADAPTER;
- }
- return Object.assign({}, exports.FILE_SYSTEM_ADAPTER, fsMethods);
-}
-exports.createFileSystemAdapter = createFileSystemAdapter;
+const define = (object, key, value) =>
+ Object.defineProperty(object, key, {value})
+const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g
-/***/ }),
-/* 644 */
-/***/ (function(module, exports, __webpack_require__) {
+// Sanitize the range of a regular expression
+// The cases are complicated, see test cases for details
+const sanitizeRange = range => range.replace(
+ REGEX_REGEXP_RANGE,
+ (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)
+ ? match
+ // Invalid range (out of order) which is ok for gitignore rules but
+ // fatal for JavaScript regular expression, so eliminate it.
+ : ''
+)
-"use strict";
+// > If the pattern ends with a slash,
+// > it is removed for the purpose of the following description,
+// > but it would only find a match with a directory.
+// > In other words, foo/ will match a directory foo and paths underneath it,
+// > but will not match a regular file or a symbolic link foo
+// > (this is consistent with the way how pathspec works in general in Git).
+// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
+// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
+// you could use option `mark: true` with `glob`
+// '`foo/`' should not continue with the '`..`'
+const DEFAULT_REPLACER_PREFIX = [
-var reusify = __webpack_require__(645)
+ // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+ [
+ // (a\ ) -> (a )
+ // (a ) -> (a)
+ // (a \ ) -> (a )
+ /\\?\s+$/,
+ match => match.indexOf('\\') === 0
+ ? ' '
+ : ''
+ ],
-function fastqueue (context, worker, concurrency) {
- if (typeof context === 'function') {
- concurrency = worker
- worker = context
- context = null
- }
+ // replace (\ ) with ' '
+ [
+ /\\\s/g,
+ () => ' '
+ ],
- var cache = reusify(Task)
- var queueHead = null
- var queueTail = null
- var _running = 0
+ // Escape metacharacters
+ // which is written down by users but means special for regular expressions.
- var self = {
- push: push,
- drain: noop,
- saturated: noop,
- pause: pause,
- paused: false,
- concurrency: concurrency,
- running: running,
- resume: resume,
- idle: idle,
- length: length,
- unshift: unshift,
- empty: noop,
- kill: kill,
- killAndDrain: killAndDrain
- }
+ // > There are 12 characters with special meanings:
+ // > - the backslash \,
+ // > - the caret ^,
+ // > - the dollar sign $,
+ // > - the period or dot .,
+ // > - the vertical bar or pipe symbol |,
+ // > - the question mark ?,
+ // > - the asterisk or star *,
+ // > - the plus sign +,
+ // > - the opening parenthesis (,
+ // > - the closing parenthesis ),
+ // > - and the opening square bracket [,
+ // > - the opening curly brace {,
+ // > These special characters are often called "metacharacters".
+ [
+ /[\\^$.|*+(){]/g,
+ match => `\\${match}`
+ ],
- return self
+ [
+ // > [abc] matches any character inside the brackets
+ // > (in this case a, b, or c);
+ /\[([^\]/]*)($|\])/g,
+ (match, p1, p2) => p2 === ']'
+ ? `[${sanitizeRange(p1)}]`
+ : `\\${match}`
+ ],
- function running () {
- return _running
- }
+ [
+ // > a question mark (?) matches a single character
+ /(?!\\)\?/g,
+ () => '[^/]'
+ ],
- function pause () {
- self.paused = true
- }
+ // leading slash
+ [
- function length () {
- var current = queueHead
- var counter = 0
+ // > A leading slash matches the beginning of the pathname.
+ // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+ // A leading slash matches the beginning of the pathname
+ /^\//,
+ () => '^'
+ ],
- while (current) {
- current = current.next
- counter++
- }
+ // replace special metacharacter slash after the leading slash
+ [
+ /\//g,
+ () => '\\/'
+ ],
- return counter
- }
+ [
+ // > A leading "**" followed by a slash means match in all directories.
+ // > For example, "**/foo" matches file or directory "foo" anywhere,
+ // > the same as pattern "foo".
+ // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+ // > under directory "foo".
+ // Notice that the '*'s have been replaced as '\\*'
+ /^\^*\\\*\\\*\\\//,
- function resume () {
- if (!self.paused) return
- self.paused = false
- for (var i = 0; i < self.concurrency; i++) {
- _running++
- release()
+ // '**/foo' <-> 'foo'
+ () => '^(?:.*\\/)?'
+ ]
+]
+
+const DEFAULT_REPLACER_SUFFIX = [
+ // starting
+ [
+ // there will be no leading '/'
+ // (which has been replaced by section "leading slash")
+ // If starts with '**', adding a '^' to the regular expression also works
+ /^(?=[^^])/,
+ function startingReplacer () {
+ return !/\/(?!$)/.test(this)
+ // > If the pattern does not contain a slash /,
+ // > Git treats it as a shell glob pattern
+ // Actually, if there is only a trailing slash,
+ // git also treats it as a shell glob pattern
+ ? '(?:^|\\/)'
+
+ // > Otherwise, Git treats the pattern as a shell glob suitable for
+ // > consumption by fnmatch(3)
+ : '^'
}
- }
+ ],
- function idle () {
- return _running === 0 && self.length() === 0
- }
+ // two globstars
+ [
+ // Use lookahead assertions so that we could match more than one `'/**'`
+ /\\\/\\\*\\\*(?=\\\/|$)/g,
- function push (value, done) {
- var current = cache.get()
+ // Zero, one or several directories
+ // should not use '*', or it will be replaced by the next replacer
- current.context = context
- current.release = release
- current.value = value
- current.callback = done || noop
+ // Check if it is not the last `'/**'`
+ (_, index, str) => index + 6 < str.length
- if (_running === self.concurrency || self.paused) {
- if (queueTail) {
- queueTail.next = current
- queueTail = current
- } else {
- queueHead = current
- queueTail = current
- self.saturated()
- }
- } else {
- _running++
- worker.call(context, current.value, current.worked)
- }
- }
+ // case: /**/
+ // > A slash followed by two consecutive asterisks then a slash matches
+ // > zero or more directories.
+ // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
+ // '/**/'
+ ? '(?:\\/[^\\/]+)*'
- function unshift (value, done) {
- var current = cache.get()
+ // case: /**
+ // > A trailing `"/**"` matches everything inside.
- current.context = context
- current.release = release
- current.value = value
- current.callback = done || noop
+ // #21: everything inside but it should not include the current folder
+ : '\\/.+'
+ ],
- if (_running === self.concurrency || self.paused) {
- if (queueHead) {
- current.next = queueHead
- queueHead = current
- } else {
- queueHead = current
- queueTail = current
- self.saturated()
- }
- } else {
- _running++
- worker.call(context, current.value, current.worked)
- }
- }
+ // intermediate wildcards
+ [
+ // Never replace escaped '*'
+ // ignore rule '\*' will match the path '*'
- function release (holder) {
- if (holder) {
- cache.release(holder)
- }
- var next = queueHead
- if (next) {
- if (!self.paused) {
- if (queueTail === queueHead) {
- queueTail = null
- }
- queueHead = next.next
- next.next = null
- worker.call(context, next.value, next.worked)
- if (queueTail === null) {
- self.empty()
- }
- } else {
- _running--
- }
- } else if (--_running === 0) {
- self.drain()
- }
- }
+ // 'abc.*/' -> go
+ // 'abc.*' -> skip this rule
+ /(^|[^\\]+)\\\*(?=.+)/g,
- function kill () {
- queueHead = null
- queueTail = null
- self.drain = noop
- }
+ // '*.js' matches '.js'
+ // '*.js' doesn't match 'abc'
+ (_, p1) => `${p1}[^\\/]*`
+ ],
- function killAndDrain () {
- queueHead = null
- queueTail = null
- self.drain()
- self.drain = noop
- }
-}
+ // trailing wildcard
+ [
+ /(\^|\\\/)?\\\*$/,
+ (_, p1) => {
+ const prefix = p1
+ // '\^':
+ // '/*' does not match ''
+ // '/*' does not match everything
-function noop () {}
+ // '\\\/':
+ // 'abc/*' does not match 'abc/'
+ ? `${p1}[^/]+`
-function Task () {
- this.value = null
- this.callback = noop
- this.next = null
- this.release = noop
- this.context = null
+ // 'a*' matches 'a'
+ // 'a*' matches 'aa'
+ : '[^/]*'
- var self = this
+ return `${prefix}(?=$|\\/$)`
+ }
+ ],
- this.worked = function worked (err, result) {
- var callback = self.callback
- self.value = null
- self.callback = noop
- callback.call(self.context, err, result)
- self.release(self)
- }
-}
+ [
+ // unescape
+ /\\\\\\/g,
+ () => '\\'
+ ]
+]
-module.exports = fastqueue
+const POSITIVE_REPLACERS = [
+ ...DEFAULT_REPLACER_PREFIX,
+ // 'f'
+ // matches
+ // - /f(end)
+ // - /f/
+ // - (start)f(end)
+ // - (start)f/
+ // doesn't match
+ // - oof
+ // - foo
+ // pseudo:
+ // -> (^|/)f(/|$)
-/***/ }),
-/* 645 */
-/***/ (function(module, exports, __webpack_require__) {
+ // ending
+ [
+ // 'js' will not match 'js.'
+ // 'ab' will not match 'abc'
+ /(?:[^*/])$/,
-"use strict";
+ // 'js*' will not match 'a.js'
+ // 'js/' will not match 'a.js'
+ // 'js' will match 'a.js' and 'a.js/'
+ match => `${match}(?=$|\\/)`
+ ],
+ ...DEFAULT_REPLACER_SUFFIX
+]
-function reusify (Constructor) {
- var head = new Constructor()
- var tail = head
+const NEGATIVE_REPLACERS = [
+ ...DEFAULT_REPLACER_PREFIX,
- function get () {
- var current = head
+ // #24, #38
+ // The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore)
+ // A negative pattern without a trailing wildcard should not
+ // re-include the things inside that directory.
- if (current.next) {
- head = current.next
- } else {
- head = new Constructor()
- tail = head
- }
+ // eg:
+ // ['node_modules/*', '!node_modules']
+ // should ignore `node_modules/a.js`
+ [
+ /(?:[^*])$/,
+ match => `${match}(?=$|\\/$)`
+ ],
- current.next = null
+ ...DEFAULT_REPLACER_SUFFIX
+]
- return current
- }
+// A simple cache, because an ignore rule only has only one certain meaning
+const regexCache = Object.create(null)
- function release (obj) {
- tail.next = obj
- tail = obj
+// @param {pattern}
+const makeRegex = (pattern, negative, ignorecase) => {
+ const r = regexCache[pattern]
+ if (r) {
+ return r
}
- return {
- get: get,
- release: release
+ const replacers = negative
+ ? NEGATIVE_REPLACERS
+ : POSITIVE_REPLACERS
+
+ const source = replacers.reduce(
+ (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+ pattern
+ )
+
+ return regexCache[pattern] = ignorecase
+ ? new RegExp(source, 'i')
+ : new RegExp(source)
+}
+
+const isString = subject => typeof subject === 'string'
+
+// > A blank line matches no files, so it can serve as a separator for readability.
+const checkPattern = pattern => pattern
+ && isString(pattern)
+ && !REGEX_TEST_BLANK_LINE.test(pattern)
+
+ // > A line starting with # serves as a comment.
+ && pattern.indexOf('#') !== 0
+
+const splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF)
+
+class IgnoreRule {
+ constructor (
+ origin,
+ pattern,
+ negative,
+ regex
+ ) {
+ this.origin = origin
+ this.pattern = pattern
+ this.negative = negative
+ this.regex = regex
}
}
-module.exports = reusify
+const createRule = (pattern, ignorecase) => {
+ const origin = pattern
+ let negative = false
+
+ // > An optional prefix "!" which negates the pattern;
+ if (pattern.indexOf('!') === 0) {
+ negative = true
+ pattern = pattern.substr(1)
+ }
+
+ pattern = pattern
+ // > Put a backslash ("\") in front of the first "!" for patterns that
+ // > begin with a literal "!", for example, `"\!important!.txt"`.
+ .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')
+ // > Put a backslash ("\") in front of the first hash for patterns that
+ // > begin with a hash.
+ .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#')
+ const regex = makeRegex(pattern, negative, ignorecase)
-/***/ }),
-/* 646 */
-/***/ (function(module, exports, __webpack_require__) {
+ return new IgnoreRule(
+ origin,
+ pattern,
+ negative,
+ regex
+ )
+}
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-function isFatalError(settings, error) {
- if (settings.errorFilter === null) {
- return true;
- }
- return !settings.errorFilter(error);
-}
-exports.isFatalError = isFatalError;
-function isAppliedFilter(filter, value) {
- return filter === null || filter(value);
-}
-exports.isAppliedFilter = isAppliedFilter;
-function replacePathSegmentSeparator(filepath, separator) {
- return filepath.split(/[\\\/]/).join(separator);
-}
-exports.replacePathSegmentSeparator = replacePathSegmentSeparator;
-function joinPathSegments(a, b, separator) {
- if (a === '') {
- return b;
- }
- return a + separator + b;
-}
-exports.joinPathSegments = joinPathSegments;
+const throwError = (message, Ctor) => {
+ throw new Ctor(message)
+}
+const checkPath = (path, originalPath, doThrow) => {
+ if (!isString(path)) {
+ return doThrow(
+ `path must be a string, but got \`${originalPath}\``,
+ TypeError
+ )
+ }
-/***/ }),
-/* 647 */
-/***/ (function(module, exports, __webpack_require__) {
+ // We don't know if we should ignore '', so throw
+ if (!path) {
+ return doThrow(`path must not be empty`, TypeError)
+ }
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const common = __webpack_require__(646);
-class Reader {
- constructor(_root, _settings) {
- this._root = _root;
- this._settings = _settings;
- this._root = common.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
- }
-}
-exports.default = Reader;
+ // Check if it is a relative path
+ if (checkPath.isNotRelative(path)) {
+ const r = '`path.relative()`d'
+ return doThrow(
+ `path should be a ${r} string, but got "${originalPath}"`,
+ RangeError
+ )
+ }
+ return true
+}
-/***/ }),
-/* 648 */
-/***/ (function(module, exports, __webpack_require__) {
+const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path)
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const stream_1 = __webpack_require__(27);
-const async_1 = __webpack_require__(634);
-class StreamProvider {
- constructor(_root, _settings) {
- this._root = _root;
- this._settings = _settings;
- this._reader = new async_1.default(this._root, this._settings);
- this._stream = new stream_1.Readable({
- objectMode: true,
- read: () => { },
- destroy: this._reader.destroy.bind(this._reader)
- });
- }
- read() {
- this._reader.onError((error) => {
- this._stream.emit('error', error);
- });
- this._reader.onEntry((entry) => {
- this._stream.push(entry);
- });
- this._reader.onEnd(() => {
- this._stream.push(null);
- });
- this._reader.read();
- return this._stream;
- }
-}
-exports.default = StreamProvider;
+checkPath.isNotRelative = isNotRelative
+checkPath.convert = p => p
+class Ignore {
+ constructor ({
+ ignorecase = true
+ } = {}) {
+ this._rules = []
+ this._ignorecase = ignorecase
+ define(this, KEY_IGNORE, true)
+ this._initCache()
+ }
-/***/ }),
-/* 649 */
-/***/ (function(module, exports, __webpack_require__) {
+ _initCache () {
+ this._ignoreCache = Object.create(null)
+ this._testCache = Object.create(null)
+ }
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const sync_1 = __webpack_require__(650);
-class SyncProvider {
- constructor(_root, _settings) {
- this._root = _root;
- this._settings = _settings;
- this._reader = new sync_1.default(this._root, this._settings);
- }
- read() {
- return this._reader.read();
- }
-}
-exports.default = SyncProvider;
+ _addPattern (pattern) {
+ // #32
+ if (pattern && pattern[KEY_IGNORE]) {
+ this._rules = this._rules.concat(pattern._rules)
+ this._added = true
+ return
+ }
+ if (checkPattern(pattern)) {
+ const rule = createRule(pattern, this._ignorecase)
+ this._added = true
+ this._rules.push(rule)
+ }
+ }
-/***/ }),
-/* 650 */
-/***/ (function(module, exports, __webpack_require__) {
+ // @param {Array | string | Ignore} pattern
+ add (pattern) {
+ this._added = false
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const fsScandir = __webpack_require__(635);
-const common = __webpack_require__(646);
-const reader_1 = __webpack_require__(647);
-class SyncReader extends reader_1.default {
- constructor() {
- super(...arguments);
- this._scandir = fsScandir.scandirSync;
- this._storage = new Set();
- this._queue = new Set();
- }
- read() {
- this._pushToQueue(this._root, this._settings.basePath);
- this._handleQueue();
- return Array.from(this._storage);
- }
- _pushToQueue(dir, base) {
- this._queue.add({ dir, base });
- }
- _handleQueue() {
- for (const item of this._queue.values()) {
- this._handleDirectory(item.dir, item.base);
- }
- }
- _handleDirectory(dir, base) {
- try {
- const entries = this._scandir(dir, this._settings.fsScandirSettings);
- for (const entry of entries) {
- this._handleEntry(entry, base);
- }
- }
- catch (error) {
- this._handleError(error);
- }
- }
- _handleError(error) {
- if (!common.isFatalError(this._settings, error)) {
- return;
- }
- throw error;
- }
- _handleEntry(entry, base) {
- const fullpath = entry.path;
- if (base !== undefined) {
- entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
- }
- if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
- this._pushToStorage(entry);
- }
- if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
- this._pushToQueue(fullpath, entry.path);
- }
- }
- _pushToStorage(entry) {
- this._storage.add(entry);
- }
-}
-exports.default = SyncReader;
+ makeArray(
+ isString(pattern)
+ ? splitPattern(pattern)
+ : pattern
+ ).forEach(this._addPattern, this)
+ // Some rules have just added to the ignore,
+ // making the behavior changed.
+ if (this._added) {
+ this._initCache()
+ }
-/***/ }),
-/* 651 */
-/***/ (function(module, exports, __webpack_require__) {
+ return this
+ }
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = __webpack_require__(16);
-const fsScandir = __webpack_require__(635);
-class Settings {
- constructor(_options = {}) {
- this._options = _options;
- this.basePath = this._getValue(this._options.basePath, undefined);
- this.concurrency = this._getValue(this._options.concurrency, Infinity);
- this.deepFilter = this._getValue(this._options.deepFilter, null);
- this.entryFilter = this._getValue(this._options.entryFilter, null);
- this.errorFilter = this._getValue(this._options.errorFilter, null);
- this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path.sep);
- this.fsScandirSettings = new fsScandir.Settings({
- followSymbolicLinks: this._options.followSymbolicLinks,
- fs: this._options.fs,
- pathSegmentSeparator: this._options.pathSegmentSeparator,
- stats: this._options.stats,
- throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
- });
- }
- _getValue(option, value) {
- return option === undefined ? value : option;
- }
-}
-exports.default = Settings;
+ // legacy
+ addPattern (pattern) {
+ return this.add(pattern)
+ }
+ // | ignored : unignored
+ // negative | 0:0 | 0:1 | 1:0 | 1:1
+ // -------- | ------- | ------- | ------- | --------
+ // 0 | TEST | TEST | SKIP | X
+ // 1 | TESTIF | SKIP | TEST | X
-/***/ }),
-/* 652 */
-/***/ (function(module, exports, __webpack_require__) {
+ // - SKIP: always skip
+ // - TEST: always test
+ // - TESTIF: only test if checkUnignored
+ // - X: that never happen
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = __webpack_require__(16);
-const fsStat = __webpack_require__(627);
-const utils = __webpack_require__(598);
-class Reader {
- constructor(_settings) {
- this._settings = _settings;
- this._fsStatSettings = new fsStat.Settings({
- followSymbolicLink: this._settings.followSymbolicLinks,
- fs: this._settings.fs,
- throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
- });
- }
- _getFullEntryPath(filepath) {
- return path.resolve(this._settings.cwd, filepath);
- }
- _makeEntry(stats, pattern) {
- const entry = {
- name: pattern,
- path: pattern,
- dirent: utils.fs.createDirentFromStats(pattern, stats)
- };
- if (this._settings.stats) {
- entry.stats = stats;
- }
- return entry;
- }
- _isFatalError(error) {
- return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
- }
-}
-exports.default = Reader;
+ // @param {boolean} whether should check if the path is unignored,
+ // setting `checkUnignored` to `false` could reduce additional
+ // path matching.
+ // @returns {TestResult} true if a file is ignored
+ _testOne (path, checkUnignored) {
+ let ignored = false
+ let unignored = false
-/***/ }),
-/* 653 */
-/***/ (function(module, exports, __webpack_require__) {
+ this._rules.forEach(rule => {
+ const {negative} = rule
+ if (
+ unignored === negative && ignored !== unignored
+ || negative && !ignored && !unignored && !checkUnignored
+ ) {
+ return
+ }
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = __webpack_require__(16);
-const deep_1 = __webpack_require__(654);
-const entry_1 = __webpack_require__(655);
-const error_1 = __webpack_require__(656);
-const entry_2 = __webpack_require__(657);
-class Provider {
- constructor(_settings) {
- this._settings = _settings;
- this.errorFilter = new error_1.default(this._settings);
- this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
- this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
- this.entryTransformer = new entry_2.default(this._settings);
- }
- _getRootDirectory(task) {
- return path.resolve(this._settings.cwd, task.base);
- }
- _getReaderOptions(task) {
- const basePath = task.base === '.' ? '' : task.base;
- return {
- basePath,
- pathSegmentSeparator: '/',
- concurrency: this._settings.concurrency,
- deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
- entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
- errorFilter: this.errorFilter.getFilter(),
- followSymbolicLinks: this._settings.followSymbolicLinks,
- fs: this._settings.fs,
- stats: this._settings.stats,
- throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
- transform: this.entryTransformer.getTransformer()
- };
- }
- _getMicromatchOptions() {
- return {
- dot: this._settings.dot,
- matchBase: this._settings.baseNameMatch,
- nobrace: !this._settings.braceExpansion,
- nocase: !this._settings.caseSensitiveMatch,
- noext: !this._settings.extglob,
- noglobstar: !this._settings.globstar,
- posix: true,
- strictSlashes: false
- };
- }
-}
-exports.default = Provider;
+ const matched = rule.regex.test(path)
+ if (matched) {
+ ignored = !negative
+ unignored = negative
+ }
+ })
-/***/ }),
-/* 654 */
-/***/ (function(module, exports, __webpack_require__) {
+ return {
+ ignored,
+ unignored
+ }
+ }
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = __webpack_require__(598);
-class DeepFilter {
- constructor(_settings, _micromatchOptions) {
- this._settings = _settings;
- this._micromatchOptions = _micromatchOptions;
- }
- getFilter(basePath, positive, negative) {
- const maxPatternDepth = this._getMaxPatternDepth(positive);
- const negativeRe = this._getNegativePatternsRe(negative);
- return (entry) => this._filter(basePath, entry, negativeRe, maxPatternDepth);
- }
- _getMaxPatternDepth(patterns) {
- const globstar = patterns.some(utils.pattern.hasGlobStar);
- return globstar ? Infinity : utils.pattern.getMaxNaivePatternsDepth(patterns);
- }
- _getNegativePatternsRe(patterns) {
- const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
- return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
- }
- _filter(basePath, entry, negativeRe, maxPatternDepth) {
- const depth = this._getEntryDepth(basePath, entry.path);
- if (this._isSkippedByDeep(depth)) {
- return false;
- }
- if (this._isSkippedByMaxPatternDepth(depth, maxPatternDepth)) {
- return false;
- }
- if (this._isSkippedSymbolicLink(entry)) {
- return false;
- }
- if (this._isSkippedDotDirectory(entry)) {
- return false;
- }
- return this._isSkippedByNegativePatterns(entry, negativeRe);
- }
- _getEntryDepth(basePath, entryPath) {
- const basePathDepth = basePath.split('/').length;
- const entryPathDepth = entryPath.split('/').length;
- return entryPathDepth - (basePath === '' ? 0 : basePathDepth);
- }
- _isSkippedByDeep(entryDepth) {
- return entryDepth >= this._settings.deep;
- }
- _isSkippedByMaxPatternDepth(entryDepth, maxPatternDepth) {
- return !this._settings.baseNameMatch && maxPatternDepth !== Infinity && entryDepth > maxPatternDepth;
- }
- _isSkippedSymbolicLink(entry) {
- return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
- }
- _isSkippedDotDirectory(entry) {
- return !this._settings.dot && entry.name.startsWith('.');
- }
- _isSkippedByNegativePatterns(entry, negativeRe) {
- return !utils.pattern.matchAny(entry.path, negativeRe);
- }
-}
-exports.default = DeepFilter;
+ // @returns {TestResult}
+ _test (originalPath, cache, checkUnignored, slices) {
+ const path = originalPath
+ // Supports nullable path
+ && checkPath.convert(originalPath)
+ checkPath(path, originalPath, throwError)
-/***/ }),
-/* 655 */
-/***/ (function(module, exports, __webpack_require__) {
+ return this._t(path, cache, checkUnignored, slices)
+ }
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = __webpack_require__(598);
-class EntryFilter {
- constructor(_settings, _micromatchOptions) {
- this._settings = _settings;
- this._micromatchOptions = _micromatchOptions;
- this.index = new Map();
- }
- getFilter(positive, negative) {
- const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
- const negativeRe = utils.pattern.convertPatternsToRe(negative, this._micromatchOptions);
- return (entry) => this._filter(entry, positiveRe, negativeRe);
- }
- _filter(entry, positiveRe, negativeRe) {
- if (this._settings.unique) {
- if (this._isDuplicateEntry(entry)) {
- return false;
- }
- this._createIndexRecord(entry);
- }
- if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
- return false;
- }
- if (this._isSkippedByAbsoluteNegativePatterns(entry, negativeRe)) {
- return false;
- }
- const filepath = this._settings.baseNameMatch ? entry.name : entry.path;
- return this._isMatchToPatterns(filepath, positiveRe) && !this._isMatchToPatterns(entry.path, negativeRe);
- }
- _isDuplicateEntry(entry) {
- return this.index.has(entry.path);
- }
- _createIndexRecord(entry) {
- this.index.set(entry.path, undefined);
- }
- _onlyFileFilter(entry) {
- return this._settings.onlyFiles && !entry.dirent.isFile();
- }
- _onlyDirectoryFilter(entry) {
- return this._settings.onlyDirectories && !entry.dirent.isDirectory();
- }
- _isSkippedByAbsoluteNegativePatterns(entry, negativeRe) {
- if (!this._settings.absolute) {
- return false;
- }
- const fullpath = utils.path.makeAbsolute(this._settings.cwd, entry.path);
- return this._isMatchToPatterns(fullpath, negativeRe);
- }
- _isMatchToPatterns(filepath, patternsRe) {
- return utils.pattern.matchAny(filepath, patternsRe);
- }
-}
-exports.default = EntryFilter;
+ _t (path, cache, checkUnignored, slices) {
+ if (path in cache) {
+ return cache[path]
+ }
+ if (!slices) {
+ // path/to/a.js
+ // ['path', 'to', 'a.js']
+ slices = path.split(SLASH)
+ }
-/***/ }),
-/* 656 */
-/***/ (function(module, exports, __webpack_require__) {
+ slices.pop()
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = __webpack_require__(598);
-class ErrorFilter {
- constructor(_settings) {
- this._settings = _settings;
- }
- getFilter() {
- return (error) => this._isNonFatalError(error);
- }
- _isNonFatalError(error) {
- return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
- }
-}
-exports.default = ErrorFilter;
+ // If the path has no parent directory, just test it
+ if (!slices.length) {
+ return cache[path] = this._testOne(path, checkUnignored)
+ }
+ const parent = this._t(
+ slices.join(SLASH) + SLASH,
+ cache,
+ checkUnignored,
+ slices
+ )
-/***/ }),
-/* 657 */
-/***/ (function(module, exports, __webpack_require__) {
+ // If the path contains a parent directory, check the parent first
+ return cache[path] = parent.ignored
+ // > It is not possible to re-include a file if a parent directory of
+ // > that file is excluded.
+ ? parent
+ : this._testOne(path, checkUnignored)
+ }
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = __webpack_require__(598);
-class EntryTransformer {
- constructor(_settings) {
- this._settings = _settings;
- }
- getTransformer() {
- return (entry) => this._transform(entry);
- }
- _transform(entry) {
- let filepath = entry.path;
- if (this._settings.absolute) {
- filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
- filepath = utils.path.unixify(filepath);
- }
- if (this._settings.markDirectories && entry.dirent.isDirectory()) {
- filepath += '/';
- }
- if (!this._settings.objectMode) {
- return filepath;
- }
- return Object.assign({}, entry, { path: filepath });
- }
-}
-exports.default = EntryTransformer;
+ ignores (path) {
+ return this._test(path, this._ignoreCache, false).ignored
+ }
+ createFilter () {
+ return path => !this.ignores(path)
+ }
-/***/ }),
-/* 658 */
-/***/ (function(module, exports, __webpack_require__) {
+ filter (paths) {
+ return makeArray(paths).filter(this.createFilter())
+ }
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const stream_1 = __webpack_require__(27);
-const stream_2 = __webpack_require__(626);
-const provider_1 = __webpack_require__(653);
-class ProviderStream extends provider_1.default {
- constructor() {
- super(...arguments);
- this._reader = new stream_2.default(this._settings);
- }
- read(task) {
- const root = this._getRootDirectory(task);
- const options = this._getReaderOptions(task);
- const source = this.api(root, task, options);
- const dest = new stream_1.Readable({ objectMode: true, read: () => { } });
- source
- .once('error', (error) => dest.emit('error', error))
- .on('data', (entry) => dest.emit('data', options.transform(entry)))
- .once('end', () => dest.emit('end'));
- return dest;
- }
- api(root, task, options) {
- if (task.dynamic) {
- return this._reader.dynamic(root, options);
- }
- return this._reader.static(task.patterns, options);
- }
-}
-exports.default = ProviderStream;
+ // @returns {TestResult}
+ test (path) {
+ return this._test(path, this._testCache, true)
+ }
+}
+const factory = options => new Ignore(options)
-/***/ }),
-/* 659 */
-/***/ (function(module, exports, __webpack_require__) {
+const returnFalse = () => false
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const sync_1 = __webpack_require__(660);
-const provider_1 = __webpack_require__(653);
-class ProviderSync extends provider_1.default {
- constructor() {
- super(...arguments);
- this._reader = new sync_1.default(this._settings);
- }
- read(task) {
- const root = this._getRootDirectory(task);
- const options = this._getReaderOptions(task);
- const entries = this.api(root, task, options);
- return entries.map(options.transform);
- }
- api(root, task, options) {
- if (task.dynamic) {
- return this._reader.dynamic(root, options);
- }
- return this._reader.static(task.patterns, options);
- }
-}
-exports.default = ProviderSync;
+const isPathValid = path =>
+ checkPath(path && checkPath.convert(path), path, returnFalse)
+factory.isPathValid = isPathValid
-/***/ }),
-/* 660 */
-/***/ (function(module, exports, __webpack_require__) {
+// Fixes typescript
+factory.default = factory
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const fsStat = __webpack_require__(627);
-const fsWalk = __webpack_require__(632);
-const reader_1 = __webpack_require__(652);
-class ReaderSync extends reader_1.default {
- constructor() {
- super(...arguments);
- this._walkSync = fsWalk.walkSync;
- this._statSync = fsStat.statSync;
- }
- dynamic(root, options) {
- return this._walkSync(root, options);
- }
- static(patterns, options) {
- const entries = [];
- for (const pattern of patterns) {
- const filepath = this._getFullEntryPath(pattern);
- const entry = this._getEntry(filepath, pattern, options);
- if (entry === null || !options.entryFilter(entry)) {
- continue;
- }
- entries.push(entry);
- }
- return entries;
- }
- _getEntry(filepath, pattern, options) {
- try {
- const stats = this._getStat(filepath);
- return this._makeEntry(stats, pattern);
- }
- catch (error) {
- if (options.errorFilter(error)) {
- return null;
- }
- throw error;
- }
- }
- _getStat(filepath) {
- return this._statSync(filepath, this._fsStatSettings);
- }
-}
-exports.default = ReaderSync;
+module.exports = factory
+
+// Windows
+// --------------------------------------------------------------
+/* istanbul ignore if */
+if (
+ // Detect `process` so that it can run in browsers.
+ typeof process !== 'undefined'
+ && (
+ process.env && process.env.IGNORE_TEST_WIN32
+ || process.platform === 'win32'
+ )
+) {
+ /* eslint no-control-regex: "off" */
+ const makePosix = str => /^\\\\\?\\/.test(str)
+ || /["<>|\u0000-\u001F]+/u.test(str)
+ ? str
+ : str.replace(/\\/g, '/')
+
+ checkPath.convert = makePosix
+
+ // 'C:\\foo' <- 'C:\\foo' has been converted to 'C:/'
+ // 'd:\\foo'
+ const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i
+ checkPath.isNotRelative = path =>
+ REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path)
+ || isNotRelative(path)
+}
/***/ }),
@@ -75639,59 +75887,17 @@ exports.default = ReaderSync;
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __webpack_require__(23);
-const os = __webpack_require__(11);
-const CPU_COUNT = os.cpus().length;
-exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
- lstat: fs.lstat,
- lstatSync: fs.lstatSync,
- stat: fs.stat,
- statSync: fs.statSync,
- readdir: fs.readdir,
- readdirSync: fs.readdirSync
-};
-// tslint:enable no-redundant-jsdoc
-class Settings {
- constructor(_options = {}) {
- this._options = _options;
- this.absolute = this._getValue(this._options.absolute, false);
- this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
- this.braceExpansion = this._getValue(this._options.braceExpansion, true);
- this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
- this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
- this.cwd = this._getValue(this._options.cwd, process.cwd());
- this.deep = this._getValue(this._options.deep, Infinity);
- this.dot = this._getValue(this._options.dot, false);
- this.extglob = this._getValue(this._options.extglob, true);
- this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
- this.fs = this._getFileSystemMethods(this._options.fs);
- this.globstar = this._getValue(this._options.globstar, true);
- this.ignore = this._getValue(this._options.ignore, []);
- this.markDirectories = this._getValue(this._options.markDirectories, false);
- this.objectMode = this._getValue(this._options.objectMode, false);
- this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
- this.onlyFiles = this._getValue(this._options.onlyFiles, true);
- this.stats = this._getValue(this._options.stats, false);
- this.suppressErrors = this._getValue(this._options.suppressErrors, false);
- this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
- this.unique = this._getValue(this._options.unique, true);
- if (this.onlyDirectories) {
- this.onlyFiles = false;
- }
- if (this.stats) {
- this.objectMode = true;
- }
- }
- _getValue(option, value) {
- return option === undefined ? value : option;
- }
- _getFileSystemMethods(methods = {}) {
- return Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER, methods);
- }
-}
-exports.default = Settings;
+
+module.exports = path => {
+ const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+ const hasNonAscii = /[^\u0000-\u0080]+/.test(path); // eslint-disable-line no-control-regex
+
+ if (isExtendedLengthPath || hasNonAscii) {
+ return path;
+ }
+
+ return path.replace(/\\/g, '/');
+};
/***/ }),
@@ -75700,1739 +75906,1725 @@ exports.default = Settings;
"use strict";
-const path = __webpack_require__(16);
-const pathType = __webpack_require__(663);
+const {Transform} = __webpack_require__(382);
-const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
-
-const getPath = (filepath, cwd) => {
- const pth = filepath[0] === '!' ? filepath.slice(1) : filepath;
- return path.isAbsolute(pth) ? pth : path.join(cwd, pth);
-};
-
-const addExtensions = (file, extensions) => {
- if (path.extname(file)) {
- return `**/${file}`;
+class ObjectTransform extends Transform {
+ constructor() {
+ super({
+ objectMode: true
+ });
}
+}
- return `**/${file}.${getExtensions(extensions)}`;
-};
-
-const getGlob = (directory, options) => {
- if (options.files && !Array.isArray(options.files)) {
- throw new TypeError(`Expected \`files\` to be of type \`Array\` but received type \`${typeof options.files}\``);
+class FilterStream extends ObjectTransform {
+ constructor(filter) {
+ super();
+ this._filter = filter;
}
- if (options.extensions && !Array.isArray(options.extensions)) {
- throw new TypeError(`Expected \`extensions\` to be of type \`Array\` but received type \`${typeof options.extensions}\``);
- }
+ _transform(data, encoding, callback) {
+ if (this._filter(data)) {
+ this.push(data);
+ }
- if (options.files && options.extensions) {
- return options.files.map(x => path.posix.join(directory, addExtensions(x, options.extensions)));
+ callback();
}
+}
- if (options.files) {
- return options.files.map(x => path.posix.join(directory, `**/${x}`));
+class UniqueStream extends ObjectTransform {
+ constructor() {
+ super();
+ this._pushed = new Set();
}
- if (options.extensions) {
- return [path.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
+ _transform(data, encoding, callback) {
+ if (!this._pushed.has(data)) {
+ this.push(data);
+ this._pushed.add(data);
+ }
+
+ callback();
}
+}
- return [path.posix.join(directory, '**')];
+module.exports = {
+ FilterStream,
+ UniqueStream
};
-module.exports = async (input, options) => {
- options = {
- cwd: process.cwd(),
- ...options
- };
- if (typeof options.cwd !== 'string') {
- throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
- }
+/***/ }),
+/* 663 */
+/***/ (function(module, exports, __webpack_require__) {
- const globs = await Promise.all([].concat(input).map(async x => {
- const isDirectory = await pathType.isDirectory(getPath(x, options.cwd));
- return isDirectory ? getGlob(x, options) : x;
- }));
+"use strict";
- return [].concat.apply([], globs); // eslint-disable-line prefer-spread
-};
+const path = __webpack_require__(4);
-module.exports.sync = (input, options) => {
- options = {
- cwd: process.cwd(),
- ...options
- };
+module.exports = path_ => {
+ let cwd = process.cwd();
- if (typeof options.cwd !== 'string') {
- throw new TypeError(`Expected \`cwd\` to be of type \`string\` but received type \`${typeof options.cwd}\``);
- }
+ path_ = path.resolve(path_);
- const globs = [].concat(input).map(x => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x);
+ if (process.platform === 'win32') {
+ cwd = cwd.toLowerCase();
+ path_ = path_.toLowerCase();
+ }
- return [].concat.apply([], globs); // eslint-disable-line prefer-spread
+ return path_ === cwd;
};
/***/ }),
-/* 663 */
+/* 664 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const {promisify} = __webpack_require__(29);
-const fs = __webpack_require__(23);
+const path = __webpack_require__(4);
-async function isType(fsStatType, statsMethodName, filePath) {
- if (typeof filePath !== 'string') {
- throw new TypeError(`Expected a string, got ${typeof filePath}`);
- }
+module.exports = (childPath, parentPath) => {
+ childPath = path.resolve(childPath);
+ parentPath = path.resolve(parentPath);
- try {
- const stats = await promisify(fs[fsStatType])(filePath);
- return stats[statsMethodName]();
- } catch (error) {
- if (error.code === 'ENOENT') {
- return false;
- }
+ if (process.platform === 'win32') {
+ childPath = childPath.toLowerCase();
+ parentPath = parentPath.toLowerCase();
+ }
- throw error;
+ if (childPath === parentPath) {
+ return false;
}
+
+ childPath += path.sep;
+ parentPath += path.sep;
+
+ return childPath.startsWith(parentPath);
+};
+
+
+/***/ }),
+/* 665 */
+/***/ (function(module, exports, __webpack_require__) {
+
+const assert = __webpack_require__(371)
+const path = __webpack_require__(4)
+const fs = __webpack_require__(349)
+let glob = undefined
+try {
+ glob = __webpack_require__(586)
+} catch (_err) {
+ // treat glob as optional.
}
-function isTypeSync(fsStatType, statsMethodName, filePath) {
- if (typeof filePath !== 'string') {
- throw new TypeError(`Expected a string, got ${typeof filePath}`);
- }
+const defaultGlobOpts = {
+ nosort: true,
+ silent: true
+}
- try {
- return fs[fsStatType](filePath)[statsMethodName]();
- } catch (error) {
- if (error.code === 'ENOENT') {
- return false;
- }
+// for EMFILE handling
+let timeout = 0
- throw error;
- }
+const isWindows = (process.platform === "win32")
+
+const defaults = options => {
+ const methods = [
+ 'unlink',
+ 'chmod',
+ 'stat',
+ 'lstat',
+ 'rmdir',
+ 'readdir'
+ ]
+ methods.forEach(m => {
+ options[m] = options[m] || fs[m]
+ m = m + 'Sync'
+ options[m] = options[m] || fs[m]
+ })
+
+ options.maxBusyTries = options.maxBusyTries || 3
+ options.emfileWait = options.emfileWait || 1000
+ if (options.glob === false) {
+ options.disableGlob = true
+ }
+ if (options.disableGlob !== true && glob === undefined) {
+ throw Error('glob dependency not found, set `options.disableGlob = true` if intentional')
+ }
+ options.disableGlob = options.disableGlob || false
+ options.glob = options.glob || defaultGlobOpts
}
-exports.isFile = isType.bind(null, 'stat', 'isFile');
-exports.isDirectory = isType.bind(null, 'stat', 'isDirectory');
-exports.isSymlink = isType.bind(null, 'lstat', 'isSymbolicLink');
-exports.isFileSync = isTypeSync.bind(null, 'statSync', 'isFile');
-exports.isDirectorySync = isTypeSync.bind(null, 'statSync', 'isDirectory');
-exports.isSymlinkSync = isTypeSync.bind(null, 'lstatSync', 'isSymbolicLink');
+const rimraf = (p, options, cb) => {
+ if (typeof options === 'function') {
+ cb = options
+ options = {}
+ }
+
+ assert(p, 'rimraf: missing path')
+ assert.equal(typeof p, 'string', 'rimraf: path should be a string')
+ assert.equal(typeof cb, 'function', 'rimraf: callback function required')
+ assert(options, 'rimraf: invalid options argument provided')
+ assert.equal(typeof options, 'object', 'rimraf: options should be object')
+
+ defaults(options)
+
+ let busyTries = 0
+ let errState = null
+ let n = 0
+
+ const next = (er) => {
+ errState = errState || er
+ if (--n === 0)
+ cb(errState)
+ }
+
+ const afterGlob = (er, results) => {
+ if (er)
+ return cb(er)
+
+ n = results.length
+ if (n === 0)
+ return cb()
+
+ results.forEach(p => {
+ const CB = (er) => {
+ if (er) {
+ if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") &&
+ busyTries < options.maxBusyTries) {
+ busyTries ++
+ // try again, with the same exact callback as this one.
+ return setTimeout(() => rimraf_(p, options, CB), busyTries * 100)
+ }
+
+ // this one won't happen if graceful-fs is used.
+ if (er.code === "EMFILE" && timeout < options.emfileWait) {
+ return setTimeout(() => rimraf_(p, options, CB), timeout ++)
+ }
+
+ // already gone
+ if (er.code === "ENOENT") er = null
+ }
+ timeout = 0
+ next(er)
+ }
+ rimraf_(p, options, CB)
+ })
+ }
-/***/ }),
-/* 664 */
-/***/ (function(module, exports, __webpack_require__) {
+ if (options.disableGlob || !glob.hasMagic(p))
+ return afterGlob(null, [p])
-"use strict";
+ options.lstat(p, (er, stat) => {
+ if (!er)
+ return afterGlob(null, [p])
-const {promisify} = __webpack_require__(29);
-const fs = __webpack_require__(23);
-const path = __webpack_require__(16);
-const fastGlob = __webpack_require__(596);
-const gitIgnore = __webpack_require__(665);
-const slash = __webpack_require__(666);
+ glob(p, options.glob, afterGlob)
+ })
-const DEFAULT_IGNORE = [
- '**/node_modules/**',
- '**/flow-typed/**',
- '**/coverage/**',
- '**/.git'
-];
+}
-const readFileP = promisify(fs.readFile);
+// Two possible strategies.
+// 1. Assume it's a file. unlink it, then do the dir stuff on EPERM or EISDIR
+// 2. Assume it's a directory. readdir, then do the file stuff on ENOTDIR
+//
+// Both result in an extra syscall when you guess wrong. However, there
+// are likely far more normal files in the world than directories. This
+// is based on the assumption that a the average number of files per
+// directory is >= 1.
+//
+// If anyone ever complains about this, then I guess the strategy could
+// be made configurable somehow. But until then, YAGNI.
+const rimraf_ = (p, options, cb) => {
+ assert(p)
+ assert(options)
+ assert(typeof cb === 'function')
-const mapGitIgnorePatternTo = base => ignore => {
- if (ignore.startsWith('!')) {
- return '!' + path.posix.join(base, ignore.slice(1));
- }
+ // sunos lets the root user unlink directories, which is... weird.
+ // so we have to lstat here and make sure it's not a dir.
+ options.lstat(p, (er, st) => {
+ if (er && er.code === "ENOENT")
+ return cb(null)
- return path.posix.join(base, ignore);
-};
+ // Windows can EPERM on stat. Life is suffering.
+ if (er && er.code === "EPERM" && isWindows)
+ fixWinEPERM(p, options, er, cb)
-const parseGitIgnore = (content, options) => {
- const base = slash(path.relative(options.cwd, path.dirname(options.fileName)));
+ if (st && st.isDirectory())
+ return rmdir(p, options, er, cb)
- return content
- .split(/\r?\n/)
- .filter(Boolean)
- .filter(line => !line.startsWith('#'))
- .map(mapGitIgnorePatternTo(base));
-};
+ options.unlink(p, er => {
+ if (er) {
+ if (er.code === "ENOENT")
+ return cb(null)
+ if (er.code === "EPERM")
+ return (isWindows)
+ ? fixWinEPERM(p, options, er, cb)
+ : rmdir(p, options, er, cb)
+ if (er.code === "EISDIR")
+ return rmdir(p, options, er, cb)
+ }
+ return cb(er)
+ })
+ })
+}
-const reduceIgnore = files => {
- return files.reduce((ignores, file) => {
- ignores.add(parseGitIgnore(file.content, {
- cwd: file.cwd,
- fileName: file.filePath
- }));
- return ignores;
- }, gitIgnore());
-};
+const fixWinEPERM = (p, options, er, cb) => {
+ assert(p)
+ assert(options)
+ assert(typeof cb === 'function')
+ if (er)
+ assert(er instanceof Error)
-const ensureAbsolutePathForCwd = (cwd, p) => {
- if (path.isAbsolute(p)) {
- if (p.startsWith(cwd)) {
- return p;
- }
+ options.chmod(p, 0o666, er2 => {
+ if (er2)
+ cb(er2.code === "ENOENT" ? null : er)
+ else
+ options.stat(p, (er3, stats) => {
+ if (er3)
+ cb(er3.code === "ENOENT" ? null : er)
+ else if (stats.isDirectory())
+ rmdir(p, options, er, cb)
+ else
+ options.unlink(p, cb)
+ })
+ })
+}
- throw new Error(`Path ${p} is not in cwd ${cwd}`);
- }
+const fixWinEPERMSync = (p, options, er) => {
+ assert(p)
+ assert(options)
+ if (er)
+ assert(er instanceof Error)
- return path.join(cwd, p);
-};
+ try {
+ options.chmodSync(p, 0o666)
+ } catch (er2) {
+ if (er2.code === "ENOENT")
+ return
+ else
+ throw er
+ }
-const getIsIgnoredPredecate = (ignores, cwd) => {
- return p => ignores.ignores(slash(path.relative(cwd, ensureAbsolutePathForCwd(cwd, p))));
-};
+ let stats
+ try {
+ stats = options.statSync(p)
+ } catch (er3) {
+ if (er3.code === "ENOENT")
+ return
+ else
+ throw er
+ }
-const getFile = async (file, cwd) => {
- const filePath = path.join(cwd, file);
- const content = await readFileP(filePath, 'utf8');
+ if (stats.isDirectory())
+ rmdirSync(p, options, er)
+ else
+ options.unlinkSync(p)
+}
- return {
- cwd,
- filePath,
- content
- };
-};
+const rmdir = (p, options, originalEr, cb) => {
+ assert(p)
+ assert(options)
+ if (originalEr)
+ assert(originalEr instanceof Error)
+ assert(typeof cb === 'function')
-const getFileSync = (file, cwd) => {
- const filePath = path.join(cwd, file);
- const content = fs.readFileSync(filePath, 'utf8');
+ // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
+ // if we guessed wrong, and it's not a directory, then
+ // raise the original error.
+ options.rmdir(p, er => {
+ if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
+ rmkids(p, options, cb)
+ else if (er && er.code === "ENOTDIR")
+ cb(originalEr)
+ else
+ cb(er)
+ })
+}
- return {
- cwd,
- filePath,
- content
- };
-};
+const rmkids = (p, options, cb) => {
+ assert(p)
+ assert(options)
+ assert(typeof cb === 'function')
-const normalizeOptions = ({
- ignore = [],
- cwd = process.cwd()
-} = {}) => {
- return {ignore, cwd};
-};
+ options.readdir(p, (er, files) => {
+ if (er)
+ return cb(er)
+ let n = files.length
+ if (n === 0)
+ return options.rmdir(p, cb)
+ let errState
+ files.forEach(f => {
+ rimraf(path.join(p, f), options, er => {
+ if (errState)
+ return
+ if (er)
+ return cb(errState = er)
+ if (--n === 0)
+ options.rmdir(p, cb)
+ })
+ })
+ })
+}
-module.exports = async options => {
- options = normalizeOptions(options);
+// this looks simpler, and is strictly *faster*, but will
+// tie up the JavaScript thread and fail on excessively
+// deep directory trees.
+const rimrafSync = (p, options) => {
+ options = options || {}
+ defaults(options)
- const paths = await fastGlob('**/.gitignore', {
- ignore: DEFAULT_IGNORE.concat(options.ignore),
- cwd: options.cwd
- });
+ assert(p, 'rimraf: missing path')
+ assert.equal(typeof p, 'string', 'rimraf: path should be a string')
+ assert(options, 'rimraf: missing options')
+ assert.equal(typeof options, 'object', 'rimraf: options should be object')
- const files = await Promise.all(paths.map(file => getFile(file, options.cwd)));
- const ignores = reduceIgnore(files);
+ let results
- return getIsIgnoredPredecate(ignores, options.cwd);
-};
+ if (options.disableGlob || !glob.hasMagic(p)) {
+ results = [p]
+ } else {
+ try {
+ options.lstatSync(p)
+ results = [p]
+ } catch (er) {
+ results = glob.sync(p, options.glob)
+ }
+ }
-module.exports.sync = options => {
- options = normalizeOptions(options);
+ if (!results.length)
+ return
- const paths = fastGlob.sync('**/.gitignore', {
- ignore: DEFAULT_IGNORE.concat(options.ignore),
- cwd: options.cwd
- });
+ for (let i = 0; i < results.length; i++) {
+ const p = results[i]
- const files = paths.map(file => getFileSync(file, options.cwd));
- const ignores = reduceIgnore(files);
+ let st
+ try {
+ st = options.lstatSync(p)
+ } catch (er) {
+ if (er.code === "ENOENT")
+ return
- return getIsIgnoredPredecate(ignores, options.cwd);
-};
+ // Windows can EPERM on stat. Life is suffering.
+ if (er.code === "EPERM" && isWindows)
+ fixWinEPERMSync(p, options, er)
+ }
+ try {
+ // sunos lets the root user unlink directories, which is... weird.
+ if (st && st.isDirectory())
+ rmdirSync(p, options, null)
+ else
+ options.unlinkSync(p)
+ } catch (er) {
+ if (er.code === "ENOENT")
+ return
+ if (er.code === "EPERM")
+ return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
+ if (er.code !== "EISDIR")
+ throw er
-/***/ }),
-/* 665 */
-/***/ (function(module, exports) {
+ rmdirSync(p, options, er)
+ }
+ }
+}
-// A simple implementation of make-array
-function makeArray (subject) {
- return Array.isArray(subject)
- ? subject
- : [subject]
+const rmdirSync = (p, options, originalEr) => {
+ assert(p)
+ assert(options)
+ if (originalEr)
+ assert(originalEr instanceof Error)
+
+ try {
+ options.rmdirSync(p)
+ } catch (er) {
+ if (er.code === "ENOENT")
+ return
+ if (er.code === "ENOTDIR")
+ throw originalEr
+ if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
+ rmkidsSync(p, options)
+ }
}
-const REGEX_TEST_BLANK_LINE = /^\s+$/
-const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/
-const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/
-const REGEX_SPLITALL_CRLF = /\r?\n/g
-// /foo,
-// ./foo,
-// ../foo,
-// .
-// ..
-const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/
+const rmkidsSync = (p, options) => {
+ assert(p)
+ assert(options)
+ options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options))
-const SLASH = '/'
-const KEY_IGNORE = typeof Symbol !== 'undefined'
- ? Symbol.for('node-ignore')
- /* istanbul ignore next */
- : 'node-ignore'
+ // We only end up here once we got ENOTEMPTY at least once, and
+ // at this point, we are guaranteed to have removed all the kids.
+ // So, we know that it won't be ENOENT or ENOTDIR or anything else.
+ // try really hard to delete stuff on windows, because it has a
+ // PROFOUNDLY annoying habit of not closing handles promptly when
+ // files are deleted, resulting in spurious ENOTEMPTY errors.
+ const retries = isWindows ? 100 : 1
+ let i = 0
+ do {
+ let threw = true
+ try {
+ const ret = options.rmdirSync(p, options)
+ threw = false
+ return ret
+ } finally {
+ if (++i < retries && threw)
+ continue
+ }
+ } while (true)
+}
-const define = (object, key, value) =>
- Object.defineProperty(object, key, {value})
+module.exports = rimraf
+rimraf.sync = rimrafSync
-const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g
-// Sanitize the range of a regular expression
-// The cases are complicated, see test cases for details
-const sanitizeRange = range => range.replace(
- REGEX_REGEXP_RANGE,
- (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)
- ? match
- // Invalid range (out of order) which is ok for gitignore rules but
- // fatal for JavaScript regular expression, so eliminate it.
- : ''
-)
+/***/ }),
+/* 666 */
+/***/ (function(module, exports, __webpack_require__) {
-// > If the pattern ends with a slash,
-// > it is removed for the purpose of the following description,
-// > but it would only find a match with a directory.
-// > In other words, foo/ will match a directory foo and paths underneath it,
-// > but will not match a regular file or a symbolic link foo
-// > (this is consistent with the way how pathspec works in general in Git).
-// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'
-// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call
-// you could use option `mark: true` with `glob`
+"use strict";
-// '`foo/`' should not continue with the '`..`'
-const DEFAULT_REPLACER_PREFIX = [
+const AggregateError = __webpack_require__(667);
- // > Trailing spaces are ignored unless they are quoted with backslash ("\")
- [
- // (a\ ) -> (a )
- // (a ) -> (a)
- // (a \ ) -> (a )
- /\\?\s+$/,
- match => match.indexOf('\\') === 0
- ? ' '
- : ''
- ],
+module.exports = async (
+ iterable,
+ mapper,
+ {
+ concurrency = Infinity,
+ stopOnError = true
+ } = {}
+) => {
+ return new Promise((resolve, reject) => {
+ if (typeof mapper !== 'function') {
+ throw new TypeError('Mapper function is required');
+ }
- // replace (\ ) with ' '
- [
- /\\\s/g,
- () => ' '
- ],
+ if (!(typeof concurrency === 'number' && concurrency >= 1)) {
+ throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${concurrency}\` (${typeof concurrency})`);
+ }
- // Escape metacharacters
- // which is written down by users but means special for regular expressions.
+ const ret = [];
+ const errors = [];
+ const iterator = iterable[Symbol.iterator]();
+ let isRejected = false;
+ let isIterableDone = false;
+ let resolvingCount = 0;
+ let currentIndex = 0;
- // > There are 12 characters with special meanings:
- // > - the backslash \,
- // > - the caret ^,
- // > - the dollar sign $,
- // > - the period or dot .,
- // > - the vertical bar or pipe symbol |,
- // > - the question mark ?,
- // > - the asterisk or star *,
- // > - the plus sign +,
- // > - the opening parenthesis (,
- // > - the closing parenthesis ),
- // > - and the opening square bracket [,
- // > - the opening curly brace {,
- // > These special characters are often called "metacharacters".
- [
- /[\\^$.|*+(){]/g,
- match => `\\${match}`
- ],
+ const next = () => {
+ if (isRejected) {
+ return;
+ }
- [
- // > [abc] matches any character inside the brackets
- // > (in this case a, b, or c);
- /\[([^\]/]*)($|\])/g,
- (match, p1, p2) => p2 === ']'
- ? `[${sanitizeRange(p1)}]`
- : `\\${match}`
- ],
+ const nextItem = iterator.next();
+ const i = currentIndex;
+ currentIndex++;
- [
- // > a question mark (?) matches a single character
- /(?!\\)\?/g,
- () => '[^/]'
- ],
+ if (nextItem.done) {
+ isIterableDone = true;
- // leading slash
- [
+ if (resolvingCount === 0) {
+ if (!stopOnError && errors.length !== 0) {
+ reject(new AggregateError(errors));
+ } else {
+ resolve(ret);
+ }
+ }
- // > A leading slash matches the beginning of the pathname.
- // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
- // A leading slash matches the beginning of the pathname
- /^\//,
- () => '^'
- ],
+ return;
+ }
- // replace special metacharacter slash after the leading slash
- [
- /\//g,
- () => '\\/'
- ],
+ resolvingCount++;
- [
- // > A leading "**" followed by a slash means match in all directories.
- // > For example, "**/foo" matches file or directory "foo" anywhere,
- // > the same as pattern "foo".
- // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
- // > under directory "foo".
- // Notice that the '*'s have been replaced as '\\*'
- /^\^*\\\*\\\*\\\//,
+ (async () => {
+ try {
+ const element = await nextItem.value;
+ ret[i] = await mapper(element, i);
+ resolvingCount--;
+ next();
+ } catch (error) {
+ if (stopOnError) {
+ isRejected = true;
+ reject(error);
+ } else {
+ errors.push(error);
+ resolvingCount--;
+ next();
+ }
+ }
+ })();
+ };
- // '**/foo' <-> 'foo'
- () => '^(?:.*\\/)?'
- ]
-]
+ for (let i = 0; i < concurrency; i++) {
+ next();
-const DEFAULT_REPLACER_SUFFIX = [
- // starting
- [
- // there will be no leading '/'
- // (which has been replaced by section "leading slash")
- // If starts with '**', adding a '^' to the regular expression also works
- /^(?=[^^])/,
- function startingReplacer () {
- return !/\/(?!$)/.test(this)
- // > If the pattern does not contain a slash /,
- // > Git treats it as a shell glob pattern
- // Actually, if there is only a trailing slash,
- // git also treats it as a shell glob pattern
- ? '(?:^|\\/)'
+ if (isIterableDone) {
+ break;
+ }
+ }
+ });
+};
- // > Otherwise, Git treats the pattern as a shell glob suitable for
- // > consumption by fnmatch(3)
- : '^'
- }
- ],
- // two globstars
- [
- // Use lookahead assertions so that we could match more than one `'/**'`
- /\\\/\\\*\\\*(?=\\\/|$)/g,
+/***/ }),
+/* 667 */
+/***/ (function(module, exports, __webpack_require__) {
- // Zero, one or several directories
- // should not use '*', or it will be replaced by the next replacer
+"use strict";
- // Check if it is not the last `'/**'`
- (_, index, str) => index + 6 < str.length
+const indentString = __webpack_require__(668);
+const cleanStack = __webpack_require__(669);
- // case: /**/
- // > A slash followed by two consecutive asterisks then a slash matches
- // > zero or more directories.
- // > For example, "a/**/b" matches "a/b", "a/x/b", "a/x/y/b" and so on.
- // '/**/'
- ? '(?:\\/[^\\/]+)*'
+const cleanInternalStack = stack => stack.replace(/\s+at .*aggregate-error\/index.js:\d+:\d+\)?/g, '');
- // case: /**
- // > A trailing `"/**"` matches everything inside.
+class AggregateError extends Error {
+ constructor(errors) {
+ if (!Array.isArray(errors)) {
+ throw new TypeError(`Expected input to be an Array, got ${typeof errors}`);
+ }
- // #21: everything inside but it should not include the current folder
- : '\\/.+'
- ],
+ errors = [...errors].map(error => {
+ if (error instanceof Error) {
+ return error;
+ }
- // intermediate wildcards
- [
- // Never replace escaped '*'
- // ignore rule '\*' will match the path '*'
+ if (error !== null && typeof error === 'object') {
+ // Handle plain error objects with message property and/or possibly other metadata
+ return Object.assign(new Error(error.message), error);
+ }
- // 'abc.*/' -> go
- // 'abc.*' -> skip this rule
- /(^|[^\\]+)\\\*(?=.+)/g,
+ return new Error(error);
+ });
- // '*.js' matches '.js'
- // '*.js' doesn't match 'abc'
- (_, p1) => `${p1}[^\\/]*`
- ],
+ let message = errors
+ .map(error => {
+ // The `stack` property is not standardized, so we can't assume it exists
+ return typeof error.stack === 'string' ? cleanInternalStack(cleanStack(error.stack)) : String(error);
+ })
+ .join('\n');
+ message = '\n' + indentString(message, 4);
+ super(message);
- // trailing wildcard
- [
- /(\^|\\\/)?\\\*$/,
- (_, p1) => {
- const prefix = p1
- // '\^':
- // '/*' does not match ''
- // '/*' does not match everything
+ this.name = 'AggregateError';
- // '\\\/':
- // 'abc/*' does not match 'abc/'
- ? `${p1}[^/]+`
+ Object.defineProperty(this, '_errors', {value: errors});
+ }
- // 'a*' matches 'a'
- // 'a*' matches 'aa'
- : '[^/]*'
+ * [Symbol.iterator]() {
+ for (const error of this._errors) {
+ yield error;
+ }
+ }
+}
- return `${prefix}(?=$|\\/$)`
- }
- ],
+module.exports = AggregateError;
- [
- // unescape
- /\\\\\\/g,
- () => '\\'
- ]
-]
-const POSITIVE_REPLACERS = [
- ...DEFAULT_REPLACER_PREFIX,
+/***/ }),
+/* 668 */
+/***/ (function(module, exports, __webpack_require__) {
- // 'f'
- // matches
- // - /f(end)
- // - /f/
- // - (start)f(end)
- // - (start)f/
- // doesn't match
- // - oof
- // - foo
- // pseudo:
- // -> (^|/)f(/|$)
+"use strict";
- // ending
- [
- // 'js' will not match 'js.'
- // 'ab' will not match 'abc'
- /(?:[^*/])$/,
- // 'js*' will not match 'a.js'
- // 'js/' will not match 'a.js'
- // 'js' will match 'a.js' and 'a.js/'
- match => `${match}(?=$|\\/)`
- ],
+module.exports = (string, count = 1, options) => {
+ options = {
+ indent: ' ',
+ includeEmptyLines: false,
+ ...options
+ };
- ...DEFAULT_REPLACER_SUFFIX
-]
+ if (typeof string !== 'string') {
+ throw new TypeError(
+ `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
+ );
+ }
-const NEGATIVE_REPLACERS = [
- ...DEFAULT_REPLACER_PREFIX,
+ if (typeof count !== 'number') {
+ throw new TypeError(
+ `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
+ );
+ }
- // #24, #38
- // The MISSING rule of [gitignore docs](https://git-scm.com/docs/gitignore)
- // A negative pattern without a trailing wildcard should not
- // re-include the things inside that directory.
+ if (typeof options.indent !== 'string') {
+ throw new TypeError(
+ `Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
+ );
+ }
- // eg:
- // ['node_modules/*', '!node_modules']
- // should ignore `node_modules/a.js`
- [
- /(?:[^*])$/,
- match => `${match}(?=$|\\/$)`
- ],
+ if (count === 0) {
+ return string;
+ }
- ...DEFAULT_REPLACER_SUFFIX
-]
+ const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
-// A simple cache, because an ignore rule only has only one certain meaning
-const regexCache = Object.create(null)
+ return string.replace(regex, options.indent.repeat(count));
+};
-// @param {pattern}
-const makeRegex = (pattern, negative, ignorecase) => {
- const r = regexCache[pattern]
- if (r) {
- return r
- }
- const replacers = negative
- ? NEGATIVE_REPLACERS
- : POSITIVE_REPLACERS
+/***/ }),
+/* 669 */
+/***/ (function(module, exports, __webpack_require__) {
- const source = replacers.reduce(
- (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
- pattern
- )
+"use strict";
- return regexCache[pattern] = ignorecase
- ? new RegExp(source, 'i')
- : new RegExp(source)
-}
+const os = __webpack_require__(364);
-const isString = subject => typeof subject === 'string'
+const extractPathRegex = /\s+at.*(?:\(|\s)(.*)\)?/;
+const pathRegex = /^(?:(?:(?:node|(?:internal\/[\w/]*|.*node_modules\/(?:babel-polyfill|pirates)\/.*)?\w+)\.js:\d+:\d+)|native)/;
+const homeDir = typeof os.homedir === 'undefined' ? '' : os.homedir();
-// > A blank line matches no files, so it can serve as a separator for readability.
-const checkPattern = pattern => pattern
- && isString(pattern)
- && !REGEX_TEST_BLANK_LINE.test(pattern)
+module.exports = (stack, options) => {
+ options = Object.assign({pretty: false}, options);
- // > A line starting with # serves as a comment.
- && pattern.indexOf('#') !== 0
+ return stack.replace(/\\/g, '/')
+ .split('\n')
+ .filter(line => {
+ const pathMatches = line.match(extractPathRegex);
+ if (pathMatches === null || !pathMatches[1]) {
+ return true;
+ }
-const splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF)
+ const match = pathMatches[1];
-class IgnoreRule {
- constructor (
- origin,
- pattern,
- negative,
- regex
- ) {
- this.origin = origin
- this.pattern = pattern
- this.negative = negative
- this.regex = regex
- }
-}
+ // Electron
+ if (
+ match.includes('.app/Contents/Resources/electron.asar') ||
+ match.includes('.app/Contents/Resources/default_app.asar')
+ ) {
+ return false;
+ }
-const createRule = (pattern, ignorecase) => {
- const origin = pattern
- let negative = false
+ return !pathRegex.test(match);
+ })
+ .filter(line => line.trim() !== '')
+ .map(line => {
+ if (options.pretty) {
+ return line.replace(extractPathRegex, (m, p1) => m.replace(p1, p1.replace(homeDir, '~')));
+ }
- // > An optional prefix "!" which negates the pattern;
- if (pattern.indexOf('!') === 0) {
- negative = true
- pattern = pattern.substr(1)
- }
+ return line;
+ })
+ .join('\n');
+};
- pattern = pattern
- // > Put a backslash ("\") in front of the first "!" for patterns that
- // > begin with a literal "!", for example, `"\!important!.txt"`.
- .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')
- // > Put a backslash ("\") in front of the first hash for patterns that
- // > begin with a hash.
- .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#')
- const regex = makeRegex(pattern, negative, ignorecase)
+/***/ }),
+/* 670 */
+/***/ (function(module, exports, __webpack_require__) {
- return new IgnoreRule(
- origin,
- pattern,
- negative,
- regex
- )
-}
+"use strict";
-const throwError = (message, Ctor) => {
- throw new Ctor(message)
-}
+const chalk = __webpack_require__(671);
+const cliCursor = __webpack_require__(675);
+const cliSpinners = __webpack_require__(679);
+const logSymbols = __webpack_require__(681);
-const checkPath = (path, originalPath, doThrow) => {
- if (!isString(path)) {
- return doThrow(
- `path must be a string, but got \`${originalPath}\``,
- TypeError
- )
- }
+class Ora {
+ constructor(options) {
+ if (typeof options === 'string') {
+ options = {
+ text: options
+ };
+ }
- // We don't know if we should ignore '', so throw
- if (!path) {
- return doThrow(`path must not be empty`, TypeError)
- }
+ this.options = Object.assign({
+ text: '',
+ color: 'cyan',
+ stream: process.stderr
+ }, options);
- // Check if it is a relative path
- if (checkPath.isNotRelative(path)) {
- const r = '`path.relative()`d'
- return doThrow(
- `path should be a ${r} string, but got "${originalPath}"`,
- RangeError
- )
- }
+ const sp = this.options.spinner;
+ this.spinner = typeof sp === 'object' ? sp : (process.platform === 'win32' ? cliSpinners.line : (cliSpinners[sp] || cliSpinners.dots)); // eslint-disable-line no-nested-ternary
- return true
-}
+ if (this.spinner.frames === undefined) {
+ throw new Error('Spinner must define `frames`');
+ }
-const isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path)
+ this.text = this.options.text;
+ this.color = this.options.color;
+ this.interval = this.options.interval || this.spinner.interval || 100;
+ this.stream = this.options.stream;
+ this.id = null;
+ this.frameIndex = 0;
+ this.enabled = typeof this.options.enabled === 'boolean' ? this.options.enabled : ((this.stream && this.stream.isTTY) && !process.env.CI);
+ }
+ frame() {
+ const frames = this.spinner.frames;
+ let frame = frames[this.frameIndex];
-checkPath.isNotRelative = isNotRelative
-checkPath.convert = p => p
+ if (this.color) {
+ frame = chalk[this.color](frame);
+ }
-class Ignore {
- constructor ({
- ignorecase = true
- } = {}) {
- this._rules = []
- this._ignorecase = ignorecase
- define(this, KEY_IGNORE, true)
- this._initCache()
- }
+ this.frameIndex = ++this.frameIndex % frames.length;
- _initCache () {
- this._ignoreCache = Object.create(null)
- this._testCache = Object.create(null)
- }
+ return frame + ' ' + this.text;
+ }
+ clear() {
+ if (!this.enabled) {
+ return this;
+ }
- _addPattern (pattern) {
- // #32
- if (pattern && pattern[KEY_IGNORE]) {
- this._rules = this._rules.concat(pattern._rules)
- this._added = true
- return
- }
+ this.stream.clearLine();
+ this.stream.cursorTo(0);
- if (checkPattern(pattern)) {
- const rule = createRule(pattern, this._ignorecase)
- this._added = true
- this._rules.push(rule)
- }
- }
+ return this;
+ }
+ render() {
+ this.clear();
+ this.stream.write(this.frame());
- // @param {Array | string | Ignore} pattern
- add (pattern) {
- this._added = false
+ return this;
+ }
+ start(text) {
+ if (text) {
+ this.text = text;
+ }
- makeArray(
- isString(pattern)
- ? splitPattern(pattern)
- : pattern
- ).forEach(this._addPattern, this)
+ if (!this.enabled || this.id) {
+ return this;
+ }
- // Some rules have just added to the ignore,
- // making the behavior changed.
- if (this._added) {
- this._initCache()
- }
+ cliCursor.hide(this.stream);
+ this.render();
+ this.id = setInterval(this.render.bind(this), this.interval);
- return this
- }
+ return this;
+ }
+ stop() {
+ if (!this.enabled) {
+ return this;
+ }
- // legacy
- addPattern (pattern) {
- return this.add(pattern)
- }
+ clearInterval(this.id);
+ this.id = null;
+ this.frameIndex = 0;
+ this.clear();
+ cliCursor.show(this.stream);
- // | ignored : unignored
- // negative | 0:0 | 0:1 | 1:0 | 1:1
- // -------- | ------- | ------- | ------- | --------
- // 0 | TEST | TEST | SKIP | X
- // 1 | TESTIF | SKIP | TEST | X
+ return this;
+ }
+ succeed(text) {
+ return this.stopAndPersist({symbol: logSymbols.success, text});
+ }
+ fail(text) {
+ return this.stopAndPersist({symbol: logSymbols.error, text});
+ }
+ warn(text) {
+ return this.stopAndPersist({symbol: logSymbols.warning, text});
+ }
+ info(text) {
+ return this.stopAndPersist({symbol: logSymbols.info, text});
+ }
+ stopAndPersist(options) {
+ if (!this.enabled) {
+ return this;
+ }
- // - SKIP: always skip
- // - TEST: always test
- // - TESTIF: only test if checkUnignored
- // - X: that never happen
+ // Legacy argument
+ // TODO: Deprecate sometime in the future
+ if (typeof options === 'string') {
+ options = {
+ symbol: options
+ };
+ }
- // @param {boolean} whether should check if the path is unignored,
- // setting `checkUnignored` to `false` could reduce additional
- // path matching.
+ options = options || {};
- // @returns {TestResult} true if a file is ignored
- _testOne (path, checkUnignored) {
- let ignored = false
- let unignored = false
+ this.stop();
+ this.stream.write(`${options.symbol || ' '} ${options.text || this.text}\n`);
- this._rules.forEach(rule => {
- const {negative} = rule
- if (
- unignored === negative && ignored !== unignored
- || negative && !ignored && !unignored && !checkUnignored
- ) {
- return
- }
+ return this;
+ }
+}
- const matched = rule.regex.test(path)
+module.exports = function (opts) {
+ return new Ora(opts);
+};
- if (matched) {
- ignored = !negative
- unignored = negative
- }
- })
+module.exports.promise = (action, options) => {
+ if (typeof action.then !== 'function') {
+ throw new TypeError('Parameter `action` must be a Promise');
+ }
- return {
- ignored,
- unignored
- }
- }
+ const spinner = new Ora(options);
+ spinner.start();
- // @returns {TestResult}
- _test (originalPath, cache, checkUnignored, slices) {
- const path = originalPath
- // Supports nullable path
- && checkPath.convert(originalPath)
+ action.then(
+ () => {
+ spinner.succeed();
+ },
+ () => {
+ spinner.fail();
+ }
+ );
- checkPath(path, originalPath, throwError)
+ return spinner;
+};
- return this._t(path, cache, checkUnignored, slices)
- }
- _t (path, cache, checkUnignored, slices) {
- if (path in cache) {
- return cache[path]
- }
+/***/ }),
+/* 671 */
+/***/ (function(module, exports, __webpack_require__) {
- if (!slices) {
- // path/to/a.js
- // ['path', 'to', 'a.js']
- slices = path.split(SLASH)
- }
+"use strict";
- slices.pop()
+const escapeStringRegexp = __webpack_require__(387);
+const ansiStyles = __webpack_require__(672);
+const stdoutColor = __webpack_require__(673).stdout;
- // If the path has no parent directory, just test it
- if (!slices.length) {
- return cache[path] = this._testOne(path, checkUnignored)
- }
+const template = __webpack_require__(674);
- const parent = this._t(
- slices.join(SLASH) + SLASH,
- cache,
- checkUnignored,
- slices
- )
+const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
- // If the path contains a parent directory, check the parent first
- return cache[path] = parent.ignored
- // > It is not possible to re-include a file if a parent directory of
- // > that file is excluded.
- ? parent
- : this._testOne(path, checkUnignored)
- }
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
- ignores (path) {
- return this._test(path, this._ignoreCache, false).ignored
- }
+// `color-convert` models to exclude from the Chalk API due to conflicts and such
+const skipModels = new Set(['gray']);
- createFilter () {
- return path => !this.ignores(path)
- }
+const styles = Object.create(null);
- filter (paths) {
- return makeArray(paths).filter(this.createFilter())
- }
+function applyOptions(obj, options) {
+ options = options || {};
- // @returns {TestResult}
- test (path) {
- return this._test(path, this._testCache, true)
- }
+ // Detect level if not set manually
+ const scLevel = stdoutColor ? stdoutColor.level : 0;
+ obj.level = options.level === undefined ? scLevel : options.level;
+ obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
}
-const factory = options => new Ignore(options)
+function Chalk(options) {
+ // We check for this.template here since calling `chalk.constructor()`
+ // by itself will have a `this` of a previously constructed chalk object
+ if (!this || !(this instanceof Chalk) || this.template) {
+ const chalk = {};
+ applyOptions(chalk, options);
-const returnFalse = () => false
+ chalk.template = function () {
+ const args = [].slice.call(arguments);
+ return chalkTag.apply(null, [chalk.template].concat(args));
+ };
-const isPathValid = path =>
- checkPath(path && checkPath.convert(path), path, returnFalse)
+ Object.setPrototypeOf(chalk, Chalk.prototype);
+ Object.setPrototypeOf(chalk.template, chalk);
-factory.isPathValid = isPathValid
+ chalk.template.constructor = Chalk;
-// Fixes typescript
-factory.default = factory
+ return chalk.template;
+ }
-module.exports = factory
+ applyOptions(this, options);
+}
-// Windows
-// --------------------------------------------------------------
-/* istanbul ignore if */
-if (
- // Detect `process` so that it can run in browsers.
- typeof process !== 'undefined'
- && (
- process.env && process.env.IGNORE_TEST_WIN32
- || process.platform === 'win32'
- )
-) {
- /* eslint no-control-regex: "off" */
- const makePosix = str => /^\\\\\?\\/.test(str)
- || /["<>|\u0000-\u001F]+/u.test(str)
- ? str
- : str.replace(/\\/g, '/')
+// Use bright blue on Windows as the normal blue color is illegible
+if (isSimpleWindowsTerm) {
+ ansiStyles.blue.open = '\u001B[94m';
+}
- checkPath.convert = makePosix
+for (const key of Object.keys(ansiStyles)) {
+ ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g');
- // 'C:\\foo' <- 'C:\\foo' has been converted to 'C:/'
- // 'd:\\foo'
- const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i
- checkPath.isNotRelative = path =>
- REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path)
- || isNotRelative(path)
+ styles[key] = {
+ get() {
+ const codes = ansiStyles[key];
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+ }
+ };
}
+styles.visible = {
+ get() {
+ return build.call(this, this._styles || [], true, 'visible');
+ }
+};
-/***/ }),
-/* 666 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
+ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), 'g');
+for (const model of Object.keys(ansiStyles.color.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
+ }
-module.exports = path => {
- const isExtendedLengthPath = /^\\\\\?\\/.test(path);
- const hasNonAscii = /[^\u0000-\u0080]+/.test(path); // eslint-disable-line no-control-regex
+ styles[model] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles.color.close,
+ closeRe: ansiStyles.color.closeRe
+ };
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
+}
- if (isExtendedLengthPath || hasNonAscii) {
- return path;
+ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), 'g');
+for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
+ if (skipModels.has(model)) {
+ continue;
}
- return path.replace(/\\/g, '/');
-};
-
+ const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+ styles[bgModel] = {
+ get() {
+ const level = this.level;
+ return function () {
+ const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
+ const codes = {
+ open,
+ close: ansiStyles.bgColor.close,
+ closeRe: ansiStyles.bgColor.closeRe
+ };
+ return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+ };
+ }
+ };
+}
-/***/ }),
-/* 667 */
-/***/ (function(module, exports, __webpack_require__) {
+const proto = Object.defineProperties(() => {}, styles);
-"use strict";
+function build(_styles, _empty, key) {
+ const builder = function () {
+ return applyStyle.apply(builder, arguments);
+ };
-const {Transform} = __webpack_require__(27);
+ builder._styles = _styles;
+ builder._empty = _empty;
-class ObjectTransform extends Transform {
- constructor() {
- super({
- objectMode: true
- });
- }
-}
+ const self = this;
-class FilterStream extends ObjectTransform {
- constructor(filter) {
- super();
- this._filter = filter;
- }
+ Object.defineProperty(builder, 'level', {
+ enumerable: true,
+ get() {
+ return self.level;
+ },
+ set(level) {
+ self.level = level;
+ }
+ });
- _transform(data, encoding, callback) {
- if (this._filter(data)) {
- this.push(data);
+ Object.defineProperty(builder, 'enabled', {
+ enumerable: true,
+ get() {
+ return self.enabled;
+ },
+ set(enabled) {
+ self.enabled = enabled;
}
+ });
- callback();
- }
+ // See below for fix regarding invisible grey/dim combination on Windows
+ builder.hasGrey = this.hasGrey || key === 'gray' || key === 'grey';
+
+ // `__proto__` is used because we must return a function, but there is
+ // no way to create a function with a different prototype
+ builder.__proto__ = proto; // eslint-disable-line no-proto
+
+ return builder;
}
-class UniqueStream extends ObjectTransform {
- constructor() {
- super();
- this._pushed = new Set();
+function applyStyle() {
+ // Support varags, but simply cast to string in case there's only one arg
+ const args = arguments;
+ const argsLen = args.length;
+ let str = String(arguments[0]);
+
+ if (argsLen === 0) {
+ return '';
}
- _transform(data, encoding, callback) {
- if (!this._pushed.has(data)) {
- this.push(data);
- this._pushed.add(data);
+ if (argsLen > 1) {
+ // Don't slice `arguments`, it prevents V8 optimizations
+ for (let a = 1; a < argsLen; a++) {
+ str += ' ' + args[a];
}
+ }
- callback();
+ if (!this.enabled || this.level <= 0 || !str) {
+ return this._empty ? '' : str;
}
-}
-module.exports = {
- FilterStream,
- UniqueStream
-};
+ // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
+ // see https://github.com/chalk/chalk/issues/58
+ // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop.
+ const originalDim = ansiStyles.dim.open;
+ if (isSimpleWindowsTerm && this.hasGrey) {
+ ansiStyles.dim.open = '';
+ }
+ for (const code of this._styles.slice().reverse()) {
+ // Replace any instances already present with a re-opening code
+ // otherwise only the part of the string until said closing code
+ // will be colored, and the rest will simply be 'plain'.
+ str = code.open + str.replace(code.closeRe, code.open) + code.close;
-/***/ }),
-/* 668 */
-/***/ (function(module, exports, __webpack_require__) {
+ // Close the styling before a linebreak and reopen
+ // after next line to fix a bleed issue on macOS
+ // https://github.com/chalk/chalk/pull/92
+ str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+ }
-"use strict";
+ // Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
+ ansiStyles.dim.open = originalDim;
-const path = __webpack_require__(16);
+ return str;
+}
-module.exports = path_ => {
- let cwd = process.cwd();
+function chalkTag(chalk, strings) {
+ if (!Array.isArray(strings)) {
+ // If chalk() was called by itself or with a string,
+ // return the string itself as a string.
+ return [].slice.call(arguments, 1).join(' ');
+ }
- path_ = path.resolve(path_);
+ const args = [].slice.call(arguments, 2);
+ const parts = [strings.raw[0]];
- if (process.platform === 'win32') {
- cwd = cwd.toLowerCase();
- path_ = path_.toLowerCase();
+ for (let i = 1; i < strings.length; i++) {
+ parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
+ parts.push(String(strings.raw[i]));
}
- return path_ === cwd;
-};
+ return template(chalk, parts.join(''));
+}
+
+Object.defineProperties(Chalk.prototype, styles);
+
+module.exports = Chalk(); // eslint-disable-line new-cap
+module.exports.supportsColor = stdoutColor;
+module.exports.default = module.exports; // For TypeScript
/***/ }),
-/* 669 */
+/* 672 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+/* WEBPACK VAR INJECTION */(function(module) {
+const colorConvert = __webpack_require__(389);
-const path = __webpack_require__(16);
-
-module.exports = (childPath, parentPath) => {
- childPath = path.resolve(childPath);
- parentPath = path.resolve(parentPath);
-
- if (process.platform === 'win32') {
- childPath = childPath.toLowerCase();
- parentPath = parentPath.toLowerCase();
- }
-
- if (childPath === parentPath) {
- return false;
- }
-
- childPath += path.sep;
- parentPath += path.sep;
+const wrapAnsi16 = (fn, offset) => function () {
+ const code = fn.apply(colorConvert, arguments);
+ return `\u001B[${code + offset}m`;
+};
- return childPath.startsWith(parentPath);
+const wrapAnsi256 = (fn, offset) => function () {
+ const code = fn.apply(colorConvert, arguments);
+ return `\u001B[${38 + offset};5;${code}m`;
};
+const wrapAnsi16m = (fn, offset) => function () {
+ const rgb = fn.apply(colorConvert, arguments);
+ return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+};
-/***/ }),
-/* 670 */
-/***/ (function(module, exports, __webpack_require__) {
+function assembleStyles() {
+ const codes = new Map();
+ const styles = {
+ modifier: {
+ reset: [0, 0],
+ // 21 isn't widely supported and 22 does the same thing
+ bold: [1, 22],
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29]
+ },
+ color: {
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+ gray: [90, 39],
-const assert = __webpack_require__(30)
-const path = __webpack_require__(16)
-const fs = __webpack_require__(23)
-let glob = undefined
-try {
- glob = __webpack_require__(591)
-} catch (_err) {
- // treat glob as optional.
-}
+ // Bright color
+ redBright: [91, 39],
+ greenBright: [92, 39],
+ yellowBright: [93, 39],
+ blueBright: [94, 39],
+ magentaBright: [95, 39],
+ cyanBright: [96, 39],
+ whiteBright: [97, 39]
+ },
+ bgColor: {
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49],
-const defaultGlobOpts = {
- nosort: true,
- silent: true
-}
+ // Bright color
+ bgBlackBright: [100, 49],
+ bgRedBright: [101, 49],
+ bgGreenBright: [102, 49],
+ bgYellowBright: [103, 49],
+ bgBlueBright: [104, 49],
+ bgMagentaBright: [105, 49],
+ bgCyanBright: [106, 49],
+ bgWhiteBright: [107, 49]
+ }
+ };
-// for EMFILE handling
-let timeout = 0
+ // Fix humans
+ styles.color.grey = styles.color.gray;
-const isWindows = (process.platform === "win32")
+ for (const groupName of Object.keys(styles)) {
+ const group = styles[groupName];
-const defaults = options => {
- const methods = [
- 'unlink',
- 'chmod',
- 'stat',
- 'lstat',
- 'rmdir',
- 'readdir'
- ]
- methods.forEach(m => {
- options[m] = options[m] || fs[m]
- m = m + 'Sync'
- options[m] = options[m] || fs[m]
- })
+ for (const styleName of Object.keys(group)) {
+ const style = group[styleName];
- options.maxBusyTries = options.maxBusyTries || 3
- options.emfileWait = options.emfileWait || 1000
- if (options.glob === false) {
- options.disableGlob = true
- }
- if (options.disableGlob !== true && glob === undefined) {
- throw Error('glob dependency not found, set `options.disableGlob = true` if intentional')
- }
- options.disableGlob = options.disableGlob || false
- options.glob = options.glob || defaultGlobOpts
-}
+ styles[styleName] = {
+ open: `\u001B[${style[0]}m`,
+ close: `\u001B[${style[1]}m`
+ };
-const rimraf = (p, options, cb) => {
- if (typeof options === 'function') {
- cb = options
- options = {}
- }
+ group[styleName] = styles[styleName];
- assert(p, 'rimraf: missing path')
- assert.equal(typeof p, 'string', 'rimraf: path should be a string')
- assert.equal(typeof cb, 'function', 'rimraf: callback function required')
- assert(options, 'rimraf: invalid options argument provided')
- assert.equal(typeof options, 'object', 'rimraf: options should be object')
+ codes.set(style[0], style[1]);
+ }
- defaults(options)
+ Object.defineProperty(styles, groupName, {
+ value: group,
+ enumerable: false
+ });
- let busyTries = 0
- let errState = null
- let n = 0
+ Object.defineProperty(styles, 'codes', {
+ value: codes,
+ enumerable: false
+ });
+ }
- const next = (er) => {
- errState = errState || er
- if (--n === 0)
- cb(errState)
- }
+ const ansi2ansi = n => n;
+ const rgb2rgb = (r, g, b) => [r, g, b];
- const afterGlob = (er, results) => {
- if (er)
- return cb(er)
+ styles.color.close = '\u001B[39m';
+ styles.bgColor.close = '\u001B[49m';
- n = results.length
- if (n === 0)
- return cb()
+ styles.color.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 0)
+ };
+ styles.color.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 0)
+ };
+ styles.color.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 0)
+ };
- results.forEach(p => {
- const CB = (er) => {
- if (er) {
- if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") &&
- busyTries < options.maxBusyTries) {
- busyTries ++
- // try again, with the same exact callback as this one.
- return setTimeout(() => rimraf_(p, options, CB), busyTries * 100)
- }
+ styles.bgColor.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 10)
+ };
- // this one won't happen if graceful-fs is used.
- if (er.code === "EMFILE" && timeout < options.emfileWait) {
- return setTimeout(() => rimraf_(p, options, CB), timeout ++)
- }
+ for (let key of Object.keys(colorConvert)) {
+ if (typeof colorConvert[key] !== 'object') {
+ continue;
+ }
- // already gone
- if (er.code === "ENOENT") er = null
- }
+ const suite = colorConvert[key];
- timeout = 0
- next(er)
- }
- rimraf_(p, options, CB)
- })
- }
+ if (key === 'ansi16') {
+ key = 'ansi';
+ }
- if (options.disableGlob || !glob.hasMagic(p))
- return afterGlob(null, [p])
+ if ('ansi16' in suite) {
+ styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+ styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+ }
- options.lstat(p, (er, stat) => {
- if (!er)
- return afterGlob(null, [p])
+ if ('ansi256' in suite) {
+ styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+ styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+ }
- glob(p, options.glob, afterGlob)
- })
+ if ('rgb' in suite) {
+ styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+ styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+ }
+ }
+ return styles;
}
-// Two possible strategies.
-// 1. Assume it's a file. unlink it, then do the dir stuff on EPERM or EISDIR
-// 2. Assume it's a directory. readdir, then do the file stuff on ENOTDIR
-//
-// Both result in an extra syscall when you guess wrong. However, there
-// are likely far more normal files in the world than directories. This
-// is based on the assumption that a the average number of files per
-// directory is >= 1.
-//
-// If anyone ever complains about this, then I guess the strategy could
-// be made configurable somehow. But until then, YAGNI.
-const rimraf_ = (p, options, cb) => {
- assert(p)
- assert(options)
- assert(typeof cb === 'function')
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+ enumerable: true,
+ get: assembleStyles
+});
- // sunos lets the root user unlink directories, which is... weird.
- // so we have to lstat here and make sure it's not a dir.
- options.lstat(p, (er, st) => {
- if (er && er.code === "ENOENT")
- return cb(null)
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(11)(module)))
- // Windows can EPERM on stat. Life is suffering.
- if (er && er.code === "EPERM" && isWindows)
- fixWinEPERM(p, options, er, cb)
+/***/ }),
+/* 673 */
+/***/ (function(module, exports, __webpack_require__) {
- if (st && st.isDirectory())
- return rmdir(p, options, er, cb)
+"use strict";
- options.unlink(p, er => {
- if (er) {
- if (er.code === "ENOENT")
- return cb(null)
- if (er.code === "EPERM")
- return (isWindows)
- ? fixWinEPERM(p, options, er, cb)
- : rmdir(p, options, er, cb)
- if (er.code === "EISDIR")
- return rmdir(p, options, er, cb)
- }
- return cb(er)
- })
- })
-}
+const os = __webpack_require__(364);
+const hasFlag = __webpack_require__(394);
-const fixWinEPERM = (p, options, er, cb) => {
- assert(p)
- assert(options)
- assert(typeof cb === 'function')
- if (er)
- assert(er instanceof Error)
+const env = process.env;
- options.chmod(p, 0o666, er2 => {
- if (er2)
- cb(er2.code === "ENOENT" ? null : er)
- else
- options.stat(p, (er3, stats) => {
- if (er3)
- cb(er3.code === "ENOENT" ? null : er)
- else if (stats.isDirectory())
- rmdir(p, options, er, cb)
- else
- options.unlink(p, cb)
- })
- })
+let forceColor;
+if (hasFlag('no-color') ||
+ hasFlag('no-colors') ||
+ hasFlag('color=false')) {
+ forceColor = false;
+} else if (hasFlag('color') ||
+ hasFlag('colors') ||
+ hasFlag('color=true') ||
+ hasFlag('color=always')) {
+ forceColor = true;
+}
+if ('FORCE_COLOR' in env) {
+ forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
}
-const fixWinEPERMSync = (p, options, er) => {
- assert(p)
- assert(options)
- if (er)
- assert(er instanceof Error)
+function translateLevel(level) {
+ if (level === 0) {
+ return false;
+ }
- try {
- options.chmodSync(p, 0o666)
- } catch (er2) {
- if (er2.code === "ENOENT")
- return
- else
- throw er
- }
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+}
- let stats
- try {
- stats = options.statSync(p)
- } catch (er3) {
- if (er3.code === "ENOENT")
- return
- else
- throw er
- }
+function supportsColor(stream) {
+ if (forceColor === false) {
+ return 0;
+ }
- if (stats.isDirectory())
- rmdirSync(p, options, er)
- else
- options.unlinkSync(p)
-}
+ if (hasFlag('color=16m') ||
+ hasFlag('color=full') ||
+ hasFlag('color=truecolor')) {
+ return 3;
+ }
-const rmdir = (p, options, originalEr, cb) => {
- assert(p)
- assert(options)
- if (originalEr)
- assert(originalEr instanceof Error)
- assert(typeof cb === 'function')
+ if (hasFlag('color=256')) {
+ return 2;
+ }
- // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
- // if we guessed wrong, and it's not a directory, then
- // raise the original error.
- options.rmdir(p, er => {
- if (er && (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM"))
- rmkids(p, options, cb)
- else if (er && er.code === "ENOTDIR")
- cb(originalEr)
- else
- cb(er)
- })
-}
+ if (stream && !stream.isTTY && forceColor !== true) {
+ // VS code debugger doesn't have isTTY set
+ if (env.VSCODE_PID) {
+ return 1;
+ }
+ return 0;
+ }
-const rmkids = (p, options, cb) => {
- assert(p)
- assert(options)
- assert(typeof cb === 'function')
+ const min = forceColor ? 1 : 0;
- options.readdir(p, (er, files) => {
- if (er)
- return cb(er)
- let n = files.length
- if (n === 0)
- return options.rmdir(p, cb)
- let errState
- files.forEach(f => {
- rimraf(path.join(p, f), options, er => {
- if (errState)
- return
- if (er)
- return cb(errState = er)
- if (--n === 0)
- options.rmdir(p, cb)
- })
- })
- })
-}
+ if (process.platform === 'win32') {
+ // Node.js 7.5.0 is the first version of Node.js to include a patch to
+ // libuv that enables 256 color output on Windows. Anything earlier and it
+ // won't work. However, here we target Node.js 8 at minimum as it is an LTS
+ // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+ // release that supports 256 colors. Windows 10 build 14931 is the first release
+ // that supports 16m/TrueColor.
+ const osRelease = os.release().split('.');
+ if (
+ Number(process.versions.node.split('.')[0]) >= 8 &&
+ Number(osRelease[0]) >= 10 &&
+ Number(osRelease[2]) >= 10586
+ ) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
-// this looks simpler, and is strictly *faster*, but will
-// tie up the JavaScript thread and fail on excessively
-// deep directory trees.
-const rimrafSync = (p, options) => {
- options = options || {}
- defaults(options)
+ return 1;
+ }
- assert(p, 'rimraf: missing path')
- assert.equal(typeof p, 'string', 'rimraf: path should be a string')
- assert(options, 'rimraf: missing options')
- assert.equal(typeof options, 'object', 'rimraf: options should be object')
+ if ('CI' in env) {
+ if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+ return 1;
+ }
- let results
+ return min;
+ }
- if (options.disableGlob || !glob.hasMagic(p)) {
- results = [p]
- } else {
- try {
- options.lstatSync(p)
- results = [p]
- } catch (er) {
- results = glob.sync(p, options.glob)
- }
- }
+ if ('TEAMCITY_VERSION' in env) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+ }
- if (!results.length)
- return
+ if (env.COLORTERM === 'truecolor') {
+ return 3;
+ }
- for (let i = 0; i < results.length; i++) {
- const p = results[i]
+ if ('TERM_PROGRAM' in env) {
+ const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
- let st
- try {
- st = options.lstatSync(p)
- } catch (er) {
- if (er.code === "ENOENT")
- return
+ switch (env.TERM_PROGRAM) {
+ case 'iTerm.app':
+ return version >= 3 ? 3 : 2;
+ case 'Apple_Terminal':
+ return 2;
+ // No default
+ }
+ }
- // Windows can EPERM on stat. Life is suffering.
- if (er.code === "EPERM" && isWindows)
- fixWinEPERMSync(p, options, er)
- }
+ if (/-256(color)?$/i.test(env.TERM)) {
+ return 2;
+ }
- try {
- // sunos lets the root user unlink directories, which is... weird.
- if (st && st.isDirectory())
- rmdirSync(p, options, null)
- else
- options.unlinkSync(p)
- } catch (er) {
- if (er.code === "ENOENT")
- return
- if (er.code === "EPERM")
- return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
- if (er.code !== "EISDIR")
- throw er
+ if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+ return 1;
+ }
- rmdirSync(p, options, er)
- }
- }
-}
+ if ('COLORTERM' in env) {
+ return 1;
+ }
-const rmdirSync = (p, options, originalEr) => {
- assert(p)
- assert(options)
- if (originalEr)
- assert(originalEr instanceof Error)
+ if (env.TERM === 'dumb') {
+ return min;
+ }
- try {
- options.rmdirSync(p)
- } catch (er) {
- if (er.code === "ENOENT")
- return
- if (er.code === "ENOTDIR")
- throw originalEr
- if (er.code === "ENOTEMPTY" || er.code === "EEXIST" || er.code === "EPERM")
- rmkidsSync(p, options)
- }
+ return min;
}
-const rmkidsSync = (p, options) => {
- assert(p)
- assert(options)
- options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options))
-
- // We only end up here once we got ENOTEMPTY at least once, and
- // at this point, we are guaranteed to have removed all the kids.
- // So, we know that it won't be ENOENT or ENOTDIR or anything else.
- // try really hard to delete stuff on windows, because it has a
- // PROFOUNDLY annoying habit of not closing handles promptly when
- // files are deleted, resulting in spurious ENOTEMPTY errors.
- const retries = isWindows ? 100 : 1
- let i = 0
- do {
- let threw = true
- try {
- const ret = options.rmdirSync(p, options)
- threw = false
- return ret
- } finally {
- if (++i < retries && threw)
- continue
- }
- } while (true)
+function getSupportLevel(stream) {
+ const level = supportsColor(stream);
+ return translateLevel(level);
}
-module.exports = rimraf
-rimraf.sync = rimrafSync
+module.exports = {
+ supportsColor: getSupportLevel,
+ stdout: getSupportLevel(process.stdout),
+ stderr: getSupportLevel(process.stderr)
+};
/***/ }),
-/* 671 */
+/* 674 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const AggregateError = __webpack_require__(672);
-
-module.exports = async (
- iterable,
- mapper,
- {
- concurrency = Infinity,
- stopOnError = true
- } = {}
-) => {
- return new Promise((resolve, reject) => {
- if (typeof mapper !== 'function') {
- throw new TypeError('Mapper function is required');
- }
-
- if (!(typeof concurrency === 'number' && concurrency >= 1)) {
- throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${concurrency}\` (${typeof concurrency})`);
- }
+const TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
- const ret = [];
- const errors = [];
- const iterator = iterable[Symbol.iterator]();
- let isRejected = false;
- let isIterableDone = false;
- let resolvingCount = 0;
- let currentIndex = 0;
+const ESCAPES = new Map([
+ ['n', '\n'],
+ ['r', '\r'],
+ ['t', '\t'],
+ ['b', '\b'],
+ ['f', '\f'],
+ ['v', '\v'],
+ ['0', '\0'],
+ ['\\', '\\'],
+ ['e', '\u001B'],
+ ['a', '\u0007']
+]);
- const next = () => {
- if (isRejected) {
- return;
- }
+function unescape(c) {
+ if ((c[0] === 'u' && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+ return String.fromCharCode(parseInt(c.slice(1), 16));
+ }
- const nextItem = iterator.next();
- const i = currentIndex;
- currentIndex++;
+ return ESCAPES.get(c) || c;
+}
- if (nextItem.done) {
- isIterableDone = true;
+function parseArguments(name, args) {
+ const results = [];
+ const chunks = args.trim().split(/\s*,\s*/g);
+ let matches;
- if (resolvingCount === 0) {
- if (!stopOnError && errors.length !== 0) {
- reject(new AggregateError(errors));
- } else {
- resolve(ret);
- }
- }
+ for (const chunk of chunks) {
+ if (!isNaN(chunk)) {
+ results.push(Number(chunk));
+ } else if ((matches = chunk.match(STRING_REGEX))) {
+ results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
+ } else {
+ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+ }
+ }
- return;
- }
+ return results;
+}
- resolvingCount++;
+function parseStyle(style) {
+ STYLE_REGEX.lastIndex = 0;
- (async () => {
- try {
- const element = await nextItem.value;
- ret[i] = await mapper(element, i);
- resolvingCount--;
- next();
- } catch (error) {
- if (stopOnError) {
- isRejected = true;
- reject(error);
- } else {
- errors.push(error);
- resolvingCount--;
- next();
- }
- }
- })();
- };
+ const results = [];
+ let matches;
- for (let i = 0; i < concurrency; i++) {
- next();
+ while ((matches = STYLE_REGEX.exec(style)) !== null) {
+ const name = matches[1];
- if (isIterableDone) {
- break;
- }
+ if (matches[2]) {
+ const args = parseArguments(name, matches[2]);
+ results.push([name].concat(args));
+ } else {
+ results.push([name]);
}
- });
-};
-
-
-/***/ }),
-/* 672 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
+ }
-const indentString = __webpack_require__(673);
-const cleanStack = __webpack_require__(674);
+ return results;
+}
-const cleanInternalStack = stack => stack.replace(/\s+at .*aggregate-error\/index.js:\d+:\d+\)?/g, '');
+function buildStyle(chalk, styles) {
+ const enabled = {};
-class AggregateError extends Error {
- constructor(errors) {
- if (!Array.isArray(errors)) {
- throw new TypeError(`Expected input to be an Array, got ${typeof errors}`);
+ for (const layer of styles) {
+ for (const style of layer.styles) {
+ enabled[style[0]] = layer.inverse ? null : style.slice(1);
}
+ }
- errors = [...errors].map(error => {
- if (error instanceof Error) {
- return error;
+ let current = chalk;
+ for (const styleName of Object.keys(enabled)) {
+ if (Array.isArray(enabled[styleName])) {
+ if (!(styleName in current)) {
+ throw new Error(`Unknown Chalk style: ${styleName}`);
}
- if (error !== null && typeof error === 'object') {
- // Handle plain error objects with message property and/or possibly other metadata
- return Object.assign(new Error(error.message), error);
+ if (enabled[styleName].length > 0) {
+ current = current[styleName].apply(current, enabled[styleName]);
+ } else {
+ current = current[styleName];
}
+ }
+ }
- return new Error(error);
- });
-
- let message = errors
- .map(error => {
- // The `stack` property is not standardized, so we can't assume it exists
- return typeof error.stack === 'string' ? cleanInternalStack(cleanStack(error.stack)) : String(error);
- })
- .join('\n');
- message = '\n' + indentString(message, 4);
- super(message);
+ return current;
+}
- this.name = 'AggregateError';
+module.exports = (chalk, tmp) => {
+ const styles = [];
+ const chunks = [];
+ let chunk = [];
- Object.defineProperty(this, '_errors', {value: errors});
- }
+ // eslint-disable-next-line max-params
+ tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
+ if (escapeChar) {
+ chunk.push(unescape(escapeChar));
+ } else if (style) {
+ const str = chunk.join('');
+ chunk = [];
+ chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+ styles.push({inverse, styles: parseStyle(style)});
+ } else if (close) {
+ if (styles.length === 0) {
+ throw new Error('Found extraneous } in Chalk template literal');
+ }
- * [Symbol.iterator]() {
- for (const error of this._errors) {
- yield error;
+ chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+ chunk = [];
+ styles.pop();
+ } else {
+ chunk.push(chr);
}
+ });
+
+ chunks.push(chunk.join(''));
+
+ if (styles.length > 0) {
+ const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+ throw new Error(errMsg);
}
-}
-module.exports = AggregateError;
+ return chunks.join('');
+};
/***/ }),
-/* 673 */
+/* 675 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
+const restoreCursor = __webpack_require__(676);
-module.exports = (string, count = 1, options) => {
- options = {
- indent: ' ',
- includeEmptyLines: false,
- ...options
- };
+let hidden = false;
- if (typeof string !== 'string') {
- throw new TypeError(
- `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
- );
- }
+exports.show = stream => {
+ const s = stream || process.stderr;
- if (typeof count !== 'number') {
- throw new TypeError(
- `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
- );
+ if (!s.isTTY) {
+ return;
}
- if (typeof options.indent !== 'string') {
- throw new TypeError(
- `Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
- );
- }
+ hidden = false;
+ s.write('\u001b[?25h');
+};
- if (count === 0) {
- return string;
+exports.hide = stream => {
+ const s = stream || process.stderr;
+
+ if (!s.isTTY) {
+ return;
}
- const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+ restoreCursor();
+ hidden = true;
+ s.write('\u001b[?25l');
+};
- return string.replace(regex, options.indent.repeat(count));
+exports.toggle = (force, stream) => {
+ if (force !== undefined) {
+ hidden = force;
+ }
+
+ if (hidden) {
+ exports.show(stream);
+ } else {
+ exports.hide(stream);
+ }
};
/***/ }),
-/* 674 */
+/* 676 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const os = __webpack_require__(11);
-
-const extractPathRegex = /\s+at.*(?:\(|\s)(.*)\)?/;
-const pathRegex = /^(?:(?:(?:node|(?:internal\/[\w/]*|.*node_modules\/(?:babel-polyfill|pirates)\/.*)?\w+)\.js:\d+:\d+)|native)/;
-const homeDir = typeof os.homedir === 'undefined' ? '' : os.homedir();
-
-module.exports = (stack, options) => {
- options = Object.assign({pretty: false}, options);
-
- return stack.replace(/\\/g, '/')
- .split('\n')
- .filter(line => {
- const pathMatches = line.match(extractPathRegex);
- if (pathMatches === null || !pathMatches[1]) {
- return true;
- }
-
- const match = pathMatches[1];
-
- // Electron
- if (
- match.includes('.app/Contents/Resources/electron.asar') ||
- match.includes('.app/Contents/Resources/default_app.asar')
- ) {
- return false;
- }
-
- return !pathRegex.test(match);
- })
- .filter(line => line.trim() !== '')
- .map(line => {
- if (options.pretty) {
- return line.replace(extractPathRegex, (m, p1) => m.replace(p1, p1.replace(homeDir, '~')));
- }
+const onetime = __webpack_require__(677);
+const signalExit = __webpack_require__(370);
- return line;
- })
- .join('\n');
-};
+module.exports = onetime(() => {
+ signalExit(() => {
+ process.stderr.write('\u001b[?25h');
+ }, {alwaysLast: true});
+});
/***/ }),
-/* 675 */
+/* 677 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const chalk = __webpack_require__(676);
-const cliCursor = __webpack_require__(680);
-const cliSpinners = __webpack_require__(684);
-const logSymbols = __webpack_require__(565);
+const mimicFn = __webpack_require__(678);
-class Ora {
- constructor(options) {
- if (typeof options === 'string') {
- options = {
- text: options
- };
- }
+module.exports = (fn, opts) => {
+ // TODO: Remove this in v3
+ if (opts === true) {
+ throw new TypeError('The second argument is now an options object');
+ }
- this.options = Object.assign({
- text: '',
- color: 'cyan',
- stream: process.stderr
- }, options);
+ if (typeof fn !== 'function') {
+ throw new TypeError('Expected a function');
+ }
- const sp = this.options.spinner;
- this.spinner = typeof sp === 'object' ? sp : (process.platform === 'win32' ? cliSpinners.line : (cliSpinners[sp] || cliSpinners.dots)); // eslint-disable-line no-nested-ternary
+ opts = opts || {};
- if (this.spinner.frames === undefined) {
- throw new Error('Spinner must define `frames`');
- }
+ let ret;
+ let called = false;
+ const fnName = fn.displayName || fn.name || '';
- this.text = this.options.text;
- this.color = this.options.color;
- this.interval = this.options.interval || this.spinner.interval || 100;
- this.stream = this.options.stream;
- this.id = null;
- this.frameIndex = 0;
- this.enabled = typeof this.options.enabled === 'boolean' ? this.options.enabled : ((this.stream && this.stream.isTTY) && !process.env.CI);
- }
- frame() {
- const frames = this.spinner.frames;
- let frame = frames[this.frameIndex];
+ const onetime = function () {
+ if (called) {
+ if (opts.throw === true) {
+ throw new Error(`Function \`${fnName}\` can only be called once`);
+ }
- if (this.color) {
- frame = chalk[this.color](frame);
+ return ret;
}
- this.frameIndex = ++this.frameIndex % frames.length;
+ called = true;
+ ret = fn.apply(this, arguments);
+ fn = null;
- return frame + ' ' + this.text;
- }
- clear() {
- if (!this.enabled) {
- return this;
- }
+ return ret;
+ };
- this.stream.clearLine();
- this.stream.cursorTo(0);
+ mimicFn(onetime, fn);
- return this;
- }
- render() {
- this.clear();
- this.stream.write(this.frame());
+ return onetime;
+};
- return this;
- }
- start(text) {
- if (text) {
- this.text = text;
- }
- if (!this.enabled || this.id) {
- return this;
- }
+/***/ }),
+/* 678 */
+/***/ (function(module, exports, __webpack_require__) {
- cliCursor.hide(this.stream);
- this.render();
- this.id = setInterval(this.render.bind(this), this.interval);
+"use strict";
- return this;
+module.exports = (to, from) => {
+ // TODO: use `Reflect.ownKeys()` when targeting Node.js 6
+ for (const prop of Object.getOwnPropertyNames(from).concat(Object.getOwnPropertySymbols(from))) {
+ Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
}
- stop() {
- if (!this.enabled) {
- return this;
- }
- clearInterval(this.id);
- this.id = null;
- this.frameIndex = 0;
- this.clear();
- cliCursor.show(this.stream);
+ return to;
+};
- return this;
- }
- succeed(text) {
- return this.stopAndPersist({symbol: logSymbols.success, text});
- }
- fail(text) {
- return this.stopAndPersist({symbol: logSymbols.error, text});
- }
- warn(text) {
- return this.stopAndPersist({symbol: logSymbols.warning, text});
- }
- info(text) {
- return this.stopAndPersist({symbol: logSymbols.info, text});
- }
- stopAndPersist(options) {
- if (!this.enabled) {
- return this;
- }
- // Legacy argument
- // TODO: Deprecate sometime in the future
- if (typeof options === 'string') {
- options = {
- symbol: options
- };
- }
+/***/ }),
+/* 679 */
+/***/ (function(module, exports, __webpack_require__) {
- options = options || {};
+"use strict";
- this.stop();
- this.stream.write(`${options.symbol || ' '} ${options.text || this.text}\n`);
+module.exports = __webpack_require__(680);
- return this;
- }
-}
-module.exports = function (opts) {
- return new Ora(opts);
-};
+/***/ }),
+/* 680 */
+/***/ (function(module) {
-module.exports.promise = (action, options) => {
- if (typeof action.then !== 'function') {
- throw new TypeError('Parameter `action` must be a Promise');
- }
+module.exports = JSON.parse("{\"dots\":{\"interval\":80,\"frames\":[\"⠋\",\"⠙\",\"⠹\",\"⠸\",\"⠼\",\"⠴\",\"⠦\",\"⠧\",\"⠇\",\"⠏\"]},\"dots2\":{\"interval\":80,\"frames\":[\"⣾\",\"⣽\",\"⣻\",\"⢿\",\"⡿\",\"⣟\",\"⣯\",\"⣷\"]},\"dots3\":{\"interval\":80,\"frames\":[\"⠋\",\"⠙\",\"⠚\",\"⠞\",\"⠖\",\"⠦\",\"⠴\",\"⠲\",\"⠳\",\"⠓\"]},\"dots4\":{\"interval\":80,\"frames\":[\"⠄\",\"⠆\",\"⠇\",\"⠋\",\"⠙\",\"⠸\",\"⠰\",\"⠠\",\"⠰\",\"⠸\",\"⠙\",\"⠋\",\"⠇\",\"⠆\"]},\"dots5\":{\"interval\":80,\"frames\":[\"⠋\",\"⠙\",\"⠚\",\"⠒\",\"⠂\",\"⠂\",\"⠒\",\"⠲\",\"⠴\",\"⠦\",\"⠖\",\"⠒\",\"⠐\",\"⠐\",\"⠒\",\"⠓\",\"⠋\"]},\"dots6\":{\"interval\":80,\"frames\":[\"⠁\",\"⠉\",\"⠙\",\"⠚\",\"⠒\",\"⠂\",\"⠂\",\"⠒\",\"⠲\",\"⠴\",\"⠤\",\"⠄\",\"⠄\",\"⠤\",\"⠴\",\"⠲\",\"⠒\",\"⠂\",\"⠂\",\"⠒\",\"⠚\",\"⠙\",\"⠉\",\"⠁\"]},\"dots7\":{\"interval\":80,\"frames\":[\"⠈\",\"⠉\",\"⠋\",\"⠓\",\"⠒\",\"⠐\",\"⠐\",\"⠒\",\"⠖\",\"⠦\",\"⠤\",\"⠠\",\"⠠\",\"⠤\",\"⠦\",\"⠖\",\"⠒\",\"⠐\",\"⠐\",\"⠒\",\"⠓\",\"⠋\",\"⠉\",\"⠈\"]},\"dots8\":{\"interval\":80,\"frames\":[\"⠁\",\"⠁\",\"⠉\",\"⠙\",\"⠚\",\"⠒\",\"⠂\",\"⠂\",\"⠒\",\"⠲\",\"⠴\",\"⠤\",\"⠄\",\"⠄\",\"⠤\",\"⠠\",\"⠠\",\"⠤\",\"⠦\",\"⠖\",\"⠒\",\"⠐\",\"⠐\",\"⠒\",\"⠓\",\"⠋\",\"⠉\",\"⠈\",\"⠈\"]},\"dots9\":{\"interval\":80,\"frames\":[\"⢹\",\"⢺\",\"⢼\",\"⣸\",\"⣇\",\"⡧\",\"⡗\",\"⡏\"]},\"dots10\":{\"interval\":80,\"frames\":[\"⢄\",\"⢂\",\"⢁\",\"⡁\",\"⡈\",\"⡐\",\"⡠\"]},\"dots11\":{\"interval\":100,\"frames\":[\"⠁\",\"⠂\",\"⠄\",\"⡀\",\"⢀\",\"⠠\",\"⠐\",\"⠈\"]},\"dots12\":{\"interval\":80,\"frames\":[\"⢀⠀\",\"⡀⠀\",\"⠄⠀\",\"⢂⠀\",\"⡂⠀\",\"⠅⠀\",\"⢃⠀\",\"⡃⠀\",\"⠍⠀\",\"⢋⠀\",\"⡋⠀\",\"⠍⠁\",\"⢋⠁\",\"⡋⠁\",\"⠍⠉\",\"⠋⠉\",\"⠋⠉\",\"⠉⠙\",\"⠉⠙\",\"⠉⠩\",\"⠈⢙\",\"⠈⡙\",\"⢈⠩\",\"⡀⢙\",\"⠄⡙\",\"⢂⠩\",\"⡂⢘\",\"⠅⡘\",\"⢃⠨\",\"⡃⢐\",\"⠍⡐\",\"⢋⠠\",\"⡋⢀\",\"⠍⡁\",\"⢋⠁\",\"⡋⠁\",\"⠍⠉\",\"⠋⠉\",\"⠋⠉\",\"⠉⠙\",\"⠉⠙\",\"⠉⠩\",\"⠈⢙\",\"⠈⡙\",\"⠈⠩\",\"⠀⢙\",\"⠀⡙\",\"⠀⠩\",\"⠀⢘\",\"⠀⡘\",\"⠀⠨\",\"⠀⢐\",\"⠀⡐\",\"⠀⠠\",\"⠀⢀\",\"⠀⡀\"]},\"line\":{\"interval\":130,\"frames\":[\"-\",\"\\\\\",\"|\",\"/\"]},\"line2\":{\"interval\":100,\"frames\":[\"⠂\",\"-\",\"–\",\"—\",\"–\",\"-\"]},\"pipe\":{\"interval\":100,\"frames\":[\"┤\",\"┘\",\"┴\",\"└\",\"├\",\"┌\",\"┬\",\"┐\"]},\"simpleDots\":{\"interval\":400,\"frames\":[\". \",\".. \",\"...\",\" \"]},\"simpleDotsScrolling\":{\"interval\":200,\"frames\":[\". \",\".. \",\"...\",\" ..\",\" .\",\" \"]},\"star\":{\"interval\":70,\"frames\":[\"✶\",\"✸\",\"✹\",\"✺\",\"✹\",\"✷\"]},\"star2\":{\"interval\":80,\"frames\":[\"+\",\"x\",\"*\"]},\"flip\":{\"interval\":70,\"frames\":[\"_\",\"_\",\"_\",\"-\",\"`\",\"`\",\"'\",\"´\",\"-\",\"_\",\"_\",\"_\"]},\"hamburger\":{\"interval\":100,\"frames\":[\"☱\",\"☲\",\"☴\"]},\"growVertical\":{\"interval\":120,\"frames\":[\"▁\",\"▃\",\"▄\",\"▅\",\"▆\",\"▇\",\"▆\",\"▅\",\"▄\",\"▃\"]},\"growHorizontal\":{\"interval\":120,\"frames\":[\"▏\",\"▎\",\"▍\",\"▌\",\"▋\",\"▊\",\"▉\",\"▊\",\"▋\",\"▌\",\"▍\",\"▎\"]},\"balloon\":{\"interval\":140,\"frames\":[\" \",\".\",\"o\",\"O\",\"@\",\"*\",\" \"]},\"balloon2\":{\"interval\":120,\"frames\":[\".\",\"o\",\"O\",\"°\",\"O\",\"o\",\".\"]},\"noise\":{\"interval\":100,\"frames\":[\"▓\",\"▒\",\"░\"]},\"bounce\":{\"interval\":120,\"frames\":[\"⠁\",\"⠂\",\"⠄\",\"⠂\"]},\"boxBounce\":{\"interval\":120,\"frames\":[\"▖\",\"▘\",\"▝\",\"▗\"]},\"boxBounce2\":{\"interval\":100,\"frames\":[\"▌\",\"▀\",\"▐\",\"▄\"]},\"triangle\":{\"interval\":50,\"frames\":[\"◢\",\"◣\",\"◤\",\"◥\"]},\"arc\":{\"interval\":100,\"frames\":[\"◜\",\"◠\",\"◝\",\"◞\",\"◡\",\"◟\"]},\"circle\":{\"interval\":120,\"frames\":[\"◡\",\"⊙\",\"◠\"]},\"squareCorners\":{\"interval\":180,\"frames\":[\"◰\",\"◳\",\"◲\",\"◱\"]},\"circleQuarters\":{\"interval\":120,\"frames\":[\"◴\",\"◷\",\"◶\",\"◵\"]},\"circleHalves\":{\"interval\":50,\"frames\":[\"◐\",\"◓\",\"◑\",\"◒\"]},\"squish\":{\"interval\":100,\"frames\":[\"╫\",\"╪\"]},\"toggle\":{\"interval\":250,\"frames\":[\"⊶\",\"⊷\"]},\"toggle2\":{\"interval\":80,\"frames\":[\"▫\",\"▪\"]},\"toggle3\":{\"interval\":120,\"frames\":[\"□\",\"■\"]},\"toggle4\":{\"interval\":100,\"frames\":[\"■\",\"□\",\"▪\",\"▫\"]},\"toggle5\":{\"interval\":100,\"frames\":[\"▮\",\"▯\"]},\"toggle6\":{\"interval\":300,\"frames\":[\"ဝ\",\"၀\"]},\"toggle7\":{\"interval\":80,\"frames\":[\"⦾\",\"⦿\"]},\"toggle8\":{\"interval\":100,\"frames\":[\"◍\",\"◌\"]},\"toggle9\":{\"interval\":100,\"frames\":[\"◉\",\"◎\"]},\"toggle10\":{\"interval\":100,\"frames\":[\"㊂\",\"㊀\",\"㊁\"]},\"toggle11\":{\"interval\":50,\"frames\":[\"⧇\",\"⧆\"]},\"toggle12\":{\"interval\":120,\"frames\":[\"☗\",\"☖\"]},\"toggle13\":{\"interval\":80,\"frames\":[\"=\",\"*\",\"-\"]},\"arrow\":{\"interval\":100,\"frames\":[\"←\",\"↖\",\"↑\",\"↗\",\"→\",\"↘\",\"↓\",\"↙\"]},\"arrow2\":{\"interval\":80,\"frames\":[\"⬆️ \",\"↗️ \",\"➡️ \",\"↘️ \",\"⬇️ \",\"↙️ \",\"⬅️ \",\"↖️ \"]},\"arrow3\":{\"interval\":120,\"frames\":[\"▹▹▹▹▹\",\"▸▹▹▹▹\",\"▹▸▹▹▹\",\"▹▹▸▹▹\",\"▹▹▹▸▹\",\"▹▹▹▹▸\"]},\"bouncingBar\":{\"interval\":80,\"frames\":[\"[ ]\",\"[= ]\",\"[== ]\",\"[=== ]\",\"[ ===]\",\"[ ==]\",\"[ =]\",\"[ ]\",\"[ =]\",\"[ ==]\",\"[ ===]\",\"[====]\",\"[=== ]\",\"[== ]\",\"[= ]\"]},\"bouncingBall\":{\"interval\":80,\"frames\":[\"( ● )\",\"( ● )\",\"( ● )\",\"( ● )\",\"( ●)\",\"( ● )\",\"( ● )\",\"( ● )\",\"( ● )\",\"(● )\"]},\"smiley\":{\"interval\":200,\"frames\":[\"😄 \",\"😝 \"]},\"monkey\":{\"interval\":300,\"frames\":[\"🙈 \",\"🙈 \",\"🙉 \",\"🙊 \"]},\"hearts\":{\"interval\":100,\"frames\":[\"💛 \",\"💙 \",\"💜 \",\"💚 \",\"❤️ \"]},\"clock\":{\"interval\":100,\"frames\":[\"🕐 \",\"🕑 \",\"🕒 \",\"🕓 \",\"🕔 \",\"🕕 \",\"🕖 \",\"🕗 \",\"🕘 \",\"🕙 \",\"🕚 \"]},\"earth\":{\"interval\":180,\"frames\":[\"🌍 \",\"🌎 \",\"🌏 \"]},\"moon\":{\"interval\":80,\"frames\":[\"🌑 \",\"🌒 \",\"🌓 \",\"🌔 \",\"🌕 \",\"🌖 \",\"🌗 \",\"🌘 \"]},\"runner\":{\"interval\":140,\"frames\":[\"🚶 \",\"🏃 \"]},\"pong\":{\"interval\":80,\"frames\":[\"▐⠂ ▌\",\"▐⠈ ▌\",\"▐ ⠂ ▌\",\"▐ ⠠ ▌\",\"▐ ⡀ ▌\",\"▐ ⠠ ▌\",\"▐ ⠂ ▌\",\"▐ ⠈ ▌\",\"▐ ⠂ ▌\",\"▐ ⠠ ▌\",\"▐ ⡀ ▌\",\"▐ ⠠ ▌\",\"▐ ⠂ ▌\",\"▐ ⠈ ▌\",\"▐ ⠂▌\",\"▐ ⠠▌\",\"▐ ⡀▌\",\"▐ ⠠ ▌\",\"▐ ⠂ ▌\",\"▐ ⠈ ▌\",\"▐ ⠂ ▌\",\"▐ ⠠ ▌\",\"▐ ⡀ ▌\",\"▐ ⠠ ▌\",\"▐ ⠂ ▌\",\"▐ ⠈ ▌\",\"▐ ⠂ ▌\",\"▐ ⠠ ▌\",\"▐ ⡀ ▌\",\"▐⠠ ▌\"]},\"shark\":{\"interval\":120,\"frames\":[\"▐|\\\\____________▌\",\"▐_|\\\\___________▌\",\"▐__|\\\\__________▌\",\"▐___|\\\\_________▌\",\"▐____|\\\\________▌\",\"▐_____|\\\\_______▌\",\"▐______|\\\\______▌\",\"▐_______|\\\\_____▌\",\"▐________|\\\\____▌\",\"▐_________|\\\\___▌\",\"▐__________|\\\\__▌\",\"▐___________|\\\\_▌\",\"▐____________|\\\\▌\",\"▐____________/|▌\",\"▐___________/|_▌\",\"▐__________/|__▌\",\"▐_________/|___▌\",\"▐________/|____▌\",\"▐_______/|_____▌\",\"▐______/|______▌\",\"▐_____/|_______▌\",\"▐____/|________▌\",\"▐___/|_________▌\",\"▐__/|__________▌\",\"▐_/|___________▌\",\"▐/|____________▌\"]},\"dqpb\":{\"interval\":100,\"frames\":[\"d\",\"q\",\"p\",\"b\"]},\"weather\":{\"interval\":100,\"frames\":[\"☀️ \",\"☀️ \",\"☀️ \",\"🌤 \",\"⛅️ \",\"🌥 \",\"☁️ \",\"🌧 \",\"🌨 \",\"🌧 \",\"🌨 \",\"🌧 \",\"🌨 \",\"⛈ \",\"🌨 \",\"🌧 \",\"🌨 \",\"☁️ \",\"🌥 \",\"⛅️ \",\"🌤 \",\"☀️ \",\"☀️ \"]},\"christmas\":{\"interval\":400,\"frames\":[\"🌲\",\"🎄\"]}}");
- const spinner = new Ora(options);
- spinner.start();
+/***/ }),
+/* 681 */
+/***/ (function(module, exports, __webpack_require__) {
- action.then(
- () => {
- spinner.succeed();
- },
- () => {
- spinner.fail();
- }
- );
+"use strict";
- return spinner;
+const chalk = __webpack_require__(682);
+
+const isSupported = process.platform !== 'win32' || process.env.CI || process.env.TERM === 'xterm-256color';
+
+const main = {
+ info: chalk.blue('ℹ'),
+ success: chalk.green('✔'),
+ warning: chalk.yellow('⚠'),
+ error: chalk.red('✖')
+};
+
+const fallbacks = {
+ info: chalk.blue('i'),
+ success: chalk.green('√'),
+ warning: chalk.yellow('‼'),
+ error: chalk.red('×')
};
+module.exports = isSupported ? main : fallbacks;
+
/***/ }),
-/* 676 */
+/* 682 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const escapeStringRegexp = __webpack_require__(3);
-const ansiStyles = __webpack_require__(677);
-const stdoutColor = __webpack_require__(678).stdout;
+const escapeStringRegexp = __webpack_require__(387);
+const ansiStyles = __webpack_require__(683);
+const stdoutColor = __webpack_require__(684).stdout;
-const template = __webpack_require__(679);
+const template = __webpack_require__(685);
const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
@@ -77658,12 +77850,12 @@ module.exports.default = module.exports; // For TypeScript
/***/ }),
-/* 677 */
+/* 683 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(module) {
-const colorConvert = __webpack_require__(6);
+const colorConvert = __webpack_require__(389);
const wrapAnsi16 = (fn, offset) => function () {
const code = fn.apply(colorConvert, arguments);
@@ -77828,16 +78020,16 @@ Object.defineProperty(module, 'exports', {
get: assembleStyles
});
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(5)(module)))
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(11)(module)))
/***/ }),
-/* 678 */
+/* 684 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const os = __webpack_require__(11);
-const hasFlag = __webpack_require__(12);
+const os = __webpack_require__(364);
+const hasFlag = __webpack_require__(394);
const env = process.env;
@@ -77973,7 +78165,7 @@ module.exports = {
/***/ }),
-/* 679 */
+/* 685 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -78107,145 +78299,6 @@ module.exports = (chalk, tmp) => {
};
-/***/ }),
-/* 680 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-const restoreCursor = __webpack_require__(681);
-
-let hidden = false;
-
-exports.show = stream => {
- const s = stream || process.stderr;
-
- if (!s.isTTY) {
- return;
- }
-
- hidden = false;
- s.write('\u001b[?25h');
-};
-
-exports.hide = stream => {
- const s = stream || process.stderr;
-
- if (!s.isTTY) {
- return;
- }
-
- restoreCursor();
- hidden = true;
- s.write('\u001b[?25l');
-};
-
-exports.toggle = (force, stream) => {
- if (force !== undefined) {
- hidden = force;
- }
-
- if (hidden) {
- exports.show(stream);
- } else {
- exports.hide(stream);
- }
-};
-
-
-/***/ }),
-/* 681 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-const onetime = __webpack_require__(682);
-const signalExit = __webpack_require__(397);
-
-module.exports = onetime(() => {
- signalExit(() => {
- process.stderr.write('\u001b[?25h');
- }, {alwaysLast: true});
-});
-
-
-/***/ }),
-/* 682 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-const mimicFn = __webpack_require__(683);
-
-module.exports = (fn, opts) => {
- // TODO: Remove this in v3
- if (opts === true) {
- throw new TypeError('The second argument is now an options object');
- }
-
- if (typeof fn !== 'function') {
- throw new TypeError('Expected a function');
- }
-
- opts = opts || {};
-
- let ret;
- let called = false;
- const fnName = fn.displayName || fn.name || '';
-
- const onetime = function () {
- if (called) {
- if (opts.throw === true) {
- throw new Error(`Function \`${fnName}\` can only be called once`);
- }
-
- return ret;
- }
-
- called = true;
- ret = fn.apply(this, arguments);
- fn = null;
-
- return ret;
- };
-
- mimicFn(onetime, fn);
-
- return onetime;
-};
-
-
-/***/ }),
-/* 683 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-module.exports = (to, from) => {
- // TODO: use `Reflect.ownKeys()` when targeting Node.js 6
- for (const prop of Object.getOwnPropertyNames(from).concat(Object.getOwnPropertySymbols(from))) {
- Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
- }
-
- return to;
-};
-
-
-/***/ }),
-/* 684 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-module.exports = __webpack_require__(685);
-
-
-/***/ }),
-/* 685 */
-/***/ (function(module) {
-
-module.exports = JSON.parse("{\"dots\":{\"interval\":80,\"frames\":[\"⠋\",\"⠙\",\"⠹\",\"⠸\",\"⠼\",\"⠴\",\"⠦\",\"⠧\",\"⠇\",\"⠏\"]},\"dots2\":{\"interval\":80,\"frames\":[\"⣾\",\"⣽\",\"⣻\",\"⢿\",\"⡿\",\"⣟\",\"⣯\",\"⣷\"]},\"dots3\":{\"interval\":80,\"frames\":[\"⠋\",\"⠙\",\"⠚\",\"⠞\",\"⠖\",\"⠦\",\"⠴\",\"⠲\",\"⠳\",\"⠓\"]},\"dots4\":{\"interval\":80,\"frames\":[\"⠄\",\"⠆\",\"⠇\",\"⠋\",\"⠙\",\"⠸\",\"⠰\",\"⠠\",\"⠰\",\"⠸\",\"⠙\",\"⠋\",\"⠇\",\"⠆\"]},\"dots5\":{\"interval\":80,\"frames\":[\"⠋\",\"⠙\",\"⠚\",\"⠒\",\"⠂\",\"⠂\",\"⠒\",\"⠲\",\"⠴\",\"⠦\",\"⠖\",\"⠒\",\"⠐\",\"⠐\",\"⠒\",\"⠓\",\"⠋\"]},\"dots6\":{\"interval\":80,\"frames\":[\"⠁\",\"⠉\",\"⠙\",\"⠚\",\"⠒\",\"⠂\",\"⠂\",\"⠒\",\"⠲\",\"⠴\",\"⠤\",\"⠄\",\"⠄\",\"⠤\",\"⠴\",\"⠲\",\"⠒\",\"⠂\",\"⠂\",\"⠒\",\"⠚\",\"⠙\",\"⠉\",\"⠁\"]},\"dots7\":{\"interval\":80,\"frames\":[\"⠈\",\"⠉\",\"⠋\",\"⠓\",\"⠒\",\"⠐\",\"⠐\",\"⠒\",\"⠖\",\"⠦\",\"⠤\",\"⠠\",\"⠠\",\"⠤\",\"⠦\",\"⠖\",\"⠒\",\"⠐\",\"⠐\",\"⠒\",\"⠓\",\"⠋\",\"⠉\",\"⠈\"]},\"dots8\":{\"interval\":80,\"frames\":[\"⠁\",\"⠁\",\"⠉\",\"⠙\",\"⠚\",\"⠒\",\"⠂\",\"⠂\",\"⠒\",\"⠲\",\"⠴\",\"⠤\",\"⠄\",\"⠄\",\"⠤\",\"⠠\",\"⠠\",\"⠤\",\"⠦\",\"⠖\",\"⠒\",\"⠐\",\"⠐\",\"⠒\",\"⠓\",\"⠋\",\"⠉\",\"⠈\",\"⠈\"]},\"dots9\":{\"interval\":80,\"frames\":[\"⢹\",\"⢺\",\"⢼\",\"⣸\",\"⣇\",\"⡧\",\"⡗\",\"⡏\"]},\"dots10\":{\"interval\":80,\"frames\":[\"⢄\",\"⢂\",\"⢁\",\"⡁\",\"⡈\",\"⡐\",\"⡠\"]},\"dots11\":{\"interval\":100,\"frames\":[\"⠁\",\"⠂\",\"⠄\",\"⡀\",\"⢀\",\"⠠\",\"⠐\",\"⠈\"]},\"dots12\":{\"interval\":80,\"frames\":[\"⢀⠀\",\"⡀⠀\",\"⠄⠀\",\"⢂⠀\",\"⡂⠀\",\"⠅⠀\",\"⢃⠀\",\"⡃⠀\",\"⠍⠀\",\"⢋⠀\",\"⡋⠀\",\"⠍⠁\",\"⢋⠁\",\"⡋⠁\",\"⠍⠉\",\"⠋⠉\",\"⠋⠉\",\"⠉⠙\",\"⠉⠙\",\"⠉⠩\",\"⠈⢙\",\"⠈⡙\",\"⢈⠩\",\"⡀⢙\",\"⠄⡙\",\"⢂⠩\",\"⡂⢘\",\"⠅⡘\",\"⢃⠨\",\"⡃⢐\",\"⠍⡐\",\"⢋⠠\",\"⡋⢀\",\"⠍⡁\",\"⢋⠁\",\"⡋⠁\",\"⠍⠉\",\"⠋⠉\",\"⠋⠉\",\"⠉⠙\",\"⠉⠙\",\"⠉⠩\",\"⠈⢙\",\"⠈⡙\",\"⠈⠩\",\"⠀⢙\",\"⠀⡙\",\"⠀⠩\",\"⠀⢘\",\"⠀⡘\",\"⠀⠨\",\"⠀⢐\",\"⠀⡐\",\"⠀⠠\",\"⠀⢀\",\"⠀⡀\"]},\"line\":{\"interval\":130,\"frames\":[\"-\",\"\\\\\",\"|\",\"/\"]},\"line2\":{\"interval\":100,\"frames\":[\"⠂\",\"-\",\"–\",\"—\",\"–\",\"-\"]},\"pipe\":{\"interval\":100,\"frames\":[\"┤\",\"┘\",\"┴\",\"└\",\"├\",\"┌\",\"┬\",\"┐\"]},\"simpleDots\":{\"interval\":400,\"frames\":[\". \",\".. \",\"...\",\" \"]},\"simpleDotsScrolling\":{\"interval\":200,\"frames\":[\". \",\".. \",\"...\",\" ..\",\" .\",\" \"]},\"star\":{\"interval\":70,\"frames\":[\"✶\",\"✸\",\"✹\",\"✺\",\"✹\",\"✷\"]},\"star2\":{\"interval\":80,\"frames\":[\"+\",\"x\",\"*\"]},\"flip\":{\"interval\":70,\"frames\":[\"_\",\"_\",\"_\",\"-\",\"`\",\"`\",\"'\",\"´\",\"-\",\"_\",\"_\",\"_\"]},\"hamburger\":{\"interval\":100,\"frames\":[\"☱\",\"☲\",\"☴\"]},\"growVertical\":{\"interval\":120,\"frames\":[\"▁\",\"▃\",\"▄\",\"▅\",\"▆\",\"▇\",\"▆\",\"▅\",\"▄\",\"▃\"]},\"growHorizontal\":{\"interval\":120,\"frames\":[\"▏\",\"▎\",\"▍\",\"▌\",\"▋\",\"▊\",\"▉\",\"▊\",\"▋\",\"▌\",\"▍\",\"▎\"]},\"balloon\":{\"interval\":140,\"frames\":[\" \",\".\",\"o\",\"O\",\"@\",\"*\",\" \"]},\"balloon2\":{\"interval\":120,\"frames\":[\".\",\"o\",\"O\",\"°\",\"O\",\"o\",\".\"]},\"noise\":{\"interval\":100,\"frames\":[\"▓\",\"▒\",\"░\"]},\"bounce\":{\"interval\":120,\"frames\":[\"⠁\",\"⠂\",\"⠄\",\"⠂\"]},\"boxBounce\":{\"interval\":120,\"frames\":[\"▖\",\"▘\",\"▝\",\"▗\"]},\"boxBounce2\":{\"interval\":100,\"frames\":[\"▌\",\"▀\",\"▐\",\"▄\"]},\"triangle\":{\"interval\":50,\"frames\":[\"◢\",\"◣\",\"◤\",\"◥\"]},\"arc\":{\"interval\":100,\"frames\":[\"◜\",\"◠\",\"◝\",\"◞\",\"◡\",\"◟\"]},\"circle\":{\"interval\":120,\"frames\":[\"◡\",\"⊙\",\"◠\"]},\"squareCorners\":{\"interval\":180,\"frames\":[\"◰\",\"◳\",\"◲\",\"◱\"]},\"circleQuarters\":{\"interval\":120,\"frames\":[\"◴\",\"◷\",\"◶\",\"◵\"]},\"circleHalves\":{\"interval\":50,\"frames\":[\"◐\",\"◓\",\"◑\",\"◒\"]},\"squish\":{\"interval\":100,\"frames\":[\"╫\",\"╪\"]},\"toggle\":{\"interval\":250,\"frames\":[\"⊶\",\"⊷\"]},\"toggle2\":{\"interval\":80,\"frames\":[\"▫\",\"▪\"]},\"toggle3\":{\"interval\":120,\"frames\":[\"□\",\"■\"]},\"toggle4\":{\"interval\":100,\"frames\":[\"■\",\"□\",\"▪\",\"▫\"]},\"toggle5\":{\"interval\":100,\"frames\":[\"▮\",\"▯\"]},\"toggle6\":{\"interval\":300,\"frames\":[\"ဝ\",\"၀\"]},\"toggle7\":{\"interval\":80,\"frames\":[\"⦾\",\"⦿\"]},\"toggle8\":{\"interval\":100,\"frames\":[\"◍\",\"◌\"]},\"toggle9\":{\"interval\":100,\"frames\":[\"◉\",\"◎\"]},\"toggle10\":{\"interval\":100,\"frames\":[\"㊂\",\"㊀\",\"㊁\"]},\"toggle11\":{\"interval\":50,\"frames\":[\"⧇\",\"⧆\"]},\"toggle12\":{\"interval\":120,\"frames\":[\"☗\",\"☖\"]},\"toggle13\":{\"interval\":80,\"frames\":[\"=\",\"*\",\"-\"]},\"arrow\":{\"interval\":100,\"frames\":[\"←\",\"↖\",\"↑\",\"↗\",\"→\",\"↘\",\"↓\",\"↙\"]},\"arrow2\":{\"interval\":80,\"frames\":[\"⬆️ \",\"↗️ \",\"➡️ \",\"↘️ \",\"⬇️ \",\"↙️ \",\"⬅️ \",\"↖️ \"]},\"arrow3\":{\"interval\":120,\"frames\":[\"▹▹▹▹▹\",\"▸▹▹▹▹\",\"▹▸▹▹▹\",\"▹▹▸▹▹\",\"▹▹▹▸▹\",\"▹▹▹▹▸\"]},\"bouncingBar\":{\"interval\":80,\"frames\":[\"[ ]\",\"[= ]\",\"[== ]\",\"[=== ]\",\"[ ===]\",\"[ ==]\",\"[ =]\",\"[ ]\",\"[ =]\",\"[ ==]\",\"[ ===]\",\"[====]\",\"[=== ]\",\"[== ]\",\"[= ]\"]},\"bouncingBall\":{\"interval\":80,\"frames\":[\"( ● )\",\"( ● )\",\"( ● )\",\"( ● )\",\"( ●)\",\"( ● )\",\"( ● )\",\"( ● )\",\"( ● )\",\"(● )\"]},\"smiley\":{\"interval\":200,\"frames\":[\"😄 \",\"😝 \"]},\"monkey\":{\"interval\":300,\"frames\":[\"🙈 \",\"🙈 \",\"🙉 \",\"🙊 \"]},\"hearts\":{\"interval\":100,\"frames\":[\"💛 \",\"💙 \",\"💜 \",\"💚 \",\"❤️ \"]},\"clock\":{\"interval\":100,\"frames\":[\"🕐 \",\"🕑 \",\"🕒 \",\"🕓 \",\"🕔 \",\"🕕 \",\"🕖 \",\"🕗 \",\"🕘 \",\"🕙 \",\"🕚 \"]},\"earth\":{\"interval\":180,\"frames\":[\"🌍 \",\"🌎 \",\"🌏 \"]},\"moon\":{\"interval\":80,\"frames\":[\"🌑 \",\"🌒 \",\"🌓 \",\"🌔 \",\"🌕 \",\"🌖 \",\"🌗 \",\"🌘 \"]},\"runner\":{\"interval\":140,\"frames\":[\"🚶 \",\"🏃 \"]},\"pong\":{\"interval\":80,\"frames\":[\"▐⠂ ▌\",\"▐⠈ ▌\",\"▐ ⠂ ▌\",\"▐ ⠠ ▌\",\"▐ ⡀ ▌\",\"▐ ⠠ ▌\",\"▐ ⠂ ▌\",\"▐ ⠈ ▌\",\"▐ ⠂ ▌\",\"▐ ⠠ ▌\",\"▐ ⡀ ▌\",\"▐ ⠠ ▌\",\"▐ ⠂ ▌\",\"▐ ⠈ ▌\",\"▐ ⠂▌\",\"▐ ⠠▌\",\"▐ ⡀▌\",\"▐ ⠠ ▌\",\"▐ ⠂ ▌\",\"▐ ⠈ ▌\",\"▐ ⠂ ▌\",\"▐ ⠠ ▌\",\"▐ ⡀ ▌\",\"▐ ⠠ ▌\",\"▐ ⠂ ▌\",\"▐ ⠈ ▌\",\"▐ ⠂ ▌\",\"▐ ⠠ ▌\",\"▐ ⡀ ▌\",\"▐⠠ ▌\"]},\"shark\":{\"interval\":120,\"frames\":[\"▐|\\\\____________▌\",\"▐_|\\\\___________▌\",\"▐__|\\\\__________▌\",\"▐___|\\\\_________▌\",\"▐____|\\\\________▌\",\"▐_____|\\\\_______▌\",\"▐______|\\\\______▌\",\"▐_______|\\\\_____▌\",\"▐________|\\\\____▌\",\"▐_________|\\\\___▌\",\"▐__________|\\\\__▌\",\"▐___________|\\\\_▌\",\"▐____________|\\\\▌\",\"▐____________/|▌\",\"▐___________/|_▌\",\"▐__________/|__▌\",\"▐_________/|___▌\",\"▐________/|____▌\",\"▐_______/|_____▌\",\"▐______/|______▌\",\"▐_____/|_______▌\",\"▐____/|________▌\",\"▐___/|_________▌\",\"▐__/|__________▌\",\"▐_/|___________▌\",\"▐/|____________▌\"]},\"dqpb\":{\"interval\":100,\"frames\":[\"d\",\"q\",\"p\",\"b\"]},\"weather\":{\"interval\":100,\"frames\":[\"☀️ \",\"☀️ \",\"☀️ \",\"🌤 \",\"⛅️ \",\"🌥 \",\"☁️ \",\"🌧 \",\"🌨 \",\"🌧 \",\"🌨 \",\"🌧 \",\"🌨 \",\"⛈ \",\"🌨 \",\"🌧 \",\"🌨 \",\"☁️ \",\"🌥 \",\"⛅️ \",\"🌤 \",\"☀️ \",\"☀️ \"]},\"christmas\":{\"interval\":400,\"frames\":[\"🌲\",\"🎄\"]}}");
-
/***/ }),
/* 686 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
@@ -78253,9 +78306,8 @@ module.exports = JSON.parse("{\"dots\":{\"interval\":80,\"frames\":[\"⠋\",\"
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RunCommand", function() { return RunCommand; });
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(34);
+/* harmony import */ var _utils_errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(516);
+/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(500);
/* harmony import */ var _utils_parallelize__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(501);
/* harmony import */ var _utils_projects__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(502);
/*
@@ -78290,16 +78342,18 @@ const RunCommand = {
const batchedProjects = Object(_utils_projects__WEBPACK_IMPORTED_MODULE_3__["topologicallyBatchProjects"])(projects, projectGraph);
if (extraArgs.length === 0) {
- _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.red.bold('\nNo script specified'));
- process.exit(1);
+ throw new _utils_errors__WEBPACK_IMPORTED_MODULE_0__["CliError"]('No script specified');
}
const scriptName = extraArgs[0];
const scriptArgs = extraArgs.slice(1);
- _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold(`\nRunning script [${chalk__WEBPACK_IMPORTED_MODULE_0___default.a.green(scriptName)}] in batched topological order\n`));
- await Object(_utils_parallelize__WEBPACK_IMPORTED_MODULE_2__["parallelizeBatches"])(batchedProjects, async pkg => {
- if (pkg.hasScript(scriptName)) {
- await pkg.runScriptStreaming(scriptName, scriptArgs);
+ await Object(_utils_parallelize__WEBPACK_IMPORTED_MODULE_2__["parallelizeBatches"])(batchedProjects, async project => {
+ if (project.hasScript(scriptName)) {
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].info(`[${project.name}] running "${scriptName}" script`);
+ await project.runScriptStreaming(scriptName, {
+ args: scriptArgs
+ });
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].success(`[${project.name}] complete`);
}
});
}
@@ -78313,9 +78367,8 @@ const RunCommand = {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "WatchCommand", function() { return WatchCommand; });
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(34);
+/* harmony import */ var _utils_errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(516);
+/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(500);
/* harmony import */ var _utils_parallelize__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(501);
/* harmony import */ var _utils_projects__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(502);
/* harmony import */ var _utils_watch__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(688);
@@ -78378,12 +78431,11 @@ const WatchCommand = {
}
if (projectsToWatch.size === 0) {
- _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.red(`\nThere are no projects to watch found. Make sure that projects define 'kbn:watch' script in 'package.json'.\n`));
- return;
+ throw new _utils_errors__WEBPACK_IMPORTED_MODULE_0__["CliError"](`There are no projects to watch found. Make sure that projects define 'kbn:watch' script in 'package.json'.`);
}
const projectNames = Array.from(projectsToWatch.keys());
- _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.green(`Running ${watchScriptName} scripts for [${projectNames.join(', ')}].`))); // Kibana should always be run the last, so we don't rely on automatic
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].info(`Running ${watchScriptName} scripts for [${projectNames.join(', ')}].`); // Kibana should always be run the last, so we don't rely on automatic
// topological batching and push it to the last one-entry batch manually.
const shouldWatchKibanaProject = projectsToWatch.delete(kibanaProjectName);
@@ -78394,8 +78446,10 @@ const WatchCommand = {
}
await Object(_utils_parallelize__WEBPACK_IMPORTED_MODULE_2__["parallelizeBatches"])(batchedProjects, async pkg => {
- const completionHint = await Object(_utils_watch__WEBPACK_IMPORTED_MODULE_4__["waitUntilWatchIsReady"])(pkg.runScriptStreaming(watchScriptName).stdout);
- _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold(`[${chalk__WEBPACK_IMPORTED_MODULE_0___default.a.green(pkg.name)}] Initial build completed (${completionHint}).`));
+ const completionHint = await Object(_utils_watch__WEBPACK_IMPORTED_MODULE_4__["waitUntilWatchIsReady"])(pkg.runScriptStreaming(watchScriptName, {
+ debug: false
+ }).stdout);
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].success(`[${pkg.name}] Initial build completed (${completionHint}).`);
});
}
@@ -78408,8 +78462,8 @@ const WatchCommand = {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "waitUntilWatchIsReady", function() { return waitUntilWatchIsReady; });
-/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(169);
-/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(270);
+/* harmony import */ var rxjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(140);
+/* harmony import */ var rxjs_operators__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(241);
/*
* Licensed to Elasticsearch B.V. under one or more contributor
* license agreements. See the NOTICE file distributed with
@@ -78482,17 +78536,11 @@ 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 chalk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var indent_string__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(690);
-/* harmony import */ var indent_string__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(indent_string__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var wrap_ansi__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(691);
-/* harmony import */ var wrap_ansi__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(wrap_ansi__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _utils_errors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(516);
-/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(34);
-/* harmony import */ var _utils_projects__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(502);
-/* harmony import */ var _utils_projects_tree__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(698);
-/* harmony import */ var _utils_kibana__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(699);
+/* harmony import */ var _utils_errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(516);
+/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(500);
+/* harmony import */ var _utils_projects__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(502);
+/* harmony import */ var _utils_projects_tree__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(690);
+/* harmony import */ var _utils_kibana__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(691);
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; }
@@ -78522,13 +78570,10 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
-
-
-
async function runCommand(command, config) {
try {
- _utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold(`Running [${chalk__WEBPACK_IMPORTED_MODULE_0___default.a.green(command.name)}] command from [${chalk__WEBPACK_IMPORTED_MODULE_0___default.a.yellow(config.rootPath)}]:\n`));
- const kbn = await _utils_kibana__WEBPACK_IMPORTED_MODULE_7__["Kibana"].loadFrom(config.rootPath);
+ _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);
const projects = kbn.getFilteredProjects({
skipKibanaPlugins: Boolean(config.options['skip-kibana-plugins']),
ossOnly: Boolean(config.options.oss),
@@ -78537,34 +78582,31 @@ async function runCommand(command, config) {
});
if (projects.size === 0) {
- _utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.red(`There are no projects found. Double check project name(s) in '-i/--include' and '-e/--exclude' filters.\n`));
+ _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.`);
return process.exit(1);
}
- const projectGraph = Object(_utils_projects__WEBPACK_IMPORTED_MODULE_5__["buildProjectGraph"])(projects);
- _utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold(`Found [${chalk__WEBPACK_IMPORTED_MODULE_0___default.a.green(projects.size.toString())}] projects:\n`));
- _utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].write(Object(_utils_projects_tree__WEBPACK_IMPORTED_MODULE_6__["renderProjectsTree"])(config.rootPath, projects));
+ 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));
await command.run(projects, projectGraph, _objectSpread({}, config, {
kbn
}));
- } catch (e) {
- _utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].write(chalk__WEBPACK_IMPORTED_MODULE_0___default.a.bold.red(`\n[${command.name}] failed:\n`));
+ } catch (error) {
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].error(`[${command.name}] failed:`);
- if (e instanceof _utils_errors__WEBPACK_IMPORTED_MODULE_3__["CliError"]) {
- const msg = chalk__WEBPACK_IMPORTED_MODULE_0___default.a.red(`CliError: ${e.message}\n`);
- _utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].write(wrap_ansi__WEBPACK_IMPORTED_MODULE_2___default()(msg, 80));
- const keys = Object.keys(e.meta);
+ if (error instanceof _utils_errors__WEBPACK_IMPORTED_MODULE_0__["CliError"]) {
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].error(error.message);
+ const metaOutput = Object.entries(error.meta).map(([key, value]) => `${key}: ${value}`).join('\n');
- if (keys.length > 0) {
- const metaOutput = keys.map(key => {
- const value = e.meta[key];
- return `${key}: ${value}`;
- });
- _utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].write('Additional debugging info:\n');
- _utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].write(indent_string__WEBPACK_IMPORTED_MODULE_1___default()(metaOutput.join('\n'), 3));
+ 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);
}
} else {
- _utils_log__WEBPACK_IMPORTED_MODULE_4__["log"].write(e.stack);
+ _utils_log__WEBPACK_IMPORTED_MODULE_1__["log"].error(error);
}
process.exit(1);
@@ -78581,400 +78623,14 @@ function toArray(value) {
/***/ }),
/* 690 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-module.exports = (str, count, opts) => {
- // Support older versions: use the third parameter as options.indent
- // TODO: Remove the workaround in the next major version
- const options = typeof opts === 'object' ? Object.assign({indent: ' '}, opts) : {indent: opts || ' '};
- count = count === undefined ? 1 : count;
-
- if (typeof str !== 'string') {
- throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof str}\``);
- }
-
- if (typeof count !== 'number') {
- throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof count}\``);
- }
-
- if (typeof options.indent !== 'string') {
- throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``);
- }
-
- if (count === 0) {
- return str;
- }
-
- const regex = options.includeEmptyLines ? /^/mg : /^(?!\s*$)/mg;
- return str.replace(regex, options.indent.repeat(count));
-}
-;
-
-
-/***/ }),
-/* 691 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-const stringWidth = __webpack_require__(692);
-const stripAnsi = __webpack_require__(696);
-
-const ESCAPES = new Set([
- '\u001B',
- '\u009B'
-]);
-
-const END_CODE = 39;
-
-const ESCAPE_CODES = new Map([
- [0, 0],
- [1, 22],
- [2, 22],
- [3, 23],
- [4, 24],
- [7, 27],
- [8, 28],
- [9, 29],
- [30, 39],
- [31, 39],
- [32, 39],
- [33, 39],
- [34, 39],
- [35, 39],
- [36, 39],
- [37, 39],
- [90, 39],
- [40, 49],
- [41, 49],
- [42, 49],
- [43, 49],
- [44, 49],
- [45, 49],
- [46, 49],
- [47, 49]
-]);
-
-const wrapAnsi = code => `${ESCAPES.values().next().value}[${code}m`;
-
-// Calculate the length of words split on ' ', ignoring
-// the extra characters added by ansi escape codes
-const wordLengths = str => str.split(' ').map(s => stringWidth(s));
-
-// Wrap a long word across multiple rows
-// Ansi escape codes do not count towards length
-const wrapWord = (rows, word, cols) => {
- const arr = Array.from(word);
-
- let insideEscape = false;
- let visible = stringWidth(stripAnsi(rows[rows.length - 1]));
-
- for (const item of arr.entries()) {
- const i = item[0];
- const char = item[1];
- const charLength = stringWidth(char);
-
- if (visible + charLength <= cols) {
- rows[rows.length - 1] += char;
- } else {
- rows.push(char);
- visible = 0;
- }
-
- if (ESCAPES.has(char)) {
- insideEscape = true;
- } else if (insideEscape && char === 'm') {
- insideEscape = false;
- continue;
- }
-
- if (insideEscape) {
- continue;
- }
-
- visible += charLength;
-
- if (visible === cols && i < arr.length - 1) {
- rows.push('');
- visible = 0;
- }
- }
-
- // It's possible that the last row we copy over is only
- // ansi escape characters, handle this edge-case
- if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
- rows[rows.length - 2] += rows.pop();
- }
-};
-
-// The wrap-ansi module can be invoked
-// in either 'hard' or 'soft' wrap mode
-//
-// 'hard' will never allow a string to take up more
-// than cols characters
-//
-// 'soft' allows long words to expand past the column length
-const exec = (str, cols, opts) => {
- const options = opts || {};
-
- if (str.trim() === '') {
- return options.trim === false ? str : str.trim();
- }
-
- let pre = '';
- let ret = '';
- let escapeCode;
-
- const lengths = wordLengths(str);
- const words = str.split(' ');
- const rows = [''];
-
- for (const item of Array.from(words).entries()) {
- const i = item[0];
- const word = item[1];
-
- rows[rows.length - 1] = options.trim === false ? rows[rows.length - 1] : rows[rows.length - 1].trim();
- let rowLength = stringWidth(rows[rows.length - 1]);
-
- if (rowLength || word === '') {
- if (rowLength === cols && options.wordWrap === false) {
- // If we start with a new word but the current row length equals the length of the columns, add a new row
- rows.push('');
- rowLength = 0;
- }
-
- rows[rows.length - 1] += ' ';
- rowLength++;
- }
-
- // In 'hard' wrap mode, the length of a line is
- // never allowed to extend past 'cols'
- if (lengths[i] > cols && options.hard) {
- if (rowLength) {
- rows.push('');
- }
- wrapWord(rows, word, cols);
- continue;
- }
-
- if (rowLength + lengths[i] > cols && rowLength > 0) {
- if (options.wordWrap === false && rowLength < cols) {
- wrapWord(rows, word, cols);
- continue;
- }
-
- rows.push('');
- }
-
- if (rowLength + lengths[i] > cols && options.wordWrap === false) {
- wrapWord(rows, word, cols);
- continue;
- }
-
- rows[rows.length - 1] += word;
- }
-
- pre = rows.map(r => options.trim === false ? r : r.trim()).join('\n');
-
- for (const item of Array.from(pre).entries()) {
- const i = item[0];
- const char = item[1];
-
- ret += char;
-
- if (ESCAPES.has(char)) {
- const code = parseFloat(/\d[^m]*/.exec(pre.slice(i, i + 4)));
- escapeCode = code === END_CODE ? null : code;
- }
-
- const code = ESCAPE_CODES.get(Number(escapeCode));
-
- if (escapeCode && code) {
- if (pre[i + 1] === '\n') {
- ret += wrapAnsi(code);
- } else if (char === '\n') {
- ret += wrapAnsi(escapeCode);
- }
- }
- }
-
- return ret;
-};
-
-// For each newline, invoke the method separately
-module.exports = (str, cols, opts) => {
- return String(str)
- .normalize()
- .split('\n')
- .map(line => exec(line, cols, opts))
- .join('\n');
-};
-
-
-/***/ }),
-/* 692 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-const stripAnsi = __webpack_require__(693);
-const isFullwidthCodePoint = __webpack_require__(695);
-
-module.exports = str => {
- if (typeof str !== 'string' || str.length === 0) {
- return 0;
- }
-
- str = stripAnsi(str);
-
- let width = 0;
-
- for (let i = 0; i < str.length; i++) {
- const code = str.codePointAt(i);
-
- // Ignore control characters
- if (code <= 0x1F || (code >= 0x7F && code <= 0x9F)) {
- continue;
- }
-
- // Ignore combining characters
- if (code >= 0x300 && code <= 0x36F) {
- continue;
- }
-
- // Surrogates
- if (code > 0xFFFF) {
- i++;
- }
-
- width += isFullwidthCodePoint(code) ? 2 : 1;
- }
-
- return width;
-};
-
-
-/***/ }),
-/* 693 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-const ansiRegex = __webpack_require__(694);
-
-module.exports = input => typeof input === 'string' ? input.replace(ansiRegex(), '') : input;
-
-
-/***/ }),
-/* 694 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-
-module.exports = () => {
- const pattern = [
- '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\\u0007)',
- '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))'
- ].join('|');
-
- return new RegExp(pattern, 'g');
-};
-
-
-/***/ }),
-/* 695 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-/* eslint-disable yoda */
-module.exports = x => {
- if (Number.isNaN(x)) {
- return false;
- }
-
- // code points are derived from:
- // http://www.unix.org/Public/UNIDATA/EastAsianWidth.txt
- if (
- x >= 0x1100 && (
- x <= 0x115f || // Hangul Jamo
- x === 0x2329 || // LEFT-POINTING ANGLE BRACKET
- x === 0x232a || // RIGHT-POINTING ANGLE BRACKET
- // CJK Radicals Supplement .. Enclosed CJK Letters and Months
- (0x2e80 <= x && x <= 0x3247 && x !== 0x303f) ||
- // Enclosed CJK Letters and Months .. CJK Unified Ideographs Extension A
- (0x3250 <= x && x <= 0x4dbf) ||
- // CJK Unified Ideographs .. Yi Radicals
- (0x4e00 <= x && x <= 0xa4c6) ||
- // Hangul Jamo Extended-A
- (0xa960 <= x && x <= 0xa97c) ||
- // Hangul Syllables
- (0xac00 <= x && x <= 0xd7a3) ||
- // CJK Compatibility Ideographs
- (0xf900 <= x && x <= 0xfaff) ||
- // Vertical Forms
- (0xfe10 <= x && x <= 0xfe19) ||
- // CJK Compatibility Forms .. Small Form Variants
- (0xfe30 <= x && x <= 0xfe6b) ||
- // Halfwidth and Fullwidth Forms
- (0xff01 <= x && x <= 0xff60) ||
- (0xffe0 <= x && x <= 0xffe6) ||
- // Kana Supplement
- (0x1b000 <= x && x <= 0x1b001) ||
- // Enclosed Ideographic Supplement
- (0x1f200 <= x && x <= 0x1f251) ||
- // CJK Unified Ideographs Extension B .. Tertiary Ideographic Plane
- (0x20000 <= x && x <= 0x3fffd)
- )
- ) {
- return true;
- }
-
- return false;
-};
-
-
-/***/ }),
-/* 696 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-const ansiRegex = __webpack_require__(697);
-
-module.exports = input => typeof input === 'string' ? input.replace(ansiRegex(), '') : input;
-
-
-/***/ }),
-/* 697 */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-
-
-module.exports = () => {
- const pattern = [
- '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\\u0007)',
- '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))'
- ].join('|');
-
- return new RegExp(pattern, 'g');
-};
-
-
-/***/ }),
-/* 698 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "renderProjectsTree", function() { return renderProjectsTree; });
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
+/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(386);
/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(16);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4);
/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
/*
* Licensed to Elasticsearch B.V. under one or more contributor
@@ -79119,20 +78775,20 @@ function addProjectToTree(tree, pathParts, project) {
}
/***/ }),
-/* 699 */
+/* 691 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__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__(16);
+/* 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__(700);
+/* harmony import */ var multimatch__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(692);
/* 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__(704);
+/* harmony import */ var is_path_inside__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(696);
/* 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 _projects__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(502);
-/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(579);
+/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(574);
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; }
@@ -79273,15 +78929,15 @@ class Kibana {
}
/***/ }),
-/* 700 */
+/* 692 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
const minimatch = __webpack_require__(506);
-const arrayUnion = __webpack_require__(701);
-const arrayDiffer = __webpack_require__(702);
-const arrify = __webpack_require__(703);
+const arrayUnion = __webpack_require__(693);
+const arrayDiffer = __webpack_require__(694);
+const arrify = __webpack_require__(695);
module.exports = (list, patterns, options = {}) => {
list = arrify(list);
@@ -79305,7 +78961,7 @@ module.exports = (list, patterns, options = {}) => {
/***/ }),
-/* 701 */
+/* 693 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -79317,7 +78973,7 @@ module.exports = (...arguments_) => {
/***/ }),
-/* 702 */
+/* 694 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -79332,7 +78988,7 @@ module.exports = arrayDiffer;
/***/ }),
-/* 703 */
+/* 695 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -79362,12 +79018,12 @@ module.exports = arrify;
/***/ }),
-/* 704 */
+/* 696 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const path = __webpack_require__(16);
+const path = __webpack_require__(4);
module.exports = (childPath, parentPath) => {
childPath = path.resolve(childPath);
@@ -79390,15 +79046,15 @@ module.exports = (childPath, parentPath) => {
/***/ }),
-/* 705 */
+/* 697 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
-/* harmony import */ var _build_production_projects__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(706);
+/* harmony import */ var _build_production_projects__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(698);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "buildProductionProjects", function() { return _build_production_projects__WEBPACK_IMPORTED_MODULE_0__["buildProductionProjects"]; });
-/* harmony import */ var _prepare_project_dependencies__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(941);
+/* harmony import */ var _prepare_project_dependencies__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(933);
/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "prepareExternalProjectDependencies", function() { return _prepare_project_dependencies__WEBPACK_IMPORTED_MODULE_1__["prepareExternalProjectDependencies"]; });
/*
@@ -79423,21 +79079,21 @@ __webpack_require__.r(__webpack_exports__);
/***/ }),
-/* 706 */
+/* 698 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "buildProductionProjects", function() { return buildProductionProjects; });
-/* harmony import */ var cpy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(707);
+/* harmony import */ var cpy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(699);
/* 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__(587);
+/* harmony import */ var del__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(582);
/* 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__(16);
+/* 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__(579);
-/* harmony import */ var _utils_fs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(20);
-/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(34);
+/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(574);
+/* harmony import */ var _utils_fs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(491);
+/* harmony import */ var _utils_log__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(500);
/* harmony import */ var _utils_package_json__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(518);
/* harmony import */ var _utils_projects__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(502);
/*
@@ -79475,7 +79131,7 @@ async function buildProductionProjects({
const projectGraph = Object(_utils_projects__WEBPACK_IMPORTED_MODULE_7__["buildProjectGraph"])(projects);
const batchedProjects = Object(_utils_projects__WEBPACK_IMPORTED_MODULE_7__["topologicallyBatchProjects"])(projects, projectGraph);
const projectNames = [...projects.values()].map(project => project.name);
- _utils_log__WEBPACK_IMPORTED_MODULE_5__["log"].write(`Preparing production build for [${projectNames.join(', ')}]`);
+ _utils_log__WEBPACK_IMPORTED_MODULE_5__["log"].info(`Preparing production build for [${projectNames.join(', ')}]`);
for (const batch of batchedProjects) {
for (const project of batch) {
@@ -79571,21 +79227,21 @@ async function copyToBuild(project, kibanaRoot, buildRoot) {
}
/***/ }),
-/* 707 */
+/* 699 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const EventEmitter = __webpack_require__(399);
-const path = __webpack_require__(16);
-const os = __webpack_require__(11);
-const pAll = __webpack_require__(708);
-const arrify = __webpack_require__(710);
-const globby = __webpack_require__(711);
-const isGlob = __webpack_require__(605);
-const cpFile = __webpack_require__(926);
-const junk = __webpack_require__(938);
-const CpyError = __webpack_require__(939);
+const EventEmitter = __webpack_require__(373);
+const path = __webpack_require__(4);
+const os = __webpack_require__(364);
+const pAll = __webpack_require__(700);
+const arrify = __webpack_require__(702);
+const globby = __webpack_require__(703);
+const isGlob = __webpack_require__(600);
+const cpFile = __webpack_require__(918);
+const junk = __webpack_require__(930);
+const CpyError = __webpack_require__(931);
const defaultOptions = {
ignoreJunk: true
@@ -79704,12 +79360,12 @@ module.exports = (source, destination, {
/***/ }),
-/* 708 */
+/* 700 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const pMap = __webpack_require__(709);
+const pMap = __webpack_require__(701);
module.exports = (iterable, options) => pMap(iterable, element => element(), options);
// TODO: Remove this for the next major release
@@ -79717,7 +79373,7 @@ module.exports.default = module.exports;
/***/ }),
-/* 709 */
+/* 701 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -79796,7 +79452,7 @@ module.exports.default = pMap;
/***/ }),
-/* 710 */
+/* 702 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -79826,17 +79482,17 @@ module.exports = arrify;
/***/ }),
-/* 711 */
+/* 703 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const fs = __webpack_require__(23);
-const arrayUnion = __webpack_require__(712);
-const glob = __webpack_require__(714);
-const fastGlob = __webpack_require__(719);
-const dirGlob = __webpack_require__(919);
-const gitignore = __webpack_require__(922);
+const fs = __webpack_require__(349);
+const arrayUnion = __webpack_require__(704);
+const glob = __webpack_require__(706);
+const fastGlob = __webpack_require__(711);
+const dirGlob = __webpack_require__(911);
+const gitignore = __webpack_require__(914);
const DEFAULT_FILTER = () => false;
@@ -79981,12 +79637,12 @@ module.exports.gitignore = gitignore;
/***/ }),
-/* 712 */
+/* 704 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var arrayUniq = __webpack_require__(713);
+var arrayUniq = __webpack_require__(705);
module.exports = function () {
return arrayUniq([].concat.apply([], arguments));
@@ -79994,7 +79650,7 @@ module.exports = function () {
/***/ }),
-/* 713 */
+/* 705 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -80063,7 +79719,7 @@ if ('Set' in global) {
/***/ }),
-/* 714 */
+/* 706 */
/***/ (function(module, exports, __webpack_require__) {
// Approach:
@@ -80108,27 +79764,27 @@ if ('Set' in global) {
module.exports = glob
-var fs = __webpack_require__(23)
+var fs = __webpack_require__(349)
var rp = __webpack_require__(504)
var minimatch = __webpack_require__(506)
var Minimatch = minimatch.Minimatch
-var inherits = __webpack_require__(715)
-var EE = __webpack_require__(399).EventEmitter
-var path = __webpack_require__(16)
-var assert = __webpack_require__(30)
+var inherits = __webpack_require__(707)
+var EE = __webpack_require__(373).EventEmitter
+var path = __webpack_require__(4)
+var assert = __webpack_require__(371)
var isAbsolute = __webpack_require__(512)
-var globSync = __webpack_require__(717)
-var common = __webpack_require__(718)
+var globSync = __webpack_require__(709)
+var common = __webpack_require__(710)
var alphasort = common.alphasort
var alphasorti = common.alphasorti
var setopts = common.setopts
var ownProp = common.ownProp
var inflight = __webpack_require__(515)
-var util = __webpack_require__(29)
+var util = __webpack_require__(397)
var childrenIgnored = common.childrenIgnored
var isIgnored = common.isIgnored
-var once = __webpack_require__(404)
+var once = __webpack_require__(378)
function glob (pattern, options, cb) {
if (typeof options === 'function') cb = options, options = {}
@@ -80859,22 +80515,22 @@ Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
/***/ }),
-/* 715 */
+/* 707 */
/***/ (function(module, exports, __webpack_require__) {
try {
- var util = __webpack_require__(29);
+ var util = __webpack_require__(397);
/* istanbul ignore next */
if (typeof util.inherits !== 'function') throw '';
module.exports = util.inherits;
} catch (e) {
/* istanbul ignore next */
- module.exports = __webpack_require__(716);
+ module.exports = __webpack_require__(708);
}
/***/ }),
-/* 716 */
+/* 708 */
/***/ (function(module, exports) {
if (typeof Object.create === 'function') {
@@ -80907,22 +80563,22 @@ if (typeof Object.create === 'function') {
/***/ }),
-/* 717 */
+/* 709 */
/***/ (function(module, exports, __webpack_require__) {
module.exports = globSync
globSync.GlobSync = GlobSync
-var fs = __webpack_require__(23)
+var fs = __webpack_require__(349)
var rp = __webpack_require__(504)
var minimatch = __webpack_require__(506)
var Minimatch = minimatch.Minimatch
-var Glob = __webpack_require__(714).Glob
-var util = __webpack_require__(29)
-var path = __webpack_require__(16)
-var assert = __webpack_require__(30)
+var Glob = __webpack_require__(706).Glob
+var util = __webpack_require__(397)
+var path = __webpack_require__(4)
+var assert = __webpack_require__(371)
var isAbsolute = __webpack_require__(512)
-var common = __webpack_require__(718)
+var common = __webpack_require__(710)
var alphasort = common.alphasort
var alphasorti = common.alphasorti
var setopts = common.setopts
@@ -81399,7 +81055,7 @@ GlobSync.prototype._makeAbs = function (f) {
/***/ }),
-/* 718 */
+/* 710 */
/***/ (function(module, exports, __webpack_require__) {
exports.alphasort = alphasort
@@ -81416,7 +81072,7 @@ function ownProp (obj, field) {
return Object.prototype.hasOwnProperty.call(obj, field)
}
-var path = __webpack_require__(16)
+var path = __webpack_require__(4)
var minimatch = __webpack_require__(506)
var isAbsolute = __webpack_require__(512)
var Minimatch = minimatch.Minimatch
@@ -81645,10 +81301,10 @@ function childrenIgnored (self, path) {
/***/ }),
-/* 719 */
+/* 711 */
/***/ (function(module, exports, __webpack_require__) {
-const pkg = __webpack_require__(720);
+const pkg = __webpack_require__(712);
module.exports = pkg.async;
module.exports.default = pkg.async;
@@ -81661,19 +81317,19 @@ module.exports.generateTasks = pkg.generateTasks;
/***/ }),
-/* 720 */
+/* 712 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var optionsManager = __webpack_require__(721);
-var taskManager = __webpack_require__(722);
-var reader_async_1 = __webpack_require__(890);
-var reader_stream_1 = __webpack_require__(914);
-var reader_sync_1 = __webpack_require__(915);
-var arrayUtils = __webpack_require__(917);
-var streamUtils = __webpack_require__(918);
+var optionsManager = __webpack_require__(713);
+var taskManager = __webpack_require__(714);
+var reader_async_1 = __webpack_require__(882);
+var reader_stream_1 = __webpack_require__(906);
+var reader_sync_1 = __webpack_require__(907);
+var arrayUtils = __webpack_require__(909);
+var streamUtils = __webpack_require__(910);
/**
* Synchronous API.
*/
@@ -81739,7 +81395,7 @@ function isString(source) {
/***/ }),
-/* 721 */
+/* 713 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -81777,13 +81433,13 @@ exports.prepare = prepare;
/***/ }),
-/* 722 */
+/* 714 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var patternUtils = __webpack_require__(723);
+var patternUtils = __webpack_require__(715);
/**
* Generate tasks based on parent directory of each pattern.
*/
@@ -81874,16 +81530,16 @@ exports.convertPatternGroupToTask = convertPatternGroupToTask;
/***/ }),
-/* 723 */
+/* 715 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var path = __webpack_require__(16);
-var globParent = __webpack_require__(724);
-var isGlob = __webpack_require__(727);
-var micromatch = __webpack_require__(728);
+var path = __webpack_require__(4);
+var globParent = __webpack_require__(716);
+var isGlob = __webpack_require__(719);
+var micromatch = __webpack_require__(720);
var GLOBSTAR = '**';
/**
* Return true for static pattern.
@@ -82029,16 +81685,16 @@ exports.matchAny = matchAny;
/***/ }),
-/* 724 */
+/* 716 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var path = __webpack_require__(16);
-var isglob = __webpack_require__(725);
-var pathDirname = __webpack_require__(726);
-var isWin32 = __webpack_require__(11).platform() === 'win32';
+var path = __webpack_require__(4);
+var isglob = __webpack_require__(717);
+var pathDirname = __webpack_require__(718);
+var isWin32 = __webpack_require__(364).platform() === 'win32';
module.exports = function globParent(str) {
// flip windows path separators
@@ -82060,7 +81716,7 @@ module.exports = function globParent(str) {
/***/ }),
-/* 725 */
+/* 717 */
/***/ (function(module, exports, __webpack_require__) {
/*!
@@ -82070,7 +81726,7 @@ module.exports = function globParent(str) {
* Licensed under the MIT License.
*/
-var isExtglob = __webpack_require__(606);
+var isExtglob = __webpack_require__(601);
module.exports = function isGlob(str) {
if (typeof str !== 'string' || str === '') {
@@ -82091,14 +81747,14 @@ module.exports = function isGlob(str) {
/***/ }),
-/* 726 */
+/* 718 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var path = __webpack_require__(16);
-var inspect = __webpack_require__(29).inspect;
+var path = __webpack_require__(4);
+var inspect = __webpack_require__(397).inspect;
function assertPath(path) {
if (typeof path !== 'string') {
@@ -82241,7 +81897,7 @@ module.exports.win32 = win32;
/***/ }),
-/* 727 */
+/* 719 */
/***/ (function(module, exports, __webpack_require__) {
/*!
@@ -82251,7 +81907,7 @@ module.exports.win32 = win32;
* Released under the MIT License.
*/
-var isExtglob = __webpack_require__(606);
+var isExtglob = __webpack_require__(601);
var chars = { '{': '}', '(': ')', '[': ']'};
module.exports = function isGlob(str, options) {
@@ -82293,7 +81949,7 @@ module.exports = function isGlob(str, options) {
/***/ }),
-/* 728 */
+/* 720 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -82303,19 +81959,19 @@ module.exports = function isGlob(str, options) {
* Module dependencies
*/
-var util = __webpack_require__(29);
-var braces = __webpack_require__(729);
-var toRegex = __webpack_require__(842);
-var extend = __webpack_require__(850);
+var util = __webpack_require__(397);
+var braces = __webpack_require__(721);
+var toRegex = __webpack_require__(834);
+var extend = __webpack_require__(842);
/**
* Local dependencies
*/
-var compilers = __webpack_require__(853);
-var parsers = __webpack_require__(886);
-var cache = __webpack_require__(887);
-var utils = __webpack_require__(888);
+var compilers = __webpack_require__(845);
+var parsers = __webpack_require__(878);
+var cache = __webpack_require__(879);
+var utils = __webpack_require__(880);
var MAX_LENGTH = 1024 * 64;
/**
@@ -83177,7 +82833,7 @@ module.exports = micromatch;
/***/ }),
-/* 729 */
+/* 721 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -83187,18 +82843,18 @@ module.exports = micromatch;
* Module dependencies
*/
-var toRegex = __webpack_require__(730);
-var unique = __webpack_require__(744);
-var extend = __webpack_require__(739);
+var toRegex = __webpack_require__(722);
+var unique = __webpack_require__(736);
+var extend = __webpack_require__(731);
/**
* Local dependencies
*/
-var compilers = __webpack_require__(745);
-var parsers = __webpack_require__(762);
-var Braces = __webpack_require__(772);
-var utils = __webpack_require__(746);
+var compilers = __webpack_require__(737);
+var parsers = __webpack_require__(754);
+var Braces = __webpack_require__(764);
+var utils = __webpack_require__(738);
var MAX_LENGTH = 1024 * 64;
var cache = {};
@@ -83502,15 +83158,15 @@ module.exports = braces;
/***/ }),
-/* 730 */
+/* 722 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var define = __webpack_require__(731);
-var extend = __webpack_require__(739);
-var not = __webpack_require__(741);
+var define = __webpack_require__(723);
+var extend = __webpack_require__(731);
+var not = __webpack_require__(733);
var MAX_LENGTH = 1024 * 64;
/**
@@ -83657,7 +83313,7 @@ module.exports.makeRe = makeRe;
/***/ }),
-/* 731 */
+/* 723 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -83670,7 +83326,7 @@ module.exports.makeRe = makeRe;
-var isDescriptor = __webpack_require__(732);
+var isDescriptor = __webpack_require__(724);
module.exports = function defineProperty(obj, prop, val) {
if (typeof obj !== 'object' && typeof obj !== 'function') {
@@ -83695,7 +83351,7 @@ module.exports = function defineProperty(obj, prop, val) {
/***/ }),
-/* 732 */
+/* 724 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -83708,9 +83364,9 @@ module.exports = function defineProperty(obj, prop, val) {
-var typeOf = __webpack_require__(733);
-var isAccessor = __webpack_require__(734);
-var isData = __webpack_require__(737);
+var typeOf = __webpack_require__(725);
+var isAccessor = __webpack_require__(726);
+var isData = __webpack_require__(729);
module.exports = function isDescriptor(obj, key) {
if (typeOf(obj) !== 'object') {
@@ -83724,7 +83380,7 @@ module.exports = function isDescriptor(obj, key) {
/***/ }),
-/* 733 */
+/* 725 */
/***/ (function(module, exports) {
var toString = Object.prototype.toString;
@@ -83877,7 +83533,7 @@ function isBuffer(val) {
/***/ }),
-/* 734 */
+/* 726 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -83890,7 +83546,7 @@ function isBuffer(val) {
-var typeOf = __webpack_require__(735);
+var typeOf = __webpack_require__(727);
// accessor descriptor properties
var accessor = {
@@ -83953,10 +83609,10 @@ module.exports = isAccessorDescriptor;
/***/ }),
-/* 735 */
+/* 727 */
/***/ (function(module, exports, __webpack_require__) {
-var isBuffer = __webpack_require__(736);
+var isBuffer = __webpack_require__(728);
var toString = Object.prototype.toString;
/**
@@ -84075,7 +83731,7 @@ module.exports = function kindOf(val) {
/***/ }),
-/* 736 */
+/* 728 */
/***/ (function(module, exports) {
/*!
@@ -84102,7 +83758,7 @@ function isSlowBuffer (obj) {
/***/ }),
-/* 737 */
+/* 729 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -84115,7 +83771,7 @@ function isSlowBuffer (obj) {
-var typeOf = __webpack_require__(738);
+var typeOf = __webpack_require__(730);
// data descriptor properties
var data = {
@@ -84164,10 +83820,10 @@ module.exports = isDataDescriptor;
/***/ }),
-/* 738 */
+/* 730 */
/***/ (function(module, exports, __webpack_require__) {
-var isBuffer = __webpack_require__(736);
+var isBuffer = __webpack_require__(728);
var toString = Object.prototype.toString;
/**
@@ -84286,13 +83942,13 @@ module.exports = function kindOf(val) {
/***/ }),
-/* 739 */
+/* 731 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isObject = __webpack_require__(740);
+var isObject = __webpack_require__(732);
module.exports = function extend(o/*, objects*/) {
if (!isObject(o)) { o = {}; }
@@ -84326,7 +83982,7 @@ function hasOwn(obj, key) {
/***/ }),
-/* 740 */
+/* 732 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -84346,13 +84002,13 @@ module.exports = function isExtendable(val) {
/***/ }),
-/* 741 */
+/* 733 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var extend = __webpack_require__(742);
+var extend = __webpack_require__(734);
/**
* The main export is a function that takes a `pattern` string and an `options` object.
@@ -84419,13 +84075,13 @@ module.exports = toRegex;
/***/ }),
-/* 742 */
+/* 734 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isObject = __webpack_require__(743);
+var isObject = __webpack_require__(735);
module.exports = function extend(o/*, objects*/) {
if (!isObject(o)) { o = {}; }
@@ -84459,7 +84115,7 @@ function hasOwn(obj, key) {
/***/ }),
-/* 743 */
+/* 735 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -84479,7 +84135,7 @@ module.exports = function isExtendable(val) {
/***/ }),
-/* 744 */
+/* 736 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -84529,13 +84185,13 @@ module.exports.immutable = function uniqueImmutable(arr) {
/***/ }),
-/* 745 */
+/* 737 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var utils = __webpack_require__(746);
+var utils = __webpack_require__(738);
module.exports = function(braces, options) {
braces.compiler
@@ -84818,25 +84474,25 @@ function hasQueue(node) {
/***/ }),
-/* 746 */
+/* 738 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var splitString = __webpack_require__(747);
+var splitString = __webpack_require__(739);
var utils = module.exports;
/**
* Module dependencies
*/
-utils.extend = __webpack_require__(739);
-utils.flatten = __webpack_require__(753);
-utils.isObject = __webpack_require__(751);
-utils.fillRange = __webpack_require__(754);
-utils.repeat = __webpack_require__(761);
-utils.unique = __webpack_require__(744);
+utils.extend = __webpack_require__(731);
+utils.flatten = __webpack_require__(745);
+utils.isObject = __webpack_require__(743);
+utils.fillRange = __webpack_require__(746);
+utils.repeat = __webpack_require__(753);
+utils.unique = __webpack_require__(736);
utils.define = function(obj, key, val) {
Object.defineProperty(obj, key, {
@@ -85168,7 +84824,7 @@ utils.escapeRegex = function(str) {
/***/ }),
-/* 747 */
+/* 739 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -85181,7 +84837,7 @@ utils.escapeRegex = function(str) {
-var extend = __webpack_require__(748);
+var extend = __webpack_require__(740);
module.exports = function(str, options, fn) {
if (typeof str !== 'string') {
@@ -85346,14 +85002,14 @@ function keepEscaping(opts, str, idx) {
/***/ }),
-/* 748 */
+/* 740 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isExtendable = __webpack_require__(749);
-var assignSymbols = __webpack_require__(752);
+var isExtendable = __webpack_require__(741);
+var assignSymbols = __webpack_require__(744);
module.exports = Object.assign || function(obj/*, objects*/) {
if (obj === null || typeof obj === 'undefined') {
@@ -85413,7 +85069,7 @@ function isEnum(obj, key) {
/***/ }),
-/* 749 */
+/* 741 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -85426,7 +85082,7 @@ function isEnum(obj, key) {
-var isPlainObject = __webpack_require__(750);
+var isPlainObject = __webpack_require__(742);
module.exports = function isExtendable(val) {
return isPlainObject(val) || typeof val === 'function' || Array.isArray(val);
@@ -85434,7 +85090,7 @@ module.exports = function isExtendable(val) {
/***/ }),
-/* 750 */
+/* 742 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -85447,7 +85103,7 @@ module.exports = function isExtendable(val) {
-var isObject = __webpack_require__(751);
+var isObject = __webpack_require__(743);
function isObjectObject(o) {
return isObject(o) === true
@@ -85478,7 +85134,7 @@ module.exports = function isPlainObject(o) {
/***/ }),
-/* 751 */
+/* 743 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -85497,7 +85153,7 @@ module.exports = function isObject(val) {
/***/ }),
-/* 752 */
+/* 744 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -85544,7 +85200,7 @@ module.exports = function(receiver, objects) {
/***/ }),
-/* 753 */
+/* 745 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -85573,7 +85229,7 @@ function flat(arr, res) {
/***/ }),
-/* 754 */
+/* 746 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -85586,11 +85242,11 @@ function flat(arr, res) {
-var util = __webpack_require__(29);
-var isNumber = __webpack_require__(755);
-var extend = __webpack_require__(757);
-var repeat = __webpack_require__(759);
-var toRegex = __webpack_require__(760);
+var util = __webpack_require__(397);
+var isNumber = __webpack_require__(747);
+var extend = __webpack_require__(749);
+var repeat = __webpack_require__(751);
+var toRegex = __webpack_require__(752);
/**
* Return a range of numbers or letters.
@@ -85788,7 +85444,7 @@ module.exports = fillRange;
/***/ }),
-/* 755 */
+/* 747 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -85801,7 +85457,7 @@ module.exports = fillRange;
-var typeOf = __webpack_require__(756);
+var typeOf = __webpack_require__(748);
module.exports = function isNumber(num) {
var type = typeOf(num);
@@ -85817,10 +85473,10 @@ module.exports = function isNumber(num) {
/***/ }),
-/* 756 */
+/* 748 */
/***/ (function(module, exports, __webpack_require__) {
-var isBuffer = __webpack_require__(736);
+var isBuffer = __webpack_require__(728);
var toString = Object.prototype.toString;
/**
@@ -85939,13 +85595,13 @@ module.exports = function kindOf(val) {
/***/ }),
-/* 757 */
+/* 749 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isObject = __webpack_require__(758);
+var isObject = __webpack_require__(750);
module.exports = function extend(o/*, objects*/) {
if (!isObject(o)) { o = {}; }
@@ -85979,7 +85635,7 @@ function hasOwn(obj, key) {
/***/ }),
-/* 758 */
+/* 750 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -85999,7 +85655,7 @@ module.exports = function isExtendable(val) {
/***/ }),
-/* 759 */
+/* 751 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -86076,7 +85732,7 @@ function repeat(str, num) {
/***/ }),
-/* 760 */
+/* 752 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -86089,8 +85745,8 @@ function repeat(str, num) {
-var repeat = __webpack_require__(759);
-var isNumber = __webpack_require__(755);
+var repeat = __webpack_require__(751);
+var isNumber = __webpack_require__(747);
var cache = {};
function toRegexRange(min, max, options) {
@@ -86377,7 +86033,7 @@ module.exports = toRegexRange;
/***/ }),
-/* 761 */
+/* 753 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -86402,14 +86058,14 @@ module.exports = function repeat(ele, num) {
/***/ }),
-/* 762 */
+/* 754 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var Node = __webpack_require__(763);
-var utils = __webpack_require__(746);
+var Node = __webpack_require__(755);
+var utils = __webpack_require__(738);
/**
* Braces parsers
@@ -86769,15 +86425,15 @@ function concatNodes(pos, node, parent, options) {
/***/ }),
-/* 763 */
+/* 755 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isObject = __webpack_require__(751);
-var define = __webpack_require__(764);
-var utils = __webpack_require__(771);
+var isObject = __webpack_require__(743);
+var define = __webpack_require__(756);
+var utils = __webpack_require__(763);
var ownNames;
/**
@@ -87268,7 +86924,7 @@ exports = module.exports = Node;
/***/ }),
-/* 764 */
+/* 756 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -87281,7 +86937,7 @@ exports = module.exports = Node;
-var isDescriptor = __webpack_require__(765);
+var isDescriptor = __webpack_require__(757);
module.exports = function defineProperty(obj, prop, val) {
if (typeof obj !== 'object' && typeof obj !== 'function') {
@@ -87306,7 +86962,7 @@ module.exports = function defineProperty(obj, prop, val) {
/***/ }),
-/* 765 */
+/* 757 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -87319,9 +86975,9 @@ module.exports = function defineProperty(obj, prop, val) {
-var typeOf = __webpack_require__(766);
-var isAccessor = __webpack_require__(767);
-var isData = __webpack_require__(769);
+var typeOf = __webpack_require__(758);
+var isAccessor = __webpack_require__(759);
+var isData = __webpack_require__(761);
module.exports = function isDescriptor(obj, key) {
if (typeOf(obj) !== 'object') {
@@ -87335,7 +86991,7 @@ module.exports = function isDescriptor(obj, key) {
/***/ }),
-/* 766 */
+/* 758 */
/***/ (function(module, exports) {
var toString = Object.prototype.toString;
@@ -87470,7 +87126,7 @@ function isBuffer(val) {
/***/ }),
-/* 767 */
+/* 759 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -87483,7 +87139,7 @@ function isBuffer(val) {
-var typeOf = __webpack_require__(768);
+var typeOf = __webpack_require__(760);
// accessor descriptor properties
var accessor = {
@@ -87546,7 +87202,7 @@ module.exports = isAccessorDescriptor;
/***/ }),
-/* 768 */
+/* 760 */
/***/ (function(module, exports) {
var toString = Object.prototype.toString;
@@ -87681,7 +87337,7 @@ function isBuffer(val) {
/***/ }),
-/* 769 */
+/* 761 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -87694,7 +87350,7 @@ function isBuffer(val) {
-var typeOf = __webpack_require__(770);
+var typeOf = __webpack_require__(762);
module.exports = function isDataDescriptor(obj, prop) {
// data descriptor properties
@@ -87737,7 +87393,7 @@ module.exports = function isDataDescriptor(obj, prop) {
/***/ }),
-/* 770 */
+/* 762 */
/***/ (function(module, exports) {
var toString = Object.prototype.toString;
@@ -87872,13 +87528,13 @@ function isBuffer(val) {
/***/ }),
-/* 771 */
+/* 763 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var typeOf = __webpack_require__(756);
+var typeOf = __webpack_require__(748);
var utils = module.exports;
/**
@@ -88898,17 +88554,17 @@ function assert(val, message) {
/***/ }),
-/* 772 */
+/* 764 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var extend = __webpack_require__(739);
-var Snapdragon = __webpack_require__(773);
-var compilers = __webpack_require__(745);
-var parsers = __webpack_require__(762);
-var utils = __webpack_require__(746);
+var extend = __webpack_require__(731);
+var Snapdragon = __webpack_require__(765);
+var compilers = __webpack_require__(737);
+var parsers = __webpack_require__(754);
+var utils = __webpack_require__(738);
/**
* Customize Snapdragon parser and renderer
@@ -89009,17 +88665,17 @@ module.exports = Braces;
/***/ }),
-/* 773 */
+/* 765 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var Base = __webpack_require__(774);
-var define = __webpack_require__(800);
-var Compiler = __webpack_require__(810);
-var Parser = __webpack_require__(839);
-var utils = __webpack_require__(819);
+var Base = __webpack_require__(766);
+var define = __webpack_require__(792);
+var Compiler = __webpack_require__(802);
+var Parser = __webpack_require__(831);
+var utils = __webpack_require__(811);
var regexCache = {};
var cache = {};
@@ -89190,20 +88846,20 @@ module.exports.Parser = Parser;
/***/ }),
-/* 774 */
+/* 766 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var util = __webpack_require__(29);
-var define = __webpack_require__(775);
-var CacheBase = __webpack_require__(776);
-var Emitter = __webpack_require__(777);
-var isObject = __webpack_require__(751);
-var merge = __webpack_require__(794);
-var pascal = __webpack_require__(797);
-var cu = __webpack_require__(798);
+var util = __webpack_require__(397);
+var define = __webpack_require__(767);
+var CacheBase = __webpack_require__(768);
+var Emitter = __webpack_require__(769);
+var isObject = __webpack_require__(743);
+var merge = __webpack_require__(786);
+var pascal = __webpack_require__(789);
+var cu = __webpack_require__(790);
/**
* Optionally define a custom `cache` namespace to use.
@@ -89632,7 +89288,7 @@ module.exports.namespace = namespace;
/***/ }),
-/* 775 */
+/* 767 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -89645,7 +89301,7 @@ module.exports.namespace = namespace;
-var isDescriptor = __webpack_require__(765);
+var isDescriptor = __webpack_require__(757);
module.exports = function defineProperty(obj, prop, val) {
if (typeof obj !== 'object' && typeof obj !== 'function') {
@@ -89670,21 +89326,21 @@ module.exports = function defineProperty(obj, prop, val) {
/***/ }),
-/* 776 */
+/* 768 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isObject = __webpack_require__(751);
-var Emitter = __webpack_require__(777);
-var visit = __webpack_require__(778);
-var toPath = __webpack_require__(781);
-var union = __webpack_require__(782);
-var del = __webpack_require__(786);
-var get = __webpack_require__(784);
-var has = __webpack_require__(791);
-var set = __webpack_require__(785);
+var isObject = __webpack_require__(743);
+var Emitter = __webpack_require__(769);
+var visit = __webpack_require__(770);
+var toPath = __webpack_require__(773);
+var union = __webpack_require__(774);
+var del = __webpack_require__(778);
+var get = __webpack_require__(776);
+var has = __webpack_require__(783);
+var set = __webpack_require__(777);
/**
* Create a `Cache` constructor that when instantiated will
@@ -89938,7 +89594,7 @@ module.exports.namespace = namespace;
/***/ }),
-/* 777 */
+/* 769 */
/***/ (function(module, exports, __webpack_require__) {
@@ -90107,7 +89763,7 @@ Emitter.prototype.hasListeners = function(event){
/***/ }),
-/* 778 */
+/* 770 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90120,8 +89776,8 @@ Emitter.prototype.hasListeners = function(event){
-var visit = __webpack_require__(779);
-var mapVisit = __webpack_require__(780);
+var visit = __webpack_require__(771);
+var mapVisit = __webpack_require__(772);
module.exports = function(collection, method, val) {
var result;
@@ -90144,7 +89800,7 @@ module.exports = function(collection, method, val) {
/***/ }),
-/* 779 */
+/* 771 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90157,7 +89813,7 @@ module.exports = function(collection, method, val) {
-var isObject = __webpack_require__(751);
+var isObject = __webpack_require__(743);
module.exports = function visit(thisArg, method, target, val) {
if (!isObject(thisArg) && typeof thisArg !== 'function') {
@@ -90184,14 +89840,14 @@ module.exports = function visit(thisArg, method, target, val) {
/***/ }),
-/* 780 */
+/* 772 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var util = __webpack_require__(29);
-var visit = __webpack_require__(779);
+var util = __webpack_require__(397);
+var visit = __webpack_require__(771);
/**
* Map `visit` over an array of objects.
@@ -90228,7 +89884,7 @@ function isObject(val) {
/***/ }),
-/* 781 */
+/* 773 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90241,7 +89897,7 @@ function isObject(val) {
-var typeOf = __webpack_require__(756);
+var typeOf = __webpack_require__(748);
module.exports = function toPath(args) {
if (typeOf(args) !== 'arguments') {
@@ -90268,16 +89924,16 @@ function filter(arr) {
/***/ }),
-/* 782 */
+/* 774 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isObject = __webpack_require__(743);
-var union = __webpack_require__(783);
-var get = __webpack_require__(784);
-var set = __webpack_require__(785);
+var isObject = __webpack_require__(735);
+var union = __webpack_require__(775);
+var get = __webpack_require__(776);
+var set = __webpack_require__(777);
module.exports = function unionValue(obj, prop, value) {
if (!isObject(obj)) {
@@ -90305,7 +89961,7 @@ function arrayify(val) {
/***/ }),
-/* 783 */
+/* 775 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90341,7 +89997,7 @@ module.exports = function union(init) {
/***/ }),
-/* 784 */
+/* 776 */
/***/ (function(module, exports) {
/*!
@@ -90397,7 +90053,7 @@ function toString(val) {
/***/ }),
-/* 785 */
+/* 777 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90410,10 +90066,10 @@ function toString(val) {
-var split = __webpack_require__(747);
-var extend = __webpack_require__(742);
-var isPlainObject = __webpack_require__(750);
-var isObject = __webpack_require__(743);
+var split = __webpack_require__(739);
+var extend = __webpack_require__(734);
+var isPlainObject = __webpack_require__(742);
+var isObject = __webpack_require__(735);
module.exports = function(obj, prop, val) {
if (!isObject(obj)) {
@@ -90459,7 +90115,7 @@ function isValidKey(key) {
/***/ }),
-/* 786 */
+/* 778 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90472,8 +90128,8 @@ function isValidKey(key) {
-var isObject = __webpack_require__(751);
-var has = __webpack_require__(787);
+var isObject = __webpack_require__(743);
+var has = __webpack_require__(779);
module.exports = function unset(obj, prop) {
if (!isObject(obj)) {
@@ -90498,7 +90154,7 @@ module.exports = function unset(obj, prop) {
/***/ }),
-/* 787 */
+/* 779 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90511,9 +90167,9 @@ module.exports = function unset(obj, prop) {
-var isObject = __webpack_require__(788);
-var hasValues = __webpack_require__(790);
-var get = __webpack_require__(784);
+var isObject = __webpack_require__(780);
+var hasValues = __webpack_require__(782);
+var get = __webpack_require__(776);
module.exports = function(obj, prop, noZero) {
if (isObject(obj)) {
@@ -90524,7 +90180,7 @@ module.exports = function(obj, prop, noZero) {
/***/ }),
-/* 788 */
+/* 780 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90537,7 +90193,7 @@ module.exports = function(obj, prop, noZero) {
-var isArray = __webpack_require__(789);
+var isArray = __webpack_require__(781);
module.exports = function isObject(val) {
return val != null && typeof val === 'object' && isArray(val) === false;
@@ -90545,7 +90201,7 @@ module.exports = function isObject(val) {
/***/ }),
-/* 789 */
+/* 781 */
/***/ (function(module, exports) {
var toString = {}.toString;
@@ -90556,7 +90212,7 @@ module.exports = Array.isArray || function (arr) {
/***/ }),
-/* 790 */
+/* 782 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90599,7 +90255,7 @@ module.exports = function hasValue(o, noZero) {
/***/ }),
-/* 791 */
+/* 783 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90612,9 +90268,9 @@ module.exports = function hasValue(o, noZero) {
-var isObject = __webpack_require__(751);
-var hasValues = __webpack_require__(792);
-var get = __webpack_require__(784);
+var isObject = __webpack_require__(743);
+var hasValues = __webpack_require__(784);
+var get = __webpack_require__(776);
module.exports = function(val, prop) {
return hasValues(isObject(val) && prop ? get(val, prop) : val);
@@ -90622,7 +90278,7 @@ module.exports = function(val, prop) {
/***/ }),
-/* 792 */
+/* 784 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90635,8 +90291,8 @@ module.exports = function(val, prop) {
-var typeOf = __webpack_require__(793);
-var isNumber = __webpack_require__(755);
+var typeOf = __webpack_require__(785);
+var isNumber = __webpack_require__(747);
module.exports = function hasValue(val) {
// is-number checks for NaN and other edge cases
@@ -90689,10 +90345,10 @@ module.exports = function hasValue(val) {
/***/ }),
-/* 793 */
+/* 785 */
/***/ (function(module, exports, __webpack_require__) {
-var isBuffer = __webpack_require__(736);
+var isBuffer = __webpack_require__(728);
var toString = Object.prototype.toString;
/**
@@ -90814,14 +90470,14 @@ module.exports = function kindOf(val) {
/***/ }),
-/* 794 */
+/* 786 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isExtendable = __webpack_require__(795);
-var forIn = __webpack_require__(796);
+var isExtendable = __webpack_require__(787);
+var forIn = __webpack_require__(788);
function mixinDeep(target, objects) {
var len = arguments.length, i = 0;
@@ -90885,7 +90541,7 @@ module.exports = mixinDeep;
/***/ }),
-/* 795 */
+/* 787 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90898,7 +90554,7 @@ module.exports = mixinDeep;
-var isPlainObject = __webpack_require__(750);
+var isPlainObject = __webpack_require__(742);
module.exports = function isExtendable(val) {
return isPlainObject(val) || typeof val === 'function' || Array.isArray(val);
@@ -90906,7 +90562,7 @@ module.exports = function isExtendable(val) {
/***/ }),
-/* 796 */
+/* 788 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -90929,7 +90585,7 @@ module.exports = function forIn(obj, fn, thisArg) {
/***/ }),
-/* 797 */
+/* 789 */
/***/ (function(module, exports) {
/*!
@@ -90956,14 +90612,14 @@ module.exports = pascalcase;
/***/ }),
-/* 798 */
+/* 790 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var util = __webpack_require__(29);
-var utils = __webpack_require__(799);
+var util = __webpack_require__(397);
+var utils = __webpack_require__(791);
/**
* Expose class utils
@@ -91328,7 +90984,7 @@ cu.bubble = function(Parent, events) {
/***/ }),
-/* 799 */
+/* 791 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -91342,10 +90998,10 @@ var utils = {};
* Lazily required module dependencies
*/
-utils.union = __webpack_require__(783);
-utils.define = __webpack_require__(800);
-utils.isObj = __webpack_require__(751);
-utils.staticExtend = __webpack_require__(807);
+utils.union = __webpack_require__(775);
+utils.define = __webpack_require__(792);
+utils.isObj = __webpack_require__(743);
+utils.staticExtend = __webpack_require__(799);
/**
@@ -91356,7 +91012,7 @@ module.exports = utils;
/***/ }),
-/* 800 */
+/* 792 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -91369,7 +91025,7 @@ module.exports = utils;
-var isDescriptor = __webpack_require__(801);
+var isDescriptor = __webpack_require__(793);
module.exports = function defineProperty(obj, prop, val) {
if (typeof obj !== 'object' && typeof obj !== 'function') {
@@ -91394,7 +91050,7 @@ module.exports = function defineProperty(obj, prop, val) {
/***/ }),
-/* 801 */
+/* 793 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -91407,9 +91063,9 @@ module.exports = function defineProperty(obj, prop, val) {
-var typeOf = __webpack_require__(802);
-var isAccessor = __webpack_require__(803);
-var isData = __webpack_require__(805);
+var typeOf = __webpack_require__(794);
+var isAccessor = __webpack_require__(795);
+var isData = __webpack_require__(797);
module.exports = function isDescriptor(obj, key) {
if (typeOf(obj) !== 'object') {
@@ -91423,7 +91079,7 @@ module.exports = function isDescriptor(obj, key) {
/***/ }),
-/* 802 */
+/* 794 */
/***/ (function(module, exports) {
var toString = Object.prototype.toString;
@@ -91576,7 +91232,7 @@ function isBuffer(val) {
/***/ }),
-/* 803 */
+/* 795 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -91589,7 +91245,7 @@ function isBuffer(val) {
-var typeOf = __webpack_require__(804);
+var typeOf = __webpack_require__(796);
// accessor descriptor properties
var accessor = {
@@ -91652,10 +91308,10 @@ module.exports = isAccessorDescriptor;
/***/ }),
-/* 804 */
+/* 796 */
/***/ (function(module, exports, __webpack_require__) {
-var isBuffer = __webpack_require__(736);
+var isBuffer = __webpack_require__(728);
var toString = Object.prototype.toString;
/**
@@ -91774,7 +91430,7 @@ module.exports = function kindOf(val) {
/***/ }),
-/* 805 */
+/* 797 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -91787,7 +91443,7 @@ module.exports = function kindOf(val) {
-var typeOf = __webpack_require__(806);
+var typeOf = __webpack_require__(798);
// data descriptor properties
var data = {
@@ -91836,10 +91492,10 @@ module.exports = isDataDescriptor;
/***/ }),
-/* 806 */
+/* 798 */
/***/ (function(module, exports, __webpack_require__) {
-var isBuffer = __webpack_require__(736);
+var isBuffer = __webpack_require__(728);
var toString = Object.prototype.toString;
/**
@@ -91958,7 +91614,7 @@ module.exports = function kindOf(val) {
/***/ }),
-/* 807 */
+/* 799 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -91971,9 +91627,9 @@ module.exports = function kindOf(val) {
-var copy = __webpack_require__(808);
-var define = __webpack_require__(800);
-var util = __webpack_require__(29);
+var copy = __webpack_require__(800);
+var define = __webpack_require__(792);
+var util = __webpack_require__(397);
/**
* Returns a function for extending the static properties,
@@ -92055,15 +91711,15 @@ module.exports = extend;
/***/ }),
-/* 808 */
+/* 800 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var typeOf = __webpack_require__(756);
-var copyDescriptor = __webpack_require__(809);
-var define = __webpack_require__(800);
+var typeOf = __webpack_require__(748);
+var copyDescriptor = __webpack_require__(801);
+var define = __webpack_require__(792);
/**
* Copy static properties, prototype properties, and descriptors from one object to another.
@@ -92236,7 +91892,7 @@ module.exports.has = has;
/***/ }),
-/* 809 */
+/* 801 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -92324,16 +91980,16 @@ function isObject(val) {
/***/ }),
-/* 810 */
+/* 802 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var use = __webpack_require__(811);
-var define = __webpack_require__(800);
-var debug = __webpack_require__(813)('snapdragon:compiler');
-var utils = __webpack_require__(819);
+var use = __webpack_require__(803);
+var define = __webpack_require__(792);
+var debug = __webpack_require__(805)('snapdragon:compiler');
+var utils = __webpack_require__(811);
/**
* Create a new `Compiler` with the given `options`.
@@ -92487,7 +92143,7 @@ Compiler.prototype = {
// source map support
if (opts.sourcemap) {
- var sourcemaps = __webpack_require__(838);
+ var sourcemaps = __webpack_require__(830);
sourcemaps(this);
this.mapVisit(this.ast.nodes);
this.applySourceMaps();
@@ -92508,7 +92164,7 @@ module.exports = Compiler;
/***/ }),
-/* 811 */
+/* 803 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -92521,7 +92177,7 @@ module.exports = Compiler;
-var utils = __webpack_require__(812);
+var utils = __webpack_require__(804);
module.exports = function base(app, opts) {
if (!utils.isObject(app) && typeof app !== 'function') {
@@ -92636,7 +92292,7 @@ module.exports = function base(app, opts) {
/***/ }),
-/* 812 */
+/* 804 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -92650,8 +92306,8 @@ var utils = {};
* Lazily required module dependencies
*/
-utils.define = __webpack_require__(800);
-utils.isObject = __webpack_require__(751);
+utils.define = __webpack_require__(792);
+utils.isObject = __webpack_require__(743);
utils.isString = function(val) {
@@ -92666,7 +92322,7 @@ module.exports = utils;
/***/ }),
-/* 813 */
+/* 805 */
/***/ (function(module, exports, __webpack_require__) {
/**
@@ -92675,14 +92331,14 @@ module.exports = utils;
*/
if (typeof process !== 'undefined' && process.type === 'renderer') {
- module.exports = __webpack_require__(814);
+ module.exports = __webpack_require__(806);
} else {
- module.exports = __webpack_require__(817);
+ module.exports = __webpack_require__(809);
}
/***/ }),
-/* 814 */
+/* 806 */
/***/ (function(module, exports, __webpack_require__) {
/**
@@ -92691,7 +92347,7 @@ if (typeof process !== 'undefined' && process.type === 'renderer') {
* Expose `debug()` as the module.
*/
-exports = module.exports = __webpack_require__(815);
+exports = module.exports = __webpack_require__(807);
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
@@ -92873,7 +92529,7 @@ function localstorage() {
/***/ }),
-/* 815 */
+/* 807 */
/***/ (function(module, exports, __webpack_require__) {
@@ -92889,7 +92545,7 @@ exports.coerce = coerce;
exports.disable = disable;
exports.enable = enable;
exports.enabled = enabled;
-exports.humanize = __webpack_require__(816);
+exports.humanize = __webpack_require__(808);
/**
* The currently active debug mode names, and names to skip.
@@ -93081,7 +92737,7 @@ function coerce(val) {
/***/ }),
-/* 816 */
+/* 808 */
/***/ (function(module, exports) {
/**
@@ -93239,15 +92895,15 @@ function plural(ms, n, name) {
/***/ }),
-/* 817 */
+/* 809 */
/***/ (function(module, exports, __webpack_require__) {
/**
* Module dependencies.
*/
-var tty = __webpack_require__(484);
-var util = __webpack_require__(29);
+var tty = __webpack_require__(471);
+var util = __webpack_require__(397);
/**
* This is the Node.js implementation of `debug()`.
@@ -93255,7 +92911,7 @@ var util = __webpack_require__(29);
* Expose `debug()` as the module.
*/
-exports = module.exports = __webpack_require__(815);
+exports = module.exports = __webpack_require__(807);
exports.init = init;
exports.log = log;
exports.formatArgs = formatArgs;
@@ -93427,14 +93083,14 @@ function createWritableStdioStream (fd) {
break;
case 'FILE':
- var fs = __webpack_require__(23);
+ var fs = __webpack_require__(349);
stream = new fs.SyncWriteStream(fd, { autoClose: false });
stream._type = 'fs';
break;
case 'PIPE':
case 'TCP':
- var net = __webpack_require__(818);
+ var net = __webpack_require__(810);
stream = new net.Socket({
fd: fd,
readable: false,
@@ -93493,13 +93149,13 @@ exports.enable(load());
/***/ }),
-/* 818 */
+/* 810 */
/***/ (function(module, exports) {
module.exports = require("net");
/***/ }),
-/* 819 */
+/* 811 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -93509,9 +93165,9 @@ module.exports = require("net");
* Module dependencies
*/
-exports.extend = __webpack_require__(742);
-exports.SourceMap = __webpack_require__(820);
-exports.sourceMapResolve = __webpack_require__(831);
+exports.extend = __webpack_require__(734);
+exports.SourceMap = __webpack_require__(812);
+exports.sourceMapResolve = __webpack_require__(823);
/**
* Convert backslash in the given string to forward slashes
@@ -93554,7 +93210,7 @@ exports.last = function(arr, n) {
/***/ }),
-/* 820 */
+/* 812 */
/***/ (function(module, exports, __webpack_require__) {
/*
@@ -93562,13 +93218,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__(821).SourceMapGenerator;
-exports.SourceMapConsumer = __webpack_require__(827).SourceMapConsumer;
-exports.SourceNode = __webpack_require__(830).SourceNode;
+exports.SourceMapGenerator = __webpack_require__(813).SourceMapGenerator;
+exports.SourceMapConsumer = __webpack_require__(819).SourceMapConsumer;
+exports.SourceNode = __webpack_require__(822).SourceNode;
/***/ }),
-/* 821 */
+/* 813 */
/***/ (function(module, exports, __webpack_require__) {
/* -*- Mode: js; js-indent-level: 2; -*- */
@@ -93578,10 +93234,10 @@ exports.SourceNode = __webpack_require__(830).SourceNode;
* http://opensource.org/licenses/BSD-3-Clause
*/
-var base64VLQ = __webpack_require__(822);
-var util = __webpack_require__(824);
-var ArraySet = __webpack_require__(825).ArraySet;
-var MappingList = __webpack_require__(826).MappingList;
+var base64VLQ = __webpack_require__(814);
+var util = __webpack_require__(816);
+var ArraySet = __webpack_require__(817).ArraySet;
+var MappingList = __webpack_require__(818).MappingList;
/**
* An instance of the SourceMapGenerator represents a source map which is
@@ -93990,7 +93646,7 @@ exports.SourceMapGenerator = SourceMapGenerator;
/***/ }),
-/* 822 */
+/* 814 */
/***/ (function(module, exports, __webpack_require__) {
/* -*- Mode: js; js-indent-level: 2; -*- */
@@ -94030,7 +93686,7 @@ exports.SourceMapGenerator = SourceMapGenerator;
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-var base64 = __webpack_require__(823);
+var base64 = __webpack_require__(815);
// 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,
@@ -94136,7 +93792,7 @@ exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
/***/ }),
-/* 823 */
+/* 815 */
/***/ (function(module, exports) {
/* -*- Mode: js; js-indent-level: 2; -*- */
@@ -94209,7 +93865,7 @@ exports.decode = function (charCode) {
/***/ }),
-/* 824 */
+/* 816 */
/***/ (function(module, exports) {
/* -*- Mode: js; js-indent-level: 2; -*- */
@@ -94632,7 +94288,7 @@ exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflate
/***/ }),
-/* 825 */
+/* 817 */
/***/ (function(module, exports, __webpack_require__) {
/* -*- Mode: js; js-indent-level: 2; -*- */
@@ -94642,7 +94298,7 @@ exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflate
* http://opensource.org/licenses/BSD-3-Clause
*/
-var util = __webpack_require__(824);
+var util = __webpack_require__(816);
var has = Object.prototype.hasOwnProperty;
var hasNativeMap = typeof Map !== "undefined";
@@ -94759,7 +94415,7 @@ exports.ArraySet = ArraySet;
/***/ }),
-/* 826 */
+/* 818 */
/***/ (function(module, exports, __webpack_require__) {
/* -*- Mode: js; js-indent-level: 2; -*- */
@@ -94769,7 +94425,7 @@ exports.ArraySet = ArraySet;
* http://opensource.org/licenses/BSD-3-Clause
*/
-var util = __webpack_require__(824);
+var util = __webpack_require__(816);
/**
* Determine whether mappingB is after mappingA with respect to generated
@@ -94844,7 +94500,7 @@ exports.MappingList = MappingList;
/***/ }),
-/* 827 */
+/* 819 */
/***/ (function(module, exports, __webpack_require__) {
/* -*- Mode: js; js-indent-level: 2; -*- */
@@ -94854,11 +94510,11 @@ exports.MappingList = MappingList;
* http://opensource.org/licenses/BSD-3-Clause
*/
-var util = __webpack_require__(824);
-var binarySearch = __webpack_require__(828);
-var ArraySet = __webpack_require__(825).ArraySet;
-var base64VLQ = __webpack_require__(822);
-var quickSort = __webpack_require__(829).quickSort;
+var util = __webpack_require__(816);
+var binarySearch = __webpack_require__(820);
+var ArraySet = __webpack_require__(817).ArraySet;
+var base64VLQ = __webpack_require__(814);
+var quickSort = __webpack_require__(821).quickSort;
function SourceMapConsumer(aSourceMap) {
var sourceMap = aSourceMap;
@@ -95932,7 +95588,7 @@ exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
/***/ }),
-/* 828 */
+/* 820 */
/***/ (function(module, exports) {
/* -*- Mode: js; js-indent-level: 2; -*- */
@@ -96049,7 +95705,7 @@ exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
/***/ }),
-/* 829 */
+/* 821 */
/***/ (function(module, exports) {
/* -*- Mode: js; js-indent-level: 2; -*- */
@@ -96169,7 +95825,7 @@ exports.quickSort = function (ary, comparator) {
/***/ }),
-/* 830 */
+/* 822 */
/***/ (function(module, exports, __webpack_require__) {
/* -*- Mode: js; js-indent-level: 2; -*- */
@@ -96179,8 +95835,8 @@ exports.quickSort = function (ary, comparator) {
* http://opensource.org/licenses/BSD-3-Clause
*/
-var SourceMapGenerator = __webpack_require__(821).SourceMapGenerator;
-var util = __webpack_require__(824);
+var SourceMapGenerator = __webpack_require__(813).SourceMapGenerator;
+var util = __webpack_require__(816);
// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
// operating systems these days (capturing the result).
@@ -96588,17 +96244,17 @@ exports.SourceNode = SourceNode;
/***/ }),
-/* 831 */
+/* 823 */
/***/ (function(module, exports, __webpack_require__) {
// Copyright 2014, 2015, 2016, 2017 Simon Lydell
// X11 (“MIT”) Licensed. (See LICENSE.)
-var sourceMappingURL = __webpack_require__(832)
-var resolveUrl = __webpack_require__(833)
-var decodeUriComponent = __webpack_require__(834)
-var urix = __webpack_require__(836)
-var atob = __webpack_require__(837)
+var sourceMappingURL = __webpack_require__(824)
+var resolveUrl = __webpack_require__(825)
+var decodeUriComponent = __webpack_require__(826)
+var urix = __webpack_require__(828)
+var atob = __webpack_require__(829)
@@ -96896,7 +96552,7 @@ module.exports = {
/***/ }),
-/* 832 */
+/* 824 */
/***/ (function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;// Copyright 2014 Simon Lydell
@@ -96959,13 +96615,13 @@ void (function(root, factory) {
/***/ }),
-/* 833 */
+/* 825 */
/***/ (function(module, exports, __webpack_require__) {
// Copyright 2014 Simon Lydell
// X11 (“MIT”) Licensed. (See LICENSE.)
-var url = __webpack_require__(452)
+var url = __webpack_require__(439)
function resolveUrl(/* ...urls */) {
return Array.prototype.reduce.call(arguments, function(resolved, nextUrl) {
@@ -96977,13 +96633,13 @@ module.exports = resolveUrl
/***/ }),
-/* 834 */
+/* 826 */
/***/ (function(module, exports, __webpack_require__) {
// Copyright 2017 Simon Lydell
// X11 (“MIT”) Licensed. (See LICENSE.)
-var decodeUriComponent = __webpack_require__(835)
+var decodeUriComponent = __webpack_require__(827)
function customDecodeUriComponent(string) {
// `decodeUriComponent` turns `+` into ` `, but that's not wanted.
@@ -96994,7 +96650,7 @@ module.exports = customDecodeUriComponent
/***/ }),
-/* 835 */
+/* 827 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -97095,13 +96751,13 @@ module.exports = function (encodedURI) {
/***/ }),
-/* 836 */
+/* 828 */
/***/ (function(module, exports, __webpack_require__) {
// Copyright 2014 Simon Lydell
// X11 (“MIT”) Licensed. (See LICENSE.)
-var path = __webpack_require__(16)
+var path = __webpack_require__(4)
"use strict"
@@ -97118,7 +96774,7 @@ module.exports = urix
/***/ }),
-/* 837 */
+/* 829 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -97132,16 +96788,16 @@ module.exports = atob.atob = atob;
/***/ }),
-/* 838 */
+/* 830 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var fs = __webpack_require__(23);
-var path = __webpack_require__(16);
-var define = __webpack_require__(800);
-var utils = __webpack_require__(819);
+var fs = __webpack_require__(349);
+var path = __webpack_require__(4);
+var define = __webpack_require__(792);
+var utils = __webpack_require__(811);
/**
* Expose `mixin()`.
@@ -97284,19 +96940,19 @@ exports.comment = function(node) {
/***/ }),
-/* 839 */
+/* 831 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var use = __webpack_require__(811);
-var util = __webpack_require__(29);
-var Cache = __webpack_require__(840);
-var define = __webpack_require__(800);
-var debug = __webpack_require__(813)('snapdragon:parser');
-var Position = __webpack_require__(841);
-var utils = __webpack_require__(819);
+var use = __webpack_require__(803);
+var util = __webpack_require__(397);
+var Cache = __webpack_require__(832);
+var define = __webpack_require__(792);
+var debug = __webpack_require__(805)('snapdragon:parser');
+var Position = __webpack_require__(833);
+var utils = __webpack_require__(811);
/**
* Create a new `Parser` with the given `input` and `options`.
@@ -97824,7 +97480,7 @@ module.exports = Parser;
/***/ }),
-/* 840 */
+/* 832 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -97931,13 +97587,13 @@ MapCache.prototype.del = function mapDelete(key) {
/***/ }),
-/* 841 */
+/* 833 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var define = __webpack_require__(800);
+var define = __webpack_require__(792);
/**
* Store position for a node
@@ -97952,16 +97608,16 @@ module.exports = function Position(start, parser) {
/***/ }),
-/* 842 */
+/* 834 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var safe = __webpack_require__(843);
-var define = __webpack_require__(849);
-var extend = __webpack_require__(850);
-var not = __webpack_require__(852);
+var safe = __webpack_require__(835);
+var define = __webpack_require__(841);
+var extend = __webpack_require__(842);
+var not = __webpack_require__(844);
var MAX_LENGTH = 1024 * 64;
/**
@@ -98114,10 +97770,10 @@ module.exports.makeRe = makeRe;
/***/ }),
-/* 843 */
+/* 835 */
/***/ (function(module, exports, __webpack_require__) {
-var parse = __webpack_require__(844);
+var parse = __webpack_require__(836);
var types = parse.types;
module.exports = function (re, opts) {
@@ -98163,13 +97819,13 @@ function isRegExp (x) {
/***/ }),
-/* 844 */
+/* 836 */
/***/ (function(module, exports, __webpack_require__) {
-var util = __webpack_require__(845);
-var types = __webpack_require__(846);
-var sets = __webpack_require__(847);
-var positions = __webpack_require__(848);
+var util = __webpack_require__(837);
+var types = __webpack_require__(838);
+var sets = __webpack_require__(839);
+var positions = __webpack_require__(840);
module.exports = function(regexpStr) {
@@ -98451,11 +98107,11 @@ module.exports.types = types;
/***/ }),
-/* 845 */
+/* 837 */
/***/ (function(module, exports, __webpack_require__) {
-var types = __webpack_require__(846);
-var sets = __webpack_require__(847);
+var types = __webpack_require__(838);
+var sets = __webpack_require__(839);
// All of these are private and only used by randexp.
@@ -98568,7 +98224,7 @@ exports.error = function(regexp, msg) {
/***/ }),
-/* 846 */
+/* 838 */
/***/ (function(module, exports) {
module.exports = {
@@ -98584,10 +98240,10 @@ module.exports = {
/***/ }),
-/* 847 */
+/* 839 */
/***/ (function(module, exports, __webpack_require__) {
-var types = __webpack_require__(846);
+var types = __webpack_require__(838);
var INTS = function() {
return [{ type: types.RANGE , from: 48, to: 57 }];
@@ -98672,10 +98328,10 @@ exports.anyChar = function() {
/***/ }),
-/* 848 */
+/* 840 */
/***/ (function(module, exports, __webpack_require__) {
-var types = __webpack_require__(846);
+var types = __webpack_require__(838);
exports.wordBoundary = function() {
return { type: types.POSITION, value: 'b' };
@@ -98695,7 +98351,7 @@ exports.end = function() {
/***/ }),
-/* 849 */
+/* 841 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -98708,8 +98364,8 @@ exports.end = function() {
-var isobject = __webpack_require__(751);
-var isDescriptor = __webpack_require__(765);
+var isobject = __webpack_require__(743);
+var isDescriptor = __webpack_require__(757);
var define = (typeof Reflect !== 'undefined' && Reflect.defineProperty)
? Reflect.defineProperty
: Object.defineProperty;
@@ -98740,14 +98396,14 @@ module.exports = function defineProperty(obj, key, val) {
/***/ }),
-/* 850 */
+/* 842 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isExtendable = __webpack_require__(851);
-var assignSymbols = __webpack_require__(752);
+var isExtendable = __webpack_require__(843);
+var assignSymbols = __webpack_require__(744);
module.exports = Object.assign || function(obj/*, objects*/) {
if (obj === null || typeof obj === 'undefined') {
@@ -98807,7 +98463,7 @@ function isEnum(obj, key) {
/***/ }),
-/* 851 */
+/* 843 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -98820,7 +98476,7 @@ function isEnum(obj, key) {
-var isPlainObject = __webpack_require__(750);
+var isPlainObject = __webpack_require__(742);
module.exports = function isExtendable(val) {
return isPlainObject(val) || typeof val === 'function' || Array.isArray(val);
@@ -98828,14 +98484,14 @@ module.exports = function isExtendable(val) {
/***/ }),
-/* 852 */
+/* 844 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var extend = __webpack_require__(850);
-var safe = __webpack_require__(843);
+var extend = __webpack_require__(842);
+var safe = __webpack_require__(835);
/**
* The main export is a function that takes a `pattern` string and an `options` object.
@@ -98907,14 +98563,14 @@ module.exports = toRegex;
/***/ }),
-/* 853 */
+/* 845 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var nanomatch = __webpack_require__(854);
-var extglob = __webpack_require__(870);
+var nanomatch = __webpack_require__(846);
+var extglob = __webpack_require__(862);
module.exports = function(snapdragon) {
var compilers = snapdragon.compiler.compilers;
@@ -98991,7 +98647,7 @@ function escapeExtglobs(compiler) {
/***/ }),
-/* 854 */
+/* 846 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -99001,18 +98657,18 @@ function escapeExtglobs(compiler) {
* Module dependencies
*/
-var util = __webpack_require__(29);
-var toRegex = __webpack_require__(855);
-var extend = __webpack_require__(856);
+var util = __webpack_require__(397);
+var toRegex = __webpack_require__(847);
+var extend = __webpack_require__(848);
/**
* Local dependencies
*/
-var compilers = __webpack_require__(858);
-var parsers = __webpack_require__(859);
-var cache = __webpack_require__(862);
-var utils = __webpack_require__(864);
+var compilers = __webpack_require__(850);
+var parsers = __webpack_require__(851);
+var cache = __webpack_require__(854);
+var utils = __webpack_require__(856);
var MAX_LENGTH = 1024 * 64;
/**
@@ -99836,15 +99492,15 @@ module.exports = nanomatch;
/***/ }),
-/* 855 */
+/* 847 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var define = __webpack_require__(800);
-var extend = __webpack_require__(742);
-var not = __webpack_require__(741);
+var define = __webpack_require__(792);
+var extend = __webpack_require__(734);
+var not = __webpack_require__(733);
var MAX_LENGTH = 1024 * 64;
/**
@@ -99991,14 +99647,14 @@ module.exports.makeRe = makeRe;
/***/ }),
-/* 856 */
+/* 848 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var isExtendable = __webpack_require__(857);
-var assignSymbols = __webpack_require__(752);
+var isExtendable = __webpack_require__(849);
+var assignSymbols = __webpack_require__(744);
module.exports = Object.assign || function(obj/*, objects*/) {
if (obj === null || typeof obj === 'undefined') {
@@ -100058,7 +99714,7 @@ function isEnum(obj, key) {
/***/ }),
-/* 857 */
+/* 849 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -100071,7 +99727,7 @@ function isEnum(obj, key) {
-var isPlainObject = __webpack_require__(750);
+var isPlainObject = __webpack_require__(742);
module.exports = function isExtendable(val) {
return isPlainObject(val) || typeof val === 'function' || Array.isArray(val);
@@ -100079,7 +99735,7 @@ module.exports = function isExtendable(val) {
/***/ }),
-/* 858 */
+/* 850 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -100425,15 +100081,15 @@ module.exports = function(nanomatch, options) {
/***/ }),
-/* 859 */
+/* 851 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var regexNot = __webpack_require__(741);
-var toRegex = __webpack_require__(855);
-var isOdd = __webpack_require__(860);
+var regexNot = __webpack_require__(733);
+var toRegex = __webpack_require__(847);
+var isOdd = __webpack_require__(852);
/**
* Characters to use in negation regex (we want to "not" match
@@ -100819,7 +100475,7 @@ module.exports.not = NOT_REGEX;
/***/ }),
-/* 860 */
+/* 852 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -100832,7 +100488,7 @@ module.exports.not = NOT_REGEX;
-var isNumber = __webpack_require__(861);
+var isNumber = __webpack_require__(853);
module.exports = function isOdd(i) {
if (!isNumber(i)) {
@@ -100846,7 +100502,7 @@ module.exports = function isOdd(i) {
/***/ }),
-/* 861 */
+/* 853 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -100874,14 +100530,14 @@ module.exports = function isNumber(num) {
/***/ }),
-/* 862 */
+/* 854 */
/***/ (function(module, exports, __webpack_require__) {
-module.exports = new (__webpack_require__(863))();
+module.exports = new (__webpack_require__(855))();
/***/ }),
-/* 863 */
+/* 855 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -100894,7 +100550,7 @@ module.exports = new (__webpack_require__(863))();
-var MapCache = __webpack_require__(840);
+var MapCache = __webpack_require__(832);
/**
* Create a new `FragmentCache` with an optional object to use for `caches`.
@@ -101016,27 +100672,27 @@ exports = module.exports = FragmentCache;
/***/ }),
-/* 864 */
+/* 856 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var utils = module.exports;
-var path = __webpack_require__(16);
+var path = __webpack_require__(4);
/**
* Module dependencies
*/
-var isWindows = __webpack_require__(865)();
-var Snapdragon = __webpack_require__(773);
-utils.define = __webpack_require__(866);
-utils.diff = __webpack_require__(867);
-utils.extend = __webpack_require__(856);
-utils.pick = __webpack_require__(868);
-utils.typeOf = __webpack_require__(869);
-utils.unique = __webpack_require__(744);
+var isWindows = __webpack_require__(857)();
+var Snapdragon = __webpack_require__(765);
+utils.define = __webpack_require__(858);
+utils.diff = __webpack_require__(859);
+utils.extend = __webpack_require__(848);
+utils.pick = __webpack_require__(860);
+utils.typeOf = __webpack_require__(861);
+utils.unique = __webpack_require__(736);
/**
* Returns true if the given value is effectively an empty string
@@ -101402,7 +101058,7 @@ utils.unixify = function(options) {
/***/ }),
-/* 865 */
+/* 857 */
/***/ (function(module, exports, __webpack_require__) {
var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
@@ -101430,7 +101086,7 @@ var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_
/***/ }),
-/* 866 */
+/* 858 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -101443,8 +101099,8 @@ var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_
-var isobject = __webpack_require__(751);
-var isDescriptor = __webpack_require__(765);
+var isobject = __webpack_require__(743);
+var isDescriptor = __webpack_require__(757);
var define = (typeof Reflect !== 'undefined' && Reflect.defineProperty)
? Reflect.defineProperty
: Object.defineProperty;
@@ -101475,7 +101131,7 @@ module.exports = function defineProperty(obj, key, val) {
/***/ }),
-/* 867 */
+/* 859 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -101529,7 +101185,7 @@ function diffArray(one, two) {
/***/ }),
-/* 868 */
+/* 860 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -101542,7 +101198,7 @@ function diffArray(one, two) {
-var isObject = __webpack_require__(751);
+var isObject = __webpack_require__(743);
module.exports = function pick(obj, keys) {
if (!isObject(obj) && typeof obj !== 'function') {
@@ -101571,7 +101227,7 @@ module.exports = function pick(obj, keys) {
/***/ }),
-/* 869 */
+/* 861 */
/***/ (function(module, exports) {
var toString = Object.prototype.toString;
@@ -101706,7 +101362,7 @@ function isBuffer(val) {
/***/ }),
-/* 870 */
+/* 862 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -101716,18 +101372,18 @@ function isBuffer(val) {
* Module dependencies
*/
-var extend = __webpack_require__(742);
-var unique = __webpack_require__(744);
-var toRegex = __webpack_require__(855);
+var extend = __webpack_require__(734);
+var unique = __webpack_require__(736);
+var toRegex = __webpack_require__(847);
/**
* Local dependencies
*/
-var compilers = __webpack_require__(871);
-var parsers = __webpack_require__(882);
-var Extglob = __webpack_require__(885);
-var utils = __webpack_require__(884);
+var compilers = __webpack_require__(863);
+var parsers = __webpack_require__(874);
+var Extglob = __webpack_require__(877);
+var utils = __webpack_require__(876);
var MAX_LENGTH = 1024 * 64;
/**
@@ -102044,13 +101700,13 @@ module.exports = extglob;
/***/ }),
-/* 871 */
+/* 863 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var brackets = __webpack_require__(872);
+var brackets = __webpack_require__(864);
/**
* Extglob compilers
@@ -102220,7 +101876,7 @@ module.exports = function(extglob) {
/***/ }),
-/* 872 */
+/* 864 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -102230,17 +101886,17 @@ module.exports = function(extglob) {
* Local dependencies
*/
-var compilers = __webpack_require__(873);
-var parsers = __webpack_require__(875);
+var compilers = __webpack_require__(865);
+var parsers = __webpack_require__(867);
/**
* Module dependencies
*/
-var debug = __webpack_require__(877)('expand-brackets');
-var extend = __webpack_require__(742);
-var Snapdragon = __webpack_require__(773);
-var toRegex = __webpack_require__(855);
+var debug = __webpack_require__(869)('expand-brackets');
+var extend = __webpack_require__(734);
+var Snapdragon = __webpack_require__(765);
+var toRegex = __webpack_require__(847);
/**
* Parses the given POSIX character class `pattern` and returns a
@@ -102438,13 +102094,13 @@ module.exports = brackets;
/***/ }),
-/* 873 */
+/* 865 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var posix = __webpack_require__(874);
+var posix = __webpack_require__(866);
module.exports = function(brackets) {
brackets.compiler
@@ -102532,7 +102188,7 @@ module.exports = function(brackets) {
/***/ }),
-/* 874 */
+/* 866 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -102561,14 +102217,14 @@ module.exports = {
/***/ }),
-/* 875 */
+/* 867 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var utils = __webpack_require__(876);
-var define = __webpack_require__(800);
+var utils = __webpack_require__(868);
+var define = __webpack_require__(792);
/**
* Text regex
@@ -102787,14 +102443,14 @@ module.exports.TEXT_REGEX = TEXT_REGEX;
/***/ }),
-/* 876 */
+/* 868 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var toRegex = __webpack_require__(855);
-var regexNot = __webpack_require__(741);
+var toRegex = __webpack_require__(847);
+var regexNot = __webpack_require__(733);
var cached;
/**
@@ -102828,7 +102484,7 @@ exports.createRegex = function(pattern, include) {
/***/ }),
-/* 877 */
+/* 869 */
/***/ (function(module, exports, __webpack_require__) {
/**
@@ -102837,14 +102493,14 @@ exports.createRegex = function(pattern, include) {
*/
if (typeof process !== 'undefined' && process.type === 'renderer') {
- module.exports = __webpack_require__(878);
+ module.exports = __webpack_require__(870);
} else {
- module.exports = __webpack_require__(881);
+ module.exports = __webpack_require__(873);
}
/***/ }),
-/* 878 */
+/* 870 */
/***/ (function(module, exports, __webpack_require__) {
/**
@@ -102853,7 +102509,7 @@ if (typeof process !== 'undefined' && process.type === 'renderer') {
* Expose `debug()` as the module.
*/
-exports = module.exports = __webpack_require__(879);
+exports = module.exports = __webpack_require__(871);
exports.log = log;
exports.formatArgs = formatArgs;
exports.save = save;
@@ -103035,7 +102691,7 @@ function localstorage() {
/***/ }),
-/* 879 */
+/* 871 */
/***/ (function(module, exports, __webpack_require__) {
@@ -103051,7 +102707,7 @@ exports.coerce = coerce;
exports.disable = disable;
exports.enable = enable;
exports.enabled = enabled;
-exports.humanize = __webpack_require__(880);
+exports.humanize = __webpack_require__(872);
/**
* The currently active debug mode names, and names to skip.
@@ -103243,7 +102899,7 @@ function coerce(val) {
/***/ }),
-/* 880 */
+/* 872 */
/***/ (function(module, exports) {
/**
@@ -103401,15 +103057,15 @@ function plural(ms, n, name) {
/***/ }),
-/* 881 */
+/* 873 */
/***/ (function(module, exports, __webpack_require__) {
/**
* Module dependencies.
*/
-var tty = __webpack_require__(484);
-var util = __webpack_require__(29);
+var tty = __webpack_require__(471);
+var util = __webpack_require__(397);
/**
* This is the Node.js implementation of `debug()`.
@@ -103417,7 +103073,7 @@ var util = __webpack_require__(29);
* Expose `debug()` as the module.
*/
-exports = module.exports = __webpack_require__(879);
+exports = module.exports = __webpack_require__(871);
exports.init = init;
exports.log = log;
exports.formatArgs = formatArgs;
@@ -103589,14 +103245,14 @@ function createWritableStdioStream (fd) {
break;
case 'FILE':
- var fs = __webpack_require__(23);
+ var fs = __webpack_require__(349);
stream = new fs.SyncWriteStream(fd, { autoClose: false });
stream._type = 'fs';
break;
case 'PIPE':
case 'TCP':
- var net = __webpack_require__(818);
+ var net = __webpack_require__(810);
stream = new net.Socket({
fd: fd,
readable: false,
@@ -103655,15 +103311,15 @@ exports.enable(load());
/***/ }),
-/* 882 */
+/* 874 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var brackets = __webpack_require__(872);
-var define = __webpack_require__(883);
-var utils = __webpack_require__(884);
+var brackets = __webpack_require__(864);
+var define = __webpack_require__(875);
+var utils = __webpack_require__(876);
/**
* Characters to use in text regex (we want to "not" match
@@ -103818,7 +103474,7 @@ module.exports = parsers;
/***/ }),
-/* 883 */
+/* 875 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -103831,7 +103487,7 @@ module.exports = parsers;
-var isDescriptor = __webpack_require__(765);
+var isDescriptor = __webpack_require__(757);
module.exports = function defineProperty(obj, prop, val) {
if (typeof obj !== 'object' && typeof obj !== 'function') {
@@ -103856,14 +103512,14 @@ module.exports = function defineProperty(obj, prop, val) {
/***/ }),
-/* 884 */
+/* 876 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var regex = __webpack_require__(741);
-var Cache = __webpack_require__(863);
+var regex = __webpack_require__(733);
+var Cache = __webpack_require__(855);
/**
* Utils
@@ -103932,7 +103588,7 @@ utils.createRegex = function(str) {
/***/ }),
-/* 885 */
+/* 877 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -103942,16 +103598,16 @@ utils.createRegex = function(str) {
* Module dependencies
*/
-var Snapdragon = __webpack_require__(773);
-var define = __webpack_require__(883);
-var extend = __webpack_require__(742);
+var Snapdragon = __webpack_require__(765);
+var define = __webpack_require__(875);
+var extend = __webpack_require__(734);
/**
* Local dependencies
*/
-var compilers = __webpack_require__(871);
-var parsers = __webpack_require__(882);
+var compilers = __webpack_require__(863);
+var parsers = __webpack_require__(874);
/**
* Customize Snapdragon parser and renderer
@@ -104017,16 +103673,16 @@ module.exports = Extglob;
/***/ }),
-/* 886 */
+/* 878 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-var extglob = __webpack_require__(870);
-var nanomatch = __webpack_require__(854);
-var regexNot = __webpack_require__(741);
-var toRegex = __webpack_require__(842);
+var extglob = __webpack_require__(862);
+var nanomatch = __webpack_require__(846);
+var regexNot = __webpack_require__(733);
+var toRegex = __webpack_require__(834);
var not;
/**
@@ -104107,33 +103763,33 @@ function textRegex(pattern) {
/***/ }),
-/* 887 */
+/* 879 */
/***/ (function(module, exports, __webpack_require__) {
-module.exports = new (__webpack_require__(863))();
+module.exports = new (__webpack_require__(855))();
/***/ }),
-/* 888 */
+/* 880 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var utils = module.exports;
-var path = __webpack_require__(16);
+var path = __webpack_require__(4);
/**
* Module dependencies
*/
-var Snapdragon = __webpack_require__(773);
-utils.define = __webpack_require__(849);
-utils.diff = __webpack_require__(867);
-utils.extend = __webpack_require__(850);
-utils.pick = __webpack_require__(868);
-utils.typeOf = __webpack_require__(889);
-utils.unique = __webpack_require__(744);
+var Snapdragon = __webpack_require__(765);
+utils.define = __webpack_require__(841);
+utils.diff = __webpack_require__(859);
+utils.extend = __webpack_require__(842);
+utils.pick = __webpack_require__(860);
+utils.typeOf = __webpack_require__(881);
+utils.unique = __webpack_require__(736);
/**
* Returns true if the platform is windows, or `path.sep` is `\\`.
@@ -104430,7 +104086,7 @@ utils.unixify = function(options) {
/***/ }),
-/* 889 */
+/* 881 */
/***/ (function(module, exports) {
var toString = Object.prototype.toString;
@@ -104565,7 +104221,7 @@ function isBuffer(val) {
/***/ }),
-/* 890 */
+/* 882 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -104584,9 +104240,9 @@ var __extends = (this && this.__extends) || (function () {
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
-var readdir = __webpack_require__(891);
-var reader_1 = __webpack_require__(904);
-var fs_stream_1 = __webpack_require__(908);
+var readdir = __webpack_require__(883);
+var reader_1 = __webpack_require__(896);
+var fs_stream_1 = __webpack_require__(900);
var ReaderAsync = /** @class */ (function (_super) {
__extends(ReaderAsync, _super);
function ReaderAsync() {
@@ -104647,15 +104303,15 @@ exports.default = ReaderAsync;
/***/ }),
-/* 891 */
+/* 883 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const readdirSync = __webpack_require__(892);
-const readdirAsync = __webpack_require__(900);
-const readdirStream = __webpack_require__(903);
+const readdirSync = __webpack_require__(884);
+const readdirAsync = __webpack_require__(892);
+const readdirStream = __webpack_require__(895);
module.exports = exports = readdirAsyncPath;
exports.readdir = exports.readdirAsync = exports.async = readdirAsyncPath;
@@ -104739,7 +104395,7 @@ function readdirStreamStat (dir, options) {
/***/ }),
-/* 892 */
+/* 884 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -104747,11 +104403,11 @@ function readdirStreamStat (dir, options) {
module.exports = readdirSync;
-const DirectoryReader = __webpack_require__(893);
+const DirectoryReader = __webpack_require__(885);
let syncFacade = {
- fs: __webpack_require__(898),
- forEach: __webpack_require__(899),
+ fs: __webpack_require__(890),
+ forEach: __webpack_require__(891),
sync: true
};
@@ -104780,18 +104436,18 @@ function readdirSync (dir, options, internalOptions) {
/***/ }),
-/* 893 */
+/* 885 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const Readable = __webpack_require__(27).Readable;
-const EventEmitter = __webpack_require__(399).EventEmitter;
-const path = __webpack_require__(16);
-const normalizeOptions = __webpack_require__(894);
-const stat = __webpack_require__(896);
-const call = __webpack_require__(897);
+const Readable = __webpack_require__(382).Readable;
+const EventEmitter = __webpack_require__(373).EventEmitter;
+const path = __webpack_require__(4);
+const normalizeOptions = __webpack_require__(886);
+const stat = __webpack_require__(888);
+const call = __webpack_require__(889);
/**
* Asynchronously reads the contents of a directory and streams the results
@@ -105167,14 +104823,14 @@ module.exports = DirectoryReader;
/***/ }),
-/* 894 */
+/* 886 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const path = __webpack_require__(16);
-const globToRegExp = __webpack_require__(895);
+const path = __webpack_require__(4);
+const globToRegExp = __webpack_require__(887);
module.exports = normalizeOptions;
@@ -105351,7 +105007,7 @@ function normalizeOptions (options, internalOptions) {
/***/ }),
-/* 895 */
+/* 887 */
/***/ (function(module, exports) {
module.exports = function (glob, opts) {
@@ -105488,13 +105144,13 @@ module.exports = function (glob, opts) {
/***/ }),
-/* 896 */
+/* 888 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const call = __webpack_require__(897);
+const call = __webpack_require__(889);
module.exports = stat;
@@ -105569,7 +105225,7 @@ function symlinkStat (fs, path, lstats, callback) {
/***/ }),
-/* 897 */
+/* 889 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -105630,14 +105286,14 @@ function callOnce (fn) {
/***/ }),
-/* 898 */
+/* 890 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const fs = __webpack_require__(23);
-const call = __webpack_require__(897);
+const fs = __webpack_require__(349);
+const call = __webpack_require__(889);
/**
* A facade around {@link fs.readdirSync} that allows it to be called
@@ -105701,7 +105357,7 @@ exports.lstat = function (path, callback) {
/***/ }),
-/* 899 */
+/* 891 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -105730,7 +105386,7 @@ function syncForEach (array, iterator, done) {
/***/ }),
-/* 900 */
+/* 892 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -105738,12 +105394,12 @@ function syncForEach (array, iterator, done) {
module.exports = readdirAsync;
-const maybe = __webpack_require__(901);
-const DirectoryReader = __webpack_require__(893);
+const maybe = __webpack_require__(893);
+const DirectoryReader = __webpack_require__(885);
let asyncFacade = {
- fs: __webpack_require__(23),
- forEach: __webpack_require__(902),
+ fs: __webpack_require__(349),
+ forEach: __webpack_require__(894),
async: true
};
@@ -105785,7 +105441,7 @@ function readdirAsync (dir, options, callback, internalOptions) {
/***/ }),
-/* 901 */
+/* 893 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -105812,7 +105468,7 @@ module.exports = function maybe (cb, promise) {
/***/ }),
-/* 902 */
+/* 894 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -105848,7 +105504,7 @@ function asyncForEach (array, iterator, done) {
/***/ }),
-/* 903 */
+/* 895 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -105856,11 +105512,11 @@ function asyncForEach (array, iterator, done) {
module.exports = readdirStream;
-const DirectoryReader = __webpack_require__(893);
+const DirectoryReader = __webpack_require__(885);
let streamFacade = {
- fs: __webpack_require__(23),
- forEach: __webpack_require__(902),
+ fs: __webpack_require__(349),
+ forEach: __webpack_require__(894),
async: true
};
@@ -105880,16 +105536,16 @@ function readdirStream (dir, options, internalOptions) {
/***/ }),
-/* 904 */
+/* 896 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var path = __webpack_require__(16);
-var deep_1 = __webpack_require__(905);
-var entry_1 = __webpack_require__(907);
-var pathUtil = __webpack_require__(906);
+var path = __webpack_require__(4);
+var deep_1 = __webpack_require__(897);
+var entry_1 = __webpack_require__(899);
+var pathUtil = __webpack_require__(898);
var Reader = /** @class */ (function () {
function Reader(options) {
this.options = options;
@@ -105955,14 +105611,14 @@ exports.default = Reader;
/***/ }),
-/* 905 */
+/* 897 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var pathUtils = __webpack_require__(906);
-var patternUtils = __webpack_require__(723);
+var pathUtils = __webpack_require__(898);
+var patternUtils = __webpack_require__(715);
var DeepFilter = /** @class */ (function () {
function DeepFilter(options, micromatchOptions) {
this.options = options;
@@ -106045,13 +105701,13 @@ exports.default = DeepFilter;
/***/ }),
-/* 906 */
+/* 898 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var path = __webpack_require__(16);
+var path = __webpack_require__(4);
/**
* Returns «true» if the last partial of the path starting with a period.
*/
@@ -106076,14 +105732,14 @@ exports.makeAbsolute = makeAbsolute;
/***/ }),
-/* 907 */
+/* 899 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var pathUtils = __webpack_require__(906);
-var patternUtils = __webpack_require__(723);
+var pathUtils = __webpack_require__(898);
+var patternUtils = __webpack_require__(715);
var EntryFilter = /** @class */ (function () {
function EntryFilter(options, micromatchOptions) {
this.options = options;
@@ -106168,7 +105824,7 @@ exports.default = EntryFilter;
/***/ }),
-/* 908 */
+/* 900 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -106187,9 +105843,9 @@ var __extends = (this && this.__extends) || (function () {
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
-var stream = __webpack_require__(27);
-var fsStat = __webpack_require__(909);
-var fs_1 = __webpack_require__(913);
+var stream = __webpack_require__(382);
+var fsStat = __webpack_require__(901);
+var fs_1 = __webpack_require__(905);
var FileSystemStream = /** @class */ (function (_super) {
__extends(FileSystemStream, _super);
function FileSystemStream() {
@@ -106239,14 +105895,14 @@ exports.default = FileSystemStream;
/***/ }),
-/* 909 */
+/* 901 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const optionsManager = __webpack_require__(910);
-const statProvider = __webpack_require__(912);
+const optionsManager = __webpack_require__(902);
+const statProvider = __webpack_require__(904);
/**
* Asynchronous API.
*/
@@ -106277,13 +105933,13 @@ exports.statSync = statSync;
/***/ }),
-/* 910 */
+/* 902 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const fsAdapter = __webpack_require__(911);
+const fsAdapter = __webpack_require__(903);
function prepare(opts) {
const options = Object.assign({
fs: fsAdapter.getFileSystemAdapter(opts ? opts.fs : undefined),
@@ -106296,13 +105952,13 @@ exports.prepare = prepare;
/***/ }),
-/* 911 */
+/* 903 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __webpack_require__(23);
+const fs = __webpack_require__(349);
exports.FILE_SYSTEM_ADAPTER = {
lstat: fs.lstat,
stat: fs.stat,
@@ -106319,7 +105975,7 @@ exports.getFileSystemAdapter = getFileSystemAdapter;
/***/ }),
-/* 912 */
+/* 904 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -106371,13 +106027,13 @@ exports.isFollowedSymlink = isFollowedSymlink;
/***/ }),
-/* 913 */
+/* 905 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var path = __webpack_require__(16);
+var path = __webpack_require__(4);
var FileSystem = /** @class */ (function () {
function FileSystem(options) {
this.options = options;
@@ -106402,7 +106058,7 @@ exports.default = FileSystem;
/***/ }),
-/* 914 */
+/* 906 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -106421,10 +106077,10 @@ var __extends = (this && this.__extends) || (function () {
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
-var stream = __webpack_require__(27);
-var readdir = __webpack_require__(891);
-var reader_1 = __webpack_require__(904);
-var fs_stream_1 = __webpack_require__(908);
+var stream = __webpack_require__(382);
+var readdir = __webpack_require__(883);
+var reader_1 = __webpack_require__(896);
+var fs_stream_1 = __webpack_require__(900);
var TransformStream = /** @class */ (function (_super) {
__extends(TransformStream, _super);
function TransformStream(reader) {
@@ -106492,7 +106148,7 @@ exports.default = ReaderStream;
/***/ }),
-/* 915 */
+/* 907 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -106511,9 +106167,9 @@ var __extends = (this && this.__extends) || (function () {
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
-var readdir = __webpack_require__(891);
-var reader_1 = __webpack_require__(904);
-var fs_sync_1 = __webpack_require__(916);
+var readdir = __webpack_require__(883);
+var reader_1 = __webpack_require__(896);
+var fs_sync_1 = __webpack_require__(908);
var ReaderSync = /** @class */ (function (_super) {
__extends(ReaderSync, _super);
function ReaderSync() {
@@ -106573,7 +106229,7 @@ exports.default = ReaderSync;
/***/ }),
-/* 916 */
+/* 908 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -106592,8 +106248,8 @@ var __extends = (this && this.__extends) || (function () {
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
-var fsStat = __webpack_require__(909);
-var fs_1 = __webpack_require__(913);
+var fsStat = __webpack_require__(901);
+var fs_1 = __webpack_require__(905);
var FileSystemSync = /** @class */ (function (_super) {
__extends(FileSystemSync, _super);
function FileSystemSync() {
@@ -106639,7 +106295,7 @@ exports.default = FileSystemSync;
/***/ }),
-/* 917 */
+/* 909 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -106655,13 +106311,13 @@ exports.flatten = flatten;
/***/ }),
-/* 918 */
+/* 910 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
-var merge2 = __webpack_require__(590);
+var merge2 = __webpack_require__(585);
/**
* Merge multiple streams and propagate their errors into one stream in parallel.
*/
@@ -106676,13 +106332,13 @@ exports.merge = merge;
/***/ }),
-/* 919 */
+/* 911 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const path = __webpack_require__(16);
-const pathType = __webpack_require__(920);
+const path = __webpack_require__(4);
+const pathType = __webpack_require__(912);
const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0];
@@ -106748,13 +106404,13 @@ module.exports.sync = (input, opts) => {
/***/ }),
-/* 920 */
+/* 912 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const fs = __webpack_require__(23);
-const pify = __webpack_require__(921);
+const fs = __webpack_require__(349);
+const pify = __webpack_require__(913);
function type(fn, fn2, fp) {
if (typeof fp !== 'string') {
@@ -106797,7 +106453,7 @@ exports.symlinkSync = typeSync.bind(null, 'lstatSync', 'isSymbolicLink');
/***/ }),
-/* 921 */
+/* 913 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -106888,17 +106544,17 @@ module.exports = (obj, opts) => {
/***/ }),
-/* 922 */
+/* 914 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const fs = __webpack_require__(23);
-const path = __webpack_require__(16);
-const fastGlob = __webpack_require__(719);
-const gitIgnore = __webpack_require__(923);
-const pify = __webpack_require__(924);
-const slash = __webpack_require__(925);
+const fs = __webpack_require__(349);
+const path = __webpack_require__(4);
+const fastGlob = __webpack_require__(711);
+const gitIgnore = __webpack_require__(915);
+const pify = __webpack_require__(916);
+const slash = __webpack_require__(917);
const DEFAULT_IGNORE = [
'**/node_modules/**',
@@ -106996,7 +106652,7 @@ module.exports.sync = options => {
/***/ }),
-/* 923 */
+/* 915 */
/***/ (function(module, exports) {
// A simple implementation of make-array
@@ -107465,7 +107121,7 @@ module.exports = options => new IgnoreBase(options)
/***/ }),
-/* 924 */
+/* 916 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -107540,7 +107196,7 @@ module.exports = (input, options) => {
/***/ }),
-/* 925 */
+/* 917 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -107558,17 +107214,17 @@ module.exports = input => {
/***/ }),
-/* 926 */
+/* 918 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const path = __webpack_require__(16);
-const {constants: fsConstants} = __webpack_require__(23);
-const pEvent = __webpack_require__(927);
-const CpFileError = __webpack_require__(930);
-const fs = __webpack_require__(934);
-const ProgressEmitter = __webpack_require__(937);
+const path = __webpack_require__(4);
+const {constants: fsConstants} = __webpack_require__(349);
+const pEvent = __webpack_require__(919);
+const CpFileError = __webpack_require__(922);
+const fs = __webpack_require__(926);
+const ProgressEmitter = __webpack_require__(929);
const cpFileAsync = async (source, destination, options, progressEmitter) => {
let readError;
@@ -107682,12 +107338,12 @@ module.exports.sync = (source, destination, options) => {
/***/ }),
-/* 927 */
+/* 919 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const pTimeout = __webpack_require__(928);
+const pTimeout = __webpack_require__(920);
const symbolAsyncIterator = Symbol.asyncIterator || '@@asyncIterator';
@@ -107978,12 +107634,12 @@ module.exports.iterator = (emitter, event, options) => {
/***/ }),
-/* 928 */
+/* 920 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const pFinally = __webpack_require__(929);
+const pFinally = __webpack_require__(921);
class TimeoutError extends Error {
constructor(message) {
@@ -108029,7 +107685,7 @@ module.exports.TimeoutError = TimeoutError;
/***/ }),
-/* 929 */
+/* 921 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -108051,12 +107707,12 @@ module.exports = (promise, onFinally) => {
/***/ }),
-/* 930 */
+/* 922 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const NestedError = __webpack_require__(931);
+const NestedError = __webpack_require__(923);
class CpFileError extends NestedError {
constructor(message, nested) {
@@ -108070,10 +107726,10 @@ module.exports = CpFileError;
/***/ }),
-/* 931 */
+/* 923 */
/***/ (function(module, exports, __webpack_require__) {
-var inherits = __webpack_require__(932);
+var inherits = __webpack_require__(924);
var NestedError = function (message, nested) {
this.nested = nested;
@@ -108124,20 +107780,20 @@ module.exports = NestedError;
/***/ }),
-/* 932 */
+/* 924 */
/***/ (function(module, exports, __webpack_require__) {
try {
- var util = __webpack_require__(29);
+ var util = __webpack_require__(397);
if (typeof util.inherits !== 'function') throw '';
module.exports = util.inherits;
} catch (e) {
- module.exports = __webpack_require__(933);
+ module.exports = __webpack_require__(925);
}
/***/ }),
-/* 933 */
+/* 925 */
/***/ (function(module, exports) {
if (typeof Object.create === 'function') {
@@ -108166,16 +107822,16 @@ if (typeof Object.create === 'function') {
/***/ }),
-/* 934 */
+/* 926 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const {promisify} = __webpack_require__(29);
-const fs = __webpack_require__(22);
-const makeDir = __webpack_require__(935);
-const pEvent = __webpack_require__(927);
-const CpFileError = __webpack_require__(930);
+const {promisify} = __webpack_require__(397);
+const fs = __webpack_require__(493);
+const makeDir = __webpack_require__(927);
+const pEvent = __webpack_require__(919);
+const CpFileError = __webpack_require__(922);
const stat = promisify(fs.stat);
const lstat = promisify(fs.lstat);
@@ -108272,15 +107928,15 @@ exports.copyFileSync = (source, destination, flags) => {
/***/ }),
-/* 935 */
+/* 927 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const fs = __webpack_require__(23);
-const path = __webpack_require__(16);
-const {promisify} = __webpack_require__(29);
-const semver = __webpack_require__(936);
+const fs = __webpack_require__(349);
+const path = __webpack_require__(4);
+const {promisify} = __webpack_require__(397);
+const semver = __webpack_require__(928);
const defaults = {
mode: 0o777 & (~process.umask()),
@@ -108429,7 +108085,7 @@ module.exports.sync = (input, options) => {
/***/ }),
-/* 936 */
+/* 928 */
/***/ (function(module, exports) {
exports = module.exports = SemVer
@@ -110031,12 +109687,12 @@ function coerce (version, options) {
/***/ }),
-/* 937 */
+/* 929 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const EventEmitter = __webpack_require__(399);
+const EventEmitter = __webpack_require__(373);
const written = new WeakMap();
@@ -110072,7 +109728,7 @@ module.exports = ProgressEmitter;
/***/ }),
-/* 938 */
+/* 930 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
@@ -110118,12 +109774,12 @@ exports.default = module.exports;
/***/ }),
-/* 939 */
+/* 931 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
-const NestedError = __webpack_require__(940);
+const NestedError = __webpack_require__(932);
class CpyError extends NestedError {
constructor(message, nested) {
@@ -110137,10 +109793,10 @@ module.exports = CpyError;
/***/ }),
-/* 940 */
+/* 932 */
/***/ (function(module, exports, __webpack_require__) {
-var inherits = __webpack_require__(29).inherits;
+var inherits = __webpack_require__(397).inherits;
var NestedError = function (message, nested) {
this.nested = nested;
@@ -110193,7 +109849,7 @@ module.exports = NestedError;
/***/ }),
-/* 941 */
+/* 933 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
diff --git a/packages/kbn-pm/package.json b/packages/kbn-pm/package.json
index 234877e9ae626..301d9653cda2b 100644
--- a/packages/kbn-pm/package.json
+++ b/packages/kbn-pm/package.json
@@ -22,7 +22,6 @@
"@types/glob": "^5.0.35",
"@types/globby": "^6.1.0",
"@types/has-ansi": "^3.0.0",
- "@types/indent-string": "^3.0.0",
"@types/lodash.clonedeepwith": "^4.5.3",
"@types/log-symbols": "^2.0.0",
"@types/ncp": "^2.0.1",
@@ -32,7 +31,6 @@
"@types/strip-ansi": "^3.0.0",
"@types/strong-log-transformer": "^1.0.0",
"@types/tempy": "^0.2.0",
- "@types/wrap-ansi": "^2.0.15",
"@types/write-pkg": "^3.1.0",
"@kbn/dev-utils": "1.0.0",
"@yarnpkg/lockfile": "^1.1.0",
@@ -42,12 +40,11 @@
"cpy": "^8.0.0",
"dedent": "^0.7.0",
"del": "^5.1.0",
- "execa": "^4.0.0",
+ "execa": "^4.0.2",
"getopts": "^2.2.4",
"glob": "^7.1.2",
"globby": "^8.0.1",
"has-ansi": "^3.0.0",
- "indent-string": "^3.2.0",
"is-path-inside": "^3.0.2",
"lodash.clonedeepwith": "^4.5.0",
"log-symbols": "^2.2.0",
@@ -66,7 +63,6 @@
"unlazy-loader": "^0.1.3",
"webpack": "^4.41.5",
"webpack-cli": "^3.3.10",
- "wrap-ansi": "^3.0.1",
"write-pkg": "^4.0.0"
},
"dependencies": {
diff --git a/packages/kbn-pm/src/cli.ts b/packages/kbn-pm/src/cli.ts
index 94f348e1835ed..b72e9ae8690aa 100644
--- a/packages/kbn-pm/src/cli.ts
+++ b/packages/kbn-pm/src/cli.ts
@@ -17,46 +17,58 @@
* under the License.
*/
-import chalk from 'chalk';
import dedent from 'dedent';
import getopts from 'getopts';
import { resolve } from 'path';
+import { pickLevelFromFlags } from '@kbn/dev-utils';
import { commands } from './commands';
import { runCommand } from './run';
import { log } from './utils/log';
function help() {
- const availableCommands = Object.keys(commands)
- .map((commandName) => commands[commandName])
- .map((command) => `${command.name} - ${command.description}`);
-
- log.write(dedent`
- usage: kbn []
-
- By default commands are run for Kibana itself, all packages in the 'packages/'
- folder and for all plugins in './plugins' and '../kibana-extra'.
-
- Available commands:
-
- ${availableCommands.join('\n ')}
-
- Global options:
-
- -e, --exclude Exclude specified project. Can be specified multiple times to exclude multiple projects, e.g. '-e kibana -e @kbn/pm'.
- -i, --include Include only specified projects. If left unspecified, it defaults to including all projects.
- --oss Do not include the x-pack when running command.
- --skip-kibana-plugins Filter all plugins in ./plugins and ../kibana-extra when running command.
- --no-cache Disable the bootstrap cache
- `);
+ log.info(
+ dedent`
+ usage: kbn []
+
+ By default commands are run for Kibana itself, all packages in the 'packages/'
+ folder and for all plugins in './plugins' and '../kibana-extra'.
+
+ Available commands:
+
+ ${Object.values(commands)
+ .map((command) => `${command.name} - ${command.description}`)
+ .join('\n ')}
+
+ Global options:
+
+ -e, --exclude Exclude specified project. Can be specified multiple times to exclude multiple projects, e.g. '-e kibana -e @kbn/pm'.
+ -i, --include Include only specified projects. If left unspecified, it defaults to including all projects.
+ --oss Do not include the x-pack when running command.
+ --skip-kibana-plugins Filter all plugins in ./plugins and ../kibana-extra when running command.
+ --no-cache Disable the bootstrap cache
+ --verbose Set log level to verbose
+ --debug Set log level to debug
+ --quiet Set log level to error
+ --silent Disable log output
+ ` + '\n'
+ );
}
export async function run(argv: string[]) {
+ log.setLogLevel(
+ pickLevelFromFlags(
+ getopts(argv, {
+ boolean: ['verbose', 'debug', 'quiet', 'silent'],
+ })
+ )
+ );
+
// We can simplify this setup (and remove this extra handling) once Yarn
// starts forwarding the `--` directly to this script, see
// https://github.com/yarnpkg/yarn/blob/b2d3e1a8fe45ef376b716d597cc79b38702a9320/src/cli/index.js#L174-L182
if (argv.includes('--')) {
- log.write(chalk.red(`Using "--" is not allowed, as it doesn't work with 'yarn kbn'.`));
+ log.error(`Using "--" is not allowed, as it doesn't work with 'yarn kbn'.`);
process.exit(1);
}
@@ -90,7 +102,7 @@ export async function run(argv: string[]) {
const command = commands[commandName];
if (command === undefined) {
- log.write(chalk.red(`[${commandName}] is not a valid command, see 'kbn --help'`));
+ log.error(`[${commandName}] is not a valid command, see 'kbn --help'`);
process.exit(1);
}
diff --git a/packages/kbn-pm/src/commands/__snapshots__/bootstrap.test.ts.snap b/packages/kbn-pm/src/commands/__snapshots__/bootstrap.test.ts.snap
index c0505710f5670..be146d710c87a 100644
--- a/packages/kbn-pm/src/commands/__snapshots__/bootstrap.test.ts.snap
+++ b/packages/kbn-pm/src/commands/__snapshots__/bootstrap.test.ts.snap
@@ -90,29 +90,32 @@ Array [
exports[`calls "kbn:bootstrap" scripts and links executables after installing deps: script 1`] = `
Array [
Array [
- "kbn:bootstrap",
- Array [],
- Project {
- "allDependencies": Object {},
- "devDependencies": Object {},
- "isWorkspaceProject": false,
- "isWorkspaceRoot": false,
- "json": Object {
- "name": "bar",
+ Object {
+ "args": Array [],
+ "debug": undefined,
+ "pkg": Project {
+ "allDependencies": Object {},
+ "devDependencies": Object {},
+ "isWorkspaceProject": false,
+ "isWorkspaceRoot": false,
+ "json": Object {
+ "name": "bar",
+ "scripts": Object {
+ "kbn:bootstrap": "node ./bar.js",
+ },
+ "version": "1.0.0",
+ },
+ "nodeModulesLocation": "/packages/kbn-pm/src/commands/packages/bar/node_modules",
+ "packageJsonLocation": "/packages/kbn-pm/src/commands/packages/bar/package.json",
+ "path": "/packages/kbn-pm/src/commands/packages/bar",
+ "productionDependencies": Object {},
"scripts": Object {
"kbn:bootstrap": "node ./bar.js",
},
+ "targetLocation": "/packages/kbn-pm/src/commands/packages/bar/target",
"version": "1.0.0",
},
- "nodeModulesLocation": "/packages/kbn-pm/src/commands/packages/bar/node_modules",
- "packageJsonLocation": "/packages/kbn-pm/src/commands/packages/bar/package.json",
- "path": "/packages/kbn-pm/src/commands/packages/bar",
- "productionDependencies": Object {},
- "scripts": Object {
- "kbn:bootstrap": "node ./bar.js",
- },
- "targetLocation": "/packages/kbn-pm/src/commands/packages/bar/target",
- "version": "1.0.0",
+ "script": "kbn:bootstrap",
},
],
]
@@ -127,36 +130,6 @@ Array [
]
`;
-exports[`does not run installer if no deps in package: logs 1`] = `
-Array [
- Array [
- "
-Running installs in topological order:",
- ],
- Array [
- "
-
-Installing dependencies in [kibana]:
-",
- ],
- Array [
- "
-Installs completed, linking package executables:
-",
- ],
- Array [
- "
-Linking executables completed, running \`kbn:bootstrap\` scripts
-",
- ],
- Array [
- "
-Bootstrapping completed!
-",
- ],
-]
-`;
-
exports[`handles "frozen-lockfile": install in dir 1`] = `
Array [
Array [
@@ -184,45 +157,3 @@ Array [
],
]
`;
-
-exports[`handles dependencies of dependencies: logs 1`] = `
-Array [
- Array [
- "
-Running installs in topological order:",
- ],
- Array [
- "
-
-Installing dependencies in [kibana]:
-",
- ],
- Array [
- "
-
-Installing dependencies in [bar]:
-",
- ],
- Array [
- "
-
-Installing dependencies in [foo]:
-",
- ],
- Array [
- "
-Installs completed, linking package executables:
-",
- ],
- Array [
- "
-Linking executables completed, running \`kbn:bootstrap\` scripts
-",
- ],
- Array [
- "
-Bootstrapping completed!
-",
- ],
-]
-`;
diff --git a/packages/kbn-pm/src/commands/bootstrap.test.ts b/packages/kbn-pm/src/commands/bootstrap.test.ts
index 072f34611f8fc..d6a30f0ef33d6 100644
--- a/packages/kbn-pm/src/commands/bootstrap.test.ts
+++ b/packages/kbn-pm/src/commands/bootstrap.test.ts
@@ -22,6 +22,8 @@ jest.mock('../utils/link_project_executables');
import { resolve } from 'path';
+import { ToolingLogCollectingWriter } from '@kbn/dev-utils';
+
import { absolutePathSnapshotSerializer, stripAnsiSnapshotSerializer } from '../test_helpers';
import { linkProjectExecutables } from '../utils/link_project_executables';
import { IPackageJson } from '../utils/package_json';
@@ -30,12 +32,20 @@ import { buildProjectGraph } from '../utils/projects';
import { installInDir, runScriptInPackageStreaming, yarnWorkspacesInfo } from '../utils/scripts';
import { BootstrapCommand } from './bootstrap';
import { Kibana } from '../utils/kibana';
+import { log } from '../utils/log';
const mockInstallInDir = installInDir as jest.Mock;
const mockRunScriptInPackageStreaming = runScriptInPackageStreaming as jest.Mock;
const mockLinkProjectExecutables = linkProjectExecutables as jest.Mock;
const mockYarnWorkspacesInfo = yarnWorkspacesInfo as jest.Mock;
+const logWriter = new ToolingLogCollectingWriter('debug');
+log.setLogLevel('silent');
+log.setWriters([logWriter]);
+beforeEach(() => {
+ logWriter.messages.length = 0;
+});
+
const createProject = (packageJson: IPackageJson, path = '.') => {
const project = new Project(
{
@@ -55,10 +65,6 @@ const createProject = (packageJson: IPackageJson, path = '.') => {
expect.addSnapshotSerializer(absolutePathSnapshotSerializer);
expect.addSnapshotSerializer(stripAnsiSnapshotSerializer);
-const noop = () => {
- // noop
-};
-
beforeEach(() => {
mockYarnWorkspacesInfo.mockResolvedValue({});
});
@@ -111,8 +117,6 @@ test('handles dependencies of dependencies', async () => {
const kbn = new Kibana(projects);
const projectGraph = buildProjectGraph(projects);
- const logMock = jest.spyOn(console, 'log').mockImplementation(noop);
-
await BootstrapCommand.run(projects, projectGraph, {
extraArgs: [],
options: {},
@@ -121,7 +125,19 @@ test('handles dependencies of dependencies', async () => {
});
expect(mockInstallInDir.mock.calls).toMatchSnapshot('install in dir');
- expect(logMock.mock.calls).toMatchSnapshot('logs');
+ expect(logWriter.messages).toMatchInlineSnapshot(`
+ Array [
+ " info [kibana] running yarn",
+ "",
+ "",
+ " info [bar] running yarn",
+ "",
+ "",
+ " info [foo] running yarn",
+ "",
+ "",
+ ]
+ `);
});
test('does not run installer if no deps in package', async () => {
@@ -148,8 +164,6 @@ test('does not run installer if no deps in package', async () => {
const kbn = new Kibana(projects);
const projectGraph = buildProjectGraph(projects);
- const logMock = jest.spyOn(console, 'log').mockImplementation(noop);
-
await BootstrapCommand.run(projects, projectGraph, {
extraArgs: [],
options: {},
@@ -158,7 +172,13 @@ test('does not run installer if no deps in package', async () => {
});
expect(mockInstallInDir.mock.calls).toMatchSnapshot('install in dir');
- expect(logMock.mock.calls).toMatchSnapshot('logs');
+ expect(logWriter.messages).toMatchInlineSnapshot(`
+ Array [
+ " info [kibana] running yarn",
+ "",
+ "",
+ ]
+ `);
});
test('handles "frozen-lockfile"', async () => {
@@ -175,8 +195,6 @@ test('handles "frozen-lockfile"', async () => {
const kbn = new Kibana(projects);
const projectGraph = buildProjectGraph(projects);
- jest.spyOn(console, 'log').mockImplementation(noop);
-
await BootstrapCommand.run(projects, projectGraph, {
extraArgs: [],
options: {
@@ -215,8 +233,6 @@ test('calls "kbn:bootstrap" scripts and links executables after installing deps'
const kbn = new Kibana(projects);
const projectGraph = buildProjectGraph(projects);
- jest.spyOn(console, 'log').mockImplementation(noop);
-
await BootstrapCommand.run(projects, projectGraph, {
extraArgs: [],
options: {},
diff --git a/packages/kbn-pm/src/commands/bootstrap.ts b/packages/kbn-pm/src/commands/bootstrap.ts
index 6146aeab21db4..80ccc5daecc56 100644
--- a/packages/kbn-pm/src/commands/bootstrap.ts
+++ b/packages/kbn-pm/src/commands/bootstrap.ts
@@ -17,12 +17,11 @@
* under the License.
*/
-import chalk from 'chalk';
-
import { linkProjectExecutables } from '../utils/link_project_executables';
import { log } from '../utils/log';
import { parallelizeBatches } from '../utils/parallelize';
import { topologicallyBatchProjects } from '../utils/projects';
+import { Project } from '../utils/project';
import { ICommand } from './';
import { getAllChecksums } from '../utils/project_checksums';
import { BootstrapCacheFile } from '../utils/bootstrap_cache_file';
@@ -42,12 +41,10 @@ export const BootstrapCommand: ICommand = {
...(options['prefer-offline'] === true ? ['--prefer-offline'] : []),
];
- log.write(chalk.bold('\nRunning installs in topological order:'));
-
for (const batch of batchedProjectsByWorkspace) {
for (const project of batch) {
if (project.isWorkspaceProject) {
- log.write(`Skipping workspace project: ${project.name}`);
+ log.verbose(`Skipping workspace project: ${project.name}`);
continue;
}
@@ -57,7 +54,6 @@ export const BootstrapCommand: ICommand = {
}
}
- log.write(chalk.bold('\nInstalls completed, linking package executables:\n'));
await linkProjectExecutables(projects, projectGraph);
/**
@@ -66,22 +62,38 @@ export const BootstrapCommand: ICommand = {
* transpiled before they can be used. Ideally we shouldn't do this unless we
* have to, as it will slow down the bootstrapping process.
*/
- log.write(chalk.bold('\nLinking executables completed, running `kbn:bootstrap` scripts\n'));
- const checksums = options.cache ? await getAllChecksums(kbn, log) : false;
- await parallelizeBatches(batchedProjects, async (project) => {
+ const checksums = await getAllChecksums(kbn, log);
+ const caches = new Map();
+ let cachedProjectCount = 0;
+
+ for (const project of projects.values()) {
if (project.hasScript('kbn:bootstrap')) {
- const cacheFile = new BootstrapCacheFile(kbn, project, checksums);
- if (cacheFile.isValid()) {
- log.success(`[${project.name}] cache up to date`);
- } else {
- cacheFile.delete();
- await project.runScriptStreaming('kbn:bootstrap');
- cacheFile.write();
+ const file = new BootstrapCacheFile(kbn, project, checksums);
+ const valid = options.cache && file.isValid();
+
+ if (valid) {
+ log.debug(`[${project.name}] cache up to date`);
}
+
+ caches.set(project, { file, valid });
+ cachedProjectCount += 1;
}
- });
+ }
+
+ if (cachedProjectCount > 0) {
+ log.success(`${cachedProjectCount} bootsrap builds are cached`);
+ }
- log.write(chalk.green.bold('\nBootstrapping completed!\n'));
+ await parallelizeBatches(batchedProjects, async (project) => {
+ const cache = caches.get(project);
+ if (cache && !cache.valid) {
+ log.info(`[${project.name}] running [kbn:bootstrap] script`);
+ cache.file.delete();
+ await project.runScriptStreaming('kbn:bootstrap');
+ cache.file.write();
+ log.success(`[${project.name}] bootstrap complete`);
+ }
+ });
},
};
diff --git a/packages/kbn-pm/src/commands/clean.ts b/packages/kbn-pm/src/commands/clean.ts
index b3d433e22bd79..26d6897992501 100644
--- a/packages/kbn-pm/src/commands/clean.ts
+++ b/packages/kbn-pm/src/commands/clean.ts
@@ -17,7 +17,6 @@
* under the License.
*/
-import chalk from 'chalk';
import del from 'del';
import ora from 'ora';
import { join, relative } from 'path';
@@ -57,10 +56,8 @@ export const CleanCommand: ICommand = {
}
if (toDelete.length === 0) {
- log.write(chalk.bold.green('\n\nNothing to delete'));
+ log.success('Nothing to delete');
} else {
- log.write(chalk.bold.red('\n\nDeleting:\n'));
-
/**
* In order to avoid patterns like `/build` in packages from accidentally
* impacting files outside the package we use `process.chdir()` to change
@@ -75,7 +72,11 @@ export const CleanCommand: ICommand = {
for (const { pattern, cwd } of toDelete) {
process.chdir(cwd);
const promise = del(pattern);
- ora.promise(promise, relative(originalCwd, join(cwd, String(pattern))));
+
+ if (log.wouldLogLevel('info')) {
+ ora.promise(promise, relative(originalCwd, join(cwd, String(pattern))));
+ }
+
await promise;
}
} finally {
diff --git a/packages/kbn-pm/src/commands/run.ts b/packages/kbn-pm/src/commands/run.ts
index 989bfef19c380..1c6760ed6f3ee 100644
--- a/packages/kbn-pm/src/commands/run.ts
+++ b/packages/kbn-pm/src/commands/run.ts
@@ -17,8 +17,7 @@
* under the License.
*/
-import chalk from 'chalk';
-
+import { CliError } from '../utils/errors';
import { log } from '../utils/log';
import { parallelizeBatches } from '../utils/parallelize';
import { topologicallyBatchProjects } from '../utils/projects';
@@ -32,20 +31,19 @@ export const RunCommand: ICommand = {
const batchedProjects = topologicallyBatchProjects(projects, projectGraph);
if (extraArgs.length === 0) {
- log.write(chalk.red.bold('\nNo script specified'));
- process.exit(1);
+ throw new CliError('No script specified');
}
const scriptName = extraArgs[0];
const scriptArgs = extraArgs.slice(1);
- log.write(
- chalk.bold(`\nRunning script [${chalk.green(scriptName)}] in batched topological order\n`)
- );
-
- await parallelizeBatches(batchedProjects, async (pkg) => {
- if (pkg.hasScript(scriptName)) {
- await pkg.runScriptStreaming(scriptName, scriptArgs);
+ await parallelizeBatches(batchedProjects, async (project) => {
+ if (project.hasScript(scriptName)) {
+ log.info(`[${project.name}] running "${scriptName}" script`);
+ await project.runScriptStreaming(scriptName, {
+ args: scriptArgs,
+ });
+ log.success(`[${project.name}] complete`);
}
});
},
diff --git a/packages/kbn-pm/src/commands/watch.ts b/packages/kbn-pm/src/commands/watch.ts
index 2e18b02a1c860..6775f728c1494 100644
--- a/packages/kbn-pm/src/commands/watch.ts
+++ b/packages/kbn-pm/src/commands/watch.ts
@@ -17,7 +17,7 @@
* under the License.
*/
-import chalk from 'chalk';
+import { CliError } from '../utils/errors';
import { log } from '../utils/log';
import { parallelizeBatches } from '../utils/parallelize';
import { ProjectMap, topologicallyBatchProjects } from '../utils/projects';
@@ -58,20 +58,13 @@ export const WatchCommand: ICommand = {
}
if (projectsToWatch.size === 0) {
- log.write(
- chalk.red(
- `\nThere are no projects to watch found. Make sure that projects define 'kbn:watch' script in 'package.json'.\n`
- )
+ throw new CliError(
+ `There are no projects to watch found. Make sure that projects define 'kbn:watch' script in 'package.json'.`
);
- return;
}
const projectNames = Array.from(projectsToWatch.keys());
- log.write(
- chalk.bold(
- chalk.green(`Running ${watchScriptName} scripts for [${projectNames.join(', ')}].`)
- )
- );
+ log.info(`Running ${watchScriptName} scripts for [${projectNames.join(', ')}].`);
// Kibana should always be run the last, so we don't rely on automatic
// topological batching and push it to the last one-entry batch manually.
@@ -85,12 +78,12 @@ export const WatchCommand: ICommand = {
await parallelizeBatches(batchedProjects, async (pkg) => {
const completionHint = await waitUntilWatchIsReady(
- pkg.runScriptStreaming(watchScriptName).stdout
+ pkg.runScriptStreaming(watchScriptName, {
+ debug: false,
+ }).stdout
);
- log.write(
- chalk.bold(`[${chalk.green(pkg.name)}] Initial build completed (${completionHint}).`)
- );
+ log.success(`[${pkg.name}] Initial build completed (${completionHint}).`);
});
},
};
diff --git a/packages/kbn-pm/src/production/build_production_projects.ts b/packages/kbn-pm/src/production/build_production_projects.ts
index 689bf51cd7bdf..f5c59fd582c59 100644
--- a/packages/kbn-pm/src/production/build_production_projects.ts
+++ b/packages/kbn-pm/src/production/build_production_projects.ts
@@ -47,7 +47,7 @@ export async function buildProductionProjects({
const batchedProjects = topologicallyBatchProjects(projects, projectGraph);
const projectNames = [...projects.values()].map((project) => project.name);
- log.write(`Preparing production build for [${projectNames.join(', ')}]`);
+ log.info(`Preparing production build for [${projectNames.join(', ')}]`);
for (const batch of batchedProjects) {
for (const project of batch) {
diff --git a/packages/kbn-pm/src/run.test.ts b/packages/kbn-pm/src/run.test.ts
index ff0dc2666afea..b2479af3809c4 100644
--- a/packages/kbn-pm/src/run.test.ts
+++ b/packages/kbn-pm/src/run.test.ts
@@ -18,9 +18,13 @@
*/
import { resolve } from 'path';
+
import { ICommand, ICommandConfig } from './commands';
import { runCommand } from './run';
import { Project } from './utils/project';
+import { log } from './utils/log';
+
+log.setLogLevel('silent');
const rootPath = resolve(`${__dirname}/utils/__fixtures__/kibana`);
@@ -51,11 +55,6 @@ beforeEach(() => {
options: {},
rootPath,
};
-
- // Reduce the noise that comes from the run command.
- jest.spyOn(console, 'log').mockImplementation(() => {
- // noop
- });
});
test('passes all found projects to the command if no filter is specified', async () => {
diff --git a/packages/kbn-pm/src/run.ts b/packages/kbn-pm/src/run.ts
index c3879c701d785..04286590bd821 100644
--- a/packages/kbn-pm/src/run.ts
+++ b/packages/kbn-pm/src/run.ts
@@ -17,10 +17,6 @@
* under the License.
*/
-import chalk from 'chalk';
-import indentString from 'indent-string';
-import wrapAnsi from 'wrap-ansi';
-
import { ICommand, ICommandConfig } from './commands';
import { CliError } from './utils/errors';
import { log } from './utils/log';
@@ -30,11 +26,7 @@ import { Kibana } from './utils/kibana';
export async function runCommand(command: ICommand, config: Omit) {
try {
- log.write(
- chalk.bold(
- `Running [${chalk.green(command.name)}] command from [${chalk.yellow(config.rootPath)}]:\n`
- )
- );
+ log.debug(`Running [${command.name}] command from [${config.rootPath}]`);
const kbn = await Kibana.loadFrom(config.rootPath);
const projects = kbn.getFilteredProjects({
@@ -45,42 +37,39 @@ export async function runCommand(command: ICommand, config: Omit 0) {
- const metaOutput = keys.map((key) => {
- const value = e.meta[key];
- return `${key}: ${value}`;
- });
+ const metaOutput = Object.entries(error.meta)
+ .map(([key, value]) => `${key}: ${value}`)
+ .join('\n');
- log.write('Additional debugging info:\n');
- log.write(indentString(metaOutput.join('\n'), 3));
+ if (metaOutput) {
+ log.info('Additional debugging info:\n');
+ log.indent(2);
+ log.info(metaOutput);
+ log.indent(-2);
}
} else {
- log.write(e.stack);
+ log.error(error);
}
process.exit(1);
diff --git a/packages/kbn-pm/src/utils/__snapshots__/link_project_executables.test.ts.snap b/packages/kbn-pm/src/utils/__snapshots__/link_project_executables.test.ts.snap
index 62091205b01a4..5bda7b544e201 100644
--- a/packages/kbn-pm/src/utils/__snapshots__/link_project_executables.test.ts.snap
+++ b/packages/kbn-pm/src/utils/__snapshots__/link_project_executables.test.ts.snap
@@ -68,14 +68,3 @@ Object {
"unlink": Array [],
}
`;
-
-exports[`bin script points to a file creates a symlink in the project node_modules/.bin directory: logs 1`] = `
-Array [
- Array [
- "[foo] bar -> ../bar/bin/bar.js",
- ],
- Array [
- "[baz] bar -> ../bar/bin/bar.js",
- ],
-]
-`;
diff --git a/packages/kbn-pm/src/utils/child_process.ts b/packages/kbn-pm/src/utils/child_process.ts
index 784446924a8dc..bafe2bf57adc2 100644
--- a/packages/kbn-pm/src/utils/child_process.ts
+++ b/packages/kbn-pm/src/utils/child_process.ts
@@ -17,19 +17,20 @@
* under the License.
*/
+import { Writable } from 'stream';
+
import chalk from 'chalk';
import execa from 'execa';
-import logSymbols from 'log-symbols';
import logTransformer from 'strong-log-transformer';
-function generateColors() {
- const colorWheel = [chalk.cyan, chalk.magenta, chalk.blue, chalk.yellow, chalk.green];
-
- const count = colorWheel.length;
- let children = 0;
+import { log } from './log';
- return () => colorWheel[children++ % count];
-}
+const colorWheel = [chalk.cyan, chalk.magenta, chalk.blue, chalk.yellow, chalk.green];
+const getColor = () => {
+ const color = colorWheel.shift()!;
+ colorWheel.push(color);
+ return color;
+};
export function spawn(command: string, args: string[], opts: execa.Options) {
return execa(command, args, {
@@ -39,13 +40,26 @@ export function spawn(command: string, args: string[], opts: execa.Options) {
});
}
-const nextColor = generateColors();
+function streamToLog(debug: boolean = true) {
+ return new Writable({
+ objectMode: true,
+ write(line, _, cb) {
+ if (line.endsWith('\n')) {
+ log[debug ? 'debug' : 'write'](line.slice(0, -1));
+ } else {
+ log[debug ? 'debug' : 'write'](line);
+ }
+
+ cb();
+ },
+ });
+}
export function spawnStreaming(
command: string,
args: string[],
opts: execa.Options,
- { prefix }: { prefix: string }
+ { prefix, debug }: { prefix: string; debug?: boolean }
) {
const spawned = execa(command, args, {
stdio: ['ignore', 'pipe', 'pipe'],
@@ -53,15 +67,12 @@ export function spawnStreaming(
...opts,
});
- const color = nextColor();
- const prefixedStdout = logTransformer({ tag: `${color.bold(prefix)}:` });
- const prefixedStderr = logTransformer({
- mergeMultiline: true,
- tag: `${logSymbols.error} ${color.bold(prefix)}:`,
- });
+ const color = getColor();
+ const prefixedStdout = logTransformer({ tag: color.bold(prefix) });
+ const prefixedStderr = logTransformer({ mergeMultiline: true, tag: color.bold(prefix) });
- spawned.stdout.pipe(prefixedStdout).pipe(process.stdout);
- spawned.stderr.pipe(prefixedStderr).pipe(process.stderr);
+ spawned.stdout.pipe(prefixedStdout).pipe(streamToLog(debug));
+ spawned.stderr.pipe(prefixedStderr).pipe(streamToLog(debug));
return spawned;
}
diff --git a/packages/kbn-pm/src/utils/link_project_executables.test.ts b/packages/kbn-pm/src/utils/link_project_executables.test.ts
index a19e1fd66f334..887c474a12eca 100644
--- a/packages/kbn-pm/src/utils/link_project_executables.test.ts
+++ b/packages/kbn-pm/src/utils/link_project_executables.test.ts
@@ -23,10 +23,19 @@ jest.mock('./fs');
import { resolve } from 'path';
+import { ToolingLogCollectingWriter } from '@kbn/dev-utils';
+
import { absolutePathSnapshotSerializer, stripAnsiSnapshotSerializer } from '../test_helpers';
import { linkProjectExecutables } from './link_project_executables';
import { Project } from './project';
import { buildProjectGraph } from './projects';
+import { log } from './log';
+
+const logWriter = new ToolingLogCollectingWriter();
+log.setWriters([logWriter]);
+beforeEach(() => {
+ logWriter.messages.length = 0;
+});
const projectsByName = new Map([
[
@@ -101,12 +110,15 @@ describe('bin script points to a file', () => {
const fs = require('./fs');
fs.isFile.mockReturnValue(true);
- const logMock = jest.spyOn(console, 'log').mockImplementation(() => {
- // noop
- });
await linkProjectExecutables(projectsByName, projectGraph);
expect(getFsMockCalls()).toMatchSnapshot('fs module calls');
- expect(logMock.mock.calls).toMatchSnapshot('logs');
+ expect(logWriter.messages).toMatchInlineSnapshot(`
+ Array [
+ " debg Linking package executables",
+ " debg [foo] bar -> ../bar/bin/bar.js",
+ " debg [baz] bar -> ../bar/bin/bar.js",
+ ]
+ `);
});
});
diff --git a/packages/kbn-pm/src/utils/link_project_executables.ts b/packages/kbn-pm/src/utils/link_project_executables.ts
index b403dfb2ecf2e..f7362788b417d 100644
--- a/packages/kbn-pm/src/utils/link_project_executables.ts
+++ b/packages/kbn-pm/src/utils/link_project_executables.ts
@@ -19,8 +19,6 @@
import { dirname, relative, resolve, sep } from 'path';
-import chalk from 'chalk';
-
import { chmod, createSymlink, isFile, mkdirp } from './fs';
import { log } from './log';
import { ProjectGraph, ProjectMap } from './projects';
@@ -37,6 +35,7 @@ export async function linkProjectExecutables(
projectsByName: ProjectMap,
projectGraph: ProjectGraph
) {
+ log.debug(`Linking package executables`);
for (const [projectName, projectDeps] of projectGraph) {
const project = projectsByName.get(projectName)!;
const binsDir = resolve(project.nodeModulesLocation, '.bin');
@@ -57,7 +56,7 @@ export async function linkProjectExecutables(
// Get relative project path with normalized path separators.
const projectRelativePath = relative(project.path, srcPath).split(sep).join('/');
- log.write(chalk`{dim [${project.name}]} ${name} -> {dim ${projectRelativePath}}`);
+ log.debug(`[${project.name}] ${name} -> ${projectRelativePath}`);
await mkdirp(dirname(dest));
await createSymlink(srcPath, dest, 'exec');
diff --git a/packages/kbn-pm/src/utils/log.ts b/packages/kbn-pm/src/utils/log.ts
index 9e5630be5bd19..786ff8b19ef4e 100644
--- a/packages/kbn-pm/src/utils/log.ts
+++ b/packages/kbn-pm/src/utils/log.ts
@@ -17,27 +17,36 @@
* under the License.
*/
-import { ToolingLog, ToolingLogCollectingWriter } from '@kbn/dev-utils';
+import {
+ ToolingLog,
+ ToolingLogTextWriter,
+ LogLevel,
+ parseLogLevel,
+ ParsedLogLevel,
+} from '@kbn/dev-utils';
class Log extends ToolingLog {
- testWriter?: ToolingLogCollectingWriter;
+ private logLevel!: ParsedLogLevel;
constructor() {
- super({
- level: 'info',
- writeTo: process.stdout,
- });
+ super();
+ this.setLogLevel('info');
}
- /**
- * Log something to the console. Ideally we would use a real logger in
- * kbn-pm, but that's a pretty big change for now.
- * @param ...args
- */
- write(...args: any[]) {
- // eslint-disable-next-line no-console
- console.log(...args);
+ setLogLevel(level: LogLevel) {
+ this.logLevel = parseLogLevel(level);
+ this.setWriters([
+ new ToolingLogTextWriter({
+ level: this.logLevel.name,
+ writeTo: process.stdout,
+ }),
+ ]);
+ }
+
+ wouldLogLevel(level: LogLevel) {
+ return this.logLevel.flags[level];
}
}
export const log = new Log();
+export { LogLevel, Log };
diff --git a/packages/kbn-pm/src/utils/project.ts b/packages/kbn-pm/src/utils/project.ts
index 91a3a5365b60e..8f45df52c7a2f 100644
--- a/packages/kbn-pm/src/utils/project.ts
+++ b/packages/kbn-pm/src/utils/project.ts
@@ -17,7 +17,6 @@
* under the License.
*/
-import chalk from 'chalk';
import fs from 'fs';
import Path from 'path';
import { inspect } from 'util';
@@ -190,16 +189,20 @@ export class Project {
}
public async runScript(scriptName: string, args: string[] = []) {
- log.write(
- chalk.bold(
- `\n\nRunning script [${chalk.green(scriptName)}] in [${chalk.green(this.name)}]:\n`
- )
- );
+ log.info(`Running script [${scriptName}] in [${this.name}]:`);
return runScriptInPackage(scriptName, args, this);
}
- public runScriptStreaming(scriptName: string, args: string[] = []) {
- return runScriptInPackageStreaming(scriptName, args, this);
+ public runScriptStreaming(
+ scriptName: string,
+ options: { args?: string[]; debug?: boolean } = {}
+ ) {
+ return runScriptInPackageStreaming({
+ script: scriptName,
+ args: options.args || [],
+ pkg: this,
+ debug: options.debug,
+ });
}
public hasDependencies() {
@@ -207,8 +210,12 @@ export class Project {
}
public async installDependencies({ extraArgs }: { extraArgs: string[] }) {
- log.write(chalk.bold(`\n\nInstalling dependencies in [${chalk.green(this.name)}]:\n`));
+ log.info(`[${this.name}] running yarn`);
+
+ log.write('');
await installInDir(this.path, extraArgs);
+ log.write('');
+
await this.removeExtraneousNodeModules();
}
@@ -239,7 +246,7 @@ export class Project {
const isDevDependency = devDependencies && devDependencies.hasOwnProperty(name);
if (!isDependency && !isDevDependency && fs.existsSync(nodeModulesPath)) {
- log.write(`No dependency on ${name}, removing link in node_modules`);
+ log.debug(`No dependency on ${name}, removing link in node_modules`);
fs.unlinkSync(nodeModulesPath);
}
});
diff --git a/packages/kbn-pm/src/utils/project_checksums.ts b/packages/kbn-pm/src/utils/project_checksums.ts
index 46dde1b32c158..839c44f4f18c4 100644
--- a/packages/kbn-pm/src/utils/project_checksums.ts
+++ b/packages/kbn-pm/src/utils/project_checksums.ts
@@ -23,12 +23,12 @@ import Crypto from 'crypto';
import { promisify } from 'util';
import execa from 'execa';
-import { ToolingLog } from '@kbn/dev-utils';
import { readYarnLock, YarnLock } from './yarn_lock';
import { ProjectMap } from '../utils/projects';
import { Project } from '../utils/project';
import { Kibana } from '../utils/kibana';
+import { Log } from '../utils/log';
export type ChecksumMap = Map;
/** map of [repo relative path to changed file, type of change] */
@@ -38,7 +38,7 @@ const statAsync = promisify(Fs.stat);
const projectBySpecificitySorter = (a: Project, b: Project) => b.path.length - a.path.length;
/** Get the changed files for a set of projects */
-async function getChangesForProjects(projects: ProjectMap, kbn: Kibana, log: ToolingLog) {
+async function getChangesForProjects(projects: ProjectMap, kbn: Kibana, log: Log) {
log.verbose('getting changed files');
const { stdout } = await execa(
@@ -150,7 +150,7 @@ async function getLatestSha(project: Project, kbn: Kibana) {
* in the yarn.lock file, does not include other projects in the workspace
* or their dependencies
*/
-function resolveDepsForProject(project: Project, yarnLock: YarnLock, kbn: Kibana, log: ToolingLog) {
+function resolveDepsForProject(project: Project, yarnLock: YarnLock, kbn: Kibana, log: Log) {
/** map of [name@range, name@resolved] */
const resolved = new Map();
@@ -198,7 +198,7 @@ async function getChecksum(
changes: Changes | undefined,
yarnLock: YarnLock,
kbn: Kibana,
- log: ToolingLog
+ log: Log
) {
const sha = await getLatestSha(project, kbn);
if (sha) {
@@ -256,7 +256,7 @@ async function getChecksum(
* - un-committed changes
* - resolved dependencies from yarn.lock referenced by project package.json
*/
-export async function getAllChecksums(kbn: Kibana, log: ToolingLog) {
+export async function getAllChecksums(kbn: Kibana, log: Log) {
const projects = kbn.getAllProjects();
const changesByProject = await getChangesForProjects(projects, kbn, log);
const yarnLock = await readYarnLock(kbn);
diff --git a/packages/kbn-pm/src/utils/scripts.ts b/packages/kbn-pm/src/utils/scripts.ts
index 009efa1285c0c..728ac4287b1ce 100644
--- a/packages/kbn-pm/src/utils/scripts.ts
+++ b/packages/kbn-pm/src/utils/scripts.ts
@@ -56,13 +56,24 @@ export async function runScriptInPackage(script: string, args: string[], pkg: Pr
/**
* Run script in the given directory
*/
-export function runScriptInPackageStreaming(script: string, args: string[], pkg: Project) {
+export function runScriptInPackageStreaming({
+ script,
+ args,
+ pkg,
+ debug,
+}: {
+ script: string;
+ args: string[];
+ pkg: Project;
+ debug?: boolean;
+}) {
const execOpts = {
cwd: pkg.path,
};
return spawnStreaming('yarn', ['run', script, ...args], execOpts, {
prefix: pkg.name,
+ debug,
});
}
diff --git a/packages/kbn-test/package.json b/packages/kbn-test/package.json
index 0ab0048619358..8e2fd1c9182ff 100644
--- a/packages/kbn-test/package.json
+++ b/packages/kbn-test/package.json
@@ -14,6 +14,7 @@
"@kbn/babel-preset": "1.0.0",
"@kbn/dev-utils": "1.0.0",
"@types/parse-link-header": "^1.0.0",
+ "@types/puppeteer": "^3.0.0",
"@types/strip-ansi": "^5.2.1",
"@types/xml2js": "^0.4.5",
"diff": "^4.0.1"
@@ -25,6 +26,7 @@
"getopts": "^2.2.4",
"glob": "^7.1.2",
"parse-link-header": "^1.0.1",
+ "puppeteer": "^3.3.0",
"strip-ansi": "^5.2.0",
"rxjs": "^6.5.3",
"tar-fs": "^1.16.3",
diff --git a/packages/kbn-test/src/index.ts b/packages/kbn-test/src/index.ts
index 585ce8181df5f..0bc7cc664df68 100644
--- a/packages/kbn-test/src/index.ts
+++ b/packages/kbn-test/src/index.ts
@@ -58,3 +58,5 @@ export { runFailedTestsReporterCli } from './failed_tests_reporter';
export { makeJunitReportPath } from './junit_report_path';
export { CI_PARALLEL_PROCESS_PREFIX } from './ci_parallel_process_prefix';
+
+export * from './page_load_metrics';
diff --git a/packages/kbn-test/src/page_load_metrics/capture_page_load_metrics.ts b/packages/kbn-test/src/page_load_metrics/capture_page_load_metrics.ts
new file mode 100644
index 0000000000000..013d49a29a51c
--- /dev/null
+++ b/packages/kbn-test/src/page_load_metrics/capture_page_load_metrics.ts
@@ -0,0 +1,81 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { ToolingLog } from '@kbn/dev-utils';
+import { NavigationOptions, createUrl, navigateToApps } from './navigation';
+
+export async function capturePageLoadMetrics(log: ToolingLog, options: NavigationOptions) {
+ const responsesByPageView = await navigateToApps(log, options);
+
+ const assetSizeMeasurements = new Map();
+
+ const numberOfPagesVisited = responsesByPageView.size;
+
+ for (const [, frameResponses] of responsesByPageView) {
+ for (const [, { url, dataLength }] of frameResponses) {
+ if (url.length === 0) {
+ throw new Error('navigateToApps(); failed to identify the url of the request');
+ }
+ if (assetSizeMeasurements.has(url)) {
+ assetSizeMeasurements.set(url, [dataLength].concat(assetSizeMeasurements.get(url) || []));
+ } else {
+ assetSizeMeasurements.set(url, [dataLength]);
+ }
+ }
+ }
+
+ return Array.from(assetSizeMeasurements.entries())
+ .map(([url, measurements]) => {
+ const baseUrl = createUrl('/', options.appConfig.url);
+ const relativeUrl = url
+ // remove the baseUrl (expect the trailing slash) to make url relative
+ .replace(baseUrl.slice(0, -1), '')
+ // strip the build number from asset urls
+ .replace(/^\/\d+\//, '/');
+ return [relativeUrl, measurements] as const;
+ })
+ .filter(([url, measurements]) => {
+ if (measurements.length !== numberOfPagesVisited) {
+ // ignore urls seen only on some pages
+ return false;
+ }
+
+ if (url.startsWith('data:')) {
+ // ignore data urls since they are already counted by other assets
+ return false;
+ }
+
+ if (url.startsWith('/api/') || url.startsWith('/internal/')) {
+ // ignore api requests since they don't have deterministic sizes
+ return false;
+ }
+
+ const allMetricsAreEqual = measurements.every((x, i) =>
+ i === 0 ? true : x === measurements[i - 1]
+ );
+ if (!allMetricsAreEqual) {
+ throw new Error(`measurements for url [${url}] are not equal [${measurements.join(',')}]`);
+ }
+
+ return true;
+ })
+ .map(([url, measurements]) => {
+ return { group: 'page load asset size', id: url, value: measurements[0] };
+ });
+}
diff --git a/packages/kbn-test/src/page_load_metrics/cli.ts b/packages/kbn-test/src/page_load_metrics/cli.ts
new file mode 100644
index 0000000000000..95421384c79cb
--- /dev/null
+++ b/packages/kbn-test/src/page_load_metrics/cli.ts
@@ -0,0 +1,90 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import Url from 'url';
+
+import { run, createFlagError } from '@kbn/dev-utils';
+import { resolve, basename } from 'path';
+import { capturePageLoadMetrics } from './capture_page_load_metrics';
+
+const defaultScreenshotsDir = resolve(__dirname, 'screenshots');
+
+export function runPageLoadMetricsCli() {
+ run(
+ async ({ flags, log }) => {
+ const kibanaUrl = flags['kibana-url'];
+ if (!kibanaUrl || typeof kibanaUrl !== 'string') {
+ throw createFlagError('Expect --kibana-url to be a string');
+ }
+
+ const parsedUrl = Url.parse(kibanaUrl);
+
+ const [username, password] = parsedUrl.auth
+ ? parsedUrl.auth.split(':')
+ : [flags.username, flags.password];
+
+ if (typeof username !== 'string' || typeof password !== 'string') {
+ throw createFlagError(
+ 'Mising username and/or password, either specify in --kibana-url or pass --username and --password'
+ );
+ }
+
+ const headless = !flags.head;
+
+ const screenshotsDir = flags.screenshotsDir || defaultScreenshotsDir;
+
+ if (typeof screenshotsDir !== 'string' || screenshotsDir === basename(screenshotsDir)) {
+ throw createFlagError('Expect screenshotsDir to be valid path string');
+ }
+
+ const metrics = await capturePageLoadMetrics(log, {
+ headless,
+ appConfig: {
+ url: kibanaUrl,
+ username,
+ password,
+ },
+ screenshotsDir,
+ });
+ for (const metric of metrics) {
+ log.info(`${metric.id}: ${metric.value}`);
+ }
+ },
+ {
+ description: `Loads several pages with Puppeteer to capture the size of assets`,
+ flags: {
+ string: ['kibana-url', 'username', 'password', 'screenshotsDir'],
+ boolean: ['head'],
+ default: {
+ username: 'elastic',
+ password: 'changeme',
+ debug: true,
+ screenshotsDir: defaultScreenshotsDir,
+ },
+ help: `
+ --kibana-url Url for Kibana we should connect to, can include login info
+ --head Run puppeteer with graphical user interface
+ --username Set username, defaults to 'elastic'
+ --password Set password, defaults to 'changeme'
+ --screenshotsDir Set screenshots directory, defaults to '${defaultScreenshotsDir}'
+ `,
+ },
+ }
+ );
+}
diff --git a/packages/kbn-test/src/page_load_metrics/event.ts b/packages/kbn-test/src/page_load_metrics/event.ts
new file mode 100644
index 0000000000000..481954bbf672e
--- /dev/null
+++ b/packages/kbn-test/src/page_load_metrics/event.ts
@@ -0,0 +1,34 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export interface ResponseReceivedEvent {
+ frameId: string;
+ loaderId: string;
+ requestId: string;
+ response: Record;
+ timestamp: number;
+ type: string;
+}
+
+export interface DataReceivedEvent {
+ encodedDataLength: number;
+ dataLength: number;
+ requestId: string;
+ timestamp: number;
+}
diff --git a/packages/kbn-test/src/page_load_metrics/index.ts b/packages/kbn-test/src/page_load_metrics/index.ts
new file mode 100644
index 0000000000000..4309d558518a6
--- /dev/null
+++ b/packages/kbn-test/src/page_load_metrics/index.ts
@@ -0,0 +1,21 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export * from './cli';
+export { capturePageLoadMetrics } from './capture_page_load_metrics';
diff --git a/packages/kbn-test/src/page_load_metrics/navigation.ts b/packages/kbn-test/src/page_load_metrics/navigation.ts
new file mode 100644
index 0000000000000..21dc681951b21
--- /dev/null
+++ b/packages/kbn-test/src/page_load_metrics/navigation.ts
@@ -0,0 +1,165 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import Fs from 'fs';
+import Url from 'url';
+import _ from 'lodash';
+import puppeteer from 'puppeteer';
+import { resolve } from 'path';
+import { ToolingLog } from '@kbn/dev-utils';
+import { ResponseReceivedEvent, DataReceivedEvent } from './event';
+
+export interface NavigationOptions {
+ headless: boolean;
+ appConfig: { url: string; username: string; password: string };
+ screenshotsDir: string;
+}
+
+export type NavigationResults = Map>;
+
+interface FrameResponse {
+ url: string;
+ dataLength: number;
+}
+
+function joinPath(pathA: string, pathB: string) {
+ return `${pathA.endsWith('/') ? pathA.slice(0, -1) : pathA}/${
+ pathB.startsWith('/') ? pathB.slice(1) : pathB
+ }`;
+}
+
+export function createUrl(path: string, url: string) {
+ const baseUrl = Url.parse(url);
+ return Url.format({
+ protocol: baseUrl.protocol,
+ hostname: baseUrl.hostname,
+ port: baseUrl.port,
+ pathname: joinPath(baseUrl.pathname || '', path),
+ });
+}
+
+async function loginToKibana(
+ log: ToolingLog,
+ browser: puppeteer.Browser,
+ options: NavigationOptions
+) {
+ log.debug(`log in to the app..`);
+ const page = await browser.newPage();
+ const loginUrl = createUrl('/login', options.appConfig.url);
+ await page.goto(loginUrl, {
+ waitUntil: 'networkidle0',
+ });
+ await page.type('[data-test-subj="loginUsername"]', options.appConfig.username);
+ await page.type('[data-test-subj="loginPassword"]', options.appConfig.password);
+ await page.click('[data-test-subj="loginSubmit"]');
+ await page.waitForNavigation({ waitUntil: 'networkidle0' });
+ await page.close();
+}
+
+export async function navigateToApps(log: ToolingLog, options: NavigationOptions) {
+ const browser = await puppeteer.launch({ headless: options.headless, args: ['--no-sandbox'] });
+ const devToolsResponses: NavigationResults = new Map();
+ const apps = [
+ { path: '/app/discover', locator: '[data-test-subj="discover-sidebar"]' },
+ { path: '/app/home', locator: '[data-test-subj="homeApp"]' },
+ { path: '/app/canvas', locator: '[data-test-subj="create-workpad-button"]' },
+ { path: '/app/maps', locator: '[title="Maps"]' },
+ { path: '/app/apm', locator: '[data-test-subj="apmMainContainer"]' },
+ ];
+
+ await loginToKibana(log, browser, options);
+
+ await Promise.all(
+ apps.map(async (app) => {
+ const page = await browser.newPage();
+ page.setCacheEnabled(false);
+ page.setDefaultNavigationTimeout(0);
+ const frameResponses = new Map();
+ devToolsResponses.set(app.path, frameResponses);
+
+ const client = await page.target().createCDPSession();
+ await client.send('Network.enable');
+
+ function getRequestData(requestId: string) {
+ if (!frameResponses.has(requestId)) {
+ frameResponses.set(requestId, { url: '', dataLength: 0 });
+ }
+
+ return frameResponses.get(requestId)!;
+ }
+
+ client.on('Network.responseReceived', (event: ResponseReceivedEvent) => {
+ getRequestData(event.requestId).url = event.response.url;
+ });
+
+ client.on('Network.dataReceived', (event: DataReceivedEvent) => {
+ getRequestData(event.requestId).dataLength += event.dataLength;
+ });
+
+ const url = createUrl(app.path, options.appConfig.url);
+ log.debug(`goto ${url}`);
+ await page.goto(url, {
+ waitUntil: 'networkidle0',
+ });
+
+ let readyAttempt = 0;
+ let selectorFound = false;
+ while (!selectorFound) {
+ readyAttempt += 1;
+ try {
+ await page.waitForSelector(app.locator, { timeout: 5000 });
+ selectorFound = true;
+ } catch (error) {
+ log.error(
+ `Page '${app.path}' was not loaded properly, unable to find '${
+ app.locator
+ }', url: ${page.url()}`
+ );
+
+ if (readyAttempt < 6) {
+ continue;
+ }
+
+ const failureDir = resolve(options.screenshotsDir, 'failure');
+ const screenshotPath = resolve(
+ failureDir,
+ `${app.path.slice(1).split('/').join('_')}_navigation.png`
+ );
+ Fs.mkdirSync(failureDir, { recursive: true });
+
+ await page.bringToFront();
+ await page.screenshot({
+ path: screenshotPath,
+ type: 'png',
+ fullPage: true,
+ });
+ log.debug(`Saving screenshot to ${screenshotPath}`);
+
+ throw new Error(`Page load timeout: ${app.path} not loaded after 30 seconds`);
+ }
+ }
+
+ await page.close();
+ })
+ );
+
+ await browser.close();
+
+ return devToolsResponses;
+}
diff --git a/packages/kbn-ui-shared-deps/entry.js b/packages/kbn-ui-shared-deps/entry.js
index ab044a6723da7..88e84fc87ae53 100644
--- a/packages/kbn-ui-shared-deps/entry.js
+++ b/packages/kbn-ui-shared-deps/entry.js
@@ -30,8 +30,8 @@ export const KbnI18nReact = require('@kbn/i18n/react');
export const Angular = require('angular');
export const Moment = require('moment');
export const MomentTimezone = require('moment-timezone/moment-timezone');
-export const Monaco = require('./monaco.ts');
-export const MonacoBare = require('monaco-editor/esm/vs/editor/editor.api');
+export const KbnMonaco = require('@kbn/monaco');
+export const MonacoBarePluginApi = require('@kbn/monaco').BarePluginApi;
export const React = require('react');
export const ReactDom = require('react-dom');
export const ReactDomServer = require('react-dom/server');
diff --git a/packages/kbn-ui-shared-deps/index.js b/packages/kbn-ui-shared-deps/index.js
index eb3add68e2866..301d176555847 100644
--- a/packages/kbn-ui-shared-deps/index.js
+++ b/packages/kbn-ui-shared-deps/index.js
@@ -42,9 +42,9 @@ exports.externals = {
'react-intl': '__kbnSharedDeps__.ReactIntl',
'react-router': '__kbnSharedDeps__.ReactRouter',
'react-router-dom': '__kbnSharedDeps__.ReactRouterDom',
- '@kbn/ui-shared-deps/monaco': '__kbnSharedDeps__.Monaco',
+ '@kbn/monaco': '__kbnSharedDeps__.KbnMonaco',
// this is how plugins/consumers from npm load monaco
- 'monaco-editor/esm/vs/editor/editor.api': '__kbnSharedDeps__.MonacoBare',
+ 'monaco-editor/esm/vs/editor/editor.api': '__kbnSharedDeps__.MonacoBarePluginApi',
/**
* big deps which are locked to a single version
diff --git a/packages/kbn-ui-shared-deps/package.json b/packages/kbn-ui-shared-deps/package.json
index 93afa303c8cad..744a656c54a7f 100644
--- a/packages/kbn-ui-shared-deps/package.json
+++ b/packages/kbn-ui-shared-deps/package.json
@@ -13,6 +13,7 @@
"@elastic/eui": "23.3.1",
"@elastic/numeral": "^2.5.0",
"@kbn/i18n": "1.0.0",
+ "@kbn/monaco": "1.0.0",
"abortcontroller-polyfill": "^1.4.0",
"angular": "^1.7.9",
"compression-webpack-plugin": "^3.1.0",
@@ -22,7 +23,6 @@
"jquery": "^3.5.0",
"moment": "^2.24.0",
"moment-timezone": "^0.5.27",
- "monaco-editor": "~0.17.0",
"react": "^16.12.0",
"react-dom": "^16.12.0",
"react-intl": "^2.8.0",
diff --git a/packages/kbn-ui-shared-deps/tsconfig.json b/packages/kbn-ui-shared-deps/tsconfig.json
index 5d981c73f1d21..5aa0f45e4100d 100644
--- a/packages/kbn-ui-shared-deps/tsconfig.json
+++ b/packages/kbn-ui-shared-deps/tsconfig.json
@@ -1,7 +1,4 @@
{
"extends": "../../tsconfig.json",
- "include": [
- "index.d.ts",
- "monaco.ts"
- ]
+ "include": ["index.d.ts", "./monaco"]
}
diff --git a/packages/kbn-ui-shared-deps/webpack.config.js b/packages/kbn-ui-shared-deps/webpack.config.js
index 7295f2e88c530..523927bd64a20 100644
--- a/packages/kbn-ui-shared-deps/webpack.config.js
+++ b/packages/kbn-ui-shared-deps/webpack.config.js
@@ -78,17 +78,6 @@ exports.getWebpackConfig = ({ dev = false } = {}) => ({
test: /\.css$/,
use: [MiniCssExtractPlugin.loader, 'css-loader'],
},
- {
- include: [require.resolve('./monaco.ts')],
- use: [
- {
- loader: 'babel-loader',
- options: {
- presets: [require.resolve('@kbn/babel-preset/webpack_preset')],
- },
- },
- ],
- },
],
},
@@ -96,6 +85,7 @@ exports.getWebpackConfig = ({ dev = false } = {}) => ({
alias: {
moment: MOMENT_SRC,
},
+ extensions: ['.js', '.ts'],
},
optimization: {
diff --git a/renovate.json5 b/renovate.json5
index 674c4e0df7904..b4f1441a50d60 100644
--- a/renovate.json5
+++ b/renovate.json5
@@ -418,14 +418,6 @@
'@types/history',
],
},
- {
- groupSlug: 'indent-string',
- groupName: 'indent-string related packages',
- packageNames: [
- 'indent-string',
- '@types/indent-string',
- ],
- },
{
groupSlug: 'inquirer',
groupName: 'inquirer related packages',
@@ -1067,14 +1059,6 @@
'@types/chokidar',
],
},
- {
- groupSlug: 'wrap-ansi',
- groupName: 'wrap-ansi related packages',
- packageNames: [
- 'wrap-ansi',
- '@types/wrap-ansi',
- ],
- },
{
groupSlug: 'write-pkg',
groupName: 'write-pkg related packages',
diff --git a/rfcs/text/0011_global_search.md b/rfcs/text/0011_global_search.md
index 5ec368a1c2f02..3b2120283d06a 100644
--- a/rfcs/text/0011_global_search.md
+++ b/rfcs/text/0011_global_search.md
@@ -194,7 +194,7 @@ Notes:
### Plugin API
-#### server API
+#### Common types
```ts
/**
@@ -208,6 +208,21 @@ type GlobalSearchResult = Omit & {
url: string;
};
+
+/**
+ * Response returned from the {@link GlobalSearchServiceStart | global search service}'s `find` API
+ */
+type GlobalSearchBatchedResults = {
+ /**
+ * Results for this batch
+ */
+ results: GlobalSearchResult[];
+};
+```
+
+#### server API
+
+```ts
/**
* Options for the server-side {@link GlobalSearchServiceStart.find | find API}
*/
@@ -226,16 +241,6 @@ interface GlobalSearchFindOptions {
aborted$?: Observable;
}
-/**
- * Response returned from the server-side {@link GlobalSearchServiceStart | global search service}'s `find` API
- */
-type GlobalSearchBatchedResults = {
- /**
- * Results for this batch
- */
- results: GlobalSearchResult[];
-};
-
/** @public */
interface GlobalSearchPluginSetup {
registerResultProvider(provider: GlobalSearchResultProvider);
@@ -265,28 +270,6 @@ interface GlobalSearchFindOptions {
aborted$?: Observable;
}
-/**
- * Enhanced {@link GlobalSearchResult | result type} for the client-side,
- * to allow navigating to a given result.
- */
-interface NavigableGlobalSearchResult extends GlobalSearchResult {
- /**
- * Navigate to this result's associated url. If the result is on this kibana instance, user will be redirected to it
- * in a SPA friendly way using `application.navigateToApp`, else, a full page refresh will be performed.
- */
- navigate: () => Promise;
-}
-
-/**
- * Response returned from the client-side {@link GlobalSearchServiceStart | global search service}'s `find` API
- */
-type GlobalSearchBatchedResults = {
- /**
- * Results for this batch
- */
- results: NavigableGlobalSearchResult[];
-};
-
/** @public */
interface GlobalSearchPluginSetup {
registerResultProvider(provider: GlobalSearchResultProvider);
@@ -304,9 +287,6 @@ Notes:
- The `registerResultProvider` setup APIs share the same signature, however the input `GlobalSearchResultProvider`
types are different on the client and server.
- The `find` start API signature got a `KibanaRequest` for `server`, when this parameter is not present for `public`.
-- The `find` API returns a observable of `NavigableGlobalSearchResult` instead of plain `GlobalSearchResult`. This type
- is here to enhance results with a `navigate` method to let the `GlobalSearch` plugin handle the navigation logic, which is
- non-trivial. See the [Redirecting to a result](#redirecting-to-a-result) section for more info.
#### http API
@@ -395,14 +375,11 @@ In current specification, the only conversion step is to transform the `result.u
#### redirecting to a result
-Parsing a relative or absolute result url to perform SPA navigation can be non trivial, and should remains the responsibility
-of the GlobalSearch plugin API.
-
-This is why `NavigableGlobalSearchResult.navigate` has been introduced on the client-side version of the `find` API
+Parsing a relative or absolute result url to perform SPA navigation can be non trivial. This is why `ApplicationService.navigateToUrl` has been introduced on the client-side core API
-When using `navigate` from a result instance, the following logic will be executed:
+When using `navigateToUrl` with the url of a result instance, the following logic will be executed:
-If all these criteria are true for `result.url`:
+If all these criteria are true for `url`:
- (only for absolute URLs) The origin of the URL matches the origin of the browser's current location
- The pathname of the URL starts with the current basePath (eg. /mybasepath/s/my-space)
diff --git a/scripts/page_load_metrics.js b/scripts/page_load_metrics.js
new file mode 100644
index 0000000000000..37500c26e0b20
--- /dev/null
+++ b/scripts/page_load_metrics.js
@@ -0,0 +1,21 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+require('../src/setup_node_env');
+require('@kbn/test').runPageLoadMetricsCli();
diff --git a/src/cli/cluster/cluster_manager.ts b/src/cli/cluster/cluster_manager.ts
index dec16b63d78f0..09f9bb2333dbe 100644
--- a/src/cli/cluster/cluster_manager.ts
+++ b/src/cli/cluster/cluster_manager.ts
@@ -262,7 +262,7 @@ export class ClusterManager {
...pluginInternalDirsIgnore,
fromRoot('src/legacy/server/sass/__tmp__'),
fromRoot('x-pack/plugins/reporting/.chromium'),
- fromRoot('x-pack/plugins/siem/cypress'),
+ fromRoot('x-pack/plugins/security_solution/cypress'),
fromRoot('x-pack/plugins/apm/e2e'),
fromRoot('x-pack/plugins/apm/scripts'),
fromRoot('x-pack/plugins/canvas/canvas_plugin_src'), // prevents server from restarting twice for Canvas plugin changes,
diff --git a/src/core/public/application/application_service.mock.ts b/src/core/public/application/application_service.mock.ts
index 300b09e17d15d..47a8a01d917eb 100644
--- a/src/core/public/application/application_service.mock.ts
+++ b/src/core/public/application/application_service.mock.ts
@@ -17,6 +17,7 @@
* under the License.
*/
+import { History } from 'history';
import { BehaviorSubject, Subject } from 'rxjs';
import { capabilitiesServiceMock } from './capabilities/capabilities_service.mock';
@@ -57,6 +58,28 @@ const createStartContractMock = (): jest.Mocked => {
};
};
+const createHistoryMock = (): jest.Mocked => {
+ return {
+ block: jest.fn(),
+ createHref: jest.fn(),
+ go: jest.fn(),
+ goBack: jest.fn(),
+ goForward: jest.fn(),
+ listen: jest.fn(),
+ push: jest.fn(),
+ replace: jest.fn(),
+ action: 'PUSH',
+ length: 1,
+ location: {
+ pathname: '/',
+ search: '',
+ hash: '',
+ key: '',
+ state: undefined,
+ },
+ };
+};
+
const createInternalStartContractMock = (): jest.Mocked => {
const currentAppId$ = new Subject();
@@ -69,6 +92,7 @@ const createInternalStartContractMock = (): jest.Mocked currentAppId$.next(appId)),
navigateToUrl: jest.fn(),
registerMountContext: jest.fn(),
+ history: createHistoryMock(),
};
};
diff --git a/src/core/public/application/application_service.tsx b/src/core/public/application/application_service.tsx
index 2224f72e2bd91..850422a61bde7 100644
--- a/src/core/public/application/application_service.tsx
+++ b/src/core/public/application/application_service.tsx
@@ -301,6 +301,7 @@ export class ApplicationService {
distinctUntilChanged(),
takeUntil(this.stop$)
),
+ history: this.history,
registerMountContext: this.mountContext.registerContext,
getUrlForApp: (
appId,
diff --git a/src/core/public/application/index.ts b/src/core/public/application/index.ts
index d51a4c0d69d42..74356cbd88b34 100644
--- a/src/core/public/application/index.ts
+++ b/src/core/public/application/index.ts
@@ -43,5 +43,6 @@ export {
PublicAppInfo,
PublicLegacyAppInfo,
// Internal types
+ InternalApplicationSetup,
InternalApplicationStart,
} from './types';
diff --git a/src/core/public/application/types.ts b/src/core/public/application/types.ts
index 8006ec846138f..7c83c684ac73d 100644
--- a/src/core/public/application/types.ts
+++ b/src/core/public/application/types.ts
@@ -18,6 +18,7 @@
*/
import { Observable } from 'rxjs';
+import { History } from 'history';
import { Capabilities } from './capabilities';
import { ChromeStart } from '../chrome';
@@ -766,6 +767,12 @@ export interface InternalApplicationStart extends Omit | undefined;
}
/** @internal */
diff --git a/src/core/public/chrome/ui/header/__snapshots__/header.test.tsx.snap b/src/core/public/chrome/ui/header/__snapshots__/header.test.tsx.snap
index b563c6d2a4ec4..305a4b2ed5b30 100644
--- a/src/core/public/chrome/ui/header/__snapshots__/header.test.tsx.snap
+++ b/src/core/public/chrome/ui/header/__snapshots__/header.test.tsx.snap
@@ -42,6 +42,25 @@ exports[`Header renders 1`] = `
},
"getComponent": [MockFunction],
"getUrlForApp": [MockFunction],
+ "history": Object {
+ "action": "PUSH",
+ "block": [MockFunction],
+ "createHref": [MockFunction],
+ "go": [MockFunction],
+ "goBack": [MockFunction],
+ "goForward": [MockFunction],
+ "length": 1,
+ "listen": [MockFunction],
+ "location": Object {
+ "hash": "",
+ "key": "",
+ "pathname": "/",
+ "search": "",
+ "state": undefined,
+ },
+ "push": [MockFunction],
+ "replace": [MockFunction],
+ },
"navigateToApp": [MockFunction],
"navigateToUrl": [MockFunction],
"registerMountContext": [MockFunction],
@@ -657,6 +676,25 @@ exports[`Header renders 2`] = `
},
"getComponent": [MockFunction],
"getUrlForApp": [MockFunction],
+ "history": Object {
+ "action": "PUSH",
+ "block": [MockFunction],
+ "createHref": [MockFunction],
+ "go": [MockFunction],
+ "goBack": [MockFunction],
+ "goForward": [MockFunction],
+ "length": 1,
+ "listen": [MockFunction],
+ "location": Object {
+ "hash": "",
+ "key": "",
+ "pathname": "/",
+ "search": "",
+ "state": undefined,
+ },
+ "push": [MockFunction],
+ "replace": [MockFunction],
+ },
"navigateToApp": [MockFunction],
"navigateToUrl": [MockFunction],
"registerMountContext": [MockFunction],
@@ -4741,6 +4779,25 @@ exports[`Header renders 3`] = `
},
"getComponent": [MockFunction],
"getUrlForApp": [MockFunction],
+ "history": Object {
+ "action": "PUSH",
+ "block": [MockFunction],
+ "createHref": [MockFunction],
+ "go": [MockFunction],
+ "goBack": [MockFunction],
+ "goForward": [MockFunction],
+ "length": 1,
+ "listen": [MockFunction],
+ "location": Object {
+ "hash": "",
+ "key": "",
+ "pathname": "/",
+ "search": "",
+ "state": undefined,
+ },
+ "push": [MockFunction],
+ "replace": [MockFunction],
+ },
"navigateToApp": [MockFunction],
"navigateToUrl": [MockFunction],
"registerMountContext": [MockFunction],
@@ -9897,6 +9954,25 @@ exports[`Header renders 4`] = `
},
"getComponent": [MockFunction],
"getUrlForApp": [MockFunction],
+ "history": Object {
+ "action": "PUSH",
+ "block": [MockFunction],
+ "createHref": [MockFunction],
+ "go": [MockFunction],
+ "goBack": [MockFunction],
+ "goForward": [MockFunction],
+ "length": 1,
+ "listen": [MockFunction],
+ "location": Object {
+ "hash": "",
+ "key": "",
+ "pathname": "/",
+ "search": "",
+ "state": undefined,
+ },
+ "push": [MockFunction],
+ "replace": [MockFunction],
+ },
"navigateToApp": [MockFunction],
"navigateToUrl": [MockFunction],
"registerMountContext": [MockFunction],
diff --git a/src/core/public/core_app/core_app.mock.ts b/src/core/public/core_app/core_app.mock.ts
new file mode 100644
index 0000000000000..b0e3871a40bf5
--- /dev/null
+++ b/src/core/public/core_app/core_app.mock.ts
@@ -0,0 +1,31 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { CoreApp } from './core_app';
+
+type CoreAppContract = PublicMethodsOf;
+const createMock = (): jest.Mocked => ({
+ setup: jest.fn(),
+ start: jest.fn(),
+ stop: jest.fn(),
+});
+
+export const coreAppMock = {
+ create: createMock,
+};
diff --git a/src/core/public/core_app/core_app.ts b/src/core/public/core_app/core_app.ts
new file mode 100644
index 0000000000000..04d58b7c3c65c
--- /dev/null
+++ b/src/core/public/core_app/core_app.ts
@@ -0,0 +1,83 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { UnregisterCallback } from 'history';
+import {
+ InternalApplicationSetup,
+ InternalApplicationStart,
+ AppNavLinkStatus,
+ AppMountParameters,
+} from '../application';
+import { HttpSetup, HttpStart } from '../http';
+import { CoreContext } from '../core_system';
+import { renderApp, setupUrlOverflowDetection } from './errors';
+import { NotificationsStart } from '../notifications';
+import { IUiSettingsClient } from '../ui_settings';
+
+interface SetupDeps {
+ application: InternalApplicationSetup;
+ http: HttpSetup;
+}
+
+interface StartDeps {
+ application: InternalApplicationStart;
+ http: HttpStart;
+ notifications: NotificationsStart;
+ uiSettings: IUiSettingsClient;
+}
+
+export class CoreApp {
+ private stopHistoryListening?: UnregisterCallback;
+
+ constructor(private readonly coreContext: CoreContext) {}
+
+ public setup({ http, application }: SetupDeps) {
+ application.register(this.coreContext.coreId, {
+ id: 'error',
+ title: 'App Error',
+ navLinkStatus: AppNavLinkStatus.hidden,
+ mount(params: AppMountParameters) {
+ // Do not use an async import here in order to ensure that network failures
+ // cannot prevent the error UI from displaying. This UI is tiny so an async
+ // import here is probably not useful anyways.
+ return renderApp(params, { basePath: http.basePath });
+ },
+ });
+ }
+
+ public start({ application, http, notifications, uiSettings }: StartDeps) {
+ if (!application.history) {
+ return;
+ }
+
+ this.stopHistoryListening = setupUrlOverflowDetection({
+ basePath: http.basePath,
+ history: application.history,
+ toasts: notifications.toasts,
+ uiSettings,
+ });
+ }
+
+ public stop() {
+ if (this.stopHistoryListening) {
+ this.stopHistoryListening();
+ this.stopHistoryListening = undefined;
+ }
+ }
+}
diff --git a/src/core/public/core_app/errors/error_application.test.ts b/src/core/public/core_app/errors/error_application.test.ts
new file mode 100644
index 0000000000000..ec3992330008f
--- /dev/null
+++ b/src/core/public/core_app/errors/error_application.test.ts
@@ -0,0 +1,61 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { act } from 'react-dom/test-utils';
+import { History, createMemoryHistory } from 'history';
+import { IBasePath } from '../../http';
+import { BasePath } from '../../http/base_path';
+
+import { renderApp } from './error_application';
+
+describe('renderApp', () => {
+ let basePath: IBasePath;
+ let element: HTMLDivElement;
+ let history: History;
+ let unmount: any;
+
+ beforeEach(() => {
+ basePath = new BasePath();
+ element = document.createElement('div');
+ history = createMemoryHistory();
+ unmount = renderApp({ element, history } as any, { basePath });
+ });
+
+ afterEach(() => unmount());
+
+ it('renders generic errors', () => {
+ act(() => {
+ history.push('/app/error');
+ });
+ // innerText not working in jsdom, so use innerHTML
+ expect(element.querySelector('.euiTitle')!.innerHTML).toMatchInlineSnapshot(
+ `"Application error"`
+ );
+ });
+
+ it('renders urlOverflow errors', () => {
+ act(() => {
+ history.push('/app/error?errorType=urlOverflow');
+ });
+ expect(element.querySelector('.euiTitle')!.innerHTML).toMatchInlineSnapshot(
+ `"The URL for this object is too long, and we can't display it"`
+ );
+ expect(element.innerHTML).toMatch('Things to try');
+ });
+});
diff --git a/src/core/public/core_app/errors/error_application.tsx b/src/core/public/core_app/errors/error_application.tsx
new file mode 100644
index 0000000000000..7124776d7086a
--- /dev/null
+++ b/src/core/public/core_app/errors/error_application.tsx
@@ -0,0 +1,102 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import React, { ReactChild, useState, useLayoutEffect } from 'react';
+import ReactDOM from 'react-dom';
+import { History } from 'history';
+import { i18n } from '@kbn/i18n';
+import { I18nProvider } from '@kbn/i18n/react';
+
+import { EuiEmptyPrompt, EuiPage, EuiPageBody, EuiPageContent } from '@elastic/eui';
+import { UrlOverflowUi } from './url_overflow_ui';
+import { IBasePath } from '../../http';
+import { AppMountParameters } from '../../application';
+
+interface Props {
+ title?: string;
+ children?: ReactChild;
+}
+
+const ErrorPage: React.FC = ({ title, children }) => {
+ title =
+ title ??
+ i18n.translate('core.application.appRenderError.defaultTitle', {
+ defaultMessage: 'Application error',
+ });
+
+ return (
+
+
+
+ {title}}
+ body={children}
+ />
+
+
+
+ );
+};
+
+const ErrorApp: React.FC<{ basePath: IBasePath; history: History }> = ({ basePath, history }) => {
+ const [currentLocation, setCurrentLocation] = useState(history.location);
+ useLayoutEffect(() => {
+ return history.listen((location) => setCurrentLocation(location));
+ }, [history]);
+
+ const searchParams = new URLSearchParams(currentLocation.search);
+ const errorType = searchParams.get('errorType');
+
+ if (errorType === 'urlOverflow') {
+ return (
+
+
+ );
+ }
+
+ return
+ ,
+ element
+ );
+
+ return () => {
+ ReactDOM.unmountComponentAtNode(element);
+ };
+};
diff --git a/src/core/public/core_app/errors/index.ts b/src/core/public/core_app/errors/index.ts
new file mode 100644
index 0000000000000..a8da0d98b3962
--- /dev/null
+++ b/src/core/public/core_app/errors/index.ts
@@ -0,0 +1,21 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export { renderApp } from './error_application';
+export { setupUrlOverflowDetection, URL_MAX_LENGTH } from './url_overflow';
diff --git a/src/core/public/core_app/errors/url_overflow.test.ts b/src/core/public/core_app/errors/url_overflow.test.ts
new file mode 100644
index 0000000000000..115bf53aa2a84
--- /dev/null
+++ b/src/core/public/core_app/errors/url_overflow.test.ts
@@ -0,0 +1,127 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { createMemoryHistory, History } from 'history';
+
+import { BasePath } from '../../http/base_path';
+import { notificationServiceMock } from '../../notifications/notifications_service.mock';
+import { uiSettingsServiceMock } from '../../ui_settings/ui_settings_service.mock';
+import { IBasePath } from '../../http';
+import { IToasts } from '../../notifications';
+import { IUiSettingsClient } from '../../ui_settings';
+
+import { setupUrlOverflowDetection, URL_MAX_LENGTH, URL_WARNING_LENGTH } from './url_overflow';
+
+const longUrl = '/' + 'a'.repeat(URL_MAX_LENGTH);
+
+describe('url overflow detection', () => {
+ let basePath: IBasePath;
+ let history: History;
+ let toasts: jest.Mocked;
+ let uiSettings: jest.Mocked;
+ let assignSpy: jest.SpyInstance;
+ let unlisten: any;
+
+ beforeEach(() => {
+ basePath = new BasePath('/test-123');
+ history = createMemoryHistory();
+ toasts = notificationServiceMock.createStartContract().toasts;
+ uiSettings = uiSettingsServiceMock.createStartContract();
+
+ // No-op mock impl to avoid jsdom warning about navigation not being implemented
+ assignSpy = jest.spyOn(window.location, 'assign').mockImplementation(() => {});
+
+ unlisten = setupUrlOverflowDetection({
+ basePath,
+ history,
+ toasts,
+ uiSettings,
+ });
+ });
+
+ afterEach(() => {
+ unlisten();
+ assignSpy.mockRestore();
+ });
+
+ it('redirects to error page when URL is too long', () => {
+ history.push(longUrl);
+ expect(assignSpy).toHaveBeenCalledWith('/app/error?errorType=urlOverflow');
+ });
+
+ it('displays a toast if URL exceeds warning threshold', () => {
+ const warningUrl = '/' + 'a'.repeat(URL_WARNING_LENGTH);
+ history.push(warningUrl);
+ expect(history.location.pathname).toEqual(warningUrl);
+ expect(assignSpy).not.toHaveBeenCalled();
+ expect(toasts.addWarning).toHaveBeenCalledWith(
+ expect.objectContaining({
+ title: 'The URL is big and Kibana might stop working',
+ text: expect.any(Function),
+ })
+ );
+
+ // Verify toast can be rendered correctly
+ const { text: mountToast } = toasts.addWarning.mock.calls[0][0] as any;
+ const element = document.createElement('div');
+ const unmount = mountToast(element);
+ expect(element).toMatchInlineSnapshot(`
+
+ Either enable the
+
+ state:storeInSessionStorage
+
+ option in
+
+ advanced settings
+
+ or simplify the onscreen visuals.
+
state:storeInSessionStorage,
+ advancedSettingsLink: (
+
+
+ ),
+ }}
+ />
+ ),
+ });
+ }
+ });
diff --git a/src/core/public/core_app/errors/url_overflow_ui.tsx b/src/core/public/core_app/errors/url_overflow_ui.tsx
new file mode 100644
index 0000000000000..30ee0f4ac41e5
--- /dev/null
+++ b/src/core/public/core_app/errors/url_overflow_ui.tsx
@@ -0,0 +1,73 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import React from 'react';
+
+import { FormattedMessage } from '@kbn/i18n/react';
+import { EuiText } from '@elastic/eui';
+
+import { IBasePath } from '../../http';
+import { IS_IE } from './url_overflow';
+
+export const UrlOverflowUi: React.FC<{ basePath: IBasePath }> = ({ basePath }) => {
+ return (
+
+
+
+
+
+
+ state:storeInSessionStorage,
+ kibanaSettingsLink: (
+
+
+ ),
+ }}
+ />
+
+
+
+ {IS_IE && (
+
+
+ )}
+
+
+ );
+};
diff --git a/src/core/public/core_app/index.ts b/src/core/public/core_app/index.ts
new file mode 100644
index 0000000000000..9876be1575ffd
--- /dev/null
+++ b/src/core/public/core_app/index.ts
@@ -0,0 +1,21 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export { CoreApp } from './core_app';
+export { URL_MAX_LENGTH } from './errors';
diff --git a/src/core/public/core_system.test.mocks.ts b/src/core/public/core_system.test.mocks.ts
index 75ab6cdb628f7..b5b99418b44b4 100644
--- a/src/core/public/core_system.test.mocks.ts
+++ b/src/core/public/core_system.test.mocks.ts
@@ -32,6 +32,7 @@ import { docLinksServiceMock } from './doc_links/doc_links_service.mock';
import { renderingServiceMock } from './rendering/rendering_service.mock';
import { contextServiceMock } from './context/context_service.mock';
import { integrationsServiceMock } from './integrations/integrations_service.mock';
+import { coreAppMock } from './core_app/core_app.mock';
export const MockLegacyPlatformService = legacyPlatformServiceMock.create();
export const LegacyPlatformServiceConstructor = jest
@@ -136,3 +137,9 @@ export const IntegrationsServiceConstructor = jest
jest.doMock('./integrations', () => ({
IntegrationsService: IntegrationsServiceConstructor,
}));
+
+export const MockCoreApp = coreAppMock.create();
+export const CoreAppConstructor = jest.fn().mockImplementation(() => MockCoreApp);
+jest.doMock('./core_app', () => ({
+ CoreApp: CoreAppConstructor,
+}));
diff --git a/src/core/public/core_system.test.ts b/src/core/public/core_system.test.ts
index 2979dd7661e59..4c1993c90a2e1 100644
--- a/src/core/public/core_system.test.ts
+++ b/src/core/public/core_system.test.ts
@@ -44,6 +44,8 @@ import {
MockContextService,
IntegrationsServiceConstructor,
MockIntegrationsService,
+ CoreAppConstructor,
+ MockCoreApp,
} from './core_system.test.mocks';
import { CoreSystem } from './core_system';
@@ -88,6 +90,7 @@ describe('constructor', () => {
expect(OverlayServiceConstructor).toHaveBeenCalledTimes(1);
expect(RenderingServiceConstructor).toHaveBeenCalledTimes(1);
expect(IntegrationsServiceConstructor).toHaveBeenCalledTimes(1);
+ expect(CoreAppConstructor).toHaveBeenCalledTimes(1);
});
it('passes injectedMetadata param to InjectedMetadataService', () => {
@@ -231,6 +234,11 @@ describe('#setup()', () => {
await setupCore();
expect(MockIntegrationsService.setup).toHaveBeenCalledTimes(1);
});
+
+ it('calls coreApp#setup()', async () => {
+ await setupCore();
+ expect(MockCoreApp.setup).toHaveBeenCalledTimes(1);
+ });
});
describe('#start()', () => {
@@ -315,10 +323,15 @@ describe('#start()', () => {
});
});
- it('calls start#setup()', async () => {
+ it('calls integrations#start()', async () => {
await startCore();
expect(MockIntegrationsService.start).toHaveBeenCalledTimes(1);
});
+
+ it('calls coreApp#start()', async () => {
+ await startCore();
+ expect(MockCoreApp.start).toHaveBeenCalledTimes(1);
+ });
});
describe('#stop()', () => {
@@ -377,6 +390,14 @@ describe('#stop()', () => {
expect(MockIntegrationsService.stop).toHaveBeenCalled();
});
+ it('calls coreApp.stop()', () => {
+ const coreSystem = createCoreSystem();
+
+ expect(MockCoreApp.stop).not.toHaveBeenCalled();
+ coreSystem.stop();
+ expect(MockCoreApp.stop).toHaveBeenCalled();
+ });
+
it('clears the rootDomElement', async () => {
const rootDomElement = document.createElement('div');
const coreSystem = createCoreSystem({
diff --git a/src/core/public/core_system.ts b/src/core/public/core_system.ts
index 46e1ecb83e9e4..aa52212344f4d 100644
--- a/src/core/public/core_system.ts
+++ b/src/core/public/core_system.ts
@@ -43,6 +43,7 @@ import { SavedObjectsService } from './saved_objects';
import { ContextService } from './context';
import { IntegrationsService } from './integrations';
import { InternalApplicationSetup, InternalApplicationStart } from './application/types';
+import { CoreApp } from './core_app';
interface Params {
rootDomElement: HTMLElement;
@@ -99,6 +100,7 @@ export class CoreSystem {
private readonly rendering: RenderingService;
private readonly context: ContextService;
private readonly integrations: IntegrationsService;
+ private readonly coreApp: CoreApp;
private readonly rootDomElement: HTMLElement;
private readonly coreContext: CoreContext;
@@ -142,6 +144,7 @@ export class CoreSystem {
this.context = new ContextService(this.coreContext);
this.plugins = new PluginsService(this.coreContext, injectedMetadata.uiPlugins);
+ this.coreApp = new CoreApp(this.coreContext);
this.legacy = new LegacyPlatformService({
requireLegacyFiles,
@@ -177,6 +180,7 @@ export class CoreSystem {
]),
});
const application = this.application.setup({ context, http, injectedMetadata });
+ this.coreApp.setup({ application, http });
const core: InternalCoreSetup = {
application,
@@ -245,6 +249,8 @@ export class CoreSystem {
uiSettings,
});
+ this.coreApp.start({ application, http, notifications, uiSettings });
+
application.registerMountContext(this.coreContext.coreId, 'core', () => ({
application: pick(application, ['capabilities', 'navigateToApp']),
chrome,
@@ -308,6 +314,7 @@ export class CoreSystem {
public stop() {
this.legacy.stop();
this.plugins.stop();
+ this.coreApp.stop();
this.notifications.stop();
this.http.stop();
this.integrations.stop();
diff --git a/src/core/public/index.ts b/src/core/public/index.ts
index bd275ca1d4565..40f614ebc3bea 100644
--- a/src/core/public/index.ts
+++ b/src/core/public/index.ts
@@ -191,6 +191,8 @@ export {
export { MountPoint, UnmountCallback, PublicUiSettingsParams } from './types';
+export { URL_MAX_LENGTH } from './core_app';
+
/**
* Core services exposed to the `Plugin` setup lifecycle
*
diff --git a/src/core/public/public.api.md b/src/core/public/public.api.md
index 74c41d010ca8d..b44eb48b9ffa9 100644
--- a/src/core/public/public.api.md
+++ b/src/core/public/public.api.md
@@ -1424,6 +1424,9 @@ export type UiSettingsType = 'undefined' | 'json' | 'markdown' | 'number' | 'sel
// @public
export type UnmountCallback = () => void;
+// @public
+export const URL_MAX_LENGTH: number;
+
// @public
export interface URLMeaningfulParts {
// (undocumented)
diff --git a/src/core/server/plugins/plugin_context.ts b/src/core/server/plugins/plugin_context.ts
index 7afb607192cae..f0db3a25e313d 100644
--- a/src/core/server/plugins/plugin_context.ts
+++ b/src/core/server/plugins/plugin_context.ts
@@ -17,7 +17,7 @@
* under the License.
*/
-import { map } from 'rxjs/operators';
+import { map, shareReplay } from 'rxjs/operators';
import { combineLatest } from 'rxjs';
import { CoreContext } from '../core_context';
import { PluginWrapper } from './plugin';
@@ -107,8 +107,8 @@ export function createPluginInitializerContext(
* @param ConfigClass A class (not an instance of a class) that contains a
* static `schema` that we validate the config at the given `path` against.
*/
- create() {
- return coreContext.configService.atPath(pluginManifest.configPath);
+ create() {
+ return coreContext.configService.atPath(pluginManifest.configPath).pipe(shareReplay(1));
},
createIfExists() {
return coreContext.configService.optionalAtPath(pluginManifest.configPath);
diff --git a/src/core/server/saved_objects/migrations/kibana/kibana_migrator.ts b/src/core/server/saved_objects/migrations/kibana/kibana_migrator.ts
index 4f69d45c192e9..69b57a498936e 100644
--- a/src/core/server/saved_objects/migrations/kibana/kibana_migrator.ts
+++ b/src/core/server/saved_objects/migrations/kibana/kibana_migrator.ts
@@ -74,6 +74,7 @@ export class KibanaMigrator {
private readonly status$ = new BehaviorSubject({
status: 'waiting',
});
+ private readonly activeMappings: IndexMapping;
/**
* Creates an instance of KibanaMigrator.
@@ -100,6 +101,9 @@ export class KibanaMigrator {
validateDoc: docValidator(savedObjectValidations || {}),
log: this.log,
});
+ // Building the active mappings (and associated md5sums) is an expensive
+ // operation so we cache the result
+ this.activeMappings = buildActiveMappings(this.mappingProperties);
}
/**
@@ -172,7 +176,7 @@ export class KibanaMigrator {
*
*/
public getActiveMappings(): IndexMapping {
- return buildActiveMappings(this.mappingProperties);
+ return this.activeMappings;
}
/**
diff --git a/src/core/server/saved_objects/routes/integration_tests/bulk_create.test.ts b/src/core/server/saved_objects/routes/integration_tests/bulk_create.test.ts
index 5b52665b6268e..28afdefe1413f 100644
--- a/src/core/server/saved_objects/routes/integration_tests/bulk_create.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/bulk_create.test.ts
@@ -21,7 +21,7 @@ import supertest from 'supertest';
import { UnwrapPromise } from '@kbn/utility-types';
import { registerBulkCreateRoute } from '../bulk_create';
import { savedObjectsClientMock } from '../../../../../core/server/mocks';
-import { setupServer } from './test_utils';
+import { setupServer } from '../test_utils';
type setupServerReturn = UnwrapPromise>;
diff --git a/src/core/server/saved_objects/routes/integration_tests/bulk_get.test.ts b/src/core/server/saved_objects/routes/integration_tests/bulk_get.test.ts
index 845bae47b41f2..521e62e16b1d8 100644
--- a/src/core/server/saved_objects/routes/integration_tests/bulk_get.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/bulk_get.test.ts
@@ -21,7 +21,7 @@ import supertest from 'supertest';
import { UnwrapPromise } from '@kbn/utility-types';
import { registerBulkGetRoute } from '../bulk_get';
import { savedObjectsClientMock } from '../../../../../core/server/mocks';
-import { setupServer } from './test_utils';
+import { setupServer } from '../test_utils';
type setupServerReturn = UnwrapPromise>;
diff --git a/src/core/server/saved_objects/routes/integration_tests/bulk_update.test.ts b/src/core/server/saved_objects/routes/integration_tests/bulk_update.test.ts
index 6356fc787a8d8..9c888406b0c96 100644
--- a/src/core/server/saved_objects/routes/integration_tests/bulk_update.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/bulk_update.test.ts
@@ -21,7 +21,7 @@ import supertest from 'supertest';
import { UnwrapPromise } from '@kbn/utility-types';
import { registerBulkUpdateRoute } from '../bulk_update';
import { savedObjectsClientMock } from '../../../../../core/server/mocks';
-import { setupServer } from './test_utils';
+import { setupServer } from '../test_utils';
type setupServerReturn = UnwrapPromise>;
diff --git a/src/core/server/saved_objects/routes/integration_tests/create.test.ts b/src/core/server/saved_objects/routes/integration_tests/create.test.ts
index 5a53a30209281..ba3d620f8fdb5 100644
--- a/src/core/server/saved_objects/routes/integration_tests/create.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/create.test.ts
@@ -21,7 +21,7 @@ import supertest from 'supertest';
import { UnwrapPromise } from '@kbn/utility-types';
import { registerCreateRoute } from '../create';
import { savedObjectsClientMock } from '../../service/saved_objects_client.mock';
-import { setupServer } from './test_utils';
+import { setupServer } from '../test_utils';
type setupServerReturn = UnwrapPromise>;
diff --git a/src/core/server/saved_objects/routes/integration_tests/delete.test.ts b/src/core/server/saved_objects/routes/integration_tests/delete.test.ts
index d4ce4d421dde1..652d267f08fe7 100644
--- a/src/core/server/saved_objects/routes/integration_tests/delete.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/delete.test.ts
@@ -21,7 +21,7 @@ import supertest from 'supertest';
import { UnwrapPromise } from '@kbn/utility-types';
import { registerDeleteRoute } from '../delete';
import { savedObjectsClientMock } from '../../../../../core/server/mocks';
-import { setupServer } from './test_utils';
+import { setupServer } from '../test_utils';
type setupServerReturn = UnwrapPromise>;
diff --git a/src/core/server/saved_objects/routes/integration_tests/export.test.ts b/src/core/server/saved_objects/routes/integration_tests/export.test.ts
index bdb2e23f0826d..7b342dde2febe 100644
--- a/src/core/server/saved_objects/routes/integration_tests/export.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/export.test.ts
@@ -27,7 +27,7 @@ import supertest from 'supertest';
import { UnwrapPromise } from '@kbn/utility-types';
import { SavedObjectConfig } from '../../saved_objects_config';
import { registerExportRoute } from '../export';
-import { setupServer, createExportableType } from './test_utils';
+import { setupServer, createExportableType } from '../test_utils';
type setupServerReturn = UnwrapPromise>;
const exportSavedObjectsToStream = exportMock.exportSavedObjectsToStream as jest.Mock;
diff --git a/src/core/server/saved_objects/routes/integration_tests/find.test.ts b/src/core/server/saved_objects/routes/integration_tests/find.test.ts
index 7916100e46831..31bda1d6b9cbd 100644
--- a/src/core/server/saved_objects/routes/integration_tests/find.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/find.test.ts
@@ -23,7 +23,7 @@ import querystring from 'querystring';
import { UnwrapPromise } from '@kbn/utility-types';
import { registerFindRoute } from '../find';
import { savedObjectsClientMock } from '../../../../../core/server/mocks';
-import { setupServer } from './test_utils';
+import { setupServer } from '../test_utils';
type setupServerReturn = UnwrapPromise>;
diff --git a/src/core/server/saved_objects/routes/integration_tests/import.test.ts b/src/core/server/saved_objects/routes/integration_tests/import.test.ts
index c4a03a0e2e7d2..c4e304a3f892f 100644
--- a/src/core/server/saved_objects/routes/integration_tests/import.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/import.test.ts
@@ -22,7 +22,7 @@ import { UnwrapPromise } from '@kbn/utility-types';
import { registerImportRoute } from '../import';
import { savedObjectsClientMock } from '../../../../../core/server/mocks';
import { SavedObjectConfig } from '../../saved_objects_config';
-import { setupServer, createExportableType } from './test_utils';
+import { setupServer, createExportableType } from '../test_utils';
type setupServerReturn = UnwrapPromise>;
diff --git a/src/core/server/saved_objects/routes/integration_tests/log_legacy_import.test.ts b/src/core/server/saved_objects/routes/integration_tests/log_legacy_import.test.ts
index 4bbe3271e0232..0fe07245dda20 100644
--- a/src/core/server/saved_objects/routes/integration_tests/log_legacy_import.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/log_legacy_import.test.ts
@@ -21,7 +21,7 @@ import supertest from 'supertest';
import { UnwrapPromise } from '@kbn/utility-types';
import { registerLogLegacyImportRoute } from '../log_legacy_import';
import { loggingServiceMock } from '../../../logging/logging_service.mock';
-import { setupServer } from './test_utils';
+import { setupServer } from '../test_utils';
type setupServerReturn = UnwrapPromise>;
diff --git a/src/core/server/saved_objects/routes/integration_tests/resolve_import_errors.test.ts b/src/core/server/saved_objects/routes/integration_tests/resolve_import_errors.test.ts
index a36f246f9dbc5..27750ec692e5a 100644
--- a/src/core/server/saved_objects/routes/integration_tests/resolve_import_errors.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/resolve_import_errors.test.ts
@@ -21,7 +21,7 @@ import supertest from 'supertest';
import { UnwrapPromise } from '@kbn/utility-types';
import { registerResolveImportErrorsRoute } from '../resolve_import_errors';
import { savedObjectsClientMock } from '../../../../../core/server/mocks';
-import { setupServer, createExportableType } from './test_utils';
+import { setupServer, createExportableType } from '../test_utils';
import { SavedObjectConfig } from '../../saved_objects_config';
type setupServerReturn = UnwrapPromise>;
diff --git a/src/core/server/saved_objects/routes/integration_tests/update.test.ts b/src/core/server/saved_objects/routes/integration_tests/update.test.ts
index b0c3d68090db6..eb6eb1cdb6bd9 100644
--- a/src/core/server/saved_objects/routes/integration_tests/update.test.ts
+++ b/src/core/server/saved_objects/routes/integration_tests/update.test.ts
@@ -21,7 +21,7 @@ import supertest from 'supertest';
import { UnwrapPromise } from '@kbn/utility-types';
import { registerUpdateRoute } from '../update';
import { savedObjectsClientMock } from '../../../../../core/server/mocks';
-import { setupServer } from './test_utils';
+import { setupServer } from '../test_utils';
type setupServerReturn = UnwrapPromise>;
diff --git a/src/core/server/saved_objects/routes/integration_tests/test_utils.ts b/src/core/server/saved_objects/routes/test_utils.ts
similarity index 83%
rename from src/core/server/saved_objects/routes/integration_tests/test_utils.ts
rename to src/core/server/saved_objects/routes/test_utils.ts
index 23e0285201dc7..a2227a8033dbd 100644
--- a/src/core/server/saved_objects/routes/integration_tests/test_utils.ts
+++ b/src/core/server/saved_objects/routes/test_utils.ts
@@ -17,14 +17,14 @@
* under the License.
*/
-import { ContextService } from '../../../context';
-import { createHttpServer, createCoreContext } from '../../../http/test_utils';
-import { coreMock } from '../../../mocks';
-import { SavedObjectsType } from '../../types';
+import { ContextService } from '../../context';
+import { createHttpServer, createCoreContext } from '../../http/test_utils';
+import { coreMock } from '../../mocks';
+import { SavedObjectsType } from '../types';
-const coreId = Symbol('core');
+const defaultCoreId = Symbol('core');
-export const setupServer = async () => {
+export const setupServer = async (coreId: symbol = defaultCoreId) => {
const coreContext = createCoreContext({ coreId });
const contextService = new ContextService(coreContext);
diff --git a/src/core/server/saved_objects/service/lib/repository.ts b/src/core/server/saved_objects/service/lib/repository.ts
index e23f8dec5927c..b093fe779cab7 100644
--- a/src/core/server/saved_objects/service/lib/repository.ts
+++ b/src/core/server/saved_objects/service/lib/repository.ts
@@ -136,7 +136,7 @@ export class SavedObjectsRepository {
injectedConstructor: any = SavedObjectsRepository
): ISavedObjectsRepository {
const mappings = migrator.getActiveMappings();
- const allTypes = Object.keys(getRootPropertiesObjects(mappings));
+ const allTypes = typeRegistry.getAllTypes().map((t) => t.name);
const serializer = new SavedObjectsSerializer(typeRegistry);
const visibleTypes = allTypes.filter((type) => !typeRegistry.isHidden(type));
diff --git a/src/core/server/test_utils.ts b/src/core/server/test_utils.ts
index f7e6fbcd0c131..6b16fe3bdef61 100644
--- a/src/core/server/test_utils.ts
+++ b/src/core/server/test_utils.ts
@@ -19,3 +19,4 @@
export { createHttpServer } from './http/test_utils';
export { ServiceStatusLevelSnapshotSerializer } from './status/test_utils';
+export { setupServer } from './saved_objects/routes/test_utils';
diff --git a/src/core/types/index.ts b/src/core/types/index.ts
index 346b4cfce70c1..07d7789d235ec 100644
--- a/src/core/types/index.ts
+++ b/src/core/types/index.ts
@@ -26,3 +26,4 @@ export * from './capabilities';
export * from './app_category';
export * from './ui_settings';
export * from './saved_objects';
+export * from './serializable';
diff --git a/src/core/types/serializable.ts b/src/core/types/serializable.ts
new file mode 100644
index 0000000000000..9e8ea123bea91
--- /dev/null
+++ b/src/core/types/serializable.ts
@@ -0,0 +1,32 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+export type Serializable =
+ | string
+ | number
+ | boolean
+ | null
+ | SerializableArray
+ | SerializableRecord;
+
+// we need interfaces instead of types here to allow cyclic references
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface SerializableArray extends Array {}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface SerializableRecord extends Record {}
diff --git a/src/dev/build/build_distributables.js b/src/dev/build/build_distributables.js
index 3a8709893565d..66f0c0355c2d9 100644
--- a/src/dev/build/build_distributables.js
+++ b/src/dev/build/build_distributables.js
@@ -30,6 +30,7 @@ import {
CleanTypescriptTask,
CleanNodeBuildsTask,
CleanTask,
+ CopyBinScriptsTask,
CopySourceTask,
CreateArchivesSourcesTask,
CreateArchivesTask,
@@ -110,6 +111,7 @@ export async function buildDistributables(options) {
* run platform-generic build tasks
*/
await run(CopySourceTask);
+ await run(CopyBinScriptsTask);
await run(CreateEmptyDirsAndFilesTask);
await run(CreateReadmeTask);
await run(TranspileBabelTask);
diff --git a/src/dev/build/tasks/bin/copy_bin_scripts_task.js b/src/dev/build/tasks/bin/copy_bin_scripts_task.js
new file mode 100644
index 0000000000000..f620f12b17d88
--- /dev/null
+++ b/src/dev/build/tasks/bin/copy_bin_scripts_task.js
@@ -0,0 +1,31 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { copyAll } from '../../lib';
+
+export const CopyBinScriptsTask = {
+ description: 'Copying bin scripts into platform-generic build directory',
+
+ async run(config, log, build) {
+ await copyAll(
+ config.resolveFromRepo('src/dev/build/tasks/bin/scripts'),
+ build.resolvePath('bin')
+ );
+ },
+};
diff --git a/src/legacy/ui/public/error_url_overflow/index.js b/src/dev/build/tasks/bin/index.js
similarity index 87%
rename from src/legacy/ui/public/error_url_overflow/index.js
rename to src/dev/build/tasks/bin/index.js
index 06a98789349f8..e970ac5ec044b 100644
--- a/src/legacy/ui/public/error_url_overflow/index.js
+++ b/src/dev/build/tasks/bin/index.js
@@ -17,5 +17,4 @@
* under the License.
*/
-import './error_url_overflow';
-export { UrlOverflowService } from '../../../../plugins/kibana_legacy/public';
+export { CopyBinScriptsTask } from './copy_bin_scripts_task';
diff --git a/bin/kibana b/src/dev/build/tasks/bin/scripts/kibana
similarity index 100%
rename from bin/kibana
rename to src/dev/build/tasks/bin/scripts/kibana
diff --git a/bin/kibana-keystore b/src/dev/build/tasks/bin/scripts/kibana-keystore
similarity index 100%
rename from bin/kibana-keystore
rename to src/dev/build/tasks/bin/scripts/kibana-keystore
diff --git a/bin/kibana-keystore.bat b/src/dev/build/tasks/bin/scripts/kibana-keystore.bat
similarity index 100%
rename from bin/kibana-keystore.bat
rename to src/dev/build/tasks/bin/scripts/kibana-keystore.bat
diff --git a/bin/kibana-plugin b/src/dev/build/tasks/bin/scripts/kibana-plugin
similarity index 100%
rename from bin/kibana-plugin
rename to src/dev/build/tasks/bin/scripts/kibana-plugin
diff --git a/bin/kibana-plugin.bat b/src/dev/build/tasks/bin/scripts/kibana-plugin.bat
similarity index 100%
rename from bin/kibana-plugin.bat
rename to src/dev/build/tasks/bin/scripts/kibana-plugin.bat
diff --git a/bin/kibana.bat b/src/dev/build/tasks/bin/scripts/kibana.bat
similarity index 100%
rename from bin/kibana.bat
rename to src/dev/build/tasks/bin/scripts/kibana.bat
diff --git a/src/dev/build/tasks/copy_source_task.js b/src/dev/build/tasks/copy_source_task.js
index ee9dc159de47f..ddc6d000bca19 100644
--- a/src/dev/build/tasks/copy_source_task.js
+++ b/src/dev/build/tasks/copy_source_task.js
@@ -42,7 +42,6 @@ export const CopySourceTask = {
'!src/es_archiver/**',
'!src/functional_test_runner/**',
'!src/dev/**',
- 'bin/**',
'typings/**',
'webpackShims/**',
'config/kibana.yml',
diff --git a/src/dev/build/tasks/index.js b/src/dev/build/tasks/index.js
index 8105fa8a7d5d4..bafb5a2fe115e 100644
--- a/src/dev/build/tasks/index.js
+++ b/src/dev/build/tasks/index.js
@@ -17,6 +17,7 @@
* under the License.
*/
+export * from './bin';
export * from './build_packages_task';
export * from './clean_tasks';
export * from './copy_source_task';
diff --git a/src/dev/build/tasks/os_packages/run_fpm.js b/src/dev/build/tasks/os_packages/run_fpm.js
index c49ff01b24086..0496bcf08fb91 100644
--- a/src/dev/build/tasks/os_packages/run_fpm.js
+++ b/src/dev/build/tasks/os_packages/run_fpm.js
@@ -123,9 +123,9 @@ export async function runFpm(config, log, build, type, pkgSpecificFlags) {
// copy the data directory at /var/lib/kibana
`${resolveWithTrailingSlash(fromBuild('data'))}=/var/lib/kibana/`,
- // copy the generated pleaserun services for systemd and sysv into /etc/
- `${resolveWithTrailingSlash(__dirname, 'service_templates/sysv/etc')}=/etc/`,
- `${resolveWithTrailingSlash(__dirname, 'service_templates/systemd/etc')}=/etc/`,
+ // copy package configurations
+ `${resolveWithTrailingSlash(__dirname, 'service_templates/sysv/')}=/`,
+ `${resolveWithTrailingSlash(__dirname, 'service_templates/systemd/')}=/`,
];
log.debug('calling fpm with args:', args);
diff --git a/src/dev/build/tasks/os_packages/service_templates/systemd/usr/lib/tmpfiles.d/kibana.conf b/src/dev/build/tasks/os_packages/service_templates/systemd/usr/lib/tmpfiles.d/kibana.conf
new file mode 100644
index 0000000000000..b5422df52fe11
--- /dev/null
+++ b/src/dev/build/tasks/os_packages/service_templates/systemd/usr/lib/tmpfiles.d/kibana.conf
@@ -0,0 +1 @@
+d /var/run/kibana 0755 kibana kibana - -
\ No newline at end of file
diff --git a/src/dev/build/tasks/os_packages/service_templates/sysv/etc/init.d/kibana b/src/dev/build/tasks/os_packages/service_templates/sysv/etc/init.d/kibana
index ce29fd12b8e3c..d935dc6e31f80 100755
--- a/src/dev/build/tasks/os_packages/service_templates/sysv/etc/init.d/kibana
+++ b/src/dev/build/tasks/os_packages/service_templates/sysv/etc/init.d/kibana
@@ -17,7 +17,7 @@
name=kibana
program=/usr/share/kibana/bin/kibana
-pidfile="/var/run/$name.pid"
+pidfile="/var/run/kibana/$name.pid"
[ -r /etc/default/$name ] && . /etc/default/$name
[ -r /etc/sysconfig/$name ] && . /etc/sysconfig/$name
@@ -37,17 +37,13 @@ emit() {
}
start() {
-
- # Ensure the log directory is setup correctly.
[ ! -d "/var/log/kibana/" ] && mkdir "/var/log/kibana/"
chown "$user":"$group" "/var/log/kibana/"
chmod 755 "/var/log/kibana/"
-
- # Setup any environmental stuff beforehand
-
-
- # Run the program!
+ [ ! -d "/var/run/kibana/" ] && mkdir "/var/run/kibana/"
+ chown "$user":"$group" "/var/run/kibana/"
+ chmod 755 "/var/run/kibana/"
chroot --userspec "$user":"$group" "$chroot" sh -c "
diff --git a/src/dev/code_coverage/nyc_config/nyc.functional.config.js b/src/dev/code_coverage/nyc_config/nyc.functional.config.js
new file mode 100644
index 0000000000000..20d266ab9e2c3
--- /dev/null
+++ b/src/dev/code_coverage/nyc_config/nyc.functional.config.js
@@ -0,0 +1,31 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const defaultExclude = require('@istanbuljs/schema/default-exclude');
+const extraExclude = ['data/optimize/**', 'src/core/server/**', '**/test/**'];
+const path = require('path');
+
+module.exports = {
+ 'temp-dir': process.env.COVERAGE_TEMP_DIR
+ ? path.resolve(process.env.COVERAGE_TEMP_DIR, 'functional')
+ : 'target/kibana-coverage/functional',
+ 'report-dir': 'target/kibana-coverage/functional-combined',
+ reporter: ['html', 'json-summary'],
+ exclude: extraExclude.concat(defaultExclude),
+};
diff --git a/src/dev/code_coverage/nyc_config/nyc.jest.config.js b/src/dev/code_coverage/nyc_config/nyc.jest.config.js
new file mode 100644
index 0000000000000..1f73347837ab3
--- /dev/null
+++ b/src/dev/code_coverage/nyc_config/nyc.jest.config.js
@@ -0,0 +1,28 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+const path = require('path');
+
+module.exports = {
+ 'temp-dir': process.env.COVERAGE_TEMP_DIR
+ ? path.resolve(process.env.COVERAGE_TEMP_DIR, 'jest')
+ : 'target/kibana-coverage/jest',
+ 'report-dir': 'target/kibana-coverage/jest-combined',
+ reporter: ['html', 'json-summary'],
+};
diff --git a/src/dev/code_coverage/shell_scripts/merge_jest_and_functional.sh b/src/dev/code_coverage/shell_scripts/merge_jest_and_functional.sh
index ff9cb36c894f8..707c6de3f88a0 100644
--- a/src/dev/code_coverage/shell_scripts/merge_jest_and_functional.sh
+++ b/src/dev/code_coverage/shell_scripts/merge_jest_and_functional.sh
@@ -1,10 +1,9 @@
#!/bin/bash
-EXTRACT_START_DIR=tmp/extracted_coverage
-EXTRACT_END_DIR=target/kibana-coverage
-COMBINED_EXTRACT_DIR=/${EXTRACT_START_DIR}/${EXTRACT_END_DIR}
+COVERAGE_TEMP_DIR=/tmp/extracted_coverage/target/kibana-coverage/
+export COVERAGE_TEMP_DIR
echo "### Merge coverage reports"
for x in jest functional; do
- yarn nyc report --temp-dir $COMBINED_EXTRACT_DIR/${x} --report-dir $EXTRACT_END_DIR/${x}-combined --reporter=html --reporter=json-summary
+ yarn nyc report --nycrc-path src/dev/code_coverage/nyc_config/nyc.${x}.config.js
done
diff --git a/src/dev/jest/config.js b/src/dev/jest/config.js
index 497a639ecab56..64db131f5219a 100644
--- a/src/dev/jest/config.js
+++ b/src/dev/jest/config.js
@@ -64,7 +64,8 @@ export default {
'\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$':
'/src/dev/jest/mocks/file_mock.js',
'\\.(css|less|scss)$': '/src/dev/jest/mocks/style_mock.js',
- '\\.ace\\.worker.js$': '/src/dev/jest/mocks/ace_worker_module_mock.js',
+ '\\.ace\\.worker.js$': '/src/dev/jest/mocks/worker_module_mock.js',
+ '\\.editor\\.worker.js$': '/src/dev/jest/mocks/worker_module_mock.js',
'^(!!)?file-loader!': '
diff --git a/examples/developer_examples/kibana.json b/examples/developer_examples/kibana.json
new file mode 100644
index 0000000000000..8c9ec2e4dcbfc
--- /dev/null
+++ b/examples/developer_examples/kibana.json
@@ -0,0 +1,9 @@
+{
+ "id": "developerExamples",
+ "version": "0.0.1",
+ "kibanaVersion": "kibana",
+ "server": false,
+ "ui": true,
+ "requiredPlugins": [],
+ "optionalPlugins": []
+}
diff --git a/examples/developer_examples/navigation.png b/examples/developer_examples/navigation.png
new file mode 100644
index 0000000000000..ac72f697e5db0
Binary files /dev/null and b/examples/developer_examples/navigation.png differ
diff --git a/examples/developer_examples/public/app.tsx b/examples/developer_examples/public/app.tsx
new file mode 100644
index 0000000000000..2ce21bae75e21
--- /dev/null
+++ b/examples/developer_examples/public/app.tsx
@@ -0,0 +1,117 @@
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import React, { useState } from 'react';
+import ReactDOM from 'react-dom';
+
+import {
+ EuiText,
+ EuiPageContent,
+ EuiCard,
+ EuiPageContentHeader,
+ EuiFlexGroup,
+ EuiFlexItem,
+ EuiFieldSearch,
+ EuiListGroup,
+ EuiHighlight,
+ EuiLink,
+ EuiButtonIcon,
+} from '@elastic/eui';
+import { AppMountParameters } from '../../../src/core/public';
+import { ExampleDefinition } from './types';
+
+interface Props {
+ examples: ExampleDefinition[];
+ navigateToApp: (appId: string) => void;
+ getUrlForApp: (appId: string) => string;
+}
+
+function DeveloperExamples({ examples, navigateToApp, getUrlForApp }: Props) {
+ const [search, setSearch] = useState