@slicemachine/init 0.1.1-dev-plugins.13 → 0.1.1-dev-plugins-validation.1

package/dist/__node_modules/ignore/index.js

@@ -1,369 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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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"}

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

@@ -1,9 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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;;"}

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

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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;"}