@slicemachine/init 1.1.19 → 2.0.0

package/dist/_node_modules/ignore/index.js

@@ -0,0 +1,371 @@
+function makeArray(subject) {
+  return Array.isArray(subject) ? subject : [subject];
+}
+const EMPTY = "";
+const SPACE = " ";
+const ESCAPE = "\\";
+const REGEX_TEST_BLANK_LINE = /^\s+$/;
+const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+const REGEX_SPLITALL_CRLF = /\r?\n/g;
+const REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+const SLASH = "/";
+let TMP_KEY_IGNORE = "node-ignore";
+if (typeof Symbol !== "undefined") {
+  TMP_KEY_IGNORE = Symbol.for("node-ignore");
+}
+const KEY_IGNORE = TMP_KEY_IGNORE;
+const define = (object, key, value) => Object.defineProperty(object, key, { value });
+const REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+const RETURN_FALSE = () => false;
+const sanitizeRange = (range) => range.replace(
+  REGEX_REGEXP_RANGE,
+  (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+);
+const cleanRangeBackSlash = (slashes) => {
+  const { length } = slashes;
+  return slashes.slice(0, length - length % 2);
+};
+const REPLACERS = [
+  // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+  [
+    // (a\ ) -> (a )
+    // (a  ) -> (a)
+    // (a \ ) -> (a  )
+    /\\?\s+$/,
+    (match) => match.indexOf("\\") === 0 ? SPACE : EMPTY
+  ],
+  // replace (\ ) with ' '
+  [
+    /\\\s/g,
+    () => SPACE
+  ],
+  // Escape metacharacters
+  // which is written down by users but means special for regular expressions.
+  // > 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}`
+  ],
+  [
+    // > a question mark (?) matches a single character
+    /(?!\\)\?/g,
+    () => "[^/]"
+  ],
+  // leading slash
+  [
+    // > 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
+    /^\//,
+    () => "^"
+  ],
+  // replace special metacharacter slash after the leading slash
+  [
+    /\//g,
+    () => "\\/"
+  ],
+  [
+    // > 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 '\\*'
+    /^\^*\\\*\\\*\\\//,
+    // '**/foo' <-> 'foo'
+    () => "^(?:.*\\/)?"
+  ],
+  // 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) ? "(?:^|\\/)" : "^";
+    }
+  ],
+  // two globstars
+  [
+    // Use lookahead assertions so that we could match more than one `'/**'`
+    /\\\/\\\*\\\*(?=\\\/|$)/g,
+    // Zero, one or several directories
+    // should not use '*', or it will be replaced by the next replacer
+    // Check if it is not the last `'/**'`
+    (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+  ],
+  // normal intermediate wildcards
+  [
+    // Never replace escaped '*'
+    // ignore rule '\*' will match the path '*'
+    // 'abc.*/' -> go
+    // 'abc.*'  -> skip this rule,
+    //    coz trailing single wildcard will be handed by [trailing wildcard]
+    /(^|[^\\]+)(\\\*)+(?=.+)/g,
+    // '*.js' matches '.js'
+    // '*.js' doesn't match 'abc'
+    (_, p1, p2) => {
+      const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+      return p1 + unescaped;
+    }
+  ],
+  [
+    // unescape, revert step 3 except for back slash
+    // For example, if a user escape a '\\*',
+    // after step 3, the result will be '\\\\\\*'
+    /\\\\\\(?=[$.|*+(){^])/g,
+    () => ESCAPE
+  ],
+  [
+    // '\\\\' -> '\\'
+    /\\\\/g,
+    () => ESCAPE
+  ],
+  [
+    // > The range notation, e.g. [a-zA-Z],
+    // > can be used to match one of the characters in a range.
+    // `\` is escaped by step 3
+    /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+    (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+  ],
+  // ending
+  [
+    // 'js' will not match 'js.'
+    // 'ab' will not match 'abc'
+    /(?:[^*])$/,
+    // WTF!
+    // https://git-scm.com/docs/gitignore
+    // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+    // which re-fixes #24, #38
+    // > If there is a separator at the end of the pattern then the pattern
+    // > will only match directories, otherwise the pattern can match both
+    // > files and directories.
+    // 'js*' will not match 'a.js'
+    // 'js/' will not match 'a.js'
+    // 'js' will match 'a.js' and 'a.js/'
+    (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+  ],
+  // trailing wildcard
+  [
+    /(\^|\\\/)?\\\*$/,
+    (_, p1) => {
+      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    }
+  ]
+];
+const regexCache = /* @__PURE__ */ Object.create(null);
+const makeRegex = (pattern, ignoreCase) => {
+  let source = regexCache[pattern];
+  if (!source) {
+    source = REPLACERS.reduce(
+      (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+      pattern
+    );
+    regexCache[pattern] = source;
+  }
+  return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+};
+const isString = (subject) => typeof subject === "string";
+const checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && 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;
+  }
+}
+const createRule = (pattern, ignoreCase) => {
+  const origin = pattern;
+  let negative = false;
+  if (pattern.indexOf("!") === 0) {
+    negative = true;
+    pattern = pattern.substr(1);
+  }
+  pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+  const regex = makeRegex(pattern, ignoreCase);
+  return new IgnoreRule(
+    origin,
+    pattern,
+    negative,
+    regex
+  );
+};
+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
+    );
+  }
+  if (!path) {
+    return doThrow(`path must not be empty`, TypeError);
+  }
+  if (checkPath.isNotRelative(path)) {
+    const r = "`path.relative()`d";
+    return doThrow(
+      `path should be a ${r} string, but got "${originalPath}"`,
+      RangeError
+    );
+  }
+  return true;
+};
+const isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+checkPath.isNotRelative = isNotRelative;
+checkPath.convert = (p) => p;
+class Ignore {
+  constructor({
+    ignorecase = true,
+    ignoreCase = ignorecase,
+    allowRelativePaths = false
+  } = {}) {
+    define(this, KEY_IGNORE, true);
+    this._rules = [];
+    this._ignoreCase = ignoreCase;
+    this._allowRelativePaths = allowRelativePaths;
+    this._initCache();
+  }
+  _initCache() {
+    this._ignoreCache = /* @__PURE__ */ Object.create(null);
+    this._testCache = /* @__PURE__ */ Object.create(null);
+  }
+  _addPattern(pattern) {
+    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);
+    }
+  }
+  // @param {Array<string> | string | Ignore} pattern
+  add(pattern) {
+    this._added = false;
+    makeArray(
+      isString(pattern) ? splitPattern(pattern) : pattern
+    ).forEach(this._addPattern, this);
+    if (this._added) {
+      this._initCache();
+    }
+    return this;
+  }
+  // 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
+  // - SKIP: always skip
+  // - TEST: always test
+  // - TESTIF: only test if checkUnignored
+  // - X: that never happen
+  // @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;
+    this._rules.forEach((rule) => {
+      const { negative } = rule;
+      if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+        return;
+      }
+      const matched = rule.regex.test(path);
+      if (matched) {
+        ignored = !negative;
+        unignored = negative;
+      }
+    });
+    return {
+      ignored,
+      unignored
+    };
+  }
+  // @returns {TestResult}
+  _test(originalPath, cache, checkUnignored, slices) {
+    const path = originalPath && checkPath.convert(originalPath);
+    checkPath(
+      path,
+      originalPath,
+      this._allowRelativePaths ? RETURN_FALSE : throwError
+    );
+    return this._t(path, cache, checkUnignored, slices);
+  }
+  _t(path, cache, checkUnignored, slices) {
+    if (path in cache) {
+      return cache[path];
+    }
+    if (!slices) {
+      slices = path.split(SLASH);
+    }
+    slices.pop();
+    if (!slices.length) {
+      return cache[path] = this._testOne(path, checkUnignored);
+    }
+    const parent = this._t(
+      slices.join(SLASH) + SLASH,
+      cache,
+      checkUnignored,
+      slices
+    );
+    return cache[path] = parent.ignored ? parent : this._testOne(path, checkUnignored);
+  }
+  ignores(path) {
+    return this._test(path, this._ignoreCache, false).ignored;
+  }
+  createFilter() {
+    return (path) => !this.ignores(path);
+  }
+  filter(paths) {
+    return makeArray(paths).filter(this.createFilter());
+  }
+  // @returns {TestResult}
+  test(path) {
+    return this._test(path, this._testCache, true);
+  }
+}
+const factory = (options) => new Ignore(options);
+const isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+factory.isPathValid = isPathValid;
+factory.default = factory;
+var ignore = factory;
+if (
+  // Detect `process` so that it can run in browsers.
+  typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")
+) {
+  const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+  checkPath.convert = makePosix;
+  const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+  checkPath.isNotRelative = (path) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+}
+export {
+  ignore as default
+};
+//# sourceMappingURL=index.js.map

