@code-yeongyu/senpi 2026.9.12-3 → 2026.9.12

package/node_modules/ignore/legacy.js

@@ -22,14 +22,7 @@ var UNDEFINED = undefined;
 var EMPTY = '';
 var SPACE = ' ';
 var ESCAPE = '\\';
-
-// The characters that carry a meaning of their own inside a regular
-//   expression, so a literal one has to be escaped before it is emitted.
-var REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
-// A line of only spaces is blank -- the trailing-space trimming empties it --
-//   but a line holding a tab is a pattern for a tab-named path, since git
-//   never trims a tab.
-var REGEX_TEST_BLANK_LINE = /^ +$/;
+var REGEX_TEST_BLANK_LINE = /^\s+$/;
 var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
 var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
 var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
@@ -43,9 +36,8 @@ var REGEX_SPLITALL_CRLF = /\r?\n/g;
 // - ..
 // Valid:
 // - .foo
-var DOUBLE_SLASH = '//';
-var SLASH_CODE = 47;
-var DOT_CODE = 46;
+var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+var REGEX_TEST_TRAILING_SLASH = /\/$/;
 var SLASH = '/';
 
 // Do not use ternary expression here, since "istanbul ignore next" is buggy
@@ -61,266 +53,37 @@ var define = function define(object, key, value) {
   });
   return value;
 };
+var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
 var RETURN_FALSE = function RETURN_FALSE() {
   return false;
 };
 
-// See fixtures #59
-var cleanRangeBackSlash = function cleanRangeBackSlash(slashes) {
-  var length = slashes.length;
-  return slashes.slice(0, length - length % 2);
-};
-
-// > The range notation, e.g. [a-zA-Z],
-// > can be used to match one of the characters in a range.
-//
-// gitignore(5) defers to fnmatch(3) for this, and git implements it in
-//   `wildmatch.c`.  A bracket expression has a sub-grammar of its own, which
-//   is neither the surrounding pattern grammar nor the JavaScript one:
-//
-//   - a `]` right after `[` or `[!` is a literal member, not the terminator
-//   - `[:alpha:]` names one of twelve POSIX classes
-//   - `\` escapes the next member, `]` included
-//   - `*`, `?` and `.` are plain literal members
-//   - an unterminated expression makes the whole pattern match nothing
-//
-// which means the expression can not be located -- let alone translated -- by
-//   a regular expression.  It is scanned out of the pattern before the
-//   replacers below run, and put back once they are done, so that neither the
-//   metacharacter escaper nor the `?` / `*` replacers ever see its body.
-
-// git classifies with its own ASCII-only ctype macros (`wildmatch.c`), never
-//   with the C library ones, so these must not be mapped onto `\d` / `\w` /
-//   `\s`, which are wider.  `/` is left out of every expansion, because a
-//   bracket expression never matches a path separator.
-var POSIX_CLASSES = {
-  alnum: '0-9A-Za-z',
-  alpha: 'A-Za-z',
-  blank: ' \\t',
-  cntrl: '\\x00-\\x1f\\x7f',
-  digit: '0-9',
-  graph: '!-.0-~',
-  lower: 'a-z',
-  print: ' -.0-~',
-  punct: '!-.:-@\\[-`{-~',
-  // git's `sane-ctype.h` classifies \v and \f as control, not space,
-  //   unlike C's `isspace`
-  space: ' \\t\\n\\r',
-  upper: 'A-Z',
-  xdigit: '0-9A-Fa-f'
-};
-var CLASS_MEMBERS_TO_ESCAPE = '\\]^-[';
-var escapeMember = function escapeMember(_char) {
-  return CLASS_MEMBERS_TO_ESCAPE.indexOf(_char) < 0 ? _char : ESCAPE + _char;
-};
-
-// > if (matched == negated || ((flags & WM_PATHNAME) && text_ch == '/'))
-// >   return WM_ABORT_TO_STARSTAR;                     (git, `wildmatch.c`)
-// A bracket expression never matches a path separator, whatever its members
-//   say, so a negated class gets `/` as one more excluded character, while a
-//   plain one -- where a literal member or a range could still let `/` in --
-//   is guarded with a lookahead, `/` being impossible to subtract from a
-//   JavaScript character class.
-var NON_SLASH = '(?!\\/)';
-var classSource = function classSource(negated, body) {
-  if (negated) {
-    return "[^\\/".concat(body, "]");
-  }
-  var source = "[".concat(body, "]");
-  return new RegExp(source).test('/') ? NON_SLASH + source : source;
+// Sanitize the range of a regular expression
+// The cases are complicated, see test cases for details
+var sanitizeRange = function sanitizeRange(range) {
+  return range.replace(REGEX_REGEXP_RANGE, function (match, from, to) {
+    return 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.
+    : EMPTY;
+  });
 };
 
-// Scan the bracket expression that starts at `pattern[start] === '['`,
-//   mirroring the member loop of git's `wildmatch.c`.
-// @returns {{end: number, source: string} | null} `null` if the expression is
-//   never terminated, which makes the whole pattern match nothing.
-var scanBracket = function scanBracket(pattern, start) {
-  var length = pattern.length;
-  var index = start + 1;
-  var negated = EMPTY;
-  var lead = pattern[index];
-  if (lead === '!' || lead === '^') {
-    negated = '^';
-    index++;
-  }
-  var body = EMPTY;
-
-  // The member a `-` could start a range from, or EMPTY when the previous
-  //   member can not open one (start of the body, or a range / POSIX class
-  //   that has just closed)
-  var prev = EMPTY;
-
-  // git scans the members with a do-while, so the first one is consumed
-  //   unconditionally.  That is the whole reason a leading `]` is a member
-  //   and not the terminator.
-  for (;;) {
-    var _char2 = pattern[index];
-    if (_char2 === UNDEFINED) {
-      return null;
-    }
-    if (_char2 === ESCAPE) {
-      var escaped = pattern[index + 1];
-      if (escaped === UNDEFINED) {
-        return null;
-      }
-      body += escapeMember(escaped);
-      prev = escaped;
-      index++;
-    } else if (_char2 === '-' && prev && index + 1 < length && pattern[index + 1] !== ']') {
-      index++;
-      var to = pattern[index];
-      if (to === ESCAPE) {
-        // A pattern can not end on a lone backslash -- `checkPattern` has
-        //   already thrown it away -- so there is an upper bound to read.
-        to = pattern[index += 1];
-      }
-      // An out-of-order range matches nothing in git but is a syntax error in
-      //   JavaScript, so it is dropped.  Its lower bound stays: git tests it
-      //   as a plain member before it ever looks at the `-`, so `[c-a]` does
-      //   match `c`.
-      if (prev <= to) {
-        body += "-".concat(escapeMember(to));
-      }
-      prev = EMPTY;
-    } else if (_char2 === '[' && pattern[index + 1] === ':') {
-      var nameStart = index + 2;
-      var end = nameStart;
-      while (end < length && pattern[end] !== ']') {
-        end++;
-      }
-      if (end === length) {
-        return null;
-      }
-      if (end > nameStart && pattern[end - 1] === ':') {
-        var expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)];
-
-        // An unknown class name makes the whole pattern match nothing
-        if (expanded === UNDEFINED) {
-          return null;
-        }
-        body += expanded;
-        prev = EMPTY;
-        index = end;
-      } else {
-        // No `:]` to close it, so the `[` is a plain member and scanning
-        //   resumes right after it.
-        body += escapeMember('[');
-        prev = '[';
-        index = nameStart - 2;
-      }
-    } else {
-      body += escapeMember(_char2);
-      prev = _char2;
-    }
-    index++;
-    if (pattern[index] === ']') {
-      return {
-        end: index,
-        source: classSource(negated, body)
-      };
-    }
-  }
+// > An optional `!` or `^` at the start of a class negates it, so that it
+// >   matches any character not in the set. (gitignore(5), fnmatch(3))
+// The leading `^` has already been escaped to `\^` by the metacharacter
+//   escaper, so we strip the literal `!` or escaped `^` and emit a single
+//   regex `^` which is the JavaScript negation token.
+var negateRange = function negateRange(range) {
+  return range.startsWith('!') || range.startsWith('\\^') ? "^".concat(range.slice(range[0] === '!' ? 1 : 2)) : range;
 };
 
