vercel 39.4.1 → 39.4.2

package/dist/index.js

@@ -46156,7 +46156,7 @@ var require_package = __commonJS2({
   "../client/package.json"(exports2, module2) {
     module2.exports = {
       name: "@vercel/client",
-      version: "13.5.5",
+      version: "13.5.6",
       main: "dist/index.js",
       typings: "dist/index.d.ts",
       homepage: "https://vercel.com",
@@ -46197,7 +46197,7 @@ var require_package = __commonJS2({
       dependencies: {
         "@vercel/build-utils": "9.1.0",
         "@vercel/error-utils": "2.0.3",
-        "@vercel/routing-utils": "5.0.0",
+        "@vercel/routing-utils": "5.0.1",
         "async-retry": "1.2.3",
         "async-sema": "3.0.0",
         "fs-extra": "8.0.1",
@@ -109973,6 +109973,396 @@ var require_dist21 = __commonJS2({
   }
 });
 
+// ../../node_modules/.pnpm/path-to-regexp@6.3.0/node_modules/path-to-regexp/dist/index.js
+var require_dist22 = __commonJS2({
+  "../../node_modules/.pnpm/path-to-regexp@6.3.0/node_modules/path-to-regexp/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.pathToRegexp = exports2.tokensToRegexp = exports2.regexpToFunction = exports2.match = exports2.tokensToFunction = exports2.compile = exports2.parse = void 0;
+    function lexer(str) {
+      var tokens = [];
+      var i = 0;
+      while (i < str.length) {
+        var char = str[i];
+        if (char === "*" || char === "+" || char === "?") {
+          tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === "\\") {
+          tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
+          continue;
+        }
+        if (char === "{") {
+          tokens.push({ type: "OPEN", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === "}") {
+          tokens.push({ type: "CLOSE", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === ":") {
+          var name = "";
+          var j = i + 1;
+          while (j < str.length) {
+            var code2 = str.charCodeAt(j);
+            if (
+              // `0-9`
+              code2 >= 48 && code2 <= 57 || // `A-Z`
+              code2 >= 65 && code2 <= 90 || // `a-z`
+              code2 >= 97 && code2 <= 122 || // `_`
+              code2 === 95
+            ) {
+              name += str[j++];
+              continue;
+            }
+            break;
+          }
+          if (!name)
+            throw new TypeError("Missing parameter name at ".concat(i));
+          tokens.push({ type: "NAME", index: i, value: name });
+          i = j;
+          continue;
+        }
+        if (char === "(") {
+          var count = 1;
+          var pattern = "";
+          var j = i + 1;
+          if (str[j] === "?") {
+            throw new TypeError('Pattern cannot start with "?" at '.concat(j));
+          }
+          while (j < str.length) {
+            if (str[j] === "\\") {
+              pattern += str[j++] + str[j++];
+              continue;
+            }
+            if (str[j] === ")") {
+              count--;
+              if (count === 0) {
+                j++;
+                break;
+              }
+            } else if (str[j] === "(") {
+              count++;
+              if (str[j + 1] !== "?") {
+                throw new TypeError("Capturing groups are not allowed at ".concat(j));
+              }
+            }
+            pattern += str[j++];
+          }
+          if (count)
+            throw new TypeError("Unbalanced pattern at ".concat(i));
+          if (!pattern)
+            throw new TypeError("Missing pattern at ".concat(i));
+          tokens.push({ type: "PATTERN", index: i, value: pattern });
+          i = j;
+          continue;
+        }
+        tokens.push({ type: "CHAR", index: i, value: str[i++] });
+      }
+      tokens.push({ type: "END", index: i, value: "" });
+      return tokens;
+    }
+    function parse9(str, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var tokens = lexer(str);
+      var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a, _b = options.delimiter, delimiter3 = _b === void 0 ? "/#?" : _b;
+      var result = [];
+      var key = 0;
+      var i = 0;
+      var path11 = "";
+      var tryConsume = function(type) {
+        if (i < tokens.length && tokens[i].type === type)
+          return tokens[i++].value;
+      };
+      var mustConsume = function(type) {
+        var value2 = tryConsume(type);
+        if (value2 !== void 0)
+          return value2;
+        var _a2 = tokens[i], nextType = _a2.type, index = _a2.index;
+        throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index, ", expected ").concat(type));
+      };
+      var consumeText = function() {
+        var result2 = "";
+        var value2;
+        while (value2 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+          result2 += value2;
+        }
+        return result2;
+      };
+      var isSafe = function(value2) {
+        for (var _i = 0, delimiter_1 = delimiter3; _i < delimiter_1.length; _i++) {
+          var char2 = delimiter_1[_i];
+          if (value2.indexOf(char2) > -1)
+            return true;
+        }
+        return false;
+      };
+      var safePattern = function(prefix2) {
+        var prev = result[result.length - 1];
+        var prevText = prefix2 || (prev && typeof prev === "string" ? prev : "");
+        if (prev && !prevText) {
+          throw new TypeError('Must have text between two parameters, missing text after "'.concat(prev.name, '"'));
+        }
+        if (!prevText || isSafe(prevText))
+          return "[^".concat(escapeString(delimiter3), "]+?");
+        return "(?:(?!".concat(escapeString(prevText), ")[^").concat(escapeString(delimiter3), "])+?");
+      };
+      while (i < tokens.length) {
+        var char = tryConsume("CHAR");
+        var name = tryConsume("NAME");
+        var pattern = tryConsume("PATTERN");
+        if (name || pattern) {
+          var prefix = char || "";
+          if (prefixes.indexOf(prefix) === -1) {
+            path11 += prefix;
+            prefix = "";
+          }
+          if (path11) {
+            result.push(path11);
+            path11 = "";
+          }
+          result.push({
+            name: name || key++,
+            prefix,
+            suffix: "",
+            pattern: pattern || safePattern(prefix),
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        var value = char || tryConsume("ESCAPED_CHAR");
+        if (value) {
+          path11 += value;
+          continue;
+        }
+        if (path11) {
+          result.push(path11);
+          path11 = "";
+        }
+        var open5 = tryConsume("OPEN");
+        if (open5) {
+          var prefix = consumeText();
+          var name_1 = tryConsume("NAME") || "";
+          var pattern_1 = tryConsume("PATTERN") || "";
+          var suffix = consumeText();
+          mustConsume("CLOSE");
+          result.push({
+            name: name_1 || (pattern_1 ? key++ : ""),
+            pattern: name_1 && !pattern_1 ? safePattern(prefix) : pattern_1,
+            prefix,
+            suffix,
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        mustConsume("END");
+      }
+      return result;
+    }
+    exports2.parse = parse9;
+    function compile(str, options) {
+      return tokensToFunction(parse9(str, options), options);
+    }
+    exports2.compile = compile;
+    function tokensToFunction(tokens, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var reFlags = flags(options);
+      var _a = options.encode, encode = _a === void 0 ? function(x) {
+        return x;
+      } : _a, _b = options.validate, validate2 = _b === void 0 ? true : _b;
+      var matches = tokens.map(function(token) {
+        if (typeof token === "object") {
+          return new RegExp("^(?:".concat(token.pattern, ")$"), reFlags);
+        }
+      });
+      return function(data) {
+        var path11 = "";
+        for (var i = 0; i < tokens.length; i++) {
+          var token = tokens[i];
+          if (typeof token === "string") {
+            path11 += token;
+            continue;
+          }
+          var value = data ? data[token.name] : void 0;
+          var optional = token.modifier === "?" || token.modifier === "*";
+          var repeat = token.modifier === "*" || token.modifier === "+";
+          if (Array.isArray(value)) {
+            if (!repeat) {
+              throw new TypeError('Expected "'.concat(token.name, '" to not repeat, but got an array'));
+            }
+            if (value.length === 0) {
+              if (optional)
+                continue;
+              throw new TypeError('Expected "'.concat(token.name, '" to not be empty'));
+            }
+            for (var j = 0; j < value.length; j++) {
+              var segment = encode(value[j], token);
+              if (validate2 && !matches[i].test(segment)) {
+                throw new TypeError('Expected all "'.concat(token.name, '" to match "').concat(token.pattern, '", but got "').concat(segment, '"'));
+              }
+              path11 += token.prefix + segment + token.suffix;
+            }
+            continue;
+          }
+          if (typeof value === "string" || typeof value === "number") {
+            var segment = encode(String(value), token);
+            if (validate2 && !matches[i].test(segment)) {
+              throw new TypeError('Expected "'.concat(token.name, '" to match "').concat(token.pattern, '", but got "').concat(segment, '"'));
+            }
+            path11 += token.prefix + segment + token.suffix;
+            continue;
+          }
+          if (optional)
+            continue;
+          var typeOfMessage = repeat ? "an array" : "a string";
+          throw new TypeError('Expected "'.concat(token.name, '" to be ').concat(typeOfMessage));
+        }
+        return path11;
+      };
+    }
+    exports2.tokensToFunction = tokensToFunction;
+    function match(str, options) {
+      var keys = [];
+      var re = pathToRegexp(str, keys, options);
+      return regexpToFunction(re, keys, options);
+    }
+    exports2.match = match;
+    function regexpToFunction(re, keys, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.decode, decode = _a === void 0 ? function(x) {
+        return x;
+      } : _a;
+      return function(pathname) {
+        var m = re.exec(pathname);
+        if (!m)
+          return false;
+        var path11 = m[0], index = m.index;
+        var params2 = /* @__PURE__ */ Object.create(null);
+        var _loop_1 = function(i2) {
+          if (m[i2] === void 0)
+            return "continue";
+          var key = keys[i2 - 1];
+          if (key.modifier === "*" || key.modifier === "+") {
+            params2[key.name] = m[i2].split(key.prefix + key.suffix).map(function(value) {
+              return decode(value, key);
+            });
+          } else {
+            params2[key.name] = decode(m[i2], key);
+          }
+        };
+        for (var i = 1; i < m.length; i++) {
+          _loop_1(i);
+        }
+        return { path: path11, index, params: params2 };
+      };
+    }
+    exports2.regexpToFunction = regexpToFunction;
+    function escapeString(str) {
+      return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+    }
+    function flags(options) {
+      return options && options.sensitive ? "" : "i";
+    }
+    function regexpToRegexp(path11, keys) {
+      if (!keys)
+        return path11;
+      var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+      var index = 0;
+      var execResult = groupsRegex.exec(path11.source);
+      while (execResult) {
+        keys.push({
+          // Use parenthesized substring match if available, index otherwise
+          name: execResult[1] || index++,
+          prefix: "",
+          suffix: "",
+          modifier: "",
+          pattern: ""
+        });
+        execResult = groupsRegex.exec(path11.source);
+      }
+      return path11;
+    }
+    function arrayToRegexp(paths, keys, options) {
+      var parts = paths.map(function(path11) {
+        return pathToRegexp(path11, keys, options).source;
+      });
+      return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
+    }
+    function stringToRegexp(path11, keys, options) {
+      return tokensToRegexp(parse9(path11, options), keys, options);
+    }
+    function tokensToRegexp(tokens, keys, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function(x) {
+        return x;
+      } : _d, _e = options.delimiter, delimiter3 = _e === void 0 ? "/#?" : _e, _f = options.endsWith, endsWith = _f === void 0 ? "" : _f;
+      var endsWithRe = "[".concat(escapeString(endsWith), "]|$");
+      var delimiterRe = "[".concat(escapeString(delimiter3), "]");
+      var route = start ? "^" : "";
+      for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+        var token = tokens_1[_i];
+        if (typeof token === "string") {
+          route += escapeString(encode(token));
+        } else {
+          var prefix = escapeString(encode(token.prefix));
+          var suffix = escapeString(encode(token.suffix));
+          if (token.pattern) {
+            if (keys)
+              keys.push(token);
+            if (prefix || suffix) {
+              if (token.modifier === "+" || token.modifier === "*") {
+                var mod = token.modifier === "*" ? "?" : "";
+                route += "(?:".concat(prefix, "((?:").concat(token.pattern, ")(?:").concat(suffix).concat(prefix, "(?:").concat(token.pattern, "))*)").concat(suffix, ")").concat(mod);
+              } else {
+                route += "(?:".concat(prefix, "(").concat(token.pattern, ")").concat(suffix, ")").concat(token.modifier);
+              }
+            } else {
+              if (token.modifier === "+" || token.modifier === "*") {
+                throw new TypeError('Can not repeat "'.concat(token.name, '" without a prefix and suffix'));
+              }
+              route += "(".concat(token.pattern, ")").concat(token.modifier);
+            }
+          } else {
+            route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier);
+          }
+        }
+      }
+      if (end) {
+        if (!strict)
+          route += "".concat(delimiterRe, "?");
+        route += !options.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
+      } else {
+        var endToken = tokens[tokens.length - 1];
+        var isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
+        if (!strict) {
+          route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
+        }
+        if (!isEndDelimited) {
+          route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
+        }
+      }
+      return new RegExp(route, flags(options));
+    }
+    exports2.tokensToRegexp = tokensToRegexp;
+    function pathToRegexp(path11, keys, options) {
+      if (path11 instanceof RegExp)
+        return regexpToRegexp(path11, keys);
+      if (Array.isArray(path11))
+        return arrayToRegexp(path11, keys, options);
+      return stringToRegexp(path11, keys, options);
+    }
+    exports2.pathToRegexp = pathToRegexp;
+  }
+});
+
 // ../routing-utils/dist/superstatic.js
 var require_superstatic = __commonJS2({
   "../routing-utils/dist/superstatic.js"(exports2, module2) {
@@ -110008,6 +110398,37 @@ var require_superstatic = __commonJS2({
     module2.exports = __toCommonJS4(superstatic_exports);
     var import_url23 = require("url");
     var import_path_to_regexp = require_dist21();
+    var import_path_to_regexp_updated = require_dist22();
+    function pathToRegexp(callerId, path11, keys, options) {
+      const currentRegExp = (0, import_path_to_regexp.pathToRegexp)(path11, keys, options);
+      try {
+        const currentKeys = keys;
+        const newKeys = [];
+        const newRegExp = (0, import_path_to_regexp_updated.pathToRegexp)(path11, newKeys, options);
+        const isDiffRegExp = currentRegExp.toString() !== newRegExp.toString();
+        if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffRegExp) {
+          const message2 = JSON.stringify({
+            path: path11,
+            currentRegExp: currentRegExp.toString(),
+            newRegExp: newRegExp.toString()
+          });
+          console.error(`[vc] PATH TO REGEXP PATH DIFF @ #${callerId}: ${message2}`);
+        }
+        const isDiffKeys = keys?.toString() !== newKeys?.toString();
+        if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffKeys) {
+          const message2 = JSON.stringify({
+            isDiffKeys,
+            currentKeys,
+            newKeys
+          });
+          console.error(`[vc] PATH TO REGEXP KEYS DIFF @ #${callerId}: ${message2}`);
+        }
+      } catch (err) {
+        const error3 = err;
+        console.error(`[vc] PATH TO REGEXP ERROR @ #${callerId}: ${error3.message}`);
+      }
+      return currentRegExp;
+    }
     var UN_NAMED_SEGMENT = "__UN_NAMED_SEGMENT__";
     function getCleanUrls2(filePaths) {
       const htmlFiles = filePaths.map(toRoute).filter((f) => f.endsWith(".html")).map((f) => ({
@@ -110163,7 +110584,7 @@ var require_superstatic = __commonJS2({
     }
     function sourceToRegex(source) {
       const keys = [];
-      const r = (0, import_path_to_regexp.pathToRegexp)(source, keys, {
+      const r = pathToRegexp("632", source, keys, {
         strict: true,
         sensitive: true,
         delimiter: "/"
@@ -110236,9 +110657,9 @@ var require_superstatic = __commonJS2({
       const hashKeys = [];
       const hostnameKeys = [];
       try {
-        (0, import_path_to_regexp.pathToRegexp)(pathname, pathnameKeys);
-        (0, import_path_to_regexp.pathToRegexp)(hash || "", hashKeys);
-        (0, import_path_to_regexp.pathToRegexp)(hostname2 || "", hostnameKeys);
+        pathToRegexp("528", pathname, pathnameKeys);
+        pathToRegexp("834", hash || "", hashKeys);
+        pathToRegexp("712", hostname2 || "", hostnameKeys);
       } catch (_) {
       }
       destParams = new Set(
@@ -110346,7 +110767,7 @@ var require_append = __commonJS2({
       appendRoutesToPhase: () => appendRoutesToPhase4
     });
     module2.exports = __toCommonJS4(append_exports);
-    var import_index = require_dist22();
+    var import_index = require_dist23();
     function appendRoutesToPhase4({
       routes: prevRoutes,
       newRoutes,
@@ -110414,7 +110835,7 @@ var require_merge3 = __commonJS2({
       mergeRoutes: () => mergeRoutes3
     });
     module2.exports = __toCommonJS4(merge_exports);
-    var import_index = require_dist22();
+    var import_index = require_dist23();
     function getBuilderRoutesMapping(builds) {
       const builderRoutes = {};
       for (const { entrypoint, routes: routes2, use } of builds) {
@@ -110856,7 +111277,7 @@ var require_types6 = __commonJS2({
 });
 
 // ../routing-utils/dist/index.js
-var require_dist22 = __commonJS2({
+var require_dist23 = __commonJS2({
   "../routing-utils/dist/index.js"(exports2, module2) {
     "use strict";
     var __defProp4 = Object.defineProperty;
@@ -131936,7 +132357,7 @@ var init_validate_config = __esm({
   "src/util/validate-config.ts"() {
     "use strict";
     import_ajv2 = __toESM3(require_ajv());
-    import_routing_utils = __toESM3(require_dist22());
+    import_routing_utils = __toESM3(require_dist23());
     import_build_utils12 = require("@vercel/build-utils");
     import_client5 = __toESM3(require_dist7());
     imagesSchema = {
@@ -133836,7 +134257,7 @@ var init_build2 = __esm({
     import_client6 = __toESM3(require_dist7());
     import_frameworks5 = __toESM3(require_frameworks());
     import_fs_detectors4 = __toESM3(require_dist20());
-    import_routing_utils2 = __toESM3(require_dist22());
+    import_routing_utils2 = __toESM3(require_dist23());
     init_output_manager();
     init_corepack();
     init_import_builders();
@@ -155420,7 +155841,7 @@ var require_src3 = __commonJS2({
 });
 
 // ../../node_modules/.pnpm/@tootallnate+once@1.1.2/node_modules/@tootallnate/once/dist/index.js
-var require_dist23 = __commonJS2({
+var require_dist24 = __commonJS2({
   "../../node_modules/.pnpm/@tootallnate+once@1.1.2/node_modules/@tootallnate/once/dist/index.js"(exports2, module2) {
     "use strict";
     function noop() {
@@ -155597,7 +156018,7 @@ var init_path_helpers = __esm({
 });
 
 // ../../node_modules/.pnpm/pcre-to-regexp@1.0.0/node_modules/pcre-to-regexp/dist/index.js
-var require_dist24 = __commonJS2({
+var require_dist25 = __commonJS2({
   "../../node_modules/.pnpm/pcre-to-regexp@1.0.0/node_modules/pcre-to-regexp/dist/index.js"(exports2, module2) {
     "use strict";
     var characterClasses = {
@@ -155932,9 +156353,9 @@ var init_router = __esm({
   "src/util/dev/router.ts"() {
     "use strict";
     import_url16 = __toESM3(require("url"));
-    import_pcre_to_regexp = __toESM3(require_dist24());
+    import_pcre_to_regexp = __toESM3(require_dist25());
     init_is_url();
-    import_routing_utils3 = __toESM3(require_dist22());
+    import_routing_utils3 = __toESM3(require_dist23());
     init_parse_query_string();
   }
 });
@@ -156431,7 +156852,7 @@ var init_builder = __esm({
     init_tree_kill();
     init_path_helpers();
     init_errors_ts();
-    import_routing_utils4 = __toESM3(require_dist22());
+    import_routing_utils4 = __toESM3(require_dist23());
     init_get_update_command();
     init_pkg_name();
     init_import_builders();
@@ -156991,7 +157412,7 @@ var init_server = __esm({
     import_chokidar = require("chokidar");
     import_dotenv2 = __toESM3(require_main3());
     import_path35 = __toESM3(require("path"));
-    import_once = __toESM3(require_dist23());
+    import_once = __toESM3(require_dist24());
     import_directory = __toESM3(require_directory());
     import_get_port = __toESM3(require_get_port());
     import_is_port_reachable = __toESM3(require_is_port_reachable());
@@ -156999,7 +157420,7 @@ var init_server = __esm({
     import_npm_package_arg2 = __toESM3(require_npa());
     import_json_parse_better_errors3 = __toESM3(require_json_parse_better_errors());
     import_client12 = __toESM3(require_dist7());
-    import_routing_utils5 = __toESM3(require_dist22());
+    import_routing_utils5 = __toESM3(require_dist23());
     import_build_utils17 = require("@vercel/build-utils");
     import_fs_detectors6 = __toESM3(require_dist20());
     import_frameworks6 = __toESM3(require_frameworks());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vercel",
-  "version": "39.4.1",
+  "version": "39.4.2",
   "preferGlobal": true,
   "license": "Apache-2.0",
   "description": "The command-line interface for Vercel",
@@ -26,12 +26,12 @@
     "@vercel/go": "3.2.1",
     "@vercel/hydrogen": "1.0.11",
     "@vercel/next": "4.4.4",
-    "@vercel/node": "5.0.3",
+    "@vercel/node": "5.0.4",
     "@vercel/python": "4.7.1",
-    "@vercel/redwood": "2.1.12",
-    "@vercel/remix-builder": "5.1.0",
+    "@vercel/redwood": "2.1.13",
+    "@vercel/remix-builder": "5.1.1",
     "@vercel/ruby": "2.2.0",
-    "@vercel/static-build": "2.5.42",
+    "@vercel/static-build": "2.5.43",
     "chokidar": "4.0.0"
   },
   "devDependencies": {
@@ -79,12 +79,12 @@
     "@types/yauzl-promise": "2.1.0",
     "@vercel-internals/constants": "1.0.4",
     "@vercel-internals/get-package-json": "1.0.0",
-    "@vercel-internals/types": "3.0.5",
-    "@vercel/client": "13.5.5",
+    "@vercel-internals/types": "3.0.6",
+    "@vercel/client": "13.5.6",
     "@vercel/error-utils": "2.0.3",
     "@vercel/frameworks": "3.5.0",
-    "@vercel/fs-detectors": "5.3.3",
-    "@vercel/routing-utils": "5.0.0",
+    "@vercel/fs-detectors": "5.3.4",
+    "@vercel/routing-utils": "5.0.1",
     "@vitest/expect": "2.1.3",
     "ajv": "6.12.3",
     "alpha-sort": "2.0.1",