package/dist/_node_modules/ignore/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../node_modules/ignore/index.js"],"sourcesContent":["// A simple implementation of make-array\nfunction makeArray (subject) {\n  return Array.isArray(subject)\n    ? subject\n    : [subject]\n}\n\nconst EMPTY = ''\nconst SPACE = ' '\nconst ESCAPE = '\\\\'\nconst REGEX_TEST_BLANK_LINE = /^\\s+$/\nconst REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\\\]|^)\\\\$/\nconst REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\\\!/\nconst REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\\\#/\nconst REGEX_SPLITALL_CRLF = /\\r?\\n/g\n// /foo,\n// ./foo,\n// ../foo,\n// .\n// ..\nconst REGEX_TEST_INVALID_PATH = /^\\.*\\/|^\\.+$/\n\nconst SLASH = '/'\n\n// Do not use ternary expression here, since \"istanbul ignore next\" is buggy\nlet TMP_KEY_IGNORE = 'node-ignore'\n/* istanbul ignore else */\nif (typeof Symbol !== 'undefined') {\n  TMP_KEY_IGNORE = Symbol.for('node-ignore')\n}\nconst KEY_IGNORE = TMP_KEY_IGNORE\n\nconst define = (object, key, value) =>\n  Object.defineProperty(object, key, {value})\n\nconst REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g\n\nconst RETURN_FALSE = () => false\n\n// Sanitize the range of a regular expression\n// The cases are complicated, see test cases for details\nconst sanitizeRange = range => range.replace(\n  REGEX_REGEXP_RANGE,\n  (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0)\n    ? match\n    // Invalid range (out of order) which is ok for gitignore rules but\n    //   fatal for JavaScript regular expression, so eliminate it.\n    : EMPTY\n)\n\n// See fixtures #59\nconst cleanRangeBackSlash = slashes => {\n  const {length} = slashes\n  return slashes.slice(0, length - length % 2)\n}\n\n// > If the pattern ends with a slash,\n// > it is removed for the purpose of the following description,\n// > but it would only find a match with a directory.\n// > In other words, foo/ will match a directory foo and paths underneath it,\n// > but will not match a regular file or a symbolic link foo\n// >  (this is consistent with the way how pathspec works in general in Git).\n// '`foo/`' will not match regular file '`foo`' or symbolic link '`foo`'\n// -> ignore-rules will not deal with it, because it costs extra `fs.stat` call\n//      you could use option `mark: true` with `glob`\n\n// '`foo/`' should not continue with the '`..`'\nconst REPLACERS = [\n\n  // > Trailing spaces are ignored unless they are quoted with backslash (\"\\\")\n  [\n    // (a\\ ) -> (a )\n    // (a  ) -> (a)\n    // (a \\ ) -> (a  )\n    /\\\\?\\s+$/,\n    match => match.indexOf('\\\\') === 0\n      ? SPACE\n      : EMPTY\n  ],\n\n  // replace (\\ ) with ' '\n  [\n    /\\\\\\s/g,\n    () => SPACE\n  ],\n\n  // Escape metacharacters\n  // which is written down by users but means special for regular expressions.\n\n  // > There are 12 characters with special meanings:\n  // > - the backslash \\,\n  // > - the caret ^,\n  // > - the dollar sign $,\n  // > - the period or dot .,\n  // > - the vertical bar or pipe symbol |,\n  // > - the question mark ?,\n  // > - the asterisk or star *,\n  // > - the plus sign +,\n  // > - the opening parenthesis (,\n  // > - the closing parenthesis ),\n  // > - and the opening square bracket [,\n  // > - the opening curly brace {,\n  // > These special characters are often called \"metacharacters\".\n  [\n    /[\\\\$.|*+(){^]/g,\n    match => `\\\\${match}`\n  ],\n\n  [\n    // > a question mark (?) matches a single character\n    /(?!\\\\)\\?/g,\n    () => '[^/]'\n  ],\n\n  // leading slash\n  [\n\n    // > A leading slash matches the beginning of the pathname.\n    // > For example, \"/*.c\" matches \"cat-file.c\" but not \"mozilla-sha1/sha1.c\".\n    // A leading slash matches the beginning of the pathname\n    /^\\//,\n    () => '^'\n  ],\n\n  // replace special metacharacter slash after the leading slash\n  [\n    /\\//g,\n    () => '\\\\/'\n  ],\n\n  [\n    // > A leading \"**\" followed by a slash means match in all directories.\n    // > For example, \"**/foo\" matches file or directory \"foo\" anywhere,\n    // > the same as pattern \"foo\".\n    // > \"**/foo/bar\" matches file or directory \"bar\" anywhere that is directly\n    // >   under directory \"foo\".\n    // Notice that the '*'s have been replaced as '\\\\*'\n    /^\\^*\\\\\\*\\\\\\*\\\\\\//,\n\n    // '**/foo' <-> 'foo'\n    () => '^(?:.*\\\\/)?'\n  ],\n\n  // starting\n  [\n    // there will be no leading '/'\n    //   (which has been replaced by section \"leading slash\")\n    // If starts with '**', adding a '^' to the regular expression also works\n    /^(?=[^^])/,\n    function startingReplacer () {\n      // If has a slash `/` at the beginning or middle\n      return !/\\/(?!$)/.test(this)\n        // > Prior to 2.22.1\n        // > If the pattern does not contain a slash /,\n        // >   Git treats it as a shell glob pattern\n        // Actually, if there is only a trailing slash,\n        //   git also treats it as a shell glob pattern\n\n        // After 2.22.1 (compatible but clearer)\n        // > If there is a separator at the beginning or middle (or both)\n        // > of the pattern, then the pattern is relative to the directory\n        // > level of the particular .gitignore file itself.\n        // > Otherwise the pattern may also match at any level below\n        // > the .gitignore level.\n        ? '(?:^|\\\\/)'\n\n        // > Otherwise, Git treats the pattern as a shell glob suitable for\n        // >   consumption by fnmatch(3)\n        : '^'\n    }\n  ],\n\n  // two globstars\n  [\n    // Use lookahead assertions so that we could match more than one `'/**'`\n    /\\\\\\/\\\\\\*\\\\\\*(?=\\\\\\/|$)/g,\n\n    // Zero, one or several directories\n    // should not use '*', or it will be replaced by the next replacer\n\n    // Check if it is not the last `'/**'`\n    (_, index, str) => index + 6 < str.length\n\n      // case: /**/\n      // > A slash followed by two consecutive asterisks then a slash matches\n      // >   zero or more directories.\n      // > For example, \"a/**/b\" matches \"a/b\", \"a/x/b\", \"a/x/y/b\" and so on.\n      // '/**/'\n      ? '(?:\\\\/[^\\\\/]+)*'\n\n      // case: /**\n      // > A trailing `\"/**\"` matches everything inside.\n\n      // #21: everything inside but it should not include the current folder\n      : '\\\\/.+'\n  ],\n\n  // normal intermediate wildcards\n  [\n    // Never replace escaped '*'\n    // ignore rule '\\*' will match the path '*'\n\n    // 'abc.*/' -> go\n    // 'abc.*'  -> skip this rule,\n    //    coz trailing single wildcard will be handed by [trailing wildcard]\n    /(^|[^\\\\]+)(\\\\\\*)+(?=.+)/g,\n\n    // '*.js' matches '.js'\n    // '*.js' doesn't match 'abc'\n    (_, p1, p2) => {\n      // 1.\n      // > An asterisk \"*\" matches anything except a slash.\n      // 2.\n      // > Other consecutive asterisks are considered regular asterisks\n      // > and will match according to the previous rules.\n      const unescaped = p2.replace(/\\\\\\*/g, '[^\\\\/]*')\n      return p1 + unescaped\n    }\n  ],\n\n  [\n    // unescape, revert step 3 except for back slash\n    // For example, if a user escape a '\\\\*',\n    // after step 3, the result will be '\\\\\\\\\\\\*'\n    /\\\\\\\\\\\\(?=[$.|*+(){^])/g,\n    () => ESCAPE\n  ],\n\n  [\n    // '\\\\\\\\' -> '\\\\'\n    /\\\\\\\\/g,\n    () => ESCAPE\n  ],\n\n  [\n    // > The range notation, e.g. [a-zA-Z],\n    // > can be used to match one of the characters in a range.\n\n    // `\\` is escaped by step 3\n    /(\\\\)?\\[([^\\]/]*?)(\\\\*)($|\\])/g,\n    (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE\n      // '\\\\[bar]' -> '\\\\\\\\[bar\\\\]'\n      ? `\\\\[${range}${cleanRangeBackSlash(endEscape)}${close}`\n      : close === ']'\n        ? endEscape.length % 2 === 0\n          // A normal case, and it is a range notation\n          // '[bar]'\n          // '[bar\\\\\\\\]'\n          ? `[${sanitizeRange(range)}${endEscape}]`\n          // Invalid range notaton\n          // '[bar\\\\]' -> '[bar\\\\\\\\]'\n          : '[]'\n        : '[]'\n  ],\n\n  // ending\n  [\n    // 'js' will not match 'js.'\n    // 'ab' will not match 'abc'\n    /(?:[^*])$/,\n\n    // WTF!\n    // https://git-scm.com/docs/gitignore\n    // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)\n    // which re-fixes #24, #38\n\n    // > If there is a separator at the end of the pattern then the pattern\n    // > will only match directories, otherwise the pattern can match both\n    // > files and directories.\n\n    // 'js*' will not match 'a.js'\n    // 'js/' will not match 'a.js'\n    // 'js' will match 'a.js' and 'a.js/'\n    match => /\\/$/.test(match)\n      // foo/ will not match 'foo'\n      ? `${match}$`\n      // foo matches 'foo' and 'foo/'\n      : `${match}(?=$|\\\\/$)`\n  ],\n\n  // trailing wildcard\n  [\n    /(\\^|\\\\\\/)?\\\\\\*$/,\n    (_, p1) => {\n      const prefix = p1\n        // '\\^':\n        // '/*' does not match EMPTY\n        // '/*' does not match everything\n\n        // '\\\\\\/':\n        // 'abc/*' does not match 'abc/'\n        ? `${p1}[^/]+`\n\n        // 'a*' matches 'a'\n        // 'a*' matches 'aa'\n        : '[^/]*'\n\n      return `${prefix}(?=$|\\\\/$)`\n    }\n  ],\n]\n\n// A simple cache, because an ignore rule only has only one certain meaning\nconst regexCache = Object.create(null)\n\n// @param {pattern}\nconst makeRegex = (pattern, ignoreCase) => {\n  let source = regexCache[pattern]\n\n  if (!source) {\n    source = REPLACERS.reduce(\n      (prev, current) => prev.replace(current[0], current[1].bind(pattern)),\n      pattern\n    )\n    regexCache[pattern] = source\n  }\n\n  return ignoreCase\n    ? new RegExp(source, 'i')\n    : new RegExp(source)\n}\n\nconst isString = subject => typeof subject === 'string'\n\n// > A blank line matches no files, so it can serve as a separator for readability.\nconst checkPattern = pattern => pattern\n  && isString(pattern)\n  && !REGEX_TEST_BLANK_LINE.test(pattern)\n  && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)\n\n  // > A line starting with # serves as a comment.\n  && pattern.indexOf('#') !== 0\n\nconst splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF)\n\nclass IgnoreRule {\n  constructor (\n    origin,\n    pattern,\n    negative,\n    regex\n  ) {\n    this.origin = origin\n    this.pattern = pattern\n    this.negative = negative\n    this.regex = regex\n  }\n}\n\nconst createRule = (pattern, ignoreCase) => {\n  const origin = pattern\n  let negative = false\n\n  // > An optional prefix \"!\" which negates the pattern;\n  if (pattern.indexOf('!') === 0) {\n    negative = true\n    pattern = pattern.substr(1)\n  }\n\n  pattern = pattern\n  // > Put a backslash (\"\\\") in front of the first \"!\" for patterns that\n  // >   begin with a literal \"!\", for example, `\"\\!important!.txt\"`.\n  .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')\n  // > Put a backslash (\"\\\") in front of the first hash for patterns that\n  // >   begin with a hash.\n  .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#')\n\n  const regex = makeRegex(pattern, ignoreCase)\n\n  return new IgnoreRule(\n    origin,\n    pattern,\n    negative,\n    regex\n  )\n}\n\nconst throwError = (message, Ctor) => {\n  throw new Ctor(message)\n}\n\nconst checkPath = (path, originalPath, doThrow) => {\n  if (!isString(path)) {\n    return doThrow(\n      `path must be a string, but got \\`${originalPath}\\``,\n      TypeError\n    )\n  }\n\n  // We don't know if we should ignore EMPTY, so throw\n  if (!path) {\n    return doThrow(`path must not be empty`, TypeError)\n  }\n\n  // Check if it is a relative path\n  if (checkPath.isNotRelative(path)) {\n    const r = '`path.relative()`d'\n    return doThrow(\n      `path should be a ${r} string, but got \"${originalPath}\"`,\n      RangeError\n    )\n  }\n\n  return true\n}\n\nconst isNotRelative = path => REGEX_TEST_INVALID_PATH.test(path)\n\ncheckPath.isNotRelative = isNotRelative\ncheckPath.convert = p => p\n\nclass Ignore {\n  constructor ({\n    ignorecase = true,\n    ignoreCase = ignorecase,\n    allowRelativePaths = false\n  } = {}) {\n    define(this, KEY_IGNORE, true)\n\n    this._rules = []\n    this._ignoreCase = ignoreCase\n    this._allowRelativePaths = allowRelativePaths\n    this._initCache()\n  }\n\n  _initCache () {\n    this._ignoreCache = Object.create(null)\n    this._testCache = Object.create(null)\n  }\n\n  _addPattern (pattern) {\n    // #32\n    if (pattern && pattern[KEY_IGNORE]) {\n      this._rules = this._rules.concat(pattern._rules)\n      this._added = true\n      return\n    }\n\n    if (checkPattern(pattern)) {\n      const rule = createRule(pattern, this._ignoreCase)\n      this._added = true\n      this._rules.push(rule)\n    }\n  }\n\n  // @param {Array<string> | string | Ignore} pattern\n  add (pattern) {\n    this._added = false\n\n    makeArray(\n      isString(pattern)\n        ? splitPattern(pattern)\n        : pattern\n    ).forEach(this._addPattern, this)\n\n    // Some rules have just added to the ignore,\n    // making the behavior changed.\n    if (this._added) {\n      this._initCache()\n    }\n\n    return this\n  }\n\n  // legacy\n  addPattern (pattern) {\n    return this.add(pattern)\n  }\n\n  //          |           ignored : unignored\n  // negative |   0:0   |   0:1   |   1:0   |   1:1\n  // -------- | ------- | ------- | ------- | --------\n  //     0    |  TEST   |  TEST   |  SKIP   |    X\n  //     1    |  TESTIF |  SKIP   |  TEST   |    X\n\n  // - SKIP: always skip\n  // - TEST: always test\n  // - TESTIF: only test if checkUnignored\n  // - X: that never happen\n\n  // @param {boolean} whether should check if the path is unignored,\n  //   setting `checkUnignored` to `false` could reduce additional\n  //   path matching.\n\n  // @returns {TestResult} true if a file is ignored\n  _testOne (path, checkUnignored) {\n    let ignored = false\n    let unignored = false\n\n    this._rules.forEach(rule => {\n      const {negative} = rule\n      if (\n        unignored === negative && ignored !== unignored\n        || negative && !ignored && !unignored && !checkUnignored\n      ) {\n        return\n      }\n\n      const matched = rule.regex.test(path)\n\n      if (matched) {\n        ignored = !negative\n        unignored = negative\n      }\n    })\n\n    return {\n      ignored,\n      unignored\n    }\n  }\n\n  // @returns {TestResult}\n  _test (originalPath, cache, checkUnignored, slices) {\n    const path = originalPath\n      // Supports nullable path\n      && checkPath.convert(originalPath)\n\n    checkPath(\n      path,\n      originalPath,\n      this._allowRelativePaths\n        ? RETURN_FALSE\n        : throwError\n    )\n\n    return this._t(path, cache, checkUnignored, slices)\n  }\n\n  _t (path, cache, checkUnignored, slices) {\n    if (path in cache) {\n      return cache[path]\n    }\n\n    if (!slices) {\n      // path/to/a.js\n      // ['path', 'to', 'a.js']\n      slices = path.split(SLASH)\n    }\n\n    slices.pop()\n\n    // If the path has no parent directory, just test it\n    if (!slices.length) {\n      return cache[path] = this._testOne(path, checkUnignored)\n    }\n\n    const parent = this._t(\n      slices.join(SLASH) + SLASH,\n      cache,\n      checkUnignored,\n      slices\n    )\n\n    // If the path contains a parent directory, check the parent first\n    return cache[path] = parent.ignored\n      // > It is not possible to re-include a file if a parent directory of\n      // >   that file is excluded.\n      ? parent\n      : this._testOne(path, checkUnignored)\n  }\n\n  ignores (path) {\n    return this._test(path, this._ignoreCache, false).ignored\n  }\n\n  createFilter () {\n    return path => !this.ignores(path)\n  }\n\n  filter (paths) {\n    return makeArray(paths).filter(this.createFilter())\n  }\n\n  // @returns {TestResult}\n  test (path) {\n    return this._test(path, this._testCache, true)\n  }\n}\n\nconst factory = options => new Ignore(options)\n\nconst isPathValid = path =>\n  checkPath(path && checkPath.convert(path), path, RETURN_FALSE)\n\nfactory.isPathValid = isPathValid\n\n// Fixes typescript\nfactory.default = factory\n\nmodule.exports = factory\n\n// Windows\n// --------------------------------------------------------------\n/* istanbul ignore if */\nif (\n  // Detect `process` so that it can run in browsers.\n  typeof process !== 'undefined'\n  && (\n    process.env && process.env.IGNORE_TEST_WIN32\n    || process.platform === 'win32'\n  )\n) {\n  /* eslint no-control-regex: \"off\" */\n  const makePosix = str => /^\\\\\\\\\\?\\\\/.test(str)\n  || /[\"<>|\\u0000-\\u001F]+/u.test(str)\n    ? str\n    : str.replace(/\\\\/g, '/')\n\n  checkPath.convert = makePosix\n\n  // 'C:\\\\foo'     <- 'C:\\\\foo' has been converted to 'C:/'\n  // 'd:\\\\foo'\n  const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\\//i\n  checkPath.isNotRelative = path =>\n    REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path)\n    || isNotRelative(path)\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/_node_modules/is-arrayish/index.cjs