-// An empty JavaScript class can never match, which is how a pattern that git
-//   gives up on (`WM_ABORT_ALL`) is expressed here.
-var NEVER_MATCH = '[]';
-
-// A NUL can appear in neither a `.gitignore` line nor a path, which makes it
-//   the one safe placeholder character.  A literal one in the pattern is
-//   held aside all the same, so a collision is impossible by construction.
-var PLACEHOLDER = "\0";
-var REGEX_RESTORE_PLACEHOLDER = new RegExp("".concat(PLACEHOLDER, "(\\d+)").concat(PLACEHOLDER), 'g');
-
-// The one wildcard the chain does not expand for itself is a trailing `*`. How
-//   it expands depends on the mode (`regex` vs `checkRegex`), so `_make` is
-//   left to do it, and until then the pending wildcard travels as this marker.
-//   That is what keeps it apart from a user-escaped literal `\*`: the unescape
-//   steps collapse the escaped one to the exact `\*` a wildcard would leave
-//   behind, so by the time `_make` runs the two are otherwise the same string
-//   and a literal star gets wrongly rewritten into a wildcard. This marker is a
-//   private-use character no compiled pattern carries, and it never survives
-//   into a `RegExp` -- `_make` always turns it back into a real wildcard first.
-var TRAILING_WILDCARD = "\uE000";
-
-// Replace every bracket expression with a placeholder the replacers below
-//   leave alone, and translate it separately.
-var extractBrackets = function extractBrackets(pattern) {
-  var sources = [];
-  var hold = function hold(source) {
-    return "".concat(PLACEHOLDER).concat(sources.push(source) - 1).concat(PLACEHOLDER);
-  };
-  var length = pattern.length;
-  var out = EMPTY;
-  var index = 0;
-  while (index < length) {
-    var _char3 = pattern[index];
-    if (_char3 === ESCAPE) {
-      // > Put a backslash ("\") in front of ... a character to make it literal.
-      //                                            (gitignore(5) -> fnmatch(3))
-      // A backslash quotes the next character, whatever it is, so `\d` is a
-      //   literal `d`, not the regex digit class, and `\?` is a literal `?`,
-      //   not a wildcard. Held aside as its literal here, the escape never
-      //   reaches the replacers below, which would otherwise let `\d`, `\b`,
-      //   `\1`, `\/` keep their regular-expression meaning, and would turn a
-      //   `\?` into `[^\/]`.
-      //
-      // Four escapes are left for the chain, each with dedicated handling it
-      //   would be wrong to bypass: `\*` (a literal star, told apart from a
-      //   wildcard by `TRAILING_WILDCARD` and the wildcard replacers), `\[`
-      //   (a literal bracket, the one `[` the bracket replacer still expects),
-      //   `\ ` (a quoted trailing space), and `\\` (a literal backslash). A
-      //   lone trailing backslash never reaches here -- `checkPattern` throws
-      //   it out first.
-      var escaped = pattern[index + 1];
-      if (escaped === '*' || escaped === '[' || escaped === SPACE || escaped === ESCAPE) {
-        out += pattern.slice(index, index + 2);
-      } else {
-        out += hold(REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : escaped);
-      }
-      index += 2;
-    } else if (_char3 === PLACEHOLDER) {
-      // Hold a literal placeholder character aside as well, so that pattern
-      //   text can never be mistaken for a placeholder we emitted.
-      out += hold("[".concat(PLACEHOLDER, "]"));
-      index++;
-    } else if (_char3 === '[') {
-      var scanned = scanBracket(pattern, index);
-      if (scanned === null) {
-        // git gives up on the whole pattern (`WM_ABORT_ALL`), so whatever
-        //   follows can not make it match either.
-        out += hold(NEVER_MATCH);
-        index = length;
-      } else {
-        out += hold(scanned.source);
-        index = scanned.end + 1;
-      }
-    } else {
-      out += _char3;
-      index++;
-    }
-  }
-  return {
-    source: out,
-    sources: sources
-  };
+// See fixtures #59
+var cleanRangeBackSlash = function cleanRangeBackSlash(slashes) {
+  var length = slashes.length;
+  return slashes.slice(0, length - length % 2);
 };
 
-// A step of the chain below is normally a `[matcher, replacer]` pair handed
-//   to `String.replace`. `DIRECT` marks the ones that are plain string work
-//   instead, and take `(source, pattern)`.
-//
-// Anchoring the two ends is exactly that -- a test of one character and a
-//   concatenation -- and putting it through the regular expression engine
-//   cost a third of this chain for nothing: 167ns where 10ns does the same
-//   job. The two are still steps in the same list, in the same places,
-//   because their position in the order is part of what they mean.
-var DIRECT = null;
-
-// A separator at the beginning or in the middle of a pattern, as opposed to
-//   one at the very end.
-var REGEX_INNER_SLASH = /\/(?!$)/;
-
 // > 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.
@@ -332,56 +95,27 @@ var REGEX_INNER_SLASH = /\/(?!$)/;
 //      you could use option `mark: true` with `glob`
 
 // '`foo/`' should not continue with the '`..`'
-// The chain that turns one gitignore pattern into a regular expression
-//   source, in order. A step is either
-//
-//   [matcher, replacer]            handed to `String.replace`
-//   [matcher, replacer, required]  the same, but skipped outright unless
-//                                    `required` appears in the string, which
-//                                    the matcher cannot match without
-//   [DIRECT, transform]            plain string work, taking (source, pattern)
-//
-// The `required` character is only ever a shortcut: finding it does not mean
-//   the matcher will match, and not finding it means it cannot. It is there
-//   because scanning for one character costs a fraction of running a matcher
-//   that then finds nothing -- for the wildcard step, whose `[^\\]+`
-//   backtracks its way through the whole string before giving up, 11ns
-//   against 400ns.
 var REPLACERS = [[
 // Remove BOM
 // TODO:
 // Other similar zero-width characters?
 /^\uFEFF/, function () {
   return EMPTY;
-}, "\uFEFF"], [
-// A trailing line terminator, left on when a whole file's contents are
-//   added as one pattern rather than split into lines. git never sees one
-//   -- it reads a `.gitignore` line by line -- so it is not part of the
-//   pattern and is dropped here, apart from the trailing-space trimming,
-//   which follows git in touching spaces and nothing else.
-/[\r\n]+$/, function () {
-  return EMPTY;
 }],
 // > Trailing spaces are ignored unless they are quoted with backslash ("\")
 [
-// Only spaces, never tabs or other whitespace: git trims a trailing run
-//   of `' '` and nothing else (dir.c, `trim_trailing_spaces`, a single
-//   `case ' '`), so a pattern ending in a tab keeps it as a literal.
 // (a\ ) -> (a )
 // (a  ) -> (a)
 // (a ) -> (a)
 // (a \ ) -> (a  )
-/((?:\\\\)*?)(\\? +)$/, function (_, m1, m2) {
+/((?:\\\\)*?)(\\?\s+)$/, function (_, m1, m2) {
   return m1 + (m2.indexOf('\\') === 0 ? SPACE : EMPTY);
 }],
 // Replace (\ ) with ' '
-// Only a space: an escaped tab or other whitespace is already a literal by
-//   the time it reaches here, and a bare tab must be left as one, not turned
-//   into a space.
 // (\ ) -> ' '
 // (\\ ) -> '\\ '
 // (\\\ ) -> '\\ '
-[/(\\+?) /g, function (_, m1) {
+[/(\\+?)\s/g, function (_, m1) {
   var length = m1.length;
   return m1.slice(0, length - length % 2) + SPACE;
 }],
@@ -408,7 +142,7 @@ var REPLACERS = [[
 // > a question mark (?) matches a single character
 /(?!\\)\?/g, function () {
   return '[^/]';
-}, '?'],
+}],
 // leading slash
 [
 // > A leading slash matches the beginning of the pathname.
@@ -416,11 +150,11 @@ var REPLACERS = [[
 // A leading slash matches the beginning of the pathname
 /^\//, function () {
   return '^';
-}, SLASH],
+}],
 // replace special metacharacter slash after the leading slash
 [/\//g, function () {
   return '\\/';
-}, SLASH], [
+}], [
 // > 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".
@@ -431,20 +165,15 @@ var REPLACERS = [[
 // '**/foo' <-> 'foo'
 function () {
   return '^(?:.*\\/)?';
-}, '*'],
+}],
 // 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
-DIRECT, function (source, pattern) {
-  // Nothing to anchor to, or already anchored
-  if (!source || source[0] === '^') {
-    return source;
-  }
-
+/^(?=[^^])/, function startingReplacer() {
   // If has a slash `/` at the beginning or middle
-  var anchor = !REGEX_INNER_SLASH.test(pattern)
+  return !/\/(?!$)/.test(this)
   // > Prior to 2.22.1
   // > If the pattern does not contain a slash /,
   // >   Git treats it as a shell glob pattern
@@ -462,7 +191,6 @@ DIRECT, function (source, pattern) {
   // > Otherwise, Git treats the pattern as a shell glob suitable for
   // >   consumption by fnmatch(3)
   : '^';
-  return anchor + source;
 }],
 // two globstars
 [
@@ -475,26 +203,19 @@ DIRECT, function (source, pattern) {
 function (_, index, str) {
   return index + 6 < str.length
 
-  // case: /**/ at the end of the pattern, i.e. a trailing `'/**/'`
-  // > A trailing `"/**/"` (a trailing `"/**"` restricted to directories)
-  // >   matches everything inside, but it should not match the current
-  // >   folder itself, so it requires at least one directory segment.
-  // 'a/**/' matches 'a/b/', 'a/x/y/' but not 'a/'
-  ? str.slice(index + 6) === '\\/' ? '(?:\\/[^\\/]+)+'
-
   // 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.
   // '/**/'
-  : '(?:\\/[^\\/]+)*'
+  ? '(?:\\/[^\\/]+)*'
 
   // case: /**
   // > A trailing `"/**"` matches everything inside.
 
   // #21: everything inside but it should not include the current folder
   : '\\/.+';
-}, '*'],
+}],
 // normal intermediate wildcards
 [
 // Never replace escaped '*'
@@ -514,55 +235,37 @@ function (_, p1, p2) {
   // > and will match according to the previous rules.
   var unescaped = p2.replace(/\\\*/g, '[^\\/]*');
   return p1 + unescaped;
-}, '*'],
-// trailing wildcard, held apart from a literal star
-[
-// The step above leaves a trailing `*` alone, so a single `\*` is all that
-//   can be left at the end here. Whether it is a wildcard or a literal
-//   turns on the backslashes the user put in front of it: the escaper has
-//   since doubled every one, so what stands here is those `2N` doubled
-//   backslashes and then the star's own escape. An even number of the
-//   original `N` leaves the star unescaped -- a wildcard -- and an odd
-//   number escapes it -- a literal. This runs while the two are still
-//   distinct, before the unescape steps below collapse the literal onto
-//   the very `\*` a wildcard leaves behind.
-/(^|[^\\])((?:\\\\)*)\\\*$/, function (match, p1, p2) {
-  return (
-    // `p2` holds the doubled user backslashes; half of them is `N`.
-    p2.length / 2 % 2 === 0
-    // A real wildcard: carry it to `_make` as the marker, so the unescape
-    //   steps and the trailing-wildcard rewrite can never mistake it for a
-    //   literal `\*` (nor the reverse).
-    ? p1 + p2 + TRAILING_WILDCARD
-    // A literal star: leave it exactly as it stands for the unescape steps.
-    : match
-  );
-}, '*'], [
+}], [
 // unescape, revert step 3 except for back slash
 // For example, if a user escape a '\\*',
 // after step 3, the result will be '\\\\\\*'
 /\\\\\\(?=[$.|*+(){^])/g, function () {
   return ESCAPE;
-}, ESCAPE + ESCAPE], [
+}], [
 // '\\\\' -> '\\'
 /\\\\/g, function () {
   return ESCAPE;
-}, ESCAPE + ESCAPE], [
-// Every real bracket expression -- POSIX classes included -- has already
-//   been held aside by `extractBrackets`, so the only `[` left in the
-//   pattern is an escaped, literal one.
+}], [
+// > 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,
-// '\\[bar]' -> '\\\\[bar\\]'
-function (match, range, endEscape, close) {
-  return "\\[".concat(range).concat(cleanRangeBackSlash(endEscape)).concat(close);
-}, '['],
+/(\\)?\[([^\]/]*?)(\\*)($|\])/g, function (match, leadEscape, range, endEscape, close) {
+  return leadEscape === ESCAPE
+  // '\\[bar]' -> '\\\\[bar\\]'
+  ? "\\[".concat(range).concat(cleanRangeBackSlash(endEscape)).concat(close) : close === ']' ? endEscape.length % 2 === 0
+  // A normal case, and it is a range notation
+  // '[bar]'
+  // '[bar\\\\]'
+  ? "[".concat(negateRange(sanitizeRange(range))).concat(endEscape, "]") // Invalid range notaton
+  // '[bar\\]' -> '[bar\\\\]'
+  : '[]' : '[]';
+}],
 // ending
 [
 // 'js' will not match 'js.'
 // 'ab' will not match 'abc'
-DIRECT,
+/(?:[^*])$/,
 // WTF!
 // https://git-scm.com/docs/gitignore
 // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
@@ -575,21 +278,13 @@ DIRECT,
 // 'js*' will not match 'a.js'
 // 'js/' will not match 'a.js'
 // 'js' will match 'a.js' and 'a.js/'
-function (source) {
-  var last = source[source.length - 1];
-
-  // The pattern is empty, or ends in the pending trailing wildcard the next
-  //   step owns. A trailing `*` that is not the marker is a literal star,
-  //   which anchors like any other final character.
-  if (!last || last === TRAILING_WILDCARD) {
-    return source;
-  }
-  return last === SLASH
+function (match) {
+  return /\/$/.test(match)
   // foo/ will not match 'foo'
-  ? "".concat(source, "$") // foo matches 'foo' and 'foo/'
-  : "".concat(source, "(?=$|\\/$)");
+  ? "".concat(match, "$") // foo matches 'foo' and 'foo/'
+  : "".concat(match, "(?=$|\\/$)");
 }]];
