@quilted/create 0.2.43 → 0.2.45

package/build/esnext/node_modules/.pnpm/ignore@5.2.4/node_modules/ignore/index.esnext

@@ -1,372 +1,376 @@
-import { getDefaultExportFromCjs } from '../../../../../_virtual/_commonjsHelpers.esnext';
-
-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;
+var ignore;
+var hasRequiredIgnore;
+function requireIgnore() {
+  if (hasRequiredIgnore) return ignore;
+  hasRequiredIgnore = 1;
+  function makeArray(subject) {
+    return Array.isArray(subject) ? subject : [subject];
   }
-}
-const createRule = (pattern, ignoreCase) => {
-  const origin = pattern;
-  let negative = false;
-  if (pattern.indexOf("!") === 0) {
-    negative = true;
-    pattern = pattern.substr(1);
+  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");
   }
-  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 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 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);
+  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;
+    }
   }
-  if (checkPath.isNotRelative(path)) {
-    const r = "`path.relative()`d";
-    return doThrow(
-      `path should be a ${r} string, but got "${originalPath}"`,
-      RangeError
+  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
     );
-  }
-  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;
+  };
+  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 (checkPattern(pattern)) {
-      const rule = createRule(pattern, this._ignoreCase);
-      this._added = true;
-      this._rules.push(rule);
+    if (!path) {
+      return doThrow(`path must not be empty`, TypeError);
     }
-  }
-  // @param {Array<string> | string | Ignore} pattern
-  add(pattern) {
-    this._added = false;
-    makeArray(
-      isString(pattern) ? splitPattern(pattern) : pattern
-    ).forEach(this._addPattern, this);
-    if (this._added) {
+    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();
     }
-    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) {
+    _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;
       }
-      const matched = rule.regex.test(path);
-      if (matched) {
-        ignored = !negative;
-        unignored = negative;
+      if (checkPattern(pattern)) {
+        const rule = createRule(pattern, this._ignoreCase);
+        this._added = true;
+        this._rules.push(rule);
       }
-    });
-    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);
+    // @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;
     }
-    slices.pop();
-    if (!slices.length) {
-      return cache[path] = this._testOne(path, checkUnignored);
+    // 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 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;
+  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);
   }
+  return ignore;
 }
-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);
-}
-const gitIgnore = /* @__PURE__ */ getDefaultExportFromCjs(ignore);
 
-export { gitIgnore as default };
+export { requireIgnore as __require };