@@ -0,0 +1,9 @@
+"use strict";
+var isArrayish = function isArrayish2(obj) {
+  if (!obj) {
+    return false;
+  }
+  return obj instanceof Array || Array.isArray(obj) || obj.length >= 0 && obj.splice instanceof Function;
+};
+module.exports = isArrayish;
+//# sourceMappingURL=index.cjs.map

package/dist/_node_modules/is-arrayish/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../../../../node_modules/is-arrayish/index.js"],"sourcesContent":["'use strict';\n\nmodule.exports = function isArrayish(obj) {\n\tif (!obj) {\n\t\treturn false;\n\t}\n\n\treturn obj instanceof Array || Array.isArray(obj) ||\n\t\t(obj.length >= 0 && obj.splice instanceof Function);\n};\n"],"names":["isArrayish"],"mappings":";AAEA,IAAA,aAAiB,SAASA,YAAW,KAAK;AACzC,MAAI,CAAC,KAAK;AACT,WAAO;AAAA,EACP;AAED,SAAO,eAAe,SAAS,MAAM,QAAQ,GAAG,KAC9C,IAAI,UAAU,KAAK,IAAI,kBAAkB;AAC5C;;","x_google_ignoreList":[0]}

package/dist/_node_modules/is-arrayish/index.js

@@ -0,0 +1,10 @@
+var isArrayish = function isArrayish2(obj) {
+  if (!obj) {
+    return false;
+  }
+  return obj instanceof Array || Array.isArray(obj) || obj.length >= 0 && obj.splice instanceof Function;
+};
+export {
+  isArrayish as default
+};
+//# sourceMappingURL=index.js.map

package/dist/_node_modules/is-arrayish/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../node_modules/is-arrayish/index.js"],"sourcesContent":["'use strict';\n\nmodule.exports = function isArrayish(obj) {\n\tif (!obj) {\n\t\treturn false;\n\t}\n\n\treturn obj instanceof Array || Array.isArray(obj) ||\n\t\t(obj.length >= 0 && obj.splice instanceof Function);\n};\n"],"names":["isArrayish"],"mappings":"AAEA,IAAA,aAAiB,SAASA,YAAW,KAAK;AACzC,MAAI,CAAC,KAAK;AACT,WAAO;AAAA,EACP;AAED,SAAO,eAAe,SAAS,MAAM,QAAQ,GAAG,KAC9C,IAAI,UAAU,KAAK,IAAI,kBAAkB;AAC5C;","x_google_ignoreList":[0]}