@mrclrchtr/supi-lsp 11.0.0 → 11.0.1

package/node_modules/@mrclrchtr/supi-code-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-runtime",
-  "version": "11.0.0",
+  "version": "11.0.1",
   "description": "Shared workspace context and capability contracts for code intelligence",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "11.0.0",
+  "version": "11.0.1",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {

package/node_modules/ignore/README.md

@@ -173,6 +173,29 @@ ig.ignores(path.join('./abc'))  // path.join('./abc') -> 'abc'
 
 In other words, each `Pathname` here should be a relative path to the directory of the gitignore rules.
 
+A `.` or `..` component anywhere else in a `Pathname` is outside the
+convention as well, though no error is thrown for it: the check reads how the
+path starts, so that it costs nothing on a hot path. `path.relative()` never
+produces such a component, and one that carries it is not matched the way
+`git` matches it — `git` drops the component from the path first, `ignore`
+matches the path as it was given.
+
+```js
+// path.relative('/', '/a/./b')  -> 'a/b'
+
+// Right
+ignore().add('a/b').ignores('a/b')       // true
+
+// Outside the convention: git matches 'a/b' here and so says true
+ignore().add('a/b').ignores('a/./b')     // false
+
+// Outside the convention: git matches 'a' here and so says false
+ignore().add('a/.').ignores('a/.')       // true
+```
+
+A rule that matches an ancestor still agrees, since the component makes no
+difference to it: `add('a').ignores('a/./b')` is `true` either way.
+
 Suppose the dir structure is:
 
 ```
@@ -265,7 +288,8 @@ Returns `TestResult`
 // Since 5.0.0
 interface TestResult {
   ignored: boolean
-  // true if the `pathname` is finally unignored by some negative pattern
+  // true if a negative pattern matched the `pathname` itself, and no parent
+  //   directory of it is ignored -- see "When both are false" below
   unignored: boolean
   // The `IgnoreRule` which ignores the pathname
   rule?: IgnoreRule
@@ -283,8 +307,39 @@ interface IgnoreRule {
 ```
 
 - `{ignored: true, unignored: false}`: the `pathname` is ignored
-- `{ignored: false, unignored: true}`: the `pathname` is unignored
-- `{ignored: false, unignored: false}`: the `pathname` is never matched by any ignore rules.
+- `{ignored: false, unignored: true}`: a negative pattern matched the `pathname` itself
+- `{ignored: false, unignored: false}`: no rule matched the `pathname` itself, and no parent directory of it is ignored
+
+### When both are `false`
+
+`{ignored: false, unignored: false}` covers two different situations:
+
+- no rule matched the `pathname`, nor any of its parent directories, or
+- no rule matched the `pathname` itself, but one of its parent directories is unignored by a negative pattern: the `pathname` is unignored **indirectly**.
+
+`unignored` stays `false` in the second case because only `ignored` passes down from a parent directory. A `pathname` whose parent directory is ignored is ignored as well — git never re-includes a file whose parent directory is excluded — but one whose parent directory is unignored is decided on its own, by the rules that match the `pathname` itself.
+
+```js
+const ig2 = ignore().add([
+  'foo*',
+  '!foobar'
+])
+
+// The directory `foobar/` is unignored directly, by `!foobar`
+ig2.test('foobar/')     // {ignored: false, unignored: true}
+
+// No rule matches `foobar/x.js` itself. It is not ignored only because its
+//   parent directory `foobar/` is not, so it is unignored indirectly
+ig2.test('foobar/x.js') // {ignored: false, unignored: false}
+```
+
+To tell the two situations apart, test the parent directories of the `pathname`, each with a trailing slash: the `pathname` is unignored indirectly if any of them is `unignored`.
+
+```js
+['foobar/'].some(dir => ig2.test(dir).unignored) // true
+```
+
+`unignored` is meant for packages that implement their own caching mechanism upon `node-ignore`. To simply tell whether a `pathname` is ignored, use `.ignores()` or check `TestResult::ignored`.
 
 ## .checkIgnore(target: string): TestResult
 
@@ -294,7 +349,7 @@ Debugs gitignore / exclude files, which is equivalent to `git check-ignore -v`.
 
 - **target** `string` the target to test.
 
-Returns `TestResult`
+Returns `TestResult`, the same shape `.test()` returns, so `{ignored: false, unignored: false}` carries the [same two meanings](#when-both-are-false) here.
 
 ```js
 ig.add({
@@ -305,10 +360,10 @@ ig.add({
 const {
   ignored,
   rule
-} = checkIgnore('foo/')
+} = ig.checkIgnore('foo/')
 
 if (ignored) {
-  console.log(`.gitignore:${result}:${rule.mark}:${rule.pattern} foo/`)
+  console.log(`.gitignore:${rule.mark}:${rule.pattern} foo/`)
 }
 
 // .gitignore:60:foo/* foo/

package/node_modules/ignore/index.d.ts

@@ -1,27 +1,61 @@
-type Pathname = string
-
-interface IgnoreRule {
-  pattern: string
-  mark?: string
-  negative: boolean
-}
-
-interface TestResult {
-  ignored: boolean
-  unignored: boolean
-  rule?: IgnoreRule
-}
-
-interface PatternParams {
-  pattern: string
-  mark?: string
-}
-
 /**
  * Creates new ignore manager.
  */
 declare function ignore(options?: ignore.Options): ignore.Ignore
 declare namespace ignore {
+  /**
+   * A path relative to the directory the rules belong to, as
+   *   `path.relative()` returns it.
+   */
+  type Pathname = string
+
+  interface PatternParams {
+    pattern: string
+    /**
+     * Carried through to `IgnoreRule.mark`, for packages that build upon
+     *   `ignore`.
+     */
+    mark?: string
+  }
+
+  interface IgnoreRule {
+    /**
+     * The original pattern.
+     */
+    pattern: string
+    /**
+     * Carried through from `PatternParams.mark`.
+     */
+    mark?: string
+    /**
+     * Whether the pattern is a negative one, such as `!foo`.
+     */
+    negative: boolean
+  }
+
+  interface TestResult {
+    /**
+     * Whether the pathname is ignored, by a rule or because a parent
+     *   directory of it is.
+     */
+    ignored: boolean
+    /**
+     * True if a negative pattern matched the pathname itself, and no parent
+     *   directory of it is ignored.
+     *
+     * Only `ignored` passes down from a parent directory, so a pathname that
+     *   is not ignored only because a parent directory was unignored keeps
+     *   this false, as does one no rule applies to at all. To tell those two
+     *   apart, test the parent directories, each with a trailing slash.
+     */
+    unignored: boolean
+    /**
+     * The rule that ignores the pathname. Present exactly when `ignored` is
+     *   true.
+     */
+    rule?: IgnoreRule
+  }
+
   interface Ignore {
     /**
      * Adds one or several rules to the current manager.
@@ -54,7 +88,8 @@ declare namespace ignore {
     ignores(pathname: Pathname): boolean
 
     /**
-     * Returns whether pathname should be ignored or unignored
+     * Tests the pathname against the rules. `ignored` and `unignored` can
+     *   both be false: see `TestResult.unignored` for the two cases.
      * @param  {string} pathname a path to check
      * @returns TestResult
      */

package/node_modules/ignore/index.js

@@ -49,12 +49,6 @@ const define = (object, key, value) => {
 
 const RETURN_FALSE = () => false
 
-// See fixtures #59
-const cleanRangeBackSlash = slashes => {
-  const {length} = slashes
-  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.
 //
@@ -194,14 +188,14 @@ const scanBracket = (pattern, start) => {
       }
 
       if (end > nameStart && pattern[end - 1] === ':') {
-        const expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)]
+        const name = pattern.slice(nameStart, end - 1)
 
         // An unknown class name makes the whole pattern match nothing
-        if (expanded === UNDEFINED) {
+        if (!Object.prototype.hasOwnProperty.call(POSIX_CLASSES, name)) {
           return null
         }
 
-        body += expanded
+        body += POSIX_CLASSES[name]
         prev = EMPTY
         index = end
       } else {
@@ -245,9 +239,10 @@ const REGEX_RESTORE_PLACEHOLDER = new RegExp(
 //   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.
+//   and a literal star gets wrongly rewritten into a wildcard. The marker is a
+//   private-use character, and `extractBrackets` keeps one that came out of the
+//   pattern apart from it, so the only marker `_make` ever turns back into a
+//   real wildcard is the one this chain put there itself.
 const TRAILING_WILDCARD = '\uE000'
 
 // A trailing "/**" is deferred the same way, because `checkRegex` has to tell
@@ -255,6 +250,28 @@ const TRAILING_WILDCARD = '\uE000'
 //   still never matches the folder itself (#21).
 const TRAILING_DOUBLESTAR = '\uE001'
 
+// The three characters above mean something to the chain that builds the
+//   source rather than to the path, so one that came out of the pattern is
+//   held aside like a bracket expression instead of going straight out. Being
+//   held is what makes it safe: the restore runs after the step that anchors
+//   the source, so the character comes back in the middle of the source and
+//   not at its end, which is the one place `_make` and `checkSourceOf` look
+//   for a marker. Without it a pattern's own character lands where a pending
+//   marker sits, and `_make` turns it into a real trailing wildcard.
+//
+// It is held as a one-member class rather than bare, in both of the branches
+//   a reserved character can reach, so that the property can be
+//   read off this function alone -- a reserved character never goes out on
+//   its own -- rather than depending on where in the chain the restore
+//   happens to run. In the expression built here `[x]` matches exactly what
+//   `x` matches, none of the three being special to a regular expression or
+//   inside a class, so no test can tell the two apart: the class is insurance,
+//   and the paragraph above is the reason it is not needed.
+const isReserved = char =>
+  char === PLACEHOLDER
+  || char === TRAILING_WILDCARD
+  || char === TRAILING_DOUBLESTAR
+
 // Replace every bracket expression with a placeholder the replacers below
 //   leave alone, and translate it separately.
 const extractBrackets = pattern => {
@@ -279,12 +296,19 @@ const extractBrackets = pattern => {
       //   `\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 can reach here after line-ending cleanup.
+      // Three escapes are still left for the chain: `\*` (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), and `\ ` (a quoted space, which one pass
+      //   below rewrites in bulk -- holding each one aside instead costs more
+      //   on a pattern built out of them). A lone trailing backslash can reach
+      //   here after line-ending cleanup.
+      //
+      // A quoted backslash is not among them. The chain doubles every
+      //   backslash, then takes the doubling back out again, and a quoted one
+      //   standing next to a character the chain also escapes left the two
+      //   counts sharing a run, so one of the escapes was lost. Held here as
+      //   the literal it means, it never joins that run.
       const escaped = pattern[index + 1]
 
       if (
@@ -298,22 +322,21 @@ const extractBrackets = pattern => {
         escaped === '*'
         || escaped === '['
         || escaped === SPACE
-        || escaped === ESCAPE
       ) {
         out += pattern.slice(index, index + 2)
       } else {
         out += hold(
           REGEX_LITERAL_SPECIAL.test(escaped)
             ? ESCAPE + escaped
-            : escaped
+            : isReserved(escaped)
+              ? `[${escaped}]`
+              : escaped
         )
       }
 
       index += 2
-    } else if (char === PLACEHOLDER) {
-      // Hold a literal placeholder character aside as well, so that pattern
-      //   text can never be mistaken for a placeholder we emitted.
-      out += hold(`[${PLACEHOLDER}]`)
+    } else if (isReserved(char)) {
+      out += hold(`[${char}]`)
       index ++
     } else if (char === '[') {
       const scanned = scanBracket(pattern, index)
@@ -559,23 +582,23 @@ const REPLACERS = [
   // 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.
+    //   can be left at the end here, and what stands in front of it says which
+    //   kind it is. A wildcard arrives as the escaper wrote it, `\*` with
+    //   nothing before it; a literal arrives as the user's own escape, which
+    //   the escaper doubled, and then the star's own -- `\\` and then `\*`.
+    //   There is no third case: every backslash still reaching the chain is
+    //   one `\*`, `\[` or `\ ` carries itself, and each is followed by its
+    //   own character, so a longer run can never form. This runs while the
+    //   two are still distinct, before the unescape steps below collapse the
+    //   literal onto the very `\*` a wildcard leaves behind.
     /(^|[^\\])((?:\\\\)*)\\\*$/,
 
     (match, p1, p2) =>
-      // `p2` holds the doubled user backslashes; half of them is `N`.
-      (p2.length / 2) % 2 === 0
+      p2 === EMPTY
         // 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
+        ? p1 + TRAILING_WILDCARD
         // A literal star: leave it exactly as it stands for the unescape steps.
         : match,
     '*'
@@ -602,12 +625,12 @@ const REPLACERS = [
     //   been held aside by `extractBrackets`, so the only `[` left in the
     //   pattern is an escaped, literal one.
 
-    // `\` is escaped by step 3
-    /\\\[([^\]/]*?)(\\*)($|\])/g,
+    // A backslash could only stand at the end of the range if it quoted the
+    //   `]`, and `\]` is held aside long before this.
+    /\\\[([^\]/]*?)($|\])/g,
 
-    // '\\[bar]' -> '\\\\[bar\\]'
-    (match, range, endEscape, close) =>
-      `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`,
+    // '\\[bar]' -> '\\\\[bar]'
+    (match, range, close) => `\\[${range}${close}`,
     '['
   ],
 
@@ -678,23 +701,10 @@ const replaceTrailingDoublestar = () => '.+(?=$|\\/$)'
 
 const 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.
-
-// The fixed pieces between the wildcard at `at` and the next wildcard of the
-//   run, joined as they appear in the source. A run never holds two wildcards
-//   in a row, so there is always at least one piece.
+// The fixed piece between the wildcard at `at` and the next wildcard of the
+//   run: the tokens that separate them, joined as they appear in the source.
+//   A run never holds two wildcards in a row, so there is always at least one
+//   token.
 const separatorAfter = (run, at) => {
   let separator = EMPTY
 
@@ -705,6 +715,29 @@ const separatorAfter = (run, at) => {
   return separator
 }
 
+// Where a run of non-slash wildcards is split by fixed pieces --
+//   `[^/]*ab[^/]*cd...` -- 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 where the piece after it begins, which leaves
+//   one way to lay out the input and no rewinding, without changing which
+//   paths match: the fixed pieces still bound the count, and the last
+//   wildcard still absorbs the rest.
+//
+// A wildcard is pinned to the whole piece, never to the piece's first
+//   character. The pin leaves no way back, so a wildcard that stopped at that
+//   first character would hand over wherever the character happens to turn
+//   up, including the places the rest of the piece cannot follow -- which is
+//   how `f*o/*/*` came to miss `foo/b/c`, the first `o` of `foo` not being
+//   the one the `o/` after it needs. Every token of a piece matches exactly
+//   one character, so the first place the whole piece fits is the leftmost
+//   place it can sit, and whatever is left over goes to the wildcards that
+//   follow.
+//
+// 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.
 const pinWildcards = source => {
   if (source.indexOf(WILDCARD) < 0) {
     return source
@@ -792,16 +825,9 @@ const pinWildcards = source => {
         return
       }
 
-      // A wildcard that is not the last in the run is pinned to the whole
-      //   fixed piece that separates it from the next wildcard, not just to
-      //   that piece's first character: stopping at the first character alone
-      //   would let the wildcard hand over at a place where the rest of the
-      //   separator cannot follow, and the pin leaves no way back, so
-      //   `f*o/*/*` would miss `foo/b/c` -- the first `o` of `foo` is not the
-      //   one the `o/` after it needs. Every piece matches exactly one
-      //   character, so pinning to the first place the whole separator fits
-      //   is the leftmost place it can sit, and the wildcards that follow
-      //   take up whatever is left.
+      // Every wildcard but the last is pinned to the whole piece that
+      //   follows it, for the reason set out above this function. The last
+      //   one stays as it is and takes up the rest.
       out += at === lastWildcard
         ? WILDCARD
         : `(?:(?!${separatorAfter(run, at)})[^\\/])*`

package/node_modules/ignore/legacy.js

@@ -60,12 +60,6 @@ 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.
 //
@@ -187,13 +181,13 @@ var scanBracket = function scanBracket(pattern, start) {
         return null;
       }
       if (end > nameStart && pattern[end - 1] === ':') {
-        var expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)];
+        var name = pattern.slice(nameStart, end - 1);
 
         // An unknown class name makes the whole pattern match nothing
-        if (expanded === UNDEFINED) {
+        if (!Object.prototype.hasOwnProperty.call(POSIX_CLASSES, name)) {
           return null;
         }
-        body += expanded;
+        body += POSIX_CLASSES[name];
         prev = EMPTY;
         index = end;
       } else {
@@ -233,9 +227,10 @@ var REGEX_RESTORE_PLACEHOLDER = new RegExp("".concat(PLACEHOLDER, "(\\d+)").conc
 //   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.
+//   and a literal star gets wrongly rewritten into a wildcard. The marker is a
+//   private-use character, and `extractBrackets` keeps one that came out of the
+//   pattern apart from it, so the only marker `_make` ever turns back into a
+//   real wildcard is the one this chain put there itself.
 var TRAILING_WILDCARD = "\uE000";
 
 // A trailing "/**" is deferred the same way, because `checkRegex` has to tell
@@ -243,6 +238,27 @@ var TRAILING_WILDCARD = "\uE000";
 //   still never matches the folder itself (#21).
 var TRAILING_DOUBLESTAR = "\uE001";
 
+// The three characters above mean something to the chain that builds the
+//   source rather than to the path, so one that came out of the pattern is
+//   held aside like a bracket expression instead of going straight out. Being
+//   held is what makes it safe: the restore runs after the step that anchors
+//   the source, so the character comes back in the middle of the source and
+//   not at its end, which is the one place `_make` and `checkSourceOf` look
+//   for a marker. Without it a pattern's own character lands where a pending
+//   marker sits, and `_make` turns it into a real trailing wildcard.
+//
+// It is held as a one-member class rather than bare, in both of the branches
+//   a reserved character can reach, so that the property can be
+//   read off this function alone -- a reserved character never goes out on
+//   its own -- rather than depending on where in the chain the restore
+//   happens to run. In the expression built here `[x]` matches exactly what
+//   `x` matches, none of the three being special to a regular expression or
+//   inside a class, so no test can tell the two apart: the class is insurance,
+//   and the paragraph above is the reason it is not needed.
+var isReserved = function isReserved(_char3) {
+  return _char3 === PLACEHOLDER || _char3 === TRAILING_WILDCARD || _char3 === TRAILING_DOUBLESTAR;
+};
+
 // Replace every bracket expression with a placeholder the replacers below
 //   leave alone, and translate it separately.
 var extractBrackets = function extractBrackets(pattern) {
@@ -254,8 +270,8 @@ var extractBrackets = function extractBrackets(pattern) {
   var out = EMPTY;
   var index = 0;
   while (index < length) {
-    var _char3 = pattern[index];
-    if (_char3 === ESCAPE) {
+    var _char4 = pattern[index];
+    if (_char4 === 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
@@ -265,29 +281,34 @@ var extractBrackets = function extractBrackets(pattern) {
       //   `\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 can reach here after line-ending cleanup.
+      // Three escapes are still left for the chain: `\*` (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), and `\ ` (a quoted space, which one pass
+      //   below rewrites in bulk -- holding each one aside instead costs more
+      //   on a pattern built out of them). A lone trailing backslash can reach
+      //   here after line-ending cleanup.
+      //
+      // A quoted backslash is not among them. The chain doubles every
+      //   backslash, then takes the doubling back out again, and a quoted one
+      //   standing next to a character the chain also escapes left the two
+      //   counts sharing a run, so one of the escapes was lost. Held here as
+      //   the literal it means, it never joins that run.
       var escaped = pattern[index + 1];
       if (escaped === UNDEFINED || escaped === SLASH && index + 2 === length) {
         // Git removes a final directory slash before matching. An escape
         //   without a character after that removal makes the pattern invalid.
         out += hold(NEVER_MATCH);
-      } else if (escaped === '*' || escaped === '[' || escaped === SPACE || escaped === ESCAPE) {
+      } else if (escaped === '*' || escaped === '[' || escaped === SPACE) {
         out += pattern.slice(index, index + 2);
       } else {
-        out += hold(REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : escaped);
+        out += hold(REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : isReserved(escaped) ? "[".concat(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, "]"));
+    } else if (isReserved(_char4)) {
+      out += hold("[".concat(_char4, "]"));
       index++;
-    } else if (_char3 === '[') {
+    } else if (_char4 === '[') {
       var scanned = scanBracket(pattern, index);
       if (scanned === null) {
         // git gives up on the whole pattern (`WM_ABORT_ALL`), so whatever
@@ -299,7 +320,7 @@ var extractBrackets = function extractBrackets(pattern) {
         index = scanned.end + 1;
       }
     } else {
-      out += _char3;
+      out += _char4;
       index++;
     }
   }
@@ -499,25 +520,23 @@ function (_, p1, p2) {
 // 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.
+//   can be left at the end here, and what stands in front of it says which
+//   kind it is. A wildcard arrives as the escaper wrote it, `\*` with
+//   nothing before it; a literal arrives as the user's own escape, which
+//   the escaper doubled, and then the star's own -- `\\` and then `\*`.
+//   There is no third case: every backslash still reaching the chain is
+//   one `\*`, `\[` or `\ ` carries itself, and each is followed by its
+//   own character, so a longer run can never form. 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
-  );
+  return p2 === EMPTY
+  // 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 + 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 '\\*',
@@ -533,11 +552,12 @@ function (_, p1, p2) {
 //   been held aside by `extractBrackets`, so the only `[` left in the
 //   pattern is an escaped, literal one.
 
-// `\` is escaped by step 3
-/\\\[([^\]/]*?)(\\*)($|\])/g,
-// '\\[bar]' -> '\\\\[bar\\]'
-function (match, range, endEscape, close) {
-  return "\\[".concat(range).concat(cleanRangeBackSlash(endEscape)).concat(close);
+// A backslash could only stand at the end of the range if it quoted the
+//   `]`, and `\]` is held aside long before this.
+/\\\[([^\]/]*?)($|\])/g,
+// '\\[bar]' -> '\\\\[bar]'
+function (match, range, close) {
+  return "\\[".concat(range).concat(close);
 }, '['],
 // ending
 [
@@ -596,30 +616,41 @@ var replaceTrailingDoublestar = function replaceTrailingDoublestar() {
 };
 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
+// The fixed piece between the wildcard at `at` and the next wildcard of the
+//   run: the tokens that separate them, joined as they appear in the source.
+//   A run never holds two wildcards in a row, so there is always at least one
+//   token.
+var separatorAfter = function separatorAfter(run, at) {
+  var separator = EMPTY;
+  for (var index = at + 1; index < run.length && !run[index].wildcard; index++) {
+    separator += run[index].single;
+  }
+  return separator;
+};
+
+// Where a run of non-slash wildcards is split by fixed pieces --
+//   `[^/]*ab[^/]*cd...` -- 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
+//   run can be pinned to stop where the piece after it begins, 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
+//   paths match: the fixed pieces still bound the count, and the last
 //   wildcard still absorbs the rest.
 //
+// A wildcard is pinned to the whole piece, never to the piece's first
+//   character. The pin leaves no way back, so a wildcard that stopped at that
+//   first character would hand over wherever the character happens to turn
+//   up, including the places the rest of the piece cannot follow -- which is
+//   how `f*o/*/*` came to miss `foo/b/c`, the first `o` of `foo` not being
+//   the one the `o/` after it needs. Every token of a piece matches exactly
+//   one character, so the first place the whole piece fits is the leftmost
+//   place it can sit, and whatever is left over goes to the wildcards that
+//   follow.
+//
 // 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.
-
-// The fixed pieces between the wildcard at `at` and the next wildcard of the
-//   run, joined as they appear in the source. A run never holds two wildcards
-//   in a row, so there is always at least one piece.
-var separatorAfter = function separatorAfter(run, at) {
-  var separator = EMPTY;
-  for (var index = at + 1; index < run.length && !run[index].wildcard; index++) {
-    separator += run[index].single;
-  }
-  return separator;
-};
 var pinWildcards = function pinWildcards(source) {
   if (source.indexOf(WILDCARD) < 0) {
     return source;
@@ -628,13 +659,13 @@ var pinWildcards = function pinWildcards(source) {
   var length = source.length;
   var index = 0;
   while (index < length) {
-    var _char4 = source[index];
+    var _char5 = source[index];
     if (source.startsWith(WILDCARD, index)) {
       tokens.push({
         wildcard: true
       });
       index += WILDCARD.length;
-    } else if (_char4 === '[') {
+    } else if (_char5 === '[') {
       var end = index + 1;
       if (source[end] === '^') {
         end++;
@@ -650,12 +681,12 @@ var pinWildcards = function pinWildcards(source) {
         single: source.slice(index, end)
       });
       index = end;
-    } else if (_char4 === ESCAPE) {
+    } else if (_char5 === ESCAPE) {
       tokens.push({
         single: source.slice(index, index + 2)
       });
       index += 2;
-    } else if (_char4 === '(') {
+    } else if (_char5 === '(') {
       var depth = 0;
       var _end = index;
       do {
@@ -675,14 +706,14 @@ var pinWildcards = function pinWildcards(source) {
         boundary: source.slice(index, _end)
       });
       index = _end;
-    } else if (_char4 === '^' || _char4 === '$') {
+    } else if (_char5 === '^' || _char5 === '$') {
       tokens.push({
-        boundary: _char4
+        boundary: _char5
       });
       index++;
     } else {
       tokens.push({
-        single: _char4
+        single: _char5
       });
       index++;
     }
@@ -702,16 +733,9 @@ var pinWildcards = function pinWildcards(source) {
         return;
       }
 
-      // A wildcard that is not the last in the run is pinned to the whole
-      //   fixed piece that separates it from the next wildcard, not just to
-      //   that piece's first character: stopping at the first character alone
-      //   would let the wildcard hand over at a place where the rest of the
-      //   separator cannot follow, and the pin leaves no way back, so
-      //   `f*o/*/*` would miss `foo/b/c` -- the first `o` of `foo` is not the
-      //   one the `o/` after it needs. Every piece matches exactly one
-      //   character, so pinning to the first place the whole separator fits
-      //   is the leftmost place it can sit, and the wildcards that follow
-      //   take up whatever is left.
+      // Every wildcard but the last is pinned to the whole piece that
+      //   follows it, for the reason set out above this function. The last
+      //   one stays as it is and takes up the rest.
       out += at === lastWildcard ? WILDCARD : "(?:(?!".concat(separatorAfter(run, at), ")[^\\/])*");
     });
     run = [];
@@ -890,8 +914,8 @@ var IgnoreRule = /*#__PURE__*/function () {
   }]);
   return IgnoreRule;
 }();
-var isLineEnd = function isLineEnd(_char5) {
-  return _char5 === '\r' || _char5 === '\n';
+var isLineEnd = function isLineEnd(_char6) {
+  return _char6 === '\r' || _char6 === '\n';
 };
 
 // Drop a line terminator, which can remain when patterns are passed as an

package/node_modules/ignore/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignore",
-  "version": "7.0.12",
+  "version": "7.0.13",
   "description": "Ignore is a manager and filter for .gitignore rules, the one used by eslint, gitbook and many others.",
   "types": "index.d.ts",
   "files": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-lsp",
-  "version": "11.0.0",
+  "version": "11.0.1",
   "description": "Language Server Protocol runtime for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -37,8 +37,8 @@
     "vscode-jsonrpc": "^9.0.0",
     "vscode-languageserver-protocol": "^3.18.0",
     "vscode-languageserver-types": "^3.18.0",
-    "@mrclrchtr/supi-code-runtime": "11.0.0",
-    "@mrclrchtr/supi-core": "11.0.0"
+    "@mrclrchtr/supi-core": "11.0.1",
+    "@mrclrchtr/supi-code-runtime": "11.0.1"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",