fastapi-rtk 0.2.23 → 0.2.25

package/dist/.external/cjs/fast-uri@3.1.0/fast-uri/lib/utils.cjs

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var utils;
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
+  const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+  function stringArrayToHexStripped(input) {
+    let acc = "";
+    let code = 0;
+    let i = 0;
+    for (i = 0; i < input.length; i++) {
+      code = input[i].charCodeAt(0);
+      if (code === 48) {
+        continue;
+      }
+      if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) {
+        return "";
+      }
+      acc += input[i];
+      break;
+    }
+    for (i += 1; i < input.length; i++) {
+      code = input[i].charCodeAt(0);
+      if (!(code >= 48 && code <= 57 || code >= 65 && code <= 70 || code >= 97 && code <= 102)) {
+        return "";
+      }
+      acc += input[i];
+    }
+    return acc;
+  }
+  const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
+  function consumeIsZone(buffer) {
+    buffer.length = 0;
+    return true;
+  }
+  function consumeHextets(buffer, address, output) {
+    if (buffer.length) {
+      const hex = stringArrayToHexStripped(buffer);
+      if (hex !== "") {
+        address.push(hex);
+      } else {
+        output.error = true;
+        return false;
+      }
+      buffer.length = 0;
+    }
+    return true;
+  }
+  function getIPV6(input) {
+    let tokenCount = 0;
+    const output = { error: false, address: "", zone: "" };
+    const address = [];
+    const buffer = [];
+    let endipv6Encountered = false;
+    let endIpv6 = false;
+    let consume = consumeHextets;
+    for (let i = 0; i < input.length; i++) {
+      const cursor = input[i];
+      if (cursor === "[" || cursor === "]") {
+        continue;
+      }
+      if (cursor === ":") {
+        if (endipv6Encountered === true) {
+          endIpv6 = true;
+        }
+        if (!consume(buffer, address, output)) {
+          break;
+        }
+        if (++tokenCount > 7) {
+          output.error = true;
+          break;
+        }
+        if (i > 0 && input[i - 1] === ":") {
+          endipv6Encountered = true;
+        }
+        address.push(":");
+        continue;
+      } else if (cursor === "%") {
+        if (!consume(buffer, address, output)) {
+          break;
+        }
+        consume = consumeIsZone;
+      } else {
+        buffer.push(cursor);
+        continue;
+      }
+    }
+    if (buffer.length) {
+      if (consume === consumeIsZone) {
+        output.zone = buffer.join("");
+      } else if (endIpv6) {
+        address.push(buffer.join(""));
+      } else {
+        address.push(stringArrayToHexStripped(buffer));
+      }
+    }
+    output.address = address.join("");
+    return output;
+  }
+  function normalizeIPv6(host) {
+    if (findToken(host, ":") < 2) {
+      return { host, isIPV6: false };
+    }
+    const ipv6 = getIPV6(host);
+    if (!ipv6.error) {
+      let newHost = ipv6.address;
+      let escapedHost = ipv6.address;
+      if (ipv6.zone) {
+        newHost += "%" + ipv6.zone;
+        escapedHost += "%25" + ipv6.zone;
+      }
+      return { host: newHost, isIPV6: true, escapedHost };
+    } else {
+      return { host, isIPV6: false };
+    }
+  }
+  function findToken(str, token) {
+    let ind = 0;
+    for (let i = 0; i < str.length; i++) {
+      if (str[i] === token) ind++;
+    }
+    return ind;
+  }
+  function removeDotSegments(path) {
+    let input = path;
+    const output = [];
+    let nextSlash = -1;
+    let len = 0;
+    while (len = input.length) {
+      if (len === 1) {
+        if (input === ".") {
+          break;
+        } else if (input === "/") {
+          output.push("/");
+          break;
+        } else {
+          output.push(input);
+          break;
+        }
+      } else if (len === 2) {
+        if (input[0] === ".") {
+          if (input[1] === ".") {
+            break;
+          } else if (input[1] === "/") {
+            input = input.slice(2);
+            continue;
+          }
+        } else if (input[0] === "/") {
+          if (input[1] === "." || input[1] === "/") {
+            output.push("/");
+            break;
+          }
+        }
+      } else if (len === 3) {
+        if (input === "/..") {
+          if (output.length !== 0) {
+            output.pop();
+          }
+          output.push("/");
+          break;
+        }
+      }
+      if (input[0] === ".") {
+        if (input[1] === ".") {
+          if (input[2] === "/") {
+            input = input.slice(3);
+            continue;
+          }
+        } else if (input[1] === "/") {
+          input = input.slice(2);
+          continue;
+        }
+      } else if (input[0] === "/") {
+        if (input[1] === ".") {
+          if (input[2] === "/") {
+            input = input.slice(2);
+            continue;
+          } else if (input[2] === ".") {
+            if (input[3] === "/") {
+              input = input.slice(3);
+              if (output.length !== 0) {
+                output.pop();
+              }
+              continue;
+            }
+          }
+        }
+      }
+      if ((nextSlash = input.indexOf("/", 1)) === -1) {
+        output.push(input);
+        break;
+      } else {
+        output.push(input.slice(0, nextSlash));
+        input = input.slice(nextSlash);
+      }
+    }
+    return output.join("");
+  }
+  function normalizeComponentEncoding(component, esc) {
+    const func = esc !== true ? escape : unescape;
+    if (component.scheme !== void 0) {
+      component.scheme = func(component.scheme);
+    }
+    if (component.userinfo !== void 0) {
+      component.userinfo = func(component.userinfo);
+    }
+    if (component.host !== void 0) {
+      component.host = func(component.host);
+    }
+    if (component.path !== void 0) {
+      component.path = func(component.path);
+    }
+    if (component.query !== void 0) {
+      component.query = func(component.query);
+    }
+    if (component.fragment !== void 0) {
+      component.fragment = func(component.fragment);
+    }
+    return component;
+  }
+  function recomposeAuthority(component) {
+    const uriTokens = [];
+    if (component.userinfo !== void 0) {
+      uriTokens.push(component.userinfo);
+      uriTokens.push("@");
+    }
+    if (component.host !== void 0) {
+      let host = unescape(component.host);
+      if (!isIPv4(host)) {
+        const ipV6res = normalizeIPv6(host);
+        if (ipV6res.isIPV6 === true) {
+          host = `[${ipV6res.escapedHost}]`;
+        } else {
+          host = component.host;
+        }
+      }
+      uriTokens.push(host);
+    }
+    if (typeof component.port === "number" || typeof component.port === "string") {
+      uriTokens.push(":");
+      uriTokens.push(String(component.port));
+    }
+    return uriTokens.length ? uriTokens.join("") : void 0;
+  }
+  utils = {
+    nonSimpleDomain,
+    recomposeAuthority,
+    normalizeComponentEncoding,
+    removeDotSegments,
+    isIPv4,
+    isUUID,
+    normalizeIPv6,
+    stringArrayToHexStripped
+  };
+  return utils;
+}
+exports.__require = requireUtils;

