@b9g/match-pattern 0.1.6 → 0.1.7

package/src/index.js

@@ -0,0 +1,2039 @@
+/// <reference types="./index.d.ts" />
+// src/index.ts
+function isValidProtocol(protocol) {
+  if (!protocol)
+    return false;
+  if (!/^[a-zA-Z]/.test(protocol))
+    return false;
+  return /^[a-zA-Z][a-zA-Z0-9+\-.]*$/.test(protocol);
+}
+function isSpecialScheme(protocol) {
+  const special = ["http", "https", "ws", "wss", "ftp", "file"];
+  return special.includes(protocol.toLowerCase());
+}
+function isDefinitelyNonSpecialScheme(protocolPattern) {
+  if (!protocolPattern)
+    return false;
+  if (protocolPattern.includes("*") || protocolPattern.includes("+")) {
+    return false;
+  }
+  const groupMatch = protocolPattern.match(/^\(([^)]+)\)$/);
+  if (groupMatch) {
+    const alternatives = groupMatch[1].split("|");
+    return alternatives.every((alt) => !isSpecialScheme(alt.trim()));
+  }
+  if (protocolPattern.includes(":")) {
+    return false;
+  }
+  return !isSpecialScheme(protocolPattern);
+}
+function getDefaultPort(protocol) {
+  const defaults = {
+    http: "80",
+    https: "443",
+    ws: "80",
+    wss: "443",
+    ftp: "21"
+  };
+  return defaults[protocol.toLowerCase()];
+}
+function toASCII(hostname) {
+  try {
+    return new URL("http://" + hostname).hostname;
+  } catch {
+    return hostname;
+  }
+}
+function requiresVFlag(pattern) {
+  let inCharClass = 0;
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === "[") {
+      inCharClass++;
+    } else if (char === "]") {
+      inCharClass = Math.max(0, inCharClass - 1);
+    } else if (inCharClass > 0) {
+      if (char === "-" && pattern[i + 1] === "-") {
+        return true;
+      }
+      if (char === "&" && pattern[i + 1] === "&") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function validateRegexGroupContent(regexContent) {
+  for (const c of regexContent) {
+    if (c.charCodeAt(0) > 127) {
+      throw new TypeError(
+        `Invalid pattern: regex groups cannot contain non-ASCII characters`
+      );
+    }
+  }
+  const invalidEscape = regexContent.match(
+    /\\([^dDwWsSnrtfv0cbBxu.\\[\](){}|^$*+?/=-])/
+  );
+  if (invalidEscape) {
+    throw new TypeError(
+      `Invalid pattern: invalid escape sequence '\\${invalidEscape[1]}' in regex group`
+    );
+  }
+}
+function validateIPv6BracketContent(content) {
+  let i = 0;
+  while (i < content.length) {
+    const char = content[i];
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (char === ":") {
+      const paramMatch = content.slice(i).match(new RegExp("^:(\\p{ID_Start}\\p{ID_Continue}*)([?+*])?", "u"));
+      if (paramMatch) {
+        i += paramMatch[0].length;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (char.charCodeAt(0) > 127) {
+      throw new TypeError(
+        `Invalid hostname pattern: non-ASCII character '${char}' in IPv6 brackets`
+      );
+    }
+    if (/[a-zA-Z]/.test(char) && !/[a-fA-F]/.test(char)) {
+      throw new TypeError(
+        `Invalid hostname pattern: invalid IPv6 character '${char}'`
+      );
+    }
+    i++;
+  }
+}
+function validateHostnamePattern(hostname) {
+  const alwaysForbidden = /[\x00 %<>?@\^|]/;
+  let i = 0;
+  while (i < hostname.length) {
+    const char = hostname[i];
+    if (char === "\\") {
+      if (i + 1 < hostname.length) {
+        const escaped = hostname[i + 1];
+        if (escaped === ":") {
+          throw new TypeError(
+            `Invalid hostname pattern: escaped colon is not allowed`
+          );
+        }
+      }
+      i += 2;
+      continue;
+    }
+    if (char === "{") {
+      const closeIdx = hostname.indexOf("}", i);
+      if (closeIdx !== -1) {
+        const braceContent = hostname.slice(i + 1, closeIdx);
+        const bracketMatch = braceContent.match(/\[([^\]]*)\]/);
+        if (bracketMatch) {
+          validateIPv6BracketContent(bracketMatch[1]);
+        }
+        i = closeIdx + 1;
+        if (hostname[i] === "?" || hostname[i] === "+" || hostname[i] === "*")
+          i++;
+        continue;
+      }
+    }
+    if (char === "(") {
+      let depth = 1;
+      let j = i + 1;
+      while (j < hostname.length && depth > 0) {
+        if (hostname[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (hostname[j] === "(")
+          depth++;
+        if (hostname[j] === ")")
+          depth--;
+        j++;
+      }
+      i = j;
+      if (hostname[i] === "?" || hostname[i] === "+" || hostname[i] === "*")
+        i++;
+      continue;
+    }
+    if (char === ":") {
+      const paramMatch = hostname.slice(i).match(new RegExp("^:(\\p{ID_Continue}+)(\\([^)]*\\))?([?+*])?", "u"));
+      if (paramMatch) {
+        i += paramMatch[0].length;
+        continue;
+      }
+      throw new TypeError(
+        `Invalid hostname pattern: unescaped colon outside of pattern syntax`
+      );
+    }
+    if (char === "*") {
+      i++;
+      if (hostname[i] === "?" || hostname[i] === "+" || hostname[i] === "*")
+        i++;
+      continue;
+    }
+    if (char === "[") {
+      const closeIdx = hostname.indexOf("]", i);
+      if (closeIdx !== -1) {
+        const ipv6Content = hostname.slice(i + 1, closeIdx);
+        validateIPv6BracketContent(ipv6Content);
+        i = closeIdx + 1;
+        continue;
+      }
+      throw new TypeError(`Invalid hostname pattern: unmatched '[' character`);
+    }
+    if (char === "]") {
+      throw new TypeError(`Invalid hostname pattern: unmatched ']' character`);
+    }
+    if (alwaysForbidden.test(char)) {
+      throw new TypeError(
+        `Invalid hostname pattern: forbidden character '${char}'`
+      );
+    }
+    i++;
+  }
+}
+function normalizeHostnamePattern(hostname) {
+  hostname = hostname.replace(/[\t\n\r]/g, "");
+  let truncateIdx = -1;
+  for (let i = 0; i < hostname.length; i++) {
+    const char = hostname[i];
+    if (char === "\\") {
+      if (i + 1 < hostname.length && hostname[i + 1] === "?") {
+        truncateIdx = i;
+        break;
+      }
+      i++;
+      continue;
+    }
+    if (char === "#" || char === "/") {
+      truncateIdx = i;
+      break;
+    }
+  }
+  if (truncateIdx !== -1) {
+    hostname = hostname.slice(0, truncateIdx);
+  }
+  return hostname;
+}
+function canonicalizePort(port, throwOnInvalid = false) {
+  if (port === "")
+    return "";
+  const stripped = port.replace(/[\t\n\r]/g, "");
+  const match = stripped.match(/^(\d+)/);
+  if (!match)
+    return void 0;
+  const numericPort = parseInt(match[1], 10);
+  if (numericPort > 65535) {
+    if (throwOnInvalid) {
+      throw new TypeError(`Invalid port: ${port} (must be 0-65535)`);
+    }
+    return void 0;
+  }
+  return numericPort.toString();
+}
+function isValidPatternPort(port) {
+  if (port === "")
+    return true;
+  const stripped = port.replace(/[\t\n\r]/g, "");
+  return /^\d+$/.test(stripped);
+}
+function encodePathname(pathname) {
+  return pathname.split("/").map((segment) => {
+    let result = "";
+    for (const char of segment) {
+      const code = char.charCodeAt(0);
+      if (code >= 65 && code <= 90 || // A-Z
+      code >= 97 && code <= 122 || // a-z
+      code >= 48 && code <= 57 || // 0-9
+      "-._~!$&'()*+,;=:@%".includes(char)) {
+        result += char;
+      } else {
+        result += encodeURIComponent(char);
+      }
+    }
+    return result;
+  }).join("/");
+}
+function encodeSearch(search) {
+  let result = "";
+  for (let i = 0; i < search.length; i++) {
+    const char = search[i];
+    const code = char.charCodeAt(0);
+    if (char === "%") {
+      if (i + 2 < search.length) {
+        const hex = search.slice(i + 1, i + 3);
+        if (/^[0-9a-fA-F]{2}$/.test(hex)) {
+          result += search.slice(i, i + 3);
+          i += 2;
+          continue;
+        }
+      }
+      result += "%25";
+    } else if (code >= 128) {
+      if (code >= 55296 && code <= 56319 && i + 1 < search.length) {
+        const nextCode = search.charCodeAt(i + 1);
+        if (nextCode >= 56320 && nextCode <= 57343) {
+          result += encodeURIComponent(search.slice(i, i + 2));
+          i++;
+          continue;
+        }
+      }
+      result += encodeURIComponent(char);
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+function encodeHash(hash) {
+  try {
+    return encodeURIComponent(decodeURIComponent(hash));
+  } catch {
+    return encodeURIComponent(hash);
+  }
+}
+function normalizePathname(pathname) {
+  if (!pathname || pathname === "/") {
+    return "/";
+  }
+  const hadLeadingSlash = pathname.startsWith("/");
+  const hadTrailingSlash = pathname.endsWith("/") && pathname !== "/";
+  const segments = pathname.split("/").filter((s, i, arr) => {
+    return s !== "" || i === arr.length - 1 && i > 0;
+  });
+  const normalized = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (segment === ".") {
+      continue;
+    } else if (segment === "..") {
+      if (normalized.length > 0 && normalized[normalized.length - 1] !== "..") {
+        normalized.pop();
+      }
+    } else if (segment === "" && i === segments.length - 1) {
+      continue;
+    } else {
+      normalized.push(segment);
+    }
+  }
+  let result = normalized.join("/");
+  if (hadLeadingSlash) {
+    result = "/" + result;
+  }
+  if (hadTrailingSlash && !result.endsWith("/")) {
+    result += "/";
+  }
+  return result;
+}
+function isSimplePattern(pathname) {
+  if (pathname.includes("\\"))
+    return false;
+  if (pathname.includes("{"))
+    return false;
+  if (pathname.includes("("))
+    return false;
+  if (pathname.includes("+"))
+    return false;
+  if (pathname.includes("?"))
+    return false;
+  const wildcardIndex = pathname.indexOf("*");
+  if (wildcardIndex !== -1) {
+    if (wildcardIndex !== pathname.length - 1)
+      return false;
+    if (pathname[wildcardIndex - 1] !== "/")
+      return false;
+  }
+  const paramMatches = pathname.matchAll(new RegExp(":(\\p{ID_Continue}+)", "gu"));
+  for (const match of paramMatches) {
+    const afterParam = pathname[match.index + match[0].length];
+    if (afterParam === "(" || afterParam === "?" || afterParam === "+" || afterParam === "*") {
+      return false;
+    }
+  }
+  return true;
+}
+function parseSimplePattern(pathname) {
+  if (!isSimplePattern(pathname)) {
+    return null;
+  }
+  const segments = [];
+  const paramNames = [];
+  let hasWildcard = false;
+  let currentStatic = "";
+  let i = 0;
+  while (i < pathname.length) {
+    const char = pathname[i];
+    if (char === ":") {
+      const match = pathname.slice(i).match(new RegExp("^:(\\p{ID_Continue}+)", "u"));
+      if (match) {
+        if (currentStatic) {
+          segments.push({ type: "static", value: currentStatic });
+          currentStatic = "";
+        }
+        const name = match[1];
+        paramNames.push(name);
+        segments.push({ type: "param", name });
+        i += match[0].length;
+        continue;
+      }
+    }
+    if (char === "*") {
+      if (currentStatic) {
+        segments.push({ type: "static", value: currentStatic });
+        currentStatic = "";
+      }
+      hasWildcard = true;
+      segments.push({ type: "wildcard" });
+      break;
+    }
+    currentStatic += char;
+    i++;
+  }
+  if (currentStatic) {
+    segments.push({ type: "static", value: currentStatic });
+  }
+  return { segments, paramNames, hasWildcard };
+}
+function findUnescapedAt(pattern) {
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] === "\\" && i + 1 < pattern.length) {
+      i++;
+      continue;
+    }
+    if (pattern[i] === "@") {
+      return i;
+    }
+  }
+  return -1;
+}
+function findEscapedColon(pattern) {
+  for (let i = 0; i < pattern.length - 1; i++) {
+    if (pattern[i] === "\\" && pattern[i + 1] === ":") {
+      return i;
+    }
+  }
+  return -1;
+}
+function findSearchDelimiter(pattern) {
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char === "\\") {
+      if (i + 1 < pattern.length && pattern[i + 1] === "?") {
+        if (parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+          return { index: i, offset: 2 };
+        }
+      }
+      i++;
+      continue;
+    }
+    if (char === "(")
+      parenDepth++;
+    else if (char === ")")
+      parenDepth--;
+    else if (char === "[")
+      bracketDepth++;
+    else if (char === "]")
+      bracketDepth--;
+    else if (char === "{")
+      braceDepth++;
+    else if (char === "}")
+      braceDepth--;
+    if (char === "?" && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+      const prev = i > 0 ? pattern[i - 1] : "";
+      if ("*+)}".includes(prev)) {
+        continue;
+      }
+      let j = i - 1;
+      while (j >= 0 && /[\w]/.test(pattern[j])) {
+        j--;
+      }
+      if (j >= 0 && pattern[j] === ":") {
+        const paramStart = j + 1;
+        if (paramStart < i && /[a-zA-Z]/.test(pattern[paramStart])) {
+          continue;
+        }
+      }
+      return { index: i, offset: 1 };
+    }
+  }
+  return { index: -1, offset: 0 };
+}
+function findPathnameStart(afterScheme) {
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  let braceStart = -1;
+  for (let i = 0; i < afterScheme.length; i++) {
+    const char = afterScheme[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === "(")
+      parenDepth++;
+    else if (char === ")")
+      parenDepth--;
+    else if (char === "[")
+      bracketDepth++;
+    else if (char === "]")
+      bracketDepth--;
+    else if (char === "{") {
+      braceDepth++;
+      if (braceDepth === 1)
+        braceStart = i;
+    } else if (char === "}") {
+      braceDepth--;
+      if (braceDepth === 0)
+        braceStart = -1;
+    } else if (char === "/" && parenDepth === 0 && bracketDepth === 0) {
+      if (braceDepth > 0 && braceStart !== -1) {
+        return { index: i, truncateHostname: i, useWildcardPathname: true };
+      }
+      return { index: i };
+    }
+  }
+  return { index: -1 };
+}
+function validatePatternStructure(pattern) {
+  if (pattern.includes("{{") || pattern.includes("}}")) {
+    throw new TypeError("Invalid pattern: consecutive braces are not allowed");
+  }
+  let braceDepth = 0;
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === "{") {
+      braceDepth++;
+      if (braceDepth > 1) {
+        throw new TypeError("Invalid pattern: nested braces are not allowed");
+      }
+    } else if (char === "}") {
+      braceDepth--;
+    }
+  }
+  const schemeIdx = pattern.indexOf("://");
+  if (schemeIdx !== -1) {
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    braceDepth = 0;
+    for (let i = 0; i < schemeIdx; i++) {
+      const char = pattern[i];
+      if (char === "\\") {
+        i++;
+        continue;
+      }
+      if (char === "(")
+        parenDepth++;
+      else if (char === ")")
+        parenDepth--;
+      else if (char === "[")
+        bracketDepth++;
+      else if (char === "]")
+        bracketDepth--;
+      else if (char === "{")
+        braceDepth++;
+      else if (char === "}")
+        braceDepth--;
+    }
+    if (parenDepth > 0 || bracketDepth > 0 || braceDepth > 0) {
+      throw new TypeError(
+        "Invalid pattern: groups cannot span the scheme separator"
+      );
+    }
+  }
+}
+function parseStringPattern(pattern) {
+  validatePatternStructure(pattern);
+  if (pattern.startsWith("?")) {
+    const hashIndex = pattern.indexOf("#");
+    if (hashIndex !== -1) {
+      return {
+        search: pattern.slice(1, hashIndex),
+        hash: pattern.slice(hashIndex + 1)
+      };
+    }
+    return { search: pattern.slice(1) };
+  }
+  if (pattern.startsWith("#")) {
+    return { hash: pattern.slice(1) };
+  }
+  const nonHierarchicalMatch = pattern.match(/^([a-zA-Z][a-zA-Z0-9+\-.]*):/);
+  if (nonHierarchicalMatch && !pattern.startsWith(nonHierarchicalMatch[0] + "/")) {
+    const protocol = nonHierarchicalMatch[1];
+    if (pattern.startsWith(protocol + "://")) {
+    } else {
+      const rest = pattern.slice(nonHierarchicalMatch[0].length);
+      if (rest.length > 0) {
+        const firstChar = rest[0];
+        if (new RegExp("\\p{ID_Start}", "u").test(firstChar)) {
+          throw new TypeError(
+            "Invalid URL pattern: non-hierarchical URL pathname cannot start with an identifier"
+          );
+        }
+      }
+      const hashIndex = rest.indexOf("#");
+      const hash = hashIndex === -1 ? void 0 : rest.slice(hashIndex + 1);
+      const beforeHash = hashIndex === -1 ? rest : rest.slice(0, hashIndex);
+      const searchDelim = findSearchDelimiter(beforeHash);
+      const search = searchDelim.index === -1 ? void 0 : beforeHash.slice(searchDelim.index + searchDelim.offset);
+      const pathname = searchDelim.index === -1 ? beforeHash : beforeHash.slice(0, searchDelim.index);
+      return { protocol, pathname, search, hash };
+    }
+  }
+  const escapedColonMatch = pattern.match(/^([a-zA-Z][a-zA-Z0-9+\-.]*)\\:/);
+  if (escapedColonMatch) {
+    const protocol = escapedColonMatch[1];
+    const rest = pattern.slice(escapedColonMatch[0].length);
+    const isSpecial = isSpecialScheme(protocol);
+    const atIdx = findUnescapedAt(rest);
+    if (isSpecial && atIdx !== -1) {
+      const userinfoStr = rest.slice(0, atIdx);
+      const afterAt = rest.slice(atIdx + 1);
+      let username;
+      let password;
+      const colonIdx = findEscapedColon(userinfoStr);
+      if (colonIdx !== -1) {
+        username = userinfoStr.slice(0, colonIdx);
+        password = userinfoStr.slice(colonIdx + 2);
+      } else {
+        username = userinfoStr;
+      }
+      const slashIdx = afterAt.indexOf("/");
+      const hashIdx = afterAt.indexOf("#");
+      const searchDelim2 = findSearchDelimiter(afterAt);
+      let hostEnd = afterAt.length;
+      if (slashIdx !== -1 && slashIdx < hostEnd)
+        hostEnd = slashIdx;
+      if (searchDelim2.index !== -1 && searchDelim2.index < hostEnd)
+        hostEnd = searchDelim2.index;
+      if (hashIdx !== -1 && hashIdx < hostEnd)
+        hostEnd = hashIdx;
+      const hostPart = afterAt.slice(0, hostEnd);
+      let hostname;
+      let port;
+      const portColonIdx = hostPart.lastIndexOf(":");
+      if (portColonIdx !== -1 && !hostPart.startsWith("[")) {
+        hostname = hostPart.slice(0, portColonIdx);
+        port = hostPart.slice(portColonIdx + 1);
+      } else {
+        hostname = hostPart;
+      }
+      let pathname2;
+      let search2;
+      let hash2;
+      if (slashIdx !== -1) {
+        const pathStart = slashIdx;
+        let pathEnd = afterAt.length;
+        if (searchDelim2.index !== -1 && searchDelim2.index > slashIdx)
+          pathEnd = Math.min(pathEnd, searchDelim2.index);
+        if (hashIdx !== -1)
+          pathEnd = Math.min(pathEnd, hashIdx);
+        pathname2 = afterAt.slice(pathStart, pathEnd);
+      }
+      if (searchDelim2.index !== -1) {
+        let searchEnd = afterAt.length;
+        if (hashIdx !== -1 && hashIdx > searchDelim2.index)
+          searchEnd = hashIdx;
+        search2 = afterAt.slice(
+          searchDelim2.index + searchDelim2.offset,
+          searchEnd
+        );
+      }
+      if (hashIdx !== -1) {
+        hash2 = afterAt.slice(hashIdx + 1);
+      }
+      return {
+        protocol,
+        username,
+        password,
+        hostname,
+        port,
+        pathname: pathname2,
+        search: search2,
+        hash: hash2
+      };
+    }
+    const hashIndex = rest.indexOf("#");
+    const hash = hashIndex === -1 ? void 0 : rest.slice(hashIndex + 1);
+    const beforeHash = hashIndex === -1 ? rest : rest.slice(0, hashIndex);
+    const searchDelim = findSearchDelimiter(beforeHash);
+    const search = searchDelim.index === -1 ? void 0 : beforeHash.slice(searchDelim.index + searchDelim.offset);
+    const pathname = searchDelim.index === -1 ? beforeHash : beforeHash.slice(0, searchDelim.index);
+    return { protocol, pathname, search, hash };
+  }
+  const protocolMatch = pattern.match(
+    /^([a-zA-Z][a-zA-Z0-9+\-.]*(?:\{[^}]*\}\??)?):/
+  );
+  if (protocolMatch && pattern.includes("://")) {
+    const hashIndex = pattern.indexOf("#");
+    const hash = hashIndex === -1 ? void 0 : pattern.slice(hashIndex + 1);
+    const beforeHash = hashIndex === -1 ? pattern : pattern.slice(0, hashIndex);
+    const searchDelim = findSearchDelimiter(beforeHash);
+    const ampIndex2 = beforeHash.indexOf("&");
+    let queryIndex = -1;
+    let searchOffset = 0;
+    if (searchDelim.index !== -1 && (ampIndex2 === -1 || searchDelim.index < ampIndex2)) {
+      queryIndex = searchDelim.index;
+      searchOffset = searchDelim.offset;
+    } else if (ampIndex2 !== -1) {
+      queryIndex = ampIndex2;
+      searchOffset = 1;
+    }
+    const search = queryIndex === -1 ? void 0 : beforeHash.slice(queryIndex + searchOffset);
+    const urlPart = queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex);
+    const schemeEndIdx = urlPart.indexOf("://");
+    const protocol = urlPart.slice(0, schemeEndIdx);
+    let afterScheme = urlPart.slice(schemeEndIdx + 3);
+    let username;
+    let password;
+    let atIndex = -1;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    let parenDepth = 0;
+    for (let i = 0; i < afterScheme.length; i++) {
+      const char = afterScheme[i];
+      if (char === "\\") {
+        i++;
+        continue;
+      }
+      if (char === "[")
+        bracketDepth++;
+      else if (char === "]")
+        bracketDepth--;
+      else if (char === "{")
+        braceDepth++;
+      else if (char === "}")
+        braceDepth--;
+      else if (char === "(")
+        parenDepth++;
+      else if (char === ")")
+        parenDepth--;
+      else if (char === "@" && bracketDepth === 0 && braceDepth === 0 && parenDepth === 0) {
+        atIndex = i;
+        break;
+      } else if (char === "/" && bracketDepth === 0 && braceDepth === 0 && parenDepth === 0) {
+        break;
+      }
+    }
+    if (atIndex !== -1) {
+      const userinfo = afterScheme.slice(0, atIndex);
+      afterScheme = afterScheme.slice(atIndex + 1);
+      let colonIndex = -1;
+      let braceDepth2 = 0;
+      for (let i = 0; i < userinfo.length; i++) {
+        const char = userinfo[i];
+        if (char === "\\") {
+          if (i + 1 < userinfo.length && userinfo[i + 1] === ":") {
+            colonIndex = i + 1;
+            break;
+          }
+          i++;
+          continue;
+        }
+        if (char === "{")
+          braceDepth2++;
+        else if (char === "}")
+          braceDepth2--;
+        else if (char === ":" && braceDepth2 === 0) {
+          const afterColon = userinfo.slice(i + 1);
+          const paramMatch = afterColon.match(
+            new RegExp("^(\\p{ID_Start}\\p{ID_Continue}*)", "u")
+          );
+          if (paramMatch) {
+            i += 1 + paramMatch[1].length;
+            if (i < userinfo.length && "?+*".includes(userinfo[i])) {
+              i++;
+            }
+            i--;
+            continue;
+          }
+          colonIndex = i;
+          break;
+        }
+      }
+      if (colonIndex !== -1) {
+        username = userinfo.slice(0, colonIndex);
+        if (username.endsWith("\\")) {
+          username = username.slice(0, -1);
+        }
+        password = userinfo.slice(colonIndex + 1);
+      } else {
+        username = userinfo;
+      }
+    }
+    const pathnameResult = findPathnameStart(afterScheme);
+    let pathname;
+    let hostPart;
+    if (pathnameResult.useWildcardPathname && pathnameResult.truncateHostname !== void 0) {
+      hostPart = afterScheme.slice(0, pathnameResult.truncateHostname);
+      const lastBrace = hostPart.lastIndexOf("{");
+      if (lastBrace !== -1) {
+        const beforeBrace = hostPart.slice(0, lastBrace);
+        const braceContent = hostPart.slice(lastBrace + 1);
+        hostPart = beforeBrace + braceContent;
+      }
+      pathname = "*";
+    } else if (pathnameResult.index === -1) {
+      pathname = "/";
+      hostPart = afterScheme;
+    } else {
+      pathname = afterScheme.slice(pathnameResult.index);
+      hostPart = afterScheme.slice(0, pathnameResult.index);
+    }
+    const portMatch = hostPart.match(/:(\d+|\([^)]+\)|\d*\{[^}]+\}\??)$/);
+    const port = portMatch ? portMatch[1] : "";
+    const hostname = portMatch ? hostPart.slice(0, -portMatch[0].length) : hostPart;
+    return {
+      protocol,
+      username,
+      password,
+      hostname,
+      port,
+      pathname,
+      search,
+      hash
+    };
+  }
+  if (pattern.startsWith("/")) {
+    const hashIndex = pattern.indexOf("#");
+    const hash = hashIndex === -1 ? void 0 : pattern.slice(hashIndex + 1);
+    const beforeHash = hashIndex === -1 ? pattern : pattern.slice(0, hashIndex);
+    const searchDelim = findSearchDelimiter(beforeHash);
+    const ampIndex2 = beforeHash.indexOf("&");
+    let queryIndex = -1;
+    let searchOffset = 0;
+    if (searchDelim.index !== -1 && (ampIndex2 === -1 || searchDelim.index < ampIndex2)) {
+      queryIndex = searchDelim.index;
+      searchOffset = searchDelim.offset;
+    } else if (ampIndex2 !== -1) {
+      queryIndex = ampIndex2;
+      searchOffset = 1;
+    }
+    const search = queryIndex === -1 ? void 0 : beforeHash.slice(queryIndex + searchOffset);
+    const pathname = queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex);
+    return { pathname, search, hash };
+  }
+  const ampIndex = pattern.indexOf("&");
+  if (ampIndex === -1) {
+    return { pathname: pattern };
+  }
+  if (ampIndex === 0) {
+    return { search: pattern.slice(1) };
+  }
+  return {
+    pathname: pattern.slice(0, ampIndex),
+    search: pattern.slice(ampIndex + 1)
+  };
+}
+function compileComponentPattern(component, ignoreCase = false) {
+  const paramNames = [];
+  let hasWildcard = false;
+  let pattern = "";
+  let i = 0;
+  let inIPv6Brackets = false;
+  while (i < component.length) {
+    const char = component[i];
+    if (char === "[" && !inIPv6Brackets) {
+      inIPv6Brackets = true;
+    } else if (char === "]" && inIPv6Brackets) {
+      inIPv6Brackets = false;
+    }
+    if (char === "\\") {
+      if (i + 1 < component.length) {
+        pattern += "\\" + component[i + 1];
+        i += 2;
+        continue;
+      }
+      pattern += "\\\\";
+      i++;
+      continue;
+    }
+    if (char === ":") {
+      const match = component.slice(i).match(new RegExp("^:(\\p{ID_Continue}+)(\\([^)]*\\))?(\\?|\\+|\\*)?", "u"));
+      if (match) {
+        const name = match[1];
+        const constraint = match[2];
+        const modifier = match[3] || "";
+        if (paramNames.includes(name)) {
+          throw new TypeError(
+            `Invalid pattern: duplicate parameter name '${name}'`
+          );
+        }
+        paramNames.push(name);
+        let basePattern;
+        if (constraint) {
+          basePattern = constraint.slice(1, -1);
+        } else if (inIPv6Brackets) {
+          basePattern = "[^\\[\\]/?#]+?";
+        } else {
+          basePattern = "[^./:?#]+?";
+        }
+        if (modifier === "?") {
+          pattern += `(${basePattern})?`;
+        } else if (modifier === "+") {
+          pattern += `(${basePattern})+`;
+        } else if (modifier === "*") {
+          pattern += `(${basePattern})*`;
+        } else {
+          pattern += `(${basePattern})`;
+        }
+        i += match[0].length;
+        continue;
+      }
+    }
+    if (char === "(" && component[i + 1] !== "?") {
+      let depth = 1;
+      let j = i + 1;
+      let regexContent = "";
+      while (j < component.length && depth > 0) {
+        if (component[j] === "\\") {
+          regexContent += component[j] + (component[j + 1] || "");
+          j += 2;
+          continue;
+        }
+        if (component[j] === "(")
+          depth++;
+        if (component[j] === ")")
+          depth--;
+        if (depth > 0)
+          regexContent += component[j];
+        j++;
+      }
+      validateRegexGroupContent(regexContent);
+      const modifier = component[j] || "";
+      if (modifier === "?" || modifier === "+" || modifier === "*") {
+        pattern += `(${regexContent})${modifier}`;
+        j++;
+      } else {
+        pattern += `(${regexContent})`;
+      }
+      paramNames.push(`$${paramNames.length}`);
+      i = j;
+      continue;
+    }
+    if (char === "{") {
+      const closeIndex = component.indexOf("}", i);
+      if (closeIndex !== -1) {
+        const content = component.slice(i + 1, closeIndex);
+        const nextChar = component[closeIndex + 1] || "";
+        const isModifier = nextChar === "?" || nextChar === "+" || nextChar === "*";
+        const compiled = compileComponentPattern(content, ignoreCase);
+        if (nextChar === "?") {
+          pattern += `(?:${compiled.regex.source.slice(1, -1)})?`;
+        } else if (nextChar === "+") {
+          pattern += `(?:${compiled.regex.source.slice(1, -1)})+`;
+        } else if (nextChar === "*") {
+          pattern += `(?:${compiled.regex.source.slice(1, -1)})*`;
+        } else {
+          pattern += compiled.regex.source.slice(1, -1);
+        }
+        paramNames.push(...compiled.paramNames);
+        i = closeIndex + 1;
+        if (isModifier)
+          i++;
+        continue;
+      }
+    }
+    if (char === "*") {
+      hasWildcard = true;
+      const modifier = component[i + 1] || "";
+      if (modifier === "?" || modifier === "+" || modifier === "*") {
+        pattern += `(.*)${modifier}`;
+        i += 2;
+      } else {
+        pattern += "(.*)";
+        i++;
+      }
+      continue;
+    }
+    if (".+?^${}()|[]\\".includes(char)) {
+      pattern += "\\" + char;
+      i++;
+    } else {
+      const code = char.charCodeAt(0);
+      if (code > 127) {
+        let toEncode = char;
+        if (code >= 55296 && code <= 56319 && i + 1 < component.length) {
+          const nextCode = component.charCodeAt(i + 1);
+          if (nextCode >= 56320 && nextCode <= 57343) {
+            toEncode = char + component[i + 1];
+            i++;
+          }
+        }
+        pattern += encodeURIComponent(toEncode);
+        i++;
+      } else {
+        pattern += char;
+        i++;
+      }
+    }
+  }
+  const needsVFlag = requiresVFlag(pattern);
+  let flags = "";
+  if (ignoreCase)
+    flags += "i";
+  if (needsVFlag)
+    flags += "v";
+  const regex = new RegExp(`^${pattern}$`, flags || void 0);
+  return { regex, paramNames, hasWildcard };
+}
+function compilePathname(pathname, encodeChars = true, ignoreCase = false) {
+  const paramNames = [];
+  let hasWildcard = false;
+  let pattern = "";
+  let i = 0;
+  while (i < pathname.length) {
+    const char = pathname[i];
+    if (char === "\\") {
+      if (i + 1 < pathname.length) {
+        const nextChar = pathname[i + 1];
+        const allowedInPath = (c) => {
+          const code = c.charCodeAt(0);
+          return code >= 65 && code <= 90 || // A-Z
+          code >= 97 && code <= 122 || // a-z
+          code >= 48 && code <= 57 || // 0-9
+          "-._~!$&'()*+,;=:@/".includes(c);
+        };
+        if (allowedInPath(nextChar)) {
+          if (".+?^${}()|[]\\*".includes(nextChar)) {
+            pattern += "\\" + nextChar;
+          } else {
+            pattern += nextChar;
+          }
+        } else {
+          pattern += encodeURIComponent(nextChar);
+        }
+        i += 2;
+        continue;
+      }
+      pattern += "\\\\";
+      i++;
+      continue;
+    }
+    if (char === ":") {
+      const match = pathname.slice(i).match(new RegExp("^:(\\p{ID_Continue}+)(\\([^)]*\\))?(\\?|\\+|\\*)?", "u"));
+      if (match) {
+        const name = match[1];
+        const constraint = match[2];
+        const modifier = match[3] || "";
+        if (paramNames.includes(name)) {
+          throw new TypeError(
+            `Invalid pattern: duplicate parameter name '${name}'`
+          );
+        }
+        paramNames.push(name);
+        let basePattern;
+        if (constraint) {
+          basePattern = constraint.slice(1, -1);
+        } else {
+          basePattern = "[^/]+?";
+        }
+        const hasPrecedingSlash = pattern.endsWith("/");
+        if (modifier === "?") {
+          const nextChar = pathname[i + match[0].length];
+          const isAtEnd = nextChar === void 0;
+          const isFollowedBySlash = nextChar === "/";
+          if (hasPrecedingSlash && (isAtEnd || isFollowedBySlash)) {
+            pattern = pattern.slice(0, -1);
+            pattern += `(?:/(${basePattern}))?`;
+          } else if (hasPrecedingSlash) {
+            pattern += `([^/]*?)`;
+          } else {
+            pattern += `(${basePattern})?`;
+          }
+        } else if (modifier === "+") {
+          const multiSegmentPattern = `${basePattern}(?:/${basePattern})*`;
+          if (hasPrecedingSlash) {
+            pattern = pattern.slice(0, -1);
+            pattern += `/(${multiSegmentPattern})`;
+          } else {
+            pattern += `(${multiSegmentPattern})`;
+          }
+        } else if (modifier === "*") {
+          const multiSegmentPattern = `${basePattern}(?:/${basePattern})*`;
+          if (hasPrecedingSlash) {
+            pattern = pattern.slice(0, -1);
+            pattern += `(?:/(${multiSegmentPattern}))?`;
+          } else {
+            pattern += `(${multiSegmentPattern})?`;
+          }
+        } else {
+          pattern += `(${basePattern})`;
+        }
+        i += match[0].length;
+        continue;
+      } else {
+        const nextChar = pathname[i + 1];
+        if (nextChar && !/^[\s/?#(){}*+]$/.test(nextChar)) {
+          throw new TypeError(
+            `Invalid pattern: invalid parameter name character after ':'`
+          );
+        }
+      }
+    }
+    if (char === "(" && pathname[i + 1] !== "?") {
+      let depth = 1;
+      let j = i + 1;
+      let regexContent = "";
+      while (j < pathname.length && depth > 0) {
+        if (pathname[j] === "\\") {
+          regexContent += pathname[j] + (pathname[j + 1] || "");
+          j += 2;
+          continue;
+        }
+        if (pathname[j] === "(")
+          depth++;
+        if (pathname[j] === ")")
+          depth--;
+        if (depth > 0)
+          regexContent += pathname[j];
+        j++;
+      }
+      validateRegexGroupContent(regexContent);
+      const modifier = pathname[j] || "";
+      const hasPrecedingSlash = pattern.endsWith("/");
+      if (modifier === "?") {
+        if (hasPrecedingSlash) {
+          pattern = pattern.slice(0, -1);
+          pattern += `(?:/(${regexContent}))?`;
+        } else {
+          pattern += `(${regexContent})?`;
+        }
+        j++;
+      } else if (modifier === "+") {
+        const multiSegmentPattern = `${regexContent}(?:/${regexContent})*`;
+        if (hasPrecedingSlash) {
+          pattern = pattern.slice(0, -1);
+          pattern += `/(${multiSegmentPattern})`;
+        } else {
+          pattern += `(${regexContent})+`;
+        }
+        j++;
+      } else if (modifier === "*") {
+        const multiSegmentPattern = `${regexContent}(?:/${regexContent})*`;
+        if (hasPrecedingSlash) {
+          pattern = pattern.slice(0, -1);
+          pattern += `(?:/(${multiSegmentPattern}))?`;
+        } else {
+          pattern += `(${regexContent})*`;
+        }
+        j++;
+      } else {
+        pattern += `(${regexContent})`;
+      }
+      paramNames.push(`$${paramNames.length}`);
+      i = j;
+      continue;
+    }
+    if (char === "{") {
+      const closeIndex = pathname.indexOf("}", i);
+      if (closeIndex !== -1) {
+        const content = pathname.slice(i + 1, closeIndex);
+        const nextChar = pathname[closeIndex + 1] || "";
+        const isModifier = nextChar === "?" || nextChar === "+" || nextChar === "*";
+        const compiled = compilePathname(content, encodeChars, ignoreCase);
+        if (nextChar === "?") {
+          pattern += `(?:${compiled.regex.source.slice(1, -1)})?`;
+        } else if (nextChar === "+") {
+          pattern += `(?:${compiled.regex.source.slice(1, -1)})+`;
+        } else if (nextChar === "*") {
+          pattern += `(?:${compiled.regex.source.slice(1, -1)})*`;
+        } else {
+          pattern += compiled.regex.source.slice(1, -1);
+        }
+        paramNames.push(...compiled.paramNames);
+        i = closeIndex + 1;
+        if (isModifier)
+          i++;
+        continue;
+      }
+    }
+    if (char === "*") {
+      hasWildcard = true;
+      const modifier = pathname[i + 1] || "";
+      const hasPrecedingSlash = pattern.endsWith("/");
+      paramNames.push(String(paramNames.length));
+      if (modifier === "?") {
+        if (hasPrecedingSlash) {
+          pattern = pattern.slice(0, -1);
+          pattern += `(?:/(.*))?`;
+        } else {
+          pattern += `(.*)?`;
+        }
+        i += 2;
+      } else if (modifier === "+") {
+        if (hasPrecedingSlash) {
+          pattern = pattern.slice(0, -1);
+          pattern += `/(.*)(?:/(.*))*`;
+        } else {
+          pattern += `(.*)+`;
+        }
+        i += 2;
+      } else if (modifier === "*") {
+        if (hasPrecedingSlash) {
+          pattern = pattern.slice(0, -1);
+          pattern += `(?:/(.*))*`;
+        } else {
+          pattern += `(.*)*`;
+        }
+        i += 2;
+      } else {
+        pattern += "(.*)";
+        i++;
+      }
+      continue;
+    }
+    if (".+?^${}()|[]\\".includes(char)) {
+      pattern += "\\" + char;
+    } else if (encodeChars) {
+      const code = char.charCodeAt(0);
+      const isAllowedInPath = code >= 65 && code <= 90 || // A-Z
+      code >= 97 && code <= 122 || // a-z
+      code >= 48 && code <= 57 || // 0-9
+      "-._~!$&'()*+,;=:@/%".includes(char);
+      if (isAllowedInPath) {
+        pattern += char;
+      } else {
+        const code2 = char.charCodeAt(0);
+        if (code2 >= 55296 && code2 <= 56319) {
+          const nextCode = i + 1 < pathname.length ? pathname.charCodeAt(i + 1) : 0;
+          if (nextCode >= 56320 && nextCode <= 57343) {
+            pattern += encodeURIComponent(char + pathname[i + 1]);
+            i++;
+          } else {
+            pattern += "%EF%BF%BD";
+          }
+        } else if (code2 >= 56320 && code2 <= 57343) {
+          pattern += "%EF%BF%BD";
+        } else {
+          pattern += encodeURIComponent(char);
+        }
+      }
+    } else {
+      pattern += char;
+    }
+    i++;
+  }
+  const needsVFlag = requiresVFlag(pattern);
+  let flags = "";
+  if (ignoreCase)
+    flags += "i";
+  if (needsVFlag)
+    flags += "v";
+  const regex = new RegExp(`^${pattern}$`, flags || void 0);
+  return { regex, paramNames, hasWildcard };
+}
+function testSearchParameters(searchPattern, actualSearch) {
+  const patternParams = parseSearchPattern(searchPattern);
+  const actualParams = parseRawSearchParams(actualSearch);
+  for (const [key, paramDef] of patternParams) {
+    if (!actualParams.has(key)) {
+      return false;
+    }
+    if (paramDef.type === "literal") {
+      if (actualParams.get(key) !== paramDef.value) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function parseRawSearchParams(search) {
+  const params = /* @__PURE__ */ new Map();
+  if (!search)
+    return params;
+  const parts = search.split("&");
+  for (const part of parts) {
+    const eqIdx = part.indexOf("=");
+    if (eqIdx === -1) {
+      params.set(part, "");
+    } else {
+      params.set(part.slice(0, eqIdx), part.slice(eqIdx + 1));
+    }
+  }
+  return params;
+}
+function extractSearchParams(searchPattern, actualParams) {
+  const params = {};
+  const patternParams = parseSearchPattern(searchPattern);
+  for (const [key, paramDef] of patternParams) {
+    const value = actualParams.get(key);
+    if (value !== null) {
+      if (paramDef.type === "named" && paramDef.name) {
+        params[paramDef.name] = value;
+      }
+    }
+  }
+  for (const [key, value] of actualParams) {
+    if (!params[key]) {
+      params[key] = value;
+    }
+  }
+  return params;
+}
+function parseSearchPattern(pattern) {
+  const params = /* @__PURE__ */ new Map();
+  const parts = pattern.split("&");
+  for (const part of parts) {
+    const [key, value] = part.split("=");
+    if (!key)
+      continue;
+    if (value === void 0) {
+      params.set(key, { type: "wildcard" });
+      continue;
+    }
+    if (value.startsWith(":")) {
+      const isOptional = value.endsWith("?");
+      params.set(key, {
+        type: "named",
+        name: value.slice(1, isOptional ? -1 : void 0)
+      });
+    } else if (value === "*") {
+      params.set(key, { type: "wildcard" });
+    } else {
+      params.set(key, { type: "literal", value: encodeSearch(value) });
+    }
+  }
+  return params;
+}
+function compileURLPatternInit(init, baseURL, options) {
+  let baseURLParsed;
+  const base = init.baseURL || baseURL;
+  if (base) {
+    try {
+      baseURLParsed = new URL(base);
+    } catch {
+    }
+  }
+  const result = {};
+  let protocol = init.protocol || (baseURLParsed ? baseURLParsed.protocol.replace(":", "") : void 0);
+  if (protocol) {
+    if (protocol.endsWith(":")) {
+      protocol = protocol.slice(0, -1);
+    }
+    result.protocol = compileComponentPattern(protocol, options.ignoreCase);
+  }
+  let hostname = init.hostname || (baseURLParsed ? baseURLParsed.hostname : void 0);
+  if (hostname) {
+    validateHostnamePattern(hostname);
+    hostname = normalizeHostnamePattern(hostname);
+    if (hostname.startsWith("[")) {
+      hostname = hostname.replace(/[A-F]/g, (c) => c.toLowerCase());
+    } else {
+      const hasPatternSyntax = /[{}()*+?:|\\]/.test(hostname);
+      if (!hasPatternSyntax) {
+        hostname = toASCII(hostname);
+      }
+    }
+    result.hostname = compileComponentPattern(hostname, options.ignoreCase);
+  }
+  if (init.port !== void 0) {
+    let port = init.port;
+    const hasPatternSyntax = /[{}()*+?:|\\]/.test(port);
+    if (protocol && !hasPatternSyntax && isValidPatternPort(port)) {
+      const canonicalPort = canonicalizePort(port, true);
+      if (canonicalPort !== void 0) {
+        const defaultPort = getDefaultPort(protocol);
+        if (defaultPort && canonicalPort === defaultPort) {
+          port = "";
+        } else {
+          port = canonicalPort;
+        }
+      }
+    }
+    result.port = compileComponentPattern(port, options.ignoreCase);
+  }
+  if (init.username !== void 0) {
+    result.username = compileComponentPattern(
+      init.username,
+      options.ignoreCase
+    );
+  }
+  if (init.password !== void 0) {
+    result.password = compileComponentPattern(
+      init.password,
+      options.ignoreCase
+    );
+  }
+  if (init.search !== void 0) {
+    let search = init.search;
+    if (search.startsWith("?")) {
+      search = search.slice(1);
+    }
+    result.search = compileComponentPattern(search, options.ignoreCase);
+  }
+  if (init.hash !== void 0) {
+    let hash = init.hash;
+    if (hash.startsWith("#")) {
+      hash = hash.slice(1);
+    }
+    result.hash = compileComponentPattern(hash, options.ignoreCase);
+  }
+  let pathname;
+  const isNonSpecialScheme = protocol && isDefinitelyNonSpecialScheme(protocol);
+  if (init.pathname !== void 0 && init.pathname !== "") {
+    pathname = init.pathname;
+    if (baseURLParsed && !pathname.startsWith("/")) {
+      const basePath = baseURLParsed.pathname;
+      if (basePath.endsWith("/")) {
+        pathname = basePath + pathname;
+      } else {
+        pathname = basePath.slice(0, basePath.lastIndexOf("/") + 1) + pathname;
+      }
+    }
+  } else if (baseURLParsed) {
+    pathname = baseURLParsed.pathname;
+  } else {
+    pathname = "*";
+  }
+  if (pathname !== "" && pathname !== "*" && pathname.startsWith("/")) {
+    pathname = normalizePathname(pathname);
+  }
+  const shouldEncodePathname = !isNonSpecialScheme;
+  result.pathname = compilePathname(
+    pathname,
+    shouldEncodePathname,
+    options.ignoreCase
+  );
+  return result;
+}
+function testURLComponents(compiled, url) {
+  if (compiled.protocol) {
+    const protocol = url.protocol.replace(":", "");
+    if (!compiled.protocol.regex.test(protocol)) {
+      return false;
+    }
+  }
+  if (compiled.hostname) {
+    if (!compiled.hostname.regex.test(url.hostname)) {
+      return false;
+    }
+  }
+  if (compiled.port) {
+    if (!compiled.port.regex.test(url.port)) {
+      return false;
+    }
+  }
+  if (compiled.username) {
+    const username = encodeURIComponent(url.username);
+    if (!compiled.username.regex.test(username)) {
+      return false;
+    }
+  }
+  if (compiled.password) {
+    const password = encodeURIComponent(url.password);
+    if (!compiled.password.regex.test(password)) {
+      return false;
+    }
+  }
+  if (compiled.hash) {
+    const hash = url.hash.replace("#", "");
+    if (!compiled.hash.regex.test(hash)) {
+      return false;
+    }
+  }
+  if (!compiled.pathname.regex.test(url.pathname)) {
+    return false;
+  }
+  return true;
+}
+function testSearchRegex(compiled, url) {
+  if (compiled.search) {
+    const search = url.search.replace("?", "");
+    return compiled.search.regex.test(search);
+  }
+  return true;
+}
+function testSearchParams(searchPattern, rawSearch) {
+  if (!searchPattern) {
+    return true;
+  }
+  return testSearchParameters(searchPattern, rawSearch);
+}
+function parseConstructorArgs(input, baseURLOrOptions, options) {
+  let baseURL;
+  let opts = {};
+  if (input === void 0) {
+    input = {};
+  }
+  if (typeof input === "object") {
+    if (typeof baseURLOrOptions === "string") {
+      throw new TypeError(
+        "Invalid arguments: baseURL must be inside the object, not as second argument"
+      );
+    }
+    opts = baseURLOrOptions || {};
+    if (input.baseURL === "") {
+      throw new TypeError("Invalid pattern: baseURL cannot be empty string");
+    }
+  } else {
+    if (typeof baseURLOrOptions === "string") {
+      if (baseURLOrOptions === "") {
+        throw new TypeError("Invalid pattern: baseURL cannot be empty string");
+      }
+      baseURL = baseURLOrOptions;
+      opts = options || {};
+    } else if (typeof baseURLOrOptions === "object") {
+      opts = baseURLOrOptions;
+    }
+  }
+  const init = typeof input === "string" ? parseStringPattern(input) : input;
+  return { init, baseURL, options: opts };
+}
+var URLPattern = class {
+  #compiled;
+  #init;
+  get pathname() {
+    return this.#init.pathname || "*";
+  }
+  get search() {
+    return this.#init.search || "*";
+  }
+  get protocol() {
+    return this.#init.protocol || "*";
+  }
+  get hostname() {
+    return this.#init.hostname || "*";
+  }
+  get port() {
+    return this.#init.port || "*";
+  }
+  get username() {
+    return this.#init.username || "*";
+  }
+  get password() {
+    return this.#init.password || "*";
+  }
+  get hash() {
+    return this.#init.hash || "*";
+  }
+  constructor(input, baseURLOrOptions, options) {
+    const {
+      init,
+      baseURL,
+      options: opts
+    } = parseConstructorArgs(input, baseURLOrOptions, options);
+    if (typeof input === "string" && !init.protocol && !baseURL && !init.baseURL) {
+      throw new TypeError(
+        "Invalid pattern: relative URL pattern requires a baseURL"
+      );
+    }
+    this.#init = init;
+    this.#compiled = compileURLPatternInit(init, baseURL, {
+      ignoreCase: opts.ignoreCase ?? false
+    });
+  }
+  test(input, baseURL) {
+    if (input === void 0) {
+      input = {};
+    }
+    if (typeof input === "object" && !(input instanceof URL)) {
+      return this.#testInit(input, baseURL);
+    }
+    let url;
+    if (typeof input === "string") {
+      try {
+        url = baseURL ? new URL(input, baseURL) : new URL(input);
+      } catch {
+        return false;
+      }
+    } else {
+      url = input;
+    }
+    if (!testURLComponents(this.#compiled, url)) {
+      return false;
+    }
+    return testSearchRegex(this.#compiled, url);
+  }
+  #testInit(input, baseURL) {
+    const base = input.baseURL || baseURL;
+    let baseURLObj;
+    if (base) {
+      try {
+        baseURLObj = new URL(base);
+      } catch {
+      }
+    }
+    const protocol = input.protocol ?? baseURLObj?.protocol.replace(":", "") ?? void 0;
+    if (protocol !== void 0 && !isValidProtocol(protocol))
+      return false;
+    if (this.#compiled.protocol) {
+      if (protocol === void 0 || !this.#compiled.protocol.regex.test(protocol))
+        return false;
+    }
+    if (this.#compiled.hostname) {
+      let hostname = input.hostname ?? baseURLObj?.hostname;
+      if (hostname === void 0)
+        return false;
+      hostname = toASCII(hostname);
+      if (!this.#compiled.hostname.regex.test(hostname))
+        return false;
+    }
+    let port = input.port ?? baseURLObj?.port;
+    if (port !== void 0) {
+      const canonical = canonicalizePort(port);
+      if (canonical === void 0)
+        return false;
+      port = canonical;
+      if (protocol) {
+        const defaultPort = getDefaultPort(protocol);
+        if (defaultPort && port === defaultPort)
+          port = "";
+      }
+    }
+    if (this.#compiled.port) {
+      if (port === void 0 || !this.#compiled.port.regex.test(port))
+        return false;
+    }
+    if (this.#compiled.username) {
+      const username = input.username ?? baseURLObj?.username;
+      if (username === void 0 || !this.#compiled.username.regex.test(encodeURIComponent(username)))
+        return false;
+    }
+    if (this.#compiled.password) {
+      const password = input.password ?? baseURLObj?.password;
+      if (password === void 0 || !this.#compiled.password.regex.test(encodeURIComponent(password)))
+        return false;
+    }
+    let pathname = input.pathname ?? baseURLObj?.pathname ?? "/";
+    if (baseURLObj && !pathname.startsWith("/")) {
+      const basePath = baseURLObj.pathname;
+      if (basePath.endsWith("/")) {
+        pathname = basePath + pathname;
+      } else {
+        pathname = basePath.slice(0, basePath.lastIndexOf("/") + 1) + pathname;
+      }
+    }
+    if (pathname.startsWith("/"))
+      pathname = normalizePathname(pathname);
+    const shouldEncode = !protocol || isSpecialScheme(protocol);
+    if (shouldEncode)
+      pathname = encodePathname(pathname);
+    if (!this.#compiled.pathname.regex.test(pathname))
+      return false;
+    if (this.#compiled.hash) {
+      let hash = input.hash ?? baseURLObj?.hash.replace("#", "") ?? void 0;
+      if (hash === void 0)
+        return false;
+      if (hash.startsWith("#"))
+        hash = hash.slice(1);
+      hash = encodeHash(hash);
+      if (!this.#compiled.hash.regex.test(hash))
+        return false;
+    }
+    if (this.#compiled.search) {
+      let search = input.search ?? baseURLObj?.search?.replace("?", "") ?? "";
+      if (search.startsWith("?"))
+        search = search.slice(1);
+      search = encodeSearch(search);
+      if (!this.#compiled.search.regex.test(search))
+        return false;
+    }
+    return true;
+  }
+  exec(input, baseURL) {
+    if (!this.test(input, baseURL))
+      return null;
+    if (typeof input === "object" && !(input instanceof URL)) {
+      return this.#execInit(input, baseURL);
+    }
+    let url;
+    if (typeof input === "string") {
+      url = baseURL ? new URL(input, baseURL) : new URL(input);
+    } else {
+      url = input;
+    }
+    const params = {};
+    const pathnameGroups = {};
+    const searchGroups = {};
+    const match = this.#compiled.pathname.regex.exec(url.pathname);
+    if (match) {
+      for (let i = 0; i < this.#compiled.pathname.paramNames.length; i++) {
+        const name = this.#compiled.pathname.paramNames[i];
+        const value = match[i + 1];
+        if (value !== void 0) {
+          params[name] = value;
+          pathnameGroups[name] = value;
+        }
+      }
+    }
+    if (this.#compiled.search) {
+      const search = url.search.replace("?", "");
+      const searchMatch = this.#compiled.search.regex.exec(search);
+      if (searchMatch) {
+        for (let i = 0; i < this.#compiled.search.paramNames.length; i++) {
+          const name = this.#compiled.search.paramNames[i];
+          const value = searchMatch[i + 1];
+          if (value !== void 0) {
+            params[name] = value;
+            searchGroups[name] = value;
+          }
+        }
+      }
+    }
+    return {
+      params,
+      pathname: { input: url.pathname, groups: pathnameGroups },
+      search: { input: url.search, groups: searchGroups },
+      protocol: { input: url.protocol, groups: {} },
+      hostname: { input: url.hostname, groups: {} },
+      port: { input: url.port, groups: {} },
+      username: { input: url.username, groups: {} },
+      password: { input: url.password, groups: {} },
+      hash: { input: url.hash, groups: {} },
+      inputs: [input]
+    };
+  }
+  #execInit(input, baseURL) {
+    const base = input.baseURL || baseURL;
+    let baseURLObj;
+    if (base) {
+      try {
+        baseURLObj = new URL(base);
+      } catch {
+      }
+    }
+    let pathname = input.pathname ?? baseURLObj?.pathname ?? "/";
+    pathname = normalizePathname(pathname);
+    const params = {};
+    const pathnameGroups = {};
+    const searchGroups = {};
+    const match = this.#compiled.pathname.regex.exec(pathname);
+    if (match) {
+      for (let i = 0; i < this.#compiled.pathname.paramNames.length; i++) {
+        const name = this.#compiled.pathname.paramNames[i];
+        const value = match[i + 1];
+        if (value !== void 0) {
+          params[name] = value;
+          pathnameGroups[name] = value;
+        }
+      }
+    }
+    if (this.#compiled.search) {
+      let search2 = input.search ?? baseURLObj?.search?.replace("?", "") ?? "";
+      if (search2.startsWith("?"))
+        search2 = search2.slice(1);
+      const searchMatch = this.#compiled.search.regex.exec(search2);
+      if (searchMatch) {
+        for (let i = 0; i < this.#compiled.search.paramNames.length; i++) {
+          const name = this.#compiled.search.paramNames[i];
+          const value = searchMatch[i + 1];
+          if (value !== void 0) {
+            params[name] = value;
+            searchGroups[name] = value;
+          }
+        }
+      }
+    }
+    const protocol = input.protocol ?? baseURLObj?.protocol.replace(":", "") ?? "";
+    const hostname = input.hostname ?? baseURLObj?.hostname ?? "";
+    let port = input.port ?? baseURLObj?.port ?? "";
+    if (port)
+      port = canonicalizePort(port) || "";
+    const hash = input.hash ?? baseURLObj?.hash?.replace("#", "") ?? "";
+    const search = input.search ?? baseURLObj?.search?.replace("?", "") ?? "";
+    return {
+      params,
+      pathname: { input: pathname, groups: pathnameGroups },
+      search: { input: search ? `?${search}` : "", groups: searchGroups },
+      protocol: { input: protocol ? `${protocol}:` : "", groups: {} },
+      hostname: { input: hostname, groups: {} },
+      port: { input: port, groups: {} },
+      username: { input: "", groups: {} },
+      password: { input: "", groups: {} },
+      hash: { input: hash ? `#${hash}` : "", groups: {} },
+      inputs: [input]
+    };
+  }
+};
+var MatchPattern = class {
+  #compiled;
+  #searchPattern;
+  #init;
+  get pathname() {
+    return this.#init.pathname || "*";
+  }
+  get search() {
+    return this.#searchPattern;
+  }
+  get protocol() {
+    return this.#init.protocol;
+  }
+  get hostname() {
+    return this.#init.hostname;
+  }
+  get port() {
+    return this.#init.port;
+  }
+  get username() {
+    return this.#init.username;
+  }
+  get password() {
+    return this.#init.password;
+  }
+  get hash() {
+    return this.#init.hash;
+  }
+  constructor(input, baseURLOrOptions, options) {
+    const {
+      init,
+      baseURL,
+      options: opts
+    } = parseConstructorArgs(input, baseURLOrOptions, options);
+    this.#init = init;
+    this.#searchPattern = init.search;
+    this.#compiled = compileURLPatternInit(init, baseURL, {
+      ignoreCase: opts.ignoreCase ?? false
+    });
+  }
+  test(input, baseURL) {
+    if (input === void 0) {
+      input = {};
+    }
+    if (typeof input === "object" && !(input instanceof URL)) {
+      return this.#testInit(input, baseURL);
+    }
+    let url;
+    if (typeof input === "string") {
+      try {
+        url = baseURL ? new URL(input, baseURL) : new URL(input);
+      } catch {
+        return false;
+      }
+    } else {
+      url = input;
+    }
+    if (!testURLComponents(this.#compiled, url)) {
+      return false;
+    }
+    if (this.#searchPattern && !this.#searchPattern.includes("=")) {
+      return testSearchRegex(this.#compiled, url);
+    }
+    const rawSearch = url.search.startsWith("?") ? url.search.slice(1) : url.search;
+    return testSearchParams(this.#searchPattern, rawSearch);
+  }
+  #testInit(input, baseURL) {
+    const base = input.baseURL || baseURL;
+    let baseURLObj;
+    if (base) {
+      try {
+        baseURLObj = new URL(base);
+      } catch {
+      }
+    }
+    const protocol = input.protocol ?? baseURLObj?.protocol.replace(":", "") ?? void 0;
+    if (protocol !== void 0 && !isValidProtocol(protocol))
+      return false;
+    if (this.#compiled.protocol) {
+      if (protocol === void 0 || !this.#compiled.protocol.regex.test(protocol))
+        return false;
+    }
+    if (this.#compiled.hostname) {
+      let hostname = input.hostname ?? baseURLObj?.hostname;
+      if (hostname === void 0)
+        return false;
+      hostname = toASCII(hostname);
+      if (!this.#compiled.hostname.regex.test(hostname))
+        return false;
+    }
+    let port = input.port ?? baseURLObj?.port;
+    if (port !== void 0) {
+      const canonical = canonicalizePort(port);
+      if (canonical === void 0)
+        return false;
+      port = canonical;
+      if (protocol) {
+        const defaultPort = getDefaultPort(protocol);
+        if (defaultPort && port === defaultPort)
+          port = "";
+      }
+    }
+    if (this.#compiled.port) {
+      if (port === void 0 || !this.#compiled.port.regex.test(port))
+        return false;
+    }
+    if (this.#compiled.username) {
+      const username = input.username ?? baseURLObj?.username;
+      if (username === void 0 || !this.#compiled.username.regex.test(encodeURIComponent(username)))
+        return false;
+    }
+    if (this.#compiled.password) {
+      const password = input.password ?? baseURLObj?.password;
+      if (password === void 0 || !this.#compiled.password.regex.test(encodeURIComponent(password)))
+        return false;
+    }
+    let pathname = input.pathname ?? baseURLObj?.pathname ?? "/";
+    if (baseURLObj && !pathname.startsWith("/")) {
+      try {
+        const resolved = new URL(pathname, baseURLObj.href);
+        pathname = resolved.pathname;
+      } catch {
+        const basePath = baseURLObj.pathname;
+        if (basePath.endsWith("/")) {
+          pathname = basePath + pathname;
+        } else {
+          pathname = basePath.slice(0, basePath.lastIndexOf("/") + 1) + pathname;
+        }
+      }
+    }
+    if (pathname.startsWith("/"))
+      pathname = normalizePathname(pathname);
+    const shouldEncode = !protocol || isSpecialScheme(protocol);
+    if (shouldEncode)
+      pathname = encodePathname(pathname);
+    if (!this.#compiled.pathname.regex.test(pathname))
+      return false;
+    if (this.#compiled.hash) {
+      let hash = input.hash ?? baseURLObj?.hash.replace("#", "") ?? void 0;
+      if (hash === void 0)
+        return false;
+      if (hash.startsWith("#"))
+        hash = hash.slice(1);
+      hash = encodeHash(hash);
+      if (!this.#compiled.hash.regex.test(hash))
+        return false;
+    }
+    if (this.#searchPattern) {
+      let search = input.search ?? baseURLObj?.search?.replace("?", "") ?? "";
+      if (search.startsWith("?"))
+        search = search.slice(1);
+      search = encodeSearch(search);
+      if (!this.#searchPattern.includes("=")) {
+        if (this.#compiled.search) {
+          return this.#compiled.search.regex.test(search);
+        }
+        return true;
+      }
+      return testSearchParams(this.#searchPattern, search);
+    }
+    return true;
+  }
+  exec(input, baseURL) {
+    if (!this.test(input, baseURL))
+      return null;
+    if (typeof input === "object" && !(input instanceof URL)) {
+      return this.#execInit(input, baseURL);
+    }
+    let url;
+    if (typeof input === "string") {
+      url = baseURL ? new URL(input, baseURL) : new URL(input);
+    } else {
+      url = input;
+    }
+    const params = {};
+    const pathnameGroups = {};
+    const searchGroups = {};
+    const match = this.#compiled.pathname.regex.exec(url.pathname);
+    if (match) {
+      for (let i = 0; i < this.#compiled.pathname.paramNames.length; i++) {
+        const name = this.#compiled.pathname.paramNames[i];
+        const value = match[i + 1];
+        if (value !== void 0) {
+          params[name] = value;
+          pathnameGroups[name] = value;
+        }
+      }
+    }
+    if (this.#searchPattern) {
+      const extracted = extractSearchParams(
+        this.#searchPattern,
+        url.searchParams
+      );
+      Object.assign(params, extracted);
+      Object.assign(searchGroups, extracted);
+    } else {
+      for (const [key, value] of url.searchParams) {
+        params[key] = value;
+        searchGroups[key] = value;
+      }
+    }
+    return {
+      params,
+      pathname: { input: url.pathname, groups: pathnameGroups },
+      search: { input: url.search, groups: searchGroups },
+      protocol: { input: url.protocol, groups: {} },
+      hostname: { input: url.hostname, groups: {} },
+      port: { input: url.port, groups: {} },
+      username: { input: url.username, groups: {} },
+      password: { input: url.password, groups: {} },
+      hash: { input: url.hash, groups: {} },
+      inputs: [input]
+    };
+  }
+  #execInit(input, baseURL) {
+    const base = input.baseURL || baseURL;
+    let baseURLObj;
+    if (base) {
+      try {
+        baseURLObj = new URL(base);
+      } catch {
+      }
+    }
+    let pathname = input.pathname ?? baseURLObj?.pathname ?? "/";
+    pathname = normalizePathname(pathname);
+    const params = {};
+    const pathnameGroups = {};
+    const searchGroups = {};
+    const match = this.#compiled.pathname.regex.exec(pathname);
+    if (match) {
+      for (let i = 0; i < this.#compiled.pathname.paramNames.length; i++) {
+        const name = this.#compiled.pathname.paramNames[i];
+        const value = match[i + 1];
+        if (value !== void 0) {
+          params[name] = value;
+          pathnameGroups[name] = value;
+        }
+      }
+    }
+    if (this.#searchPattern) {
+      const search2 = input.search ?? baseURLObj?.search?.replace("?", "") ?? "";
+      const extracted = extractSearchParams(
+        this.#searchPattern,
+        new URLSearchParams(search2)
+      );
+      Object.assign(params, extracted);
+      Object.assign(searchGroups, extracted);
+    }
+    const protocol = input.protocol ?? baseURLObj?.protocol.replace(":", "") ?? "";
+    const hostname = input.hostname ?? baseURLObj?.hostname ?? "";
+    let port = input.port ?? baseURLObj?.port ?? "";
+    if (port)
+      port = canonicalizePort(port) || "";
+    const hash = input.hash ?? baseURLObj?.hash?.replace("#", "") ?? "";
+    const search = input.search ?? baseURLObj?.search?.replace("?", "") ?? "";
+    return {
+      params,
+      pathname: { input: pathname, groups: pathnameGroups },
+      search: { input: search ? `?${search}` : "", groups: searchGroups },
+      protocol: { input: protocol ? `${protocol}:` : "", groups: {} },
+      hostname: { input: hostname, groups: {} },
+      port: { input: port, groups: {} },
+      username: { input: "", groups: {} },
+      password: { input: "", groups: {} },
+      hash: { input: hash ? `#${hash}` : "", groups: {} },
+      inputs: [input]
+    };
+  }
+};
+export {
+  MatchPattern,
+  URLPattern,
+  compilePathname,
+  isSimplePattern,
+  parseSimplePattern
+};