@spotlightjs/spotlight 4.11.4 → 4.11.6

package/dist/node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/index.js

@@ -2,294 +2,299 @@
 !(function() {
   try {
     var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
-    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "0c10e33d-1edb-4e4f-80a8-3920b642693c", e._sentryDebugIdIdentifier = "sentry-dbid-0c10e33d-1edb-4e4f-80a8-3920b642693c");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "b4f0eda2-259a-4c7b-aaf9-58c9f879a0a3", e._sentryDebugIdIdentifier = "sentry-dbid-b4f0eda2-259a-4c7b-aaf9-58c9f879a0a3");
   } catch (e2) {
   }
 })();
-import { __module as fastUri$1 } from "../../../../../_virtual/index11.js";
-import { u as utils } from "./lib/utils.js";
-import { s as schemes } from "./lib/schemes.js";
-const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = utils;
-const { SCHEMES, getSchemeHandler } = schemes;
-function normalize(uri, options) {
-  if (typeof uri === "string") {
-    uri = /** @type {T} */
-    normalizeString(uri, options);
-  } else if (typeof uri === "object") {
-    uri = /** @type {T} */
-    parse(serialize(uri, options), options);
+import { __module as fastUri } from "../../../../../_virtual/index12.js";
+import { __require as requireUtils } from "./lib/utils.js";
+import { __require as requireSchemes } from "./lib/schemes.js";
+var hasRequiredFastUri;
+function requireFastUri() {
+  if (hasRequiredFastUri) return fastUri.exports;
+  hasRequiredFastUri = 1;
+  const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = requireUtils();
+  const { SCHEMES, getSchemeHandler } = requireSchemes();
+  function normalize(uri, options) {
+    if (typeof uri === "string") {
+      uri = /** @type {T} */
+      normalizeString(uri, options);
+    } else if (typeof uri === "object") {
+      uri = /** @type {T} */
+      parse(serialize(uri, options), options);
+    }
+    return uri;
   }
-  return uri;
-}
-function resolve(baseURI, relativeURI, options) {
-  const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-  const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
-  schemelessOptions.skipEscape = true;
-  return serialize(resolved, schemelessOptions);
-}
-function resolveComponent(base, relative, options, skipNormalization) {
-  const target = {};
-  if (!skipNormalization) {
-    base = parse(serialize(base, options), options);
-    relative = parse(serialize(relative, options), options);
+  function resolve(baseURI, relativeURI, options) {
+    const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
+    const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+    schemelessOptions.skipEscape = true;
+    return serialize(resolved, schemelessOptions);
   }
-  options = options || {};
-  if (!options.tolerant && relative.scheme) {
-    target.scheme = relative.scheme;
-    target.userinfo = relative.userinfo;
-    target.host = relative.host;
-    target.port = relative.port;
-    target.path = removeDotSegments(relative.path || "");
-    target.query = relative.query;
-  } else {
-    if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
+  function resolveComponent(base, relative, options, skipNormalization) {
+    const target = {};
+    if (!skipNormalization) {
+      base = parse(serialize(base, options), options);
+      relative = parse(serialize(relative, options), options);
+    }
+    options = options || {};
+    if (!options.tolerant && relative.scheme) {
+      target.scheme = relative.scheme;
       target.userinfo = relative.userinfo;
       target.host = relative.host;
       target.port = relative.port;
       target.path = removeDotSegments(relative.path || "");
       target.query = relative.query;
     } else {
-      if (!relative.path) {
-        target.path = base.path;
-        if (relative.query !== void 0) {
-          target.query = relative.query;
-        } else {
-          target.query = base.query;
-        }
+      if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
+        target.userinfo = relative.userinfo;
+        target.host = relative.host;
+        target.port = relative.port;
+        target.path = removeDotSegments(relative.path || "");
+        target.query = relative.query;
       } else {
-        if (relative.path[0] === "/") {
-          target.path = removeDotSegments(relative.path);
+        if (!relative.path) {
+          target.path = base.path;
+          if (relative.query !== void 0) {
+            target.query = relative.query;
+          } else {
+            target.query = base.query;
+          }
         } else {
-          if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-            target.path = "/" + relative.path;
-          } else if (!base.path) {
-            target.path = relative.path;
+          if (relative.path[0] === "/") {
+            target.path = removeDotSegments(relative.path);
           } else {
-            target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+            if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
+              target.path = "/" + relative.path;
+            } else if (!base.path) {
+              target.path = relative.path;
+            } else {
+              target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+            }
+            target.path = removeDotSegments(target.path);
           }
-          target.path = removeDotSegments(target.path);
+          target.query = relative.query;
         }
-        target.query = relative.query;
+        target.userinfo = base.userinfo;
+        target.host = base.host;
+        target.port = base.port;
       }
-      target.userinfo = base.userinfo;
-      target.host = base.host;
-      target.port = base.port;
+      target.scheme = base.scheme;
     }
-    target.scheme = base.scheme;
+    target.fragment = relative.fragment;
+    return target;
   }
-  target.fragment = relative.fragment;
-  return target;
-}
-function equal(uriA, uriB, options) {
-  const normalizedA = normalizeComparableURI(uriA, options);
-  const normalizedB = normalizeComparableURI(uriB, options);
-  return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
-}
-function serialize(cmpts, opts) {
-  const component = {
-    host: cmpts.host,
-    scheme: cmpts.scheme,
-    userinfo: cmpts.userinfo,
-    port: cmpts.port,
-    path: cmpts.path,
-    query: cmpts.query,
-    nid: cmpts.nid,
-    nss: cmpts.nss,
-    uuid: cmpts.uuid,
-    fragment: cmpts.fragment,
-    reference: cmpts.reference,
-    resourceName: cmpts.resourceName,
-    secure: cmpts.secure,
-    error: ""
-  };
-  const options = Object.assign({}, opts);
-  const uriTokens = [];
-  const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
-  if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
-  if (component.path !== void 0) {
-    if (!options.skipEscape) {
-      component.path = escapePreservingEscapes(component.path);
-      if (component.scheme !== void 0) {
-        component.path = component.path.split("%3A").join(":");
+  function equal(uriA, uriB, options) {
+    const normalizedA = normalizeComparableURI(uriA, options);
+    const normalizedB = normalizeComparableURI(uriB, options);
+    return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+  }
+  function serialize(cmpts, opts) {
+    const component = {
+      host: cmpts.host,
+      scheme: cmpts.scheme,
+      userinfo: cmpts.userinfo,
+      port: cmpts.port,
+      path: cmpts.path,
+      query: cmpts.query,
+      nid: cmpts.nid,
+      nss: cmpts.nss,
+      uuid: cmpts.uuid,
+      fragment: cmpts.fragment,
+      reference: cmpts.reference,
+      resourceName: cmpts.resourceName,
+      secure: cmpts.secure,
+      error: ""
+    };
+    const options = Object.assign({}, opts);
+    const uriTokens = [];
+    const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
+    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+    if (component.path !== void 0) {
+      if (!options.skipEscape) {
+        component.path = escapePreservingEscapes(component.path);
+        if (component.scheme !== void 0) {
+          component.path = component.path.split("%3A").join(":");
+        }
+      } else {
+        component.path = normalizePercentEncoding(component.path);
       }
-    } else {
-      component.path = normalizePercentEncoding(component.path);
     }
-  }
-  if (options.reference !== "suffix" && component.scheme) {
-    uriTokens.push(component.scheme, ":");
-  }
-  const authority = recomposeAuthority(component);
-  if (authority !== void 0) {
-    if (options.reference !== "suffix") {
-      uriTokens.push("//");
+    if (options.reference !== "suffix" && component.scheme) {
+      uriTokens.push(component.scheme, ":");
     }
-    uriTokens.push(authority);
-    if (component.path && component.path[0] !== "/") {
-      uriTokens.push("/");
+    const authority = recomposeAuthority(component);
+    if (authority !== void 0) {
+      if (options.reference !== "suffix") {
+        uriTokens.push("//");
+      }
+      uriTokens.push(authority);
+      if (component.path && component.path[0] !== "/") {
+        uriTokens.push("/");
+      }
     }
-  }
-  if (component.path !== void 0) {
-    let s = component.path;
-    if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
-      s = removeDotSegments(s);
+    if (component.path !== void 0) {
+      let s = component.path;
+      if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
+        s = removeDotSegments(s);
+      }
+      if (authority === void 0 && s[0] === "/" && s[1] === "/") {
+        s = "/%2F" + s.slice(2);
+      }
+      uriTokens.push(s);
     }
-    if (authority === void 0 && s[0] === "/" && s[1] === "/") {
-      s = "/%2F" + s.slice(2);
+    if (component.query !== void 0) {
+      uriTokens.push("?", component.query);
     }
-    uriTokens.push(s);
-  }
-  if (component.query !== void 0) {
-    uriTokens.push("?", component.query);
-  }
-  if (component.fragment !== void 0) {
-    uriTokens.push("#", component.fragment);
-  }
-  return uriTokens.join("");
-}
-const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-function getParseError(parsed, matches) {
-  if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
-    return 'URI path must start with "/" when authority is present.';
-  }
-  if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
-    return "URI port is malformed.";
-  }
-  return void 0;
-}
-function parseWithStatus(uri, opts) {
-  const options = Object.assign({}, opts);
-  const parsed = {
-    scheme: void 0,
-    userinfo: void 0,
-    host: "",
-    port: void 0,
-    path: "",
-    query: void 0,
-    fragment: void 0
-  };
-  let malformedAuthorityOrPort = false;
-  let isIP = false;
-  if (options.reference === "suffix") {
-    if (options.scheme) {
-      uri = options.scheme + ":" + uri;
-    } else {
-      uri = "//" + uri;
+    if (component.fragment !== void 0) {
+      uriTokens.push("#", component.fragment);
     }
+    return uriTokens.join("");
   }
-  const matches = uri.match(URI_PARSE);
-  if (matches) {
-    parsed.scheme = matches[1];
-    parsed.userinfo = matches[3];
-    parsed.host = matches[4];
-    parsed.port = parseInt(matches[5], 10);
-    parsed.path = matches[6] || "";
-    parsed.query = matches[7];
-    parsed.fragment = matches[8];
-    if (isNaN(parsed.port)) {
-      parsed.port = matches[5];
+  const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+  function getParseError(parsed, matches) {
+    if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+      return 'URI path must start with "/" when authority is present.';
     }
-    const parseError = getParseError(parsed, matches);
-    if (parseError !== void 0) {
-      parsed.error = parsed.error || parseError;
-      malformedAuthorityOrPort = true;
+    if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+      return "URI port is malformed.";
     }
-    if (parsed.host) {
-      const ipv4result = isIPv4(parsed.host);
-      if (ipv4result === false) {
-        const ipv6result = normalizeIPv6(parsed.host);
-        parsed.host = ipv6result.host.toLowerCase();
-        isIP = ipv6result.isIPV6;
+    return void 0;
+  }
+  function parseWithStatus(uri, opts) {
+    const options = Object.assign({}, opts);
+    const parsed = {
+      scheme: void 0,
+      userinfo: void 0,
+      host: "",
+      port: void 0,
+      path: "",
+      query: void 0,
+      fragment: void 0
+    };
+    let malformedAuthorityOrPort = false;
+    let isIP = false;
+    if (options.reference === "suffix") {
+      if (options.scheme) {
+        uri = options.scheme + ":" + uri;
       } else {
-        isIP = true;
+        uri = "//" + uri;
       }
     }
-    if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) {
-      parsed.reference = "same-document";
-    } else if (parsed.scheme === void 0) {
-      parsed.reference = "relative";
-    } else if (parsed.fragment === void 0) {
-      parsed.reference = "absolute";
-    } else {
-      parsed.reference = "uri";
-    }
-    if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) {
-      parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
-    }
-    const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-      if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-        try {
-          parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
-        } catch (e) {
-          parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-        }
+    const matches = uri.match(URI_PARSE);
+    if (matches) {
+      parsed.scheme = matches[1];
+      parsed.userinfo = matches[3];
+      parsed.host = matches[4];
+      parsed.port = parseInt(matches[5], 10);
+      parsed.path = matches[6] || "";
+      parsed.query = matches[7];
+      parsed.fragment = matches[8];
+      if (isNaN(parsed.port)) {
+        parsed.port = matches[5];
       }
-    }
-    if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-      if (uri.indexOf("%") !== -1) {
-        if (parsed.scheme !== void 0) {
-          parsed.scheme = unescape(parsed.scheme);
-        }
-        if (parsed.host !== void 0) {
-          parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+      const parseError = getParseError(parsed, matches);
+      if (parseError !== void 0) {
+        parsed.error = parsed.error || parseError;
+        malformedAuthorityOrPort = true;
+      }
+      if (parsed.host) {
+        const ipv4result = isIPv4(parsed.host);
+        if (ipv4result === false) {
+          const ipv6result = normalizeIPv6(parsed.host);
+          parsed.host = ipv6result.host.toLowerCase();
+          isIP = ipv6result.isIPV6;
+        } else {
+          isIP = true;
         }
       }
-      if (parsed.path) {
-        parsed.path = normalizePathEncoding(parsed.path);
+      if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) {
+        parsed.reference = "same-document";
+      } else if (parsed.scheme === void 0) {
+        parsed.reference = "relative";
+      } else if (parsed.fragment === void 0) {
+        parsed.reference = "absolute";
+      } else {
+        parsed.reference = "uri";
+      }
+      if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) {
+        parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
       }
-      if (parsed.fragment) {
-        try {
-          parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-        } catch {
-          parsed.error = parsed.error || "URI malformed";
+      const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
+      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
+        if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
+          try {
+            parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
+          } catch (e) {
+            parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+          }
         }
       }
+      if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
+        if (uri.indexOf("%") !== -1) {
+          if (parsed.scheme !== void 0) {
+            parsed.scheme = unescape(parsed.scheme);
+          }
+          if (parsed.host !== void 0) {
+            parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
+          }
+        }
+        if (parsed.path) {
+          parsed.path = normalizePathEncoding(parsed.path);
+        }
+        if (parsed.fragment) {
+          try {
+            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+          } catch {
+            parsed.error = parsed.error || "URI malformed";
+          }
+        }
+      }
+      if (schemeHandler && schemeHandler.parse) {
+        schemeHandler.parse(parsed, options);
+      }
+    } else {
+      parsed.error = parsed.error || "URI can not be parsed.";
     }
-    if (schemeHandler && schemeHandler.parse) {
-      schemeHandler.parse(parsed, options);
-    }
-  } else {
-    parsed.error = parsed.error || "URI can not be parsed.";
+    return { parsed, malformedAuthorityOrPort };
   }
-  return { parsed, malformedAuthorityOrPort };
-}
-function parse(uri, opts) {
-  return parseWithStatus(uri, opts).parsed;
-}
-function normalizeString(uri, opts) {
-  return normalizeStringWithStatus(uri, opts).normalized;
-}
-function normalizeStringWithStatus(uri, opts) {
-  const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
-  return {
-    normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-    malformedAuthorityOrPort
-  };
-}
-function normalizeComparableURI(uri, opts) {
-  if (typeof uri === "string") {
-    const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-    return malformedAuthorityOrPort ? void 0 : normalized;
+  function parse(uri, opts) {
+    return parseWithStatus(uri, opts).parsed;
+  }
+  function normalizeString(uri, opts) {
+    return normalizeStringWithStatus(uri, opts).normalized;
+  }
+  function normalizeStringWithStatus(uri, opts) {
+    const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+    return {
+      normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+      malformedAuthorityOrPort
+    };
   }
-  if (typeof uri === "object") {
-    return serialize(uri, opts);
+  function normalizeComparableURI(uri, opts) {
+    if (typeof uri === "string") {
+      const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+      return malformedAuthorityOrPort ? void 0 : normalized;
+    }
+    if (typeof uri === "object") {
+      return serialize(uri, opts);
+    }
   }
+  const fastUri$1 = {
+    SCHEMES,
+    normalize,
+    resolve,
+    resolveComponent,
+    equal,
+    serialize,
+    parse
+  };
+  fastUri.exports = fastUri$1;
+  fastUri.exports.default = fastUri$1;
+  fastUri.exports.fastUri = fastUri$1;
+  return fastUri.exports;
 }
-const fastUri = {
-  SCHEMES,
-  normalize,
-  resolve,
-  resolveComponent,
-  equal,
-  serialize,
-  parse
-};
-fastUri$1.exports = fastUri;
-fastUri$1.exports.default = fastUri;
-fastUri$1.exports.fastUri = fastUri;
-var fastUriExports = fastUri$1.exports;
 export {
-  fastUriExports as f
+  requireFastUri as __require
 };
 //# sourceMappingURL=index.js.map