@mrclrchtr/supi-lsp 11.0.1 → 11.2.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;
@@ -386,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.
 
@@ -754,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;
@@ -1081,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.
@@ -1104,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;
@@ -1249,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",
@@ -1268,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;
       }
@@ -1281,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",
@@ -1319,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.13",
+  "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/semver/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.