@vm0/cli 9.222.1 → 9.222.3

package/chunk-KJNJT27A.js

@@ -1,612 +0,0 @@
-#!/usr/bin/env node
-import { createRequire as __createRequire } from "node:module";
-const require = __createRequire(import.meta.url);
-import {
-  hasBaseUrlParams,
-  hasRawWhitespace,
-  hasUnsafeUrlCodepoint,
-  parseSegment,
-  splitPathSegments,
-  validateBaseUrl
-} from "./chunk-LR3SNXFF.js";
-import {
-  init_esm_shims
-} from "./chunk-DIRAZ3YX.js";
-
-// ../../packages/connectors/src/firewall-rule-matcher.ts
-init_esm_shims();
-var VALID_RULE_METHODS = /* @__PURE__ */ new Set([
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "HEAD",
-  "OPTIONS",
-  "ANY"
-]);
-var FORBIDDEN_RUNTIME_HOST_CHARS = new Set("#%*,/<>?@\\^|{}".split(""));
-var FORBIDDEN_BASE_PATTERN_HOST_CHARS = new Set("#%,/<>?@\\^|".split(""));
-var PERCENT_ESCAPE_LENGTH = 3;
-var HEX_DIGITS = new Set("0123456789abcdefABCDEF".split(""));
-var PATH_SCORE_MULTIPLIER = 1e6;
-var AUTHORITY_SCORE_MULTIPLIER = 100;
-var LITERAL_SEGMENT_SCORE = 1e3;
-var MIXED_PARAM_SEGMENT_SCORE = 100;
-var PLAIN_PARAM_SEGMENT_SCORE = 10;
-var PLUS_GREEDY_SEGMENT_SCORE = 1;
-var ROOT_PATH_SCORE = 1;
-var STATIC_BASE_SCORE_BONUS = 1;
-var PERCENT_DECODED_AUTHORITY_SYNTAX_CHARS = /* @__PURE__ */ new Set([
-  "{",
-  "}",
-  "*",
-  ".",
-  "\u3002",
-  "\uFF0E",
-  "\uFF61",
-  ":"
-]);
-function matchMixedSegment(runtime, prefix, suffix) {
-  if (!runtime.startsWith(prefix)) return null;
-  if (!runtime.endsWith(suffix)) return null;
-  if (runtime.length <= prefix.length + suffix.length) return null;
-  return runtime.slice(prefix.length, runtime.length - suffix.length);
-}
-function hasNonEmptySegment(segments, start) {
-  for (let i = start; i < segments.length; i++) {
-    if (segments[i] !== "") return true;
-  }
-  return false;
-}
-function codePointLength(value) {
-  return [...value].length;
-}
-function hasUnsafeRuntimeUrlSyntax(value) {
-  return hasUnsafeUrlCodepoint(value) || hasRawWhitespace(value) || value.includes("\\") || !value.includes("://");
-}
-function stripTrailingSlash(value) {
-  return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-function isInvalidGreedyParam(patternIndex, lastPatternIndex, prefix, suffix) {
-  return patternIndex !== lastPatternIndex || prefix !== "" || suffix !== "";
-}
-function pathSpecificity(pattern) {
-  if (!pattern.startsWith("/") || pattern.includes("?") || pattern.includes("#") || pattern.includes("\\") || hasRawWhitespace(pattern) || hasUnsafeUrlCodepoint(pattern)) {
-    return null;
-  }
-  let literalSegments = 0;
-  let mixedParamSegments = 0;
-  let plainParamSegments = 0;
-  let plusGreedySegments = 0;
-  let starGreedySegments = 0;
-  let literalChars = 0;
-  const segments = splitPathSegments(pattern);
-  const paramNames = /* @__PURE__ */ new Set();
-  const lastSegmentIndex = segments.length - 1;
-  for (let index = 0; index < segments.length; index += 1) {
-    const seg = segments[index];
-    const parsed = parseSegment(seg);
-    if (parsed.kind === "error") return null;
-    if (parsed.kind === "literal") {
-      literalSegments += 1;
-      literalChars += codePointLength(parsed.value);
-      continue;
-    }
-    if (paramNames.has(parsed.name)) return null;
-    paramNames.add(parsed.name);
-    if (parsed.greedy !== "" && isInvalidGreedyParam(
-      index,
-      lastSegmentIndex,
-      parsed.prefix,
-      parsed.suffix
-    )) {
-      return null;
-    }
-    literalChars += codePointLength(parsed.prefix) + codePointLength(parsed.suffix);
-    if (parsed.prefix !== "" || parsed.suffix !== "") {
-      mixedParamSegments += 1;
-    } else if (parsed.greedy === "+") {
-      plusGreedySegments += 1;
-    } else if (parsed.greedy === "*") {
-      starGreedySegments += 1;
-    } else {
-      plainParamSegments += 1;
-    }
-  }
-  return [
-    literalSegments,
-    mixedParamSegments,
-    plainParamSegments,
-    plusGreedySegments,
-    -starGreedySegments,
-    literalChars,
-    segments.length
-  ];
-}
-function comparePathSpecificity(left, right) {
-  for (let i = 0; i < left.length; i++) {
-    const difference = left[i] - right[i];
-    if (difference !== 0) return difference;
-  }
-  return 0;
-}
-function matchingRulePath(rule, upperMethod) {
-  const spaceIdx = rule.indexOf(" ");
-  if (spaceIdx === -1) return null;
-  const ruleMethod = rule.slice(0, spaceIdx);
-  if (!VALID_RULE_METHODS.has(ruleMethod)) return null;
-  if (ruleMethod !== "ANY" && ruleMethod !== upperMethod) return null;
-  return rule.slice(spaceIdx + 1);
-}
-function isValidPermissionName(permissionName) {
-  return permissionName !== "" && permissionName !== "all";
-}
-function isObjectRecord(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function getRoutingApiPermissionRuleSetsForMatch(api, serviceName, apiBase) {
-  if (!isObjectRecord(api)) return null;
-  if (typeof api.base !== "string") return null;
-  try {
-    validateBaseUrl(api.base, serviceName);
-  } catch {
-    return null;
-  }
-  if (apiBase !== null && stripTrailingSlash(api.base) !== apiBase) return null;
-  if (!Array.isArray(api.routes)) return null;
-  const rulesByPermission = /* @__PURE__ */ new Map();
-  for (const route of api.routes) {
-    if (!isObjectRecord(route)) continue;
-    if (typeof route.permissionName !== "string") continue;
-    if (!isValidPermissionName(route.permissionName)) continue;
-    if (typeof route.rule !== "string") continue;
-    const rules = rulesByPermission.get(route.permissionName);
-    if (rules) {
-      rules.push(route.rule);
-    } else {
-      rulesByPermission.set(route.permissionName, [route.rule]);
-    }
-  }
-  return [...rulesByPermission.entries()].map(([name, rules]) => {
-    return { name, rules };
-  });
-}
-function recordPermissionMatch(state, permission, specificity) {
-  if (state.bestSpecificity === null || comparePathSpecificity(specificity, state.bestSpecificity) > 0) {
-    state.bestSpecificity = specificity;
-    state.matched.length = 0;
-  }
-  if (comparePathSpecificity(specificity, state.bestSpecificity) === 0 && !state.matched.includes(permission)) {
-    state.matched.push(permission);
-  }
-}
-function relativePathFromSegments(segments, consumed) {
-  const rest = segments.slice(consumed).join("/");
-  return rest === "" ? "/" : `/${rest}`;
-}
-function stripUrlQueryAndFragment(url) {
-  const queryIndex = url.indexOf("?");
-  const fragmentIndex = url.indexOf("#");
-  let end = url.length;
-  if (queryIndex !== -1) end = Math.min(end, queryIndex);
-  if (fragmentIndex !== -1) end = Math.min(end, fragmentIndex);
-  return url.slice(0, end);
-}
-function rawPathFromUrl(url) {
-  const urlWithoutQuery = stripUrlQueryAndFragment(url);
-  const schemeEnd = urlWithoutQuery.indexOf("://");
-  const authorityStart = schemeEnd === -1 ? 0 : schemeEnd + 3;
-  const pathStart = urlWithoutQuery.indexOf("/", authorityStart);
-  return pathStart === -1 ? "/" : urlWithoutQuery.slice(pathStart);
-}
-function rawBasePathFromUrl(url) {
-  const urlWithoutQuery = stripUrlQueryAndFragment(url);
-  const schemeEnd = urlWithoutQuery.indexOf("://");
-  const authorityStart = schemeEnd === -1 ? 0 : schemeEnd + 3;
-  const pathStart = urlWithoutQuery.indexOf("/", authorityStart);
-  return pathStart === -1 ? "" : urlWithoutQuery.slice(pathStart);
-}
-function rawAuthorityFromUrl(url) {
-  const urlWithoutQuery = stripUrlQueryAndFragment(url);
-  const schemeEnd = urlWithoutQuery.indexOf("://");
-  if (schemeEnd === -1) return null;
-  const authorityStart = schemeEnd + 3;
-  const pathStart = urlWithoutQuery.indexOf("/", authorityStart);
-  const authority = pathStart === -1 ? urlWithoutQuery.slice(authorityStart) : urlWithoutQuery.slice(authorityStart, pathStart);
-  return authority === "" ? null : authority;
-}
-function hasNonAscii(value) {
-  for (let index = 0; index < value.length; index += 1) {
-    if (value.charCodeAt(index) > 127) return true;
-  }
-  return false;
-}
-function rawHostFromAuthority(authority) {
-  const withoutUserinfo = authority.slice(authority.lastIndexOf("@") + 1);
-  if (withoutUserinfo.startsWith("[")) {
-    const closeBracket = withoutUserinfo.indexOf("]");
-    return closeBracket === -1 ? withoutUserinfo : withoutUserinfo.slice(0, closeBracket + 1);
-  }
-  const portSeparator = withoutUserinfo.lastIndexOf(":");
-  return portSeparator === -1 ? withoutUserinfo : withoutUserinfo.slice(0, portSeparator);
-}
-function authorityHasEmptyPort(authority) {
-  const withoutUserinfo = authority.slice(authority.lastIndexOf("@") + 1);
-  if (withoutUserinfo.startsWith("[")) {
-    const closeBracket = withoutUserinfo.indexOf("]");
-    if (closeBracket === -1) return false;
-    return withoutUserinfo.slice(closeBracket + 1) === ":";
-  }
-  const portSeparator = withoutUserinfo.lastIndexOf(":");
-  if (portSeparator === -1) return false;
-  return withoutUserinfo.indexOf(":") === portSeparator && portSeparator === withoutUserinfo.length - 1;
-}
-function rawAuthorityHostStartsWithDigit(authority) {
-  const firstChar = rawHostFromAuthority(authority)[0];
-  return firstChar !== void 0 && firstChar >= "0" && firstChar <= "9";
-}
-function runtimeAuthorityOriginForHostValidation(url) {
-  const authority = rawAuthorityFromUrl(url);
-  if (authority === null) return null;
-  if (!authority.includes("%") && !hasNonAscii(authority) && !rawAuthorityHostStartsWithDigit(authority)) {
-    return null;
-  }
-  const schemeEnd = url.indexOf("://");
-  if (schemeEnd === -1) return null;
-  return `${url.slice(0, schemeEnd)}://${authority}`;
-}
-function hasPercentEncodedAuthoritySyntax(value) {
-  let index = value.indexOf("%");
-  while (index !== -1) {
-    let runEnd = index;
-    while (runEnd < value.length && value[runEnd] === "%") {
-      const firstHexDigit = value[runEnd + 1];
-      const secondHexDigit = value[runEnd + 2];
-      if (!firstHexDigit || !secondHexDigit || !HEX_DIGITS.has(firstHexDigit) || !HEX_DIGITS.has(secondHexDigit)) {
-        return true;
-      }
-      runEnd += PERCENT_ESCAPE_LENGTH;
-    }
-    let decodedRun;
-    try {
-      decodedRun = decodeURIComponent(value.slice(index, runEnd));
-    } catch {
-      return true;
-    }
-    for (const char of decodedRun) {
-      if (PERCENT_DECODED_AUTHORITY_SYNTAX_CHARS.has(char)) {
-        return true;
-      }
-    }
-    index = value.indexOf("%", runEnd);
-  }
-  return false;
-}
-function hasMalformedRuntimeAuthoritySyntax(url) {
-  const authority = rawAuthorityFromUrl(url);
-  if (authority === null) return false;
-  return authority.includes("\\") || authorityHasEmptyPort(authority) || hasPercentEncodedAuthoritySyntax(authority);
-}
-function scoreLiteralSegment(segment) {
-  return LITERAL_SEGMENT_SCORE + codePointLength(segment);
-}
-function scorePatternSegment(segment, allowParams) {
-  if (!allowParams) return scoreLiteralSegment(segment);
-  const parsed = parseSegment(segment);
-  if (parsed.kind === "error") return 0;
-  if (parsed.kind === "literal") {
-    return scoreLiteralSegment(parsed.value);
-  }
-  const literalChars = codePointLength(parsed.prefix) + codePointLength(parsed.suffix);
-  if (parsed.prefix !== "" || parsed.suffix !== "") {
-    return MIXED_PARAM_SEGMENT_SCORE + literalChars;
-  }
-  if (parsed.greedy === "+") return PLUS_GREEDY_SEGMENT_SCORE;
-  if (parsed.greedy === "*") return 0;
-  return PLAIN_PARAM_SEGMENT_SCORE;
-}
-function scorePatternSegments(segments, allowParams) {
-  return segments.reduce((score, segment) => {
-    return score + scorePatternSegment(segment, allowParams);
-  }, 0);
-}
-function scorePathPattern(path, allowParams) {
-  if (path === "") return 0;
-  if (path === "/") return ROOT_PATH_SCORE;
-  return scorePatternSegments(splitPathSegments(path), allowParams);
-}
-function splitAuthoritySegments(authority) {
-  if (authority.startsWith("[")) return [authority];
-  const normalized = authority.endsWith(".") ? authority.slice(0, -1) : authority;
-  return normalized === "" ? [] : normalized.split(".");
-}
-function baseUrlSpecificityScore(rawBase, hasParams) {
-  const baseForMatch = stripTrailingSlash(rawBase);
-  const authorityScore = scorePatternSegments(
-    splitAuthoritySegments(rawAuthorityFromUrl(baseForMatch) ?? ""),
-    hasParams
-  );
-  const pathScore = scorePathPattern(
-    rawBasePathFromUrl(baseForMatch),
-    hasParams
-  );
-  return pathScore * PATH_SCORE_MULTIPLIER + authorityScore * AUTHORITY_SCORE_MULTIPLIER + (hasParams ? 0 : STATIC_BASE_SCORE_BONUS);
-}
-function matchStaticBasePathPrefix(path, pattern) {
-  if (pattern === "") {
-    return path === "" ? "/" : path;
-  }
-  if (pattern === "/") {
-    if (!path.startsWith(pattern)) return null;
-    const relativePath2 = path.slice(pattern.length);
-    if (relativePath2 !== "" && !relativePath2.startsWith("/")) return null;
-    return relativePath2 === "" ? "/" : relativePath2;
-  }
-  if (!path.startsWith(pattern)) return null;
-  const relativePath = path.slice(pattern.length);
-  if (relativePath !== "" && !relativePath.startsWith("/")) return null;
-  return relativePath === "" ? "/" : relativePath;
-}
-function normalizeUrlHostname(hostname, options = {}) {
-  let normalized = hostname.toLowerCase();
-  if (normalized.endsWith(".")) {
-    normalized = normalized.slice(0, -1);
-    if (normalized === "" || normalized.endsWith(".")) {
-      return null;
-    }
-  }
-  if (normalized.split(".").some((label) => {
-    return label === "";
-  })) {
-    return null;
-  }
-  const forbiddenChars = options.allowHostParams === true ? FORBIDDEN_BASE_PATTERN_HOST_CHARS : FORBIDDEN_RUNTIME_HOST_CHARS;
-  if (!normalized.startsWith("[") && [...normalized].some((char) => {
-    return forbiddenChars.has(char);
-  })) {
-    return null;
-  }
-  return normalized;
-}
-function normalizedUrlAuthority(parsed, options = {}) {
-  if (parsed.username !== "" || parsed.password !== "") {
-    return null;
-  }
-  const hostname = normalizeUrlHostname(parsed.hostname, options);
-  if (hostname === null || hostname === "") {
-    return null;
-  }
-  return parsed.port === "" ? hostname : `${hostname}:${parsed.port}`;
-}
-function matchStaticFirewallBaseUrl(url, rawBase) {
-  const parsedUrl = new URL(url);
-  const parsedBase = new URL(rawBase);
-  if (parsedUrl.protocol.toLowerCase() !== parsedBase.protocol.toLowerCase()) {
-    return null;
-  }
-  const baseHasParams = hasBaseUrlParams(rawBase);
-  const baseForMatch = stripTrailingSlash(rawBase);
-  const urlAuthority = normalizedUrlAuthority(parsedUrl);
-  const baseAuthority = normalizedUrlAuthority(parsedBase, {
-    allowHostParams: baseHasParams
-  });
-  if (urlAuthority === null || baseAuthority === null) return null;
-  if (baseHasParams) {
-    if (matchFirewallHost(urlAuthority, baseAuthority) === null) return null;
-  } else if (urlAuthority !== baseAuthority) {
-    return null;
-  }
-  const basePath = rawBasePathFromUrl(baseForMatch);
-  const relativePath = baseHasParams ? matchFirewallPathPrefix(rawPathFromUrl(url), basePath) : matchStaticBasePathPrefix(rawPathFromUrl(url), basePath);
-  if (relativePath === null) return null;
-  const displayBase = stripTrailingSlash(rawBase);
-  return {
-    displayBase,
-    relativePath,
-    score: baseUrlSpecificityScore(rawBase, baseHasParams)
-  };
-}
-function matchFirewallBaseUrl(url, rawBase) {
-  if (hasUnsafeRuntimeUrlSyntax(url) || hasMalformedRuntimeAuthoritySyntax(url)) {
-    return null;
-  }
-  const runtimeAuthorityOrigin = runtimeAuthorityOriginForHostValidation(url);
-  try {
-    if (runtimeAuthorityOrigin !== null) {
-      validateBaseUrl(runtimeAuthorityOrigin, "runtime");
-    }
-    validateBaseUrl(rawBase, "firewall");
-    return matchStaticFirewallBaseUrl(url, rawBase);
-  } catch {
-    return null;
-  }
-}
-function matchFirewallHost(host, pattern) {
-  const hostSegsOrig = host.split(".");
-  const hostSegsLower = hostSegsOrig.map((segment) => {
-    return segment.toLowerCase();
-  });
-  const patternSegs = pattern.split(".").reverse();
-  hostSegsOrig.reverse();
-  hostSegsLower.reverse();
-  const params = {};
-  let hi = 0;
-  const lastPatternIndex = patternSegs.length - 1;
-  for (let patternIndex = 0; patternIndex < patternSegs.length; patternIndex++) {
-    const seg = patternSegs[patternIndex];
-    const parsed = parseSegment(seg);
-    if (parsed.kind === "error") return null;
-    if (parsed.kind === "literal") {
-      if (hi >= hostSegsLower.length || hostSegsLower[hi] !== parsed.value.toLowerCase()) {
-        return null;
-      }
-      hi += 1;
-      continue;
-    }
-    const { name, prefix, suffix, greedy } = parsed;
-    if (greedy === "+") {
-      if (isInvalidGreedyParam(patternIndex, lastPatternIndex, prefix, suffix))
-        return null;
-      if (hi >= hostSegsOrig.length) return null;
-      params[name] = hostSegsOrig.slice(hi).reverse().join(".");
-      return params;
-    }
-    if (greedy === "*") {
-      if (isInvalidGreedyParam(patternIndex, lastPatternIndex, prefix, suffix))
-        return null;
-      params[name] = hostSegsOrig.slice(hi).reverse().join(".");
-      return params;
-    }
-    if (hi >= hostSegsOrig.length) return null;
-    if (prefix === "" && suffix === "") {
-      params[name] = hostSegsLower[hi];
-    } else {
-      const captured = matchMixedSegment(
-        hostSegsLower[hi],
-        prefix.toLowerCase(),
-        suffix.toLowerCase()
-      );
-      if (captured === null) return null;
-      params[name] = captured;
-    }
-    hi += 1;
-  }
-  return hi === hostSegsOrig.length ? params : null;
-}
-function matchFirewallPathPrefix(path, pattern) {
-  const pathSegs = splitPathSegments(path);
-  const patternSegs = splitPathSegments(pattern);
-  let pi = 0;
-  const lastPatternIndex = patternSegs.length - 1;
-  for (let patternIndex = 0; patternIndex < patternSegs.length; patternIndex++) {
-    const seg = patternSegs[patternIndex];
-    const parsed = parseSegment(seg);
-    if (parsed.kind === "error") return null;
-    if (parsed.kind === "literal") {
-      if (pi >= pathSegs.length || pathSegs[pi] !== parsed.value) return null;
-      pi += 1;
-      continue;
-    }
-    const { prefix, suffix, greedy } = parsed;
-    if (greedy === "+") {
-      if (isInvalidGreedyParam(patternIndex, lastPatternIndex, prefix, suffix))
-        return null;
-      if (pi >= pathSegs.length || !hasNonEmptySegment(pathSegs, pi)) {
-        return null;
-      }
-      return "/";
-    }
-    if (greedy === "*") {
-      if (isInvalidGreedyParam(patternIndex, lastPatternIndex, prefix, suffix))
-        return null;
-      return "/";
-    }
-    if (pi >= pathSegs.length) return null;
-    const runtime = pathSegs[pi];
-    if (prefix === "" && suffix === "") {
-      if (runtime === "") return null;
-    } else if (matchMixedSegment(runtime, prefix, suffix) === null) {
-      return null;
-    }
-    pi += 1;
-  }
-  return relativePathFromSegments(pathSegs, pi);
-}
-function matchFirewallPath(path, pattern) {
-  const pathSegs = splitPathSegments(path);
-  const patternSegs = splitPathSegments(pattern);
-  const params = {};
-  let pi = 0;
-  const lastPatternIndex = patternSegs.length - 1;
-  for (let patternIndex = 0; patternIndex < patternSegs.length; patternIndex++) {
-    const seg = patternSegs[patternIndex];
-    const parsed = parseSegment(seg);
-    if (parsed.kind === "error") return null;
-    if (parsed.kind === "literal") {
-      if (pi >= pathSegs.length || pathSegs[pi] !== parsed.value) return null;
-      pi++;
-      continue;
-    }
-    const { name, prefix, suffix, greedy } = parsed;
-    if (greedy === "+") {
-      if (isInvalidGreedyParam(patternIndex, lastPatternIndex, prefix, suffix))
-        return null;
-      if (pi >= pathSegs.length || !hasNonEmptySegment(pathSegs, pi)) {
-        return null;
-      }
-      params[name] = pathSegs.slice(pi).join("/");
-      return params;
-    }
-    if (greedy === "*") {
-      if (isInvalidGreedyParam(patternIndex, lastPatternIndex, prefix, suffix))
-        return null;
-      params[name] = pathSegs.slice(pi).join("/");
-      return params;
-    }
-    if (pi >= pathSegs.length) return null;
-    const runtime = pathSegs[pi];
-    if (prefix === "" && suffix === "") {
-      if (runtime === "") return null;
-      params[name] = runtime;
-    } else {
-      const captured = matchMixedSegment(runtime, prefix, suffix);
-      if (captured === null) return null;
-      params[name] = captured;
-    }
-    pi++;
-  }
-  if (pi !== pathSegs.length) return null;
-  return params;
-}
-function findMatchingRoutingPermissions(method, path, apis, options = {}) {
-  if (!Array.isArray(apis)) return [];
-  const serviceName = options.serviceName ?? "routing";
-  const apiBase = options.apiBase === void 0 ? null : stripTrailingSlash(options.apiBase);
-  const matchApis = [];
-  for (const api of apis) {
-    const permissionRuleSets = getRoutingApiPermissionRuleSetsForMatch(
-      api,
-      serviceName,
-      apiBase
-    );
-    if (permissionRuleSets !== null) {
-      matchApis.push({ permissionRuleSets });
-    }
-  }
-  return findMatchingPermissionRuleSets(method, path, matchApis);
-}
-function findMatchingPermissionRuleSets(method, path, apis) {
-  const upperMethod = method.toUpperCase();
-  const matched = [];
-  for (const api of apis) {
-    const state = { bestSpecificity: null, matched: [] };
-    for (const permission of api.permissionRuleSets) {
-      for (const rule of permission.rules) {
-        const rest = matchingRulePath(rule, upperMethod);
-        if (rest === null) continue;
-        if (matchFirewallPath(path, rest) !== null) {
-          const specificity = pathSpecificity(rest);
-          if (specificity === null) continue;
-          recordPermissionMatch(state, permission.name, specificity);
-        }
-      }
-    }
-    for (const permission of state.matched) {
-      if (!matched.includes(permission)) {
-        matched.push(permission);
-      }
-    }
-  }
-  return matched;
-}
-
-export {
-  matchFirewallBaseUrl,
-  findMatchingRoutingPermissions
-};
-//# sourceMappingURL=chunk-KJNJT27A.js.map