package/dist/.external/esm/ajv@8.17.1/ajv/dist/compile/index.mjs

@@ -1,4 +1,4 @@
-import { __exports as compile } from "../../../../../../.bundled/jsonforms/esm/_virtual/index6.mjs";
+import { __exports as compile } from "../../../../../../.bundled/jsonforms/esm/_virtual/index10.mjs";
 import { __require as requireCodegen } from "./codegen/index.mjs";
 import { __require as requireValidation_error } from "../runtime/validation_error.mjs";
 import { __require as requireNames } from "./names.mjs";

package/dist/.external/esm/ajv@8.17.1/ajv/dist/runtime/uri.mjs

@@ -1,5 +1,5 @@
 import { __exports as uri } from "../../../../../../.bundled/jsonforms/esm/_virtual/uri.mjs";
-import { __require as requireFastUri } from "../../../../fast-uri@3.0.6/fast-uri/index.mjs";
+import { __require as requireFastUri } from "../../../../fast-uri@3.1.0/fast-uri/index.mjs";
 var hasRequiredUri;
 function requireUri() {
   if (hasRequiredUri) return uri;

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/applicator/index.mjs

@@ -1,4 +1,4 @@
-import { __exports as applicator } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index9.mjs";
+import { __exports as applicator } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index8.mjs";
 import { __require as requireAdditionalItems } from "./additionalItems.mjs";
 import { __require as requirePrefixItems } from "./prefixItems.mjs";
 import { __require as requireItems } from "./items.mjs";

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/core/index.mjs

@@ -1,4 +1,4 @@
-import { __exports as core } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index7.mjs";
+import { __exports as core } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index6.mjs";
 import { __require as requireId } from "./id.mjs";
 import { __require as requireRef } from "./ref.mjs";
 var hasRequiredCore;

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/format/index.mjs

@@ -1,4 +1,4 @@
-import { __exports as format } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index10.mjs";
+import { __exports as format } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index9.mjs";
 import { __require as requireFormat$1 } from "./format.mjs";
 var hasRequiredFormat;
 function requireFormat() {

package/dist/.external/esm/ajv@8.17.1/ajv/dist/vocabularies/validation/index.mjs

@@ -1,4 +1,4 @@
-import { __exports as validation } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index8.mjs";
+import { __exports as validation } from "../../../../../../../.bundled/jsonforms/esm/_virtual/index7.mjs";
 import { __require as requireLimitNumber } from "./limitNumber.mjs";
 import { __require as requireMultipleOf } from "./multipleOf.mjs";
 import { __require as requireLimitLength } from "./limitLength.mjs";

package/dist/.external/esm/{fast-uri@3.0.6 → fast-uri@3.1.0}/fast-uri/index.mjs

@@ -5,22 +5,25 @@ var hasRequiredFastUri;
 function requireFastUri() {
   if (hasRequiredFastUri) return fastUri.exports;
   hasRequiredFastUri = 1;
-  const { normalizeIPv6, normalizeIPv4, removeDotSegments, recomposeAuthority, normalizeComponentEncoding } = requireUtils();
-  const SCHEMES = requireSchemes();
+  const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = requireUtils();
+  const { SCHEMES, getSchemeHandler } = requireSchemes();
   function normalize(uri, options) {
     if (typeof uri === "string") {
-      uri = serialize(parse(uri, options), options);
+      uri = /** @type {T} */
+      serialize(parse(uri, options), options);
     } else if (typeof uri === "object") {
-      uri = parse(serialize(uri, options), options);
+      uri = /** @type {T} */
+      parse(serialize(uri, options), options);
     }
     return uri;
   }
   function resolve(baseURI, relativeURI, options) {
-    const schemelessOptions = Object.assign({ scheme: "null" }, options);
-    const resolved = resolveComponents(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
-    return serialize(resolved, { ...schemelessOptions, skipEscape: true });
+    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 resolveComponents(base, relative, options, skipNormalization) {
+  function resolveComponent(base, relative, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
       base = parse(serialize(base, options), options);
@@ -50,7 +53,7 @@ function requireFastUri() {
             target.query = base.query;
           }
         } else {
-          if (relative.path.charAt(0) === "/") {
+          if (relative.path[0] === "/") {
             target.path = removeDotSegments(relative.path);
           } else {
             if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
@@ -89,7 +92,7 @@ function requireFastUri() {
     return uriA.toLowerCase() === uriB.toLowerCase();
   }
   function serialize(cmpts, opts) {
-    const components = {
+    const component = {
       host: cmpts.host,
       scheme: cmpts.scheme,
       userinfo: cmpts.userinfo,
@@ -107,60 +110,49 @@ function requireFastUri() {
     };
     const options = Object.assign({}, opts);
     const uriTokens = [];
-    const schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
-    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);
-    if (components.path !== void 0) {
+    const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
+    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
+    if (component.path !== void 0) {
       if (!options.skipEscape) {
-        components.path = escape(components.path);
-        if (components.scheme !== void 0) {
-          components.path = components.path.split("%3A").join(":");
+        component.path = escape(component.path);
+        if (component.scheme !== void 0) {
+          component.path = component.path.split("%3A").join(":");
         }
       } else {
-        components.path = unescape(components.path);
+        component.path = unescape(component.path);
       }
     }
-    if (options.reference !== "suffix" && components.scheme) {
-      uriTokens.push(components.scheme, ":");
+    if (options.reference !== "suffix" && component.scheme) {
+      uriTokens.push(component.scheme, ":");
     }
-    const authority = recomposeAuthority(components);
+    const authority = recomposeAuthority(component);
     if (authority !== void 0) {
       if (options.reference !== "suffix") {
         uriTokens.push("//");
       }
       uriTokens.push(authority);
-      if (components.path && components.path.charAt(0) !== "/") {
+      if (component.path && component.path[0] !== "/") {
         uriTokens.push("/");
       }
     }
-    if (components.path !== void 0) {
-      let s = components.path;
+    if (component.path !== void 0) {
+      let s = component.path;
       if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
         s = removeDotSegments(s);
       }
-      if (authority === void 0) {
-        s = s.replace(/^\/\//u, "/%2F");
+      if (authority === void 0 && s[0] === "/" && s[1] === "/") {
+        s = "/%2F" + s.slice(2);
       }
       uriTokens.push(s);
     }
-    if (components.query !== void 0) {
-      uriTokens.push("?", components.query);
+    if (component.query !== void 0) {
+      uriTokens.push("?", component.query);
     }
-    if (components.fragment !== void 0) {
-      uriTokens.push("#", components.fragment);
+    if (component.fragment !== void 0) {
+      uriTokens.push("#", component.fragment);
     }
     return uriTokens.join("");
   }
-  const hexLookUp = Array.from({ length: 127 }, (_v, k) => /[^!"$&'()*+,\-.;=_`a-z{}~]/u.test(String.fromCharCode(k)));
-  function nonSimpleDomain(value) {
-    let code = 0;
-    for (let i = 0, len = value.length; i < len; ++i) {
-      code = value.charCodeAt(i);
-      if (code > 126 || hexLookUp[code]) {
-        return true;
-      }
-    }
-    return false;
-  }
   const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
   function parse(uri, opts) {
     const options = Object.assign({}, opts);
@@ -173,9 +165,14 @@ function requireFastUri() {
       query: void 0,
       fragment: void 0
     };
-    const gotEncoding = uri.indexOf("%") !== -1;
     let isIP = false;
-    if (options.reference === "suffix") uri = (options.scheme ? options.scheme + ":" : "") + "//" + uri;
+    if (options.reference === "suffix") {
+      if (options.scheme) {
+        uri = options.scheme + ":" + uri;
+      } else {
+        uri = "//" + uri;
+      }
+    }
     const matches = uri.match(URI_PARSE);
     if (matches) {
       parsed.scheme = matches[1];
@@ -189,13 +186,12 @@ function requireFastUri() {
         parsed.port = matches[5];
       }
       if (parsed.host) {
-        const ipv4result = normalizeIPv4(parsed.host);
-        if (ipv4result.isIPV4 === false) {
-          const ipv6result = normalizeIPv6(ipv4result.host);
+        const ipv4result = isIPv4(parsed.host);
+        if (ipv4result === false) {
+          const ipv6result = normalizeIPv6(parsed.host);
           parsed.host = ipv6result.host.toLowerCase();
           isIP = ipv6result.isIPV6;
         } else {
-          parsed.host = ipv4result.host;
           isIP = true;
         }
       }
@@ -211,7 +207,7 @@ function requireFastUri() {
       if (options.reference && options.reference !== "suffix" && options.reference !== parsed.reference) {
         parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
       }
-      const schemeHandler = SCHEMES[(options.scheme || parsed.scheme || "").toLowerCase()];
+      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 {
@@ -222,11 +218,13 @@ function requireFastUri() {
         }
       }
       if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-        if (gotEncoding && parsed.scheme !== void 0) {
-          parsed.scheme = unescape(parsed.scheme);
-        }
-        if (gotEncoding && parsed.host !== void 0) {
-          parsed.host = unescape(parsed.host);
+        if (uri.indexOf("%") !== -1) {
+          if (parsed.scheme !== void 0) {
+            parsed.scheme = unescape(parsed.scheme);
+          }
+          if (parsed.host !== void 0) {
+            parsed.host = unescape(parsed.host);
+          }
         }
         if (parsed.path) {
           parsed.path = escape(unescape(parsed.path));
@@ -247,7 +245,7 @@ function requireFastUri() {
     SCHEMES,
     normalize,
     resolve,
-    resolveComponents,
+    resolveComponent,
     equal,
     serialize,
     parse