@mrclrchtr/supi-lsp 11.0.0 → 11.1.0

package/node_modules/ignore/legacy.js

@@ -26,6 +26,8 @@ var ESCAPE = '\\';
 var REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
 var BOM = "\uFEFF";
 var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+// A run of two or more asterisks is a globstar (#175)
+var REGEX_ANCHORED_GLOBSTAR = /^\/\*{2,}$/;
 var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
 var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
 var REGEX_SPLITALL_CRLF = /\r?\n/g;
@@ -60,12 +62,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 +183,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 +229,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 +240,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 +272,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 +283,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 +322,7 @@ var extractBrackets = function extractBrackets(pattern) {
         index = scanned.end + 1;
       }
     } else {
-      out += _char3;
+      out += _char4;
       index++;
     }
   }
@@ -365,6 +388,18 @@ var REPLACERS = [
 /(\\+)( ?)/g, function (_, run, space) {
   return space ? run.slice(0, run.length - run.length % 2) + SPACE : run;
 }, ESCAPE + SPACE],
+// git's wildmatch() reads a run of two or more asterisks as one globstar
+//   whenever the run fills a path segment: it starts the pattern or follows
+//   a `/`, and it ends the pattern or comes before a `/`. A run of two is
+//   already `**`; a longer one is folded into `**` here, so the steps
+//   below only ever have to know `**`.
+// `***/foo` -> `**/foo`, `a/***/b` -> `a/**/b`, `a/***` -> `a/**`
+// git also takes a run beside a literal prefix (`a***/b`) or beside an
+//   escaped slash (`***\/b`) as a globstar, and this does not; the README
+//   lists both, under "A run of asterisks".
+[/(^|\/)\*{3,}(?=\/|$)/g, function (_, start) {
+  return "".concat(start, "**");
+}, '*'],
 // Escape metacharacters
 // which is written down by users but means special for regular expressions.
 