-var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/;
+var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
 var MODE_IGNORE = 'regex';
 var MODE_CHECK_IGNORE = 'checkRegex';
 var UNDERSCORE = '_';
@@ -615,208 +310,15 @@ var TRAILING_WILD_CARD_REPLACERS = (_TRAILING_WILD_CARD_R = {}, _defineProperty(
   : '[^/]*';
   return "".concat(prefix, "(?=$|\\/$)");
 }), _TRAILING_WILD_CARD_R);
-var WILDCARD = '[^\\/]*';
-
-// Where a run of non-slash wildcards is split by single fixed characters --
-//   `[^/]*x[^/]*y...` -- the engine has many equivalent ways to lay the
-//   input across the wildcards, and on input that does not match it works
-//   through all of them, so the time grows with the number of wildcards
-//   rather than the length of the path. Every wildcard but the last in such a
-//   run can be pinned to stop at the character that follows it, which leaves
-//   one way to lay out the input and no rewinding, without changing which
-//   paths match: the fixed characters still bound the count, and the last
-//   wildcard still absorbs the rest.
-//
-// The source is read one token at a time -- a wildcard, a single-character
-//   piece (a literal, an escape, a class), or a parenthesised group or anchor
-//   that ends the run -- so only a genuine wildcard is touched.
-var pinWildcards = function pinWildcards(source) {
-  if (source.indexOf(WILDCARD) < 0) {
-    return source;
-  }
-  var tokens = [];
-  var length = source.length;
-  var index = 0;
-  while (index < length) {
-    var _char4 = source[index];
-    if (source.startsWith(WILDCARD, index)) {
-      tokens.push({
-        wildcard: true
-      });
-      index += WILDCARD.length;
-    } else if (_char4 === '[') {
-      var end = index + 1;
-      if (source[end] === '^') {
-        end++;
-      }
-      if (source[end] === ']') {
-        end++;
-      }
-      while (end < length && source[end] !== ']') {
-        end += source[end] === ESCAPE ? 2 : 1;
-      }
-      end++;
-      tokens.push({
-        single: source.slice(index, end)
-      });
-      index = end;
-    } else if (_char4 === ESCAPE) {
-      tokens.push({
-        single: source.slice(index, index + 2)
-      });
-      index += 2;
-    } else if (_char4 === '(') {
-      var depth = 0;
-      var _end = index;
-      do {
-        if (source[_end] === ESCAPE) {
-          _end++;
-        } else if (source[_end] === '(') {
-          depth++;
-        } else if (source[_end] === ')') {
-          depth--;
-        }
-        _end++;
-      } while (_end < length && depth > 0);
-      if ('*+?'.indexOf(source[_end]) >= 0) {
-        _end++;
-      }
-      tokens.push({
-        boundary: source.slice(index, _end)
-      });
-      index = _end;
-    } else if (_char4 === '^' || _char4 === '$') {
-      tokens.push({
-        boundary: _char4
-      });
-      index++;
-    } else {
-      tokens.push({
-        single: _char4
-      });
-      index++;
-    }
-  }
-  var out = EMPTY;
-  var run = [];
-  var flush = function flush() {
-    var lastWildcard;
-    run.forEach(function (token, at) {
-      if (token.wildcard) {
-        lastWildcard = at;
-      }
-    });
-    run.forEach(function (token, at) {
-      if (!token.wildcard) {
-        out += token.single;
-        return;
-      }
-
-      // A wildcard that is not the last in the run is always immediately
-      //   followed by the single character that separates it from the next
-      //   one, because a run never holds two wildcards in a row, so it can be
-      //   pinned to stop there. The last wildcard stays as it is and takes up
-      //   the rest.
-      out += at === lastWildcard ? WILDCARD : "(?:(?!".concat(run[at + 1].single, ")[^\\/])*");
-    });
-    run = [];
-  };
-  tokens.forEach(function (token) {
-    if (token.boundary === undefined) {
-      run.push(token);
-      return;
-    }
-    flush();
-    out += token.boundary;
-  });
-  flush();
-  return out;
-};
 
 // @param {pattern}
 var makeRegexPrefix = function makeRegexPrefix(pattern) {
-  var _extractBrackets = extractBrackets(pattern),
-    source = _extractBrackets.source,
-    sources = _extractBrackets.sources;
-  var replaced = REPLACERS.reduce(
-  // A pass whose matcher finds nothing hands back the very string it was
-  //   given, so asking first costs a search and saves a rewrite. Ten of the
-  //   fifteen passes never fire for a typical .gitignore line, and between
-  //   them they were 45% of this chain.
-  function (prev, _ref) {
-    var _ref2 = _slicedToArray(_ref, 3),
+  return REPLACERS.reduce(function (prev, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
       matcher = _ref2[0],
-      replacer = _ref2[1],
-      required = _ref2[2];
-    if (matcher === DIRECT) {
-      return replacer(prev, pattern);
-    }
-    if (required !== UNDEFINED && prev.indexOf(required) < 0) {
-      return prev;
-    }
-
-    // A pass whose matcher finds nothing hands back the very string it was
-    //   given, so asking first costs a search and saves a rewrite.
-    return matcher.test(prev) ? prev.replace(matcher, replacer.bind(pattern)) : prev;
-  }, source);
-
-  // Most patterns hold no bracket expression at all, and then there is
-  //   nothing to put back.
-  return sources.length ? replaced.replace(REGEX_RESTORE_PLACEHOLDER, function (match, index) {
-    return sources[index];
-  }) : replaced;
-};
-
-// A trailing slash does not stop a pattern being basename-only: it restricts
-//   the match to a directory, it does not let the pattern reach across one.
-//   Everything else a pattern can hold -- a wildcard, a character class, an
-//   escape -- stays inside a single path segment too, so a pattern with no
-//   separator in it can only ever describe the last one.
-var matchesBasename = function matchesBasename(body) {
-  var index = body.indexOf(SLASH);
-  return index < 0 || index === body.length - 1;
-};
-
-// The last segment of a path, keeping a trailing slash, because a pattern that
-//   ends in one matches only a directory.
-// 'a/b/c.js' -> 'c.js';  'a/b/' -> 'b/';  'c.js' -> 'c.js' (no copy made)
-var basenameOf = function basenameOf(path) {
-  var end = path.length - 1;
-  var index = path.lastIndexOf(SLASH, path[end] === SLASH ? end - 1 : end);
-  return index < 0 ? path : path.slice(index + 1);
-};
-
-// The parent directory of a path, with its trailing separator, or EMPTY when
-//   the path has none.
-// 'a/b/c' -> 'a/b/';  'a/b/' -> 'a/';  'a' -> EMPTY;  'a/' -> EMPTY
-//
-// A path holding an empty segment has to be taken apart, because its
-//   ancestors are not prefixes of it: the parent of 'a//b' is 'a/', not
-//   'a//', and the parent of '/a/' is nothing at all. Both shapes reach here
-//   -- 'a//b' is accepted outright, and `checkIgnore` does not put the path
-//   it is given through the relative-path check.
-//
-// Every other path is a prefix of itself, and cutting one costs a fraction of
-//   splitting it into an array and joining that back at every level: 73ns
-//   against 207ns.
-var parentOf = function parentOf(path) {
-  if (path.charCodeAt(0) === SLASH_CODE || path.indexOf(DOUBLE_SLASH) >= 0) {
-    var slices = path.split(SLASH).filter(Boolean);
-    slices.pop();
-    return slices.length ? slices.join(SLASH) + SLASH : EMPTY;
-  }
-  var end = path.length - 1;
-
-  // Look back from before a trailing separator, since that one belongs to the
-  //   path itself.
-  //
-  // A negative place to start would be a trap here: `lastIndexOf` clamps one
-  //   to 0 and searches there rather than reporting no match, so '/' would
-  //   come back as its own parent and the walk would never end. It cannot
-  //   happen -- that is the only path short enough to produce one, and the
-  //   test above has already sent it the other way.
-  var cut = path.lastIndexOf(SLASH, path.charCodeAt(end) === SLASH_CODE ? end - 1 : end);
-  return cut < 0 ? EMPTY : path.slice(0, cut + 1);
+      replacer = _ref2[1];
+    return prev.replace(matcher, replacer.bind(pattern));
+  }, pattern);
 };
 var isString = function isString(subject) {
   return typeof subject === 'string';
@@ -842,18 +344,7 @@ var IgnoreRule = /*#__PURE__*/function () {
     define(this, 'ignoreCase', ignoreCase);
     define(this, 'regexPrefix', prefix);
   }
-
-  // Worked out on first use and kept behind an own property, the way `regex`
-  //   caches itself in `_regex`. Deciding it in the constructor instead would
-  //   add a fourth `defineProperty` to every rule ever built, which cost 4% of
-  //   every compile -- including the compiles of rules that are never matched
-  //   against anything.
   _createClass(IgnoreRule, [{
-    key: "_basenameOnly",
-    get: function get() {
-      return define(this, '_basenameOnly', matchesBasename(this.body));
-    }
-  }, {
     key: "regex",
     get: function get() {
       var key = UNDERSCORE + MODE_IGNORE;
@@ -874,9 +365,9 @@ var IgnoreRule = /*#__PURE__*/function () {
   }, {
     key: "_make",
     value: function _make(mode, key) {
-      var str = pinWildcards(this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD,
+      var str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD,
       // It does not need to bind pattern
-      TRAILING_WILD_CARD_REPLACERS[mode]));
+      TRAILING_WILD_CARD_REPLACERS[mode]);
       var regex = this.ignoreCase ? new RegExp(str, 'i') : new RegExp(str);
       return define(this, key, regex);
     }
@@ -909,21 +400,6 @@ var RuleManager = /*#__PURE__*/function () {
     _classCallCheck(this, RuleManager);
     this._ignoreCase = ignoreCase;
     this._rules = [];
-
-    // How many of the rules git would tag `EXC_FLAG_NODIR`.
-    //
-    // The scan uses it to decide, once for the whole set, whether handing
-    //   those rules the basename is worth what it costs the others. The
-    //   shortcut saves a full-path scan on every rule it applies to and costs
-    //   a check on every rule it does not, so a set where almost nothing is
-    //   basename-only comes out behind -- a 955 pattern set with 44 of them
-    //   measured 19% slower with the shortcut always on.
-    //
-    // Deciding this by measurement rather than by meaning is safe: a
-    //   basename-only pattern gives the very same answer against the whole
-    //   path, it just takes longer to say so. The choice can only change how
-    //   fast the scan runs, never what it returns.
-    this._basenameCount = 0;
   }
   _createClass(RuleManager, [{
     key: "_add",
@@ -931,7 +407,6 @@ var RuleManager = /*#__PURE__*/function () {
       // #32
       if (pattern && pattern[KEY_IGNORE]) {
         this._rules = this._rules.concat(pattern._rules._rules);
-        this._basenameCount += pattern._rules._basenameCount;
         this._added = true;
         return;
       }
@@ -944,13 +419,6 @@ var RuleManager = /*#__PURE__*/function () {
         var rule = createRule(pattern, this._ignoreCase);
         this._added = true;
         this._rules.push(rule);
-
-        // Deliberately not `rule._basenameOnly`: reading that would materialise
-        //   the rule's own copy, and the whole point of leaving it lazy is that
-        //   a rule which is compiled and never matched never pays for it.
-        if (matchesBasename(rule.body)) {
-          this._basenameCount++;
-        }
       }
     }
 
@@ -977,23 +445,7 @@ var RuleManager = /*#__PURE__*/function () {
       var ignored = false;
       var unignored = false;
       var matchedRule;
-
-      // Most of a .gitignore is patterns with no slash in them, and running
-      //   those against the whole path makes the regular expression engine walk
-      //   every directory name on the way to the only segment that could match.
-      //   Handing them the basename instead is what git does, and it is where
-      //   the time in a directory walk goes: the rule scan was two thirds of it.
-      var rules = this._rules;
-      var length = rules.length;
-      var shortcut = this._basenameCount * 2 >= length;
-      var basename = shortcut ? basenameOf(path) : path;
-
-      // A plain loop rather than `forEach`, so that `path`, `basename` and
-      //   `shortcut` are locals. As a callback they became closure variables,
-      //   and reaching for one of those once per rule cost 10% of a scan over a
-      //   large rule set -- more than the shortcut they were there to serve.
-      for (var index = 0; index < length; index++) {
-        var rule = rules[index];
+      this._rules.forEach(function (rule) {
         var negative = rule.negative;
 
         //          |           ignored : unignored
@@ -1007,13 +459,17 @@ var RuleManager = /*#__PURE__*/function () {
         // - TEST: always test
         // - TESTIF: only test if checkUnignored
         // - X: that never happen
-        var skip = unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored;
-        if (!skip && rule[mode].test(shortcut && rule._basenameOnly ? basename : path)) {
-          ignored = !negative;
-          unignored = negative;
-          matchedRule = negative ? UNDEFINED : rule;
+        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+          return;
         }
-      }
+        var matched = rule[mode].test(path);
+        if (!matched) {
+          return;
+        }
+        ignored = !negative;
+        unignored = negative;
+        matchedRule = negative ? UNDEFINED : rule;
+      });
       var ret = {
         ignored: ignored,
         unignored: unignored
@@ -1046,39 +502,8 @@ var checkPath = function checkPath(path, originalPath, doThrow) {
   }
   return true;
 };
-
-// > pathname should be a `path.relative()`d one
-//
-// The same thing `REGEX_TEST_INVALID_PATH` says, spelled out: a path is not
-//   relative if it begins with a separator, or with `./` or `../`, or is
-//   nothing but `.` or `..`. Every match is decided by the first three
-//   characters, and this runs on every path handed to the library -- where it
-//   was 55% of a cached lookup, more than the cache lookup itself.
 var isNotRelative = function isNotRelative(path) {
-  var first = path.charCodeAt(0);
-  if (first === SLASH_CODE) {
-    return true;
-  }
-  if (first !== DOT_CODE) {
-    return false;
-  }
-
-  // '.'
-  if (path.length === 1) {
-    return true;
-  }
-  var second = path.charCodeAt(1);
-
-  // './'
-  if (second === SLASH_CODE) {
-    return true;
-  }
-  if (second !== DOT_CODE) {
-    return false;
-  }
-
-  // '..' or '../'
-  return path.length === 2 || path.charCodeAt(2) === SLASH_CODE;
+  return REGEX_TEST_INVALID_PATH.test(path);
 };
 checkPath.isNotRelative = isNotRelative;
 
@@ -1133,24 +558,25 @@ var Ignore = /*#__PURE__*/function () {
     // @returns {TestResult}
   }, {
     key: "_test",
-    value: function _test(originalPath, cache, checkUnignored) {
+    value: function _test(originalPath, cache, checkUnignored, slices) {
       var path = originalPath
       // Supports nullable path
       && checkPath.convert(originalPath);
       checkPath(path, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
-      return this._t(path, cache, checkUnignored);
+      return this._t(path, cache, checkUnignored, slices);
     }
   }, {
     key: "checkIgnore",
     value: function checkIgnore(path) {
       // If the path doest not end with a slash, `.ignores()` is much equivalent
       //   to `git check-ignore`
-      if (path.charCodeAt(path.length - 1) !== SLASH_CODE) {
+      if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
         return this.test(path);
       }
-      var parentPath = parentOf(path);
-      if (parentPath) {
-        var parent = this._t(parentPath, this._testCache, true);
+      var slices = path.split(SLASH).filter(Boolean);
+      slices.pop();
+      if (slices.length) {
+        var parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
         if (parent.ignored) {
           return parent;
         }
@@ -1165,15 +591,27 @@ var Ignore = /*#__PURE__*/function () {
     // The cache for the result of a certain checking
     cache,
     // Whether should check if the path is unignored
-    checkUnignored) {
+    checkUnignored,
+    // The path slices
+    slices) {
       if (path in cache) {
         return cache[path];
       }
-      var parentPath = parentOf(path);
+      if (!slices) {
+        // path/to/a.js
+        // ['path', 'to', 'a.js']
+        slices = path.split(SLASH).filter(Boolean);
+      }
+      slices.pop();
+
+      // If the path has no parent directory, just test it
+      if (!slices.length) {
+        return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
+      }
+      var parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
 
       // If the path contains a parent directory, check the parent first
-      var parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
-      return cache[path] = parent && parent.ignored
+      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._rules.test(path, checkUnignored, MODE_IGNORE);