@@ -499,25 +534,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 +566,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 +630,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 +673,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 +695,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 +720,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 +747,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 = [];
@@ -730,6 +768,14 @@ var pinWildcards = function pinWildcards(source) {
 
 // @param {pattern}
 var makeRegexPrefix = function makeRegexPrefix(pattern) {
+  // `/**` matches every path, as `**` does. The translation below only finds
+  //   a globstar beside a slash it keeps, and the leading one is turned into
+  //   an anchor, so `/**` would come out as `/*` and match one level only.
+  //   Here rather than in `createRule`, so that `checkSourceOf`, which
+  //   compiles `/**/` again without its trailing slash, gets it too.
+  if (REGEX_ANCHORED_GLOBSTAR.test(pattern)) {
+    pattern = '**';
+  }
   var _extractBrackets = extractBrackets(pattern),
     source = _extractBrackets.source,
     sources = _extractBrackets.sources;
@@ -890,8 +936,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
@@ -1057,19 +1103,12 @@ var RuleManager = /*#__PURE__*/function () {
 
     // Test one single path without recursively checking parent directories
     //
-    // - checkUnignored `boolean` whether should check if the path is unignored,
-    //   setting `checkUnignored` to `false` could reduce additional
-    //   path matching.
-    // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+    // - mode `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
 
-    // @returns {TestResult} true if a file is ignored
+    // @returns {TestResult}
   }, {
     key: "test",
-    value: function test(path, checkUnignored, mode) {
-      var ignored = false;
-      var unignored = false;
-      var matchedRule;
-
+    value: function test(path, mode) {
       // 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.
@@ -1080,40 +1119,31 @@ var RuleManager = /*#__PURE__*/function () {
       var shortcut = this._basenameCount * 2 >= length;
       var basename = shortcut ? basenameOf(path) : path;
 
+      // The last rule to match decides, as in git, and it is the rule
+      //   `git check-ignore -v` reports, so the scan runs from the end and stops
+      //   at the first match.
       // 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++) {
+      for (var index = length - 1; index >= 0; index--) {
         var rule = rules[index];
-        var negative = rule.negative;
-
-        //          |           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
-        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 (rule[mode].test(shortcut && rule._basenameOnly ? basename : path)) {
+          var negative = rule.negative;
+          var ret = {
+            ignored: !negative,
+            unignored: negative
+          };
+          if (!negative) {
+            ret.rule = rule;
+          }
+          return ret;
         }
       }
-      var ret = {
-        ignored: ignored,
-        unignored: unignored
+      return {
+        ignored: false,
+        unignored: false
       };
-      if (matchedRule) {
-        ret.rule = matchedRule;
-      }
-      return ret;
     }
   }]);
   return RuleManager;
@@ -1225,12 +1255,12 @@ var Ignore = /*#__PURE__*/function () {
     // @returns {TestResult}
   }, {
     key: "_test",
-    value: function _test(originalPath, cache, checkUnignored) {
+    value: function _test(originalPath, cache) {
       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);
     }
   }, {
     key: "checkIgnore",
@@ -1244,7 +1274,7 @@ var Ignore = /*#__PURE__*/function () {
       // Like `git check-ignore`: a directory excluded by itself or by an
       //   ancestor settles it, and only then is the literal 'abc/' matched
       //   against the rules (see `checkSourceOf`).
-      var dir = this._t(path, this._testCache, true);
+      var dir = this._t(path, this._testCache);
       if (dir.ignored) {
         return dir;
       }
@@ -1257,25 +1287,23 @@ var Ignore = /*#__PURE__*/function () {
     // The path to be tested
     path,
     // The cache for the result of a certain checking
-    cache,
-    // Whether should check if the path is unignored
-    checkUnignored) {
+    cache) {
       if (path in cache) {
         return cache[path];
       }
       var parentPath = parentOf(path);
 
       // If the path contains a parent directory, check the parent first
-      var parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
+      var parent = parentPath ? this._t(parentPath, cache) : UNDEFINED;
       return cache[path] = parent && 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);
+      ? parent : this._rules.test(path, MODE_IGNORE);
     }
   }, {
     key: "ignores",
     value: function ignores(path) {
-      return this._test(path, this._ignoreCache, false).ignored;
+      return this._test(path, this._ignoreCache).ignored;
     }
   }, {
     key: "createFilter",
@@ -1295,7 +1323,7 @@ var Ignore = /*#__PURE__*/function () {
   }, {
     key: "test",
     value: function test(path) {
-      return this._test(path, this._testCache, true);
+      return this._test(path, this._testCache);
     }
   }]);
   return Ignore;

package/node_modules/ignore/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignore",
-  "version": "7.0.12",
+  "version": "7.0.14",
   "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/node_modules/vscode-jsonrpc/README.md

@@ -6,6 +6,11 @@
 
 This npm module implements the base messaging protocol spoken between a VSCode language server and a VSCode language client.
 
+The Node.js entry point requires Node.js 14.17.0 or newer. The runtime abstraction layer exposes
+`RAL().crypto.randomUUID()` for cryptographically generated v4 UUIDs. The browser implementation
+uses native `crypto.randomUUID()` when available and falls back to `crypto.getRandomValues()`,
+including in non-secure contexts. Custom RAL implementations must provide this capability.
+
 The npm module can also be used standalone to establish a [JSON-RPC](http://www.jsonrpc.org/) channel between
 a client and a server. Below an example how to setup a JSON-RPC connection. First the client side.
 

package/node_modules/vscode-jsonrpc/lib/browser/ril.js

@@ -145,6 +145,14 @@ class PromiseImpl {
 exports.PromiseImpl = PromiseImpl;
 const _textEncoder = new TextEncoder();
 const _ril = Object.freeze({
+    crypto: Object.freeze({
+        randomUUID() {
+            if (typeof globalThis.crypto.randomUUID === 'function') {
+                return globalThis.crypto.randomUUID();
+            }
+            return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, c => (+c ^ (globalThis.crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (+c / 4)))).toString(16));
+        }
+    }),
     messageBuffer: Object.freeze({
         create: (encoding) => new MessageBuffer(encoding)
     }),

package/node_modules/vscode-jsonrpc/lib/common/connection.js

@@ -418,11 +418,16 @@ function createMessageConnection(messageReader, messageWriter, _logger, options)
             }
             finally {
                 if (result instanceof Promise) {
+                    // Both settlements must release the parallelism slot. Written as
+                    // .then(...).catch(...) the rejection path skipped the decrement, so
+                    // one failed dispatch left `inFlight` permanently elevated and
+                    // triggerMessageQueue() bailed out forever after.
                     result.then(() => {
-                        inFlight--;
-                        triggerMessageQueue();
                     }).catch((error) => {
                         logger.error(`Processing message queue failed: ${error.toString()}`);
+                    }).finally(() => {
+                        inFlight--;
+                        triggerMessageQueue();
                     });
                 }
                 else {

package/node_modules/vscode-jsonrpc/lib/common/ral.d.ts

@@ -42,7 +42,15 @@ interface _WritableStream {
 }
 interface _DuplexStream extends _ReadableStream, _WritableStream {
 }
+/**
+ * Runtime abstraction implemented by this npm module.
+ * External implementations are not supported. Changes to this interface do not
+ * require a major version bump.
+ */
 interface RAL {
+    readonly crypto: {
+        randomUUID(): string;
+    };
     readonly applicationJson: {
         readonly encoder: ContentTypeEncoder;
         readonly decoder: ContentTypeDecoder;

package/node_modules/vscode-jsonrpc/lib/node/main.d.ts

@@ -46,12 +46,26 @@ export declare class StreamMessageWriter extends WriteableStreamMessageWriter {
 export declare function generateRandomPipeName(): string;
 export interface PipeTransport {
     onConnected(): Promise<[MessageReader, MessageWriter]>;
+    /**
+     * Closes the underlying server if a client hasn't connected yet. Callers
+     * should invoke this if they abandon the transport before `onConnected`
+     * resolves (for example because the server process failed to start) to
+     * avoid leaking the listening pipe.
+     */
+    close(): void;
 }
 export declare function createClientPipeTransport(pipeName: string, encoding?: RAL.MessageBufferEncoding): Promise<PipeTransport>;
 export declare function createServerPipeTransport(pipeName: string, encoding?: RAL.MessageBufferEncoding): [MessageReader, MessageWriter];
 export interface SocketTransport {
     port(): number;
     onConnected(): Promise<[MessageReader, MessageWriter]>;
+    /**
+     * Closes the underlying server if a client hasn't connected yet. Callers
+     * should invoke this if they abandon the transport before `onConnected`
+     * resolves (for example because the server process failed to start) to
+     * avoid leaking the listening socket.
+     */
+    close(): void;
 }
 export declare function createClientSocketTransport(port: number, encoding?: RAL.MessageBufferEncoding): Promise<SocketTransport>;
 export declare function createServerSocketTransport(port: number, encoding?: RAL.MessageBufferEncoding): [MessageReader, MessageWriter];