fastapi-rtk 0.1.13 → 0.1.15

package/dist/.external/cjs/fast-deep-equal@3.1.3/fast-deep-equal/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var fastDeepEqual;
+var hasRequiredFastDeepEqual;
+function requireFastDeepEqual() {
+  if (hasRequiredFastDeepEqual) return fastDeepEqual;
+  hasRequiredFastDeepEqual = 1;
+  fastDeepEqual = function equal(a, b) {
+    if (a === b) return true;
+    if (a && b && typeof a == "object" && typeof b == "object") {
+      if (a.constructor !== b.constructor) return false;
+      var length, i, keys;
+      if (Array.isArray(a)) {
+        length = a.length;
+        if (length != b.length) return false;
+        for (i = length; i-- !== 0; )
+          if (!equal(a[i], b[i])) return false;
+        return true;
+      }
+      if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+      if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+      if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+      keys = Object.keys(a);
+      length = keys.length;
+      if (length !== Object.keys(b).length) return false;
+      for (i = length; i-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+      for (i = length; i-- !== 0; ) {
+        var key = keys[i];
+        if (!equal(a[key], b[key])) return false;
+      }
+      return true;
+    }
+    return a !== a && b !== b;
+  };
+  return fastDeepEqual;
+}
+exports.__require = requireFastDeepEqual;

package/dist/.external/cjs/fast-uri@3.0.6/fast-uri/index.cjs

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../../../.bundled/jsonforms/cjs/_virtual/index12.cjs");
+const utils = require("./lib/utils.cjs");
+const schemes = require("./lib/schemes.cjs");
+var hasRequiredFastUri;
+function requireFastUri() {
+  if (hasRequiredFastUri) return index.__module.exports;
+  hasRequiredFastUri = 1;
+  const { normalizeIPv6, normalizeIPv4, removeDotSegments, recomposeAuthority, normalizeComponentEncoding } = utils.__require();
+  const SCHEMES = schemes.__require();
+  function normalize(uri, options) {
+    if (typeof uri === "string") {
+      uri = serialize(parse(uri, options), options);
+    } else if (typeof uri === "object") {
+      uri = 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 });
+  }
+  function resolveComponents(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.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) {
+          target.path = base.path;
+          if (relative.query !== void 0) {
+            target.query = relative.query;
+          } else {
+            target.query = base.query;
+          }
+        } else {
+          if (relative.path.charAt(0) === "/") {
+            target.path = removeDotSegments(relative.path);
+          } 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;
+            } else {
+              target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
+            }
+            target.path = removeDotSegments(target.path);
+          }
+          target.query = relative.query;
+        }
+        target.userinfo = base.userinfo;
+        target.host = base.host;
+        target.port = base.port;
+      }
+      target.scheme = base.scheme;
+    }
+    target.fragment = relative.fragment;
+    return target;
+  }
+  function equal(uriA, uriB, options) {
+    if (typeof uriA === "string") {
+      uriA = unescape(uriA);
+      uriA = serialize(normalizeComponentEncoding(parse(uriA, options), true), { ...options, skipEscape: true });
+    } else if (typeof uriA === "object") {
+      uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
+    }
+    if (typeof uriB === "string") {
+      uriB = unescape(uriB);
+      uriB = serialize(normalizeComponentEncoding(parse(uriB, options), true), { ...options, skipEscape: true });
+    } else if (typeof uriB === "object") {
+      uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
+    }
+    return uriA.toLowerCase() === uriB.toLowerCase();
+  }
+  function serialize(cmpts, opts) {
+    const components = {
+      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 = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
+    if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(components, options);
+    if (components.path !== void 0) {
+      if (!options.skipEscape) {
+        components.path = escape(components.path);
+        if (components.scheme !== void 0) {
+          components.path = components.path.split("%3A").join(":");
+        }
+      } else {
+        components.path = unescape(components.path);
+      }
+    }
+    if (options.reference !== "suffix" && components.scheme) {
+      uriTokens.push(components.scheme, ":");
+    }
+    const authority = recomposeAuthority(components);
+    if (authority !== void 0) {
+      if (options.reference !== "suffix") {
+        uriTokens.push("//");
+      }
+      uriTokens.push(authority);
+      if (components.path && components.path.charAt(0) !== "/") {
+        uriTokens.push("/");
+      }
+    }
+    if (components.path !== void 0) {
+      let s = components.path;
+      if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
+        s = removeDotSegments(s);
+      }
+      if (authority === void 0) {
+        s = s.replace(/^\/\//u, "/%2F");
+      }
+      uriTokens.push(s);
+    }
+    if (components.query !== void 0) {
+      uriTokens.push("?", components.query);
+    }
+    if (components.fragment !== void 0) {
+      uriTokens.push("#", components.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);
+    const parsed = {
+      scheme: void 0,
+      userinfo: void 0,
+      host: "",
+      port: void 0,
+      path: "",
+      query: void 0,
+      fragment: void 0
+    };
+    const gotEncoding = uri.indexOf("%") !== -1;
+    let isIP = false;
+    if (options.reference === "suffix") uri = (options.scheme ? options.scheme + ":" : "") + "//" + uri;
+    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 (parsed.host) {
+        const ipv4result = normalizeIPv4(parsed.host);
+        if (ipv4result.isIPV4 === false) {
+          const ipv6result = normalizeIPv6(ipv4result.host);
+          parsed.host = ipv6result.host.toLowerCase();
+          isIP = ipv6result.isIPV6;
+        } else {
+          parsed.host = ipv4result.host;
+          isIP = true;
+        }
+      }
+      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 = SCHEMES[(options.scheme || parsed.scheme || "").toLowerCase()];
+      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 (gotEncoding && parsed.scheme !== void 0) {
+          parsed.scheme = unescape(parsed.scheme);
+        }
+        if (gotEncoding && parsed.host !== void 0) {
+          parsed.host = unescape(parsed.host);
+        }
+        if (parsed.path) {
+          parsed.path = escape(unescape(parsed.path));
+        }
+        if (parsed.fragment) {
+          parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+        }
+      }
+      if (schemeHandler && schemeHandler.parse) {
+        schemeHandler.parse(parsed, options);
+      }
+    } else {
+      parsed.error = parsed.error || "URI can not be parsed.";
+    }
+    return parsed;
+  }
+  const fastUri = {
+    SCHEMES,
+    normalize,
+    resolve,
+    resolveComponents,
+    equal,
+    serialize,
+    parse
+  };
+  index.__module.exports = fastUri;
+  index.__module.exports.default = fastUri;
+  index.__module.exports.fastUri = fastUri;
+  return index.__module.exports;
+}
+exports.__require = requireFastUri;

package/dist/.external/cjs/fast-uri@3.0.6/fast-uri/lib/schemes.cjs

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var schemes;
+var hasRequiredSchemes;
+function requireSchemes() {
+  if (hasRequiredSchemes) return schemes;
+  hasRequiredSchemes = 1;
+  const UUID_REG = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu;
+  const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+  function isSecure(wsComponents) {
+    return typeof wsComponents.secure === "boolean" ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
+  }
+  function httpParse(components) {
+    if (!components.host) {
+      components.error = components.error || "HTTP URIs must have a host.";
+    }
+    return components;
+  }
+  function httpSerialize(components) {
+    const secure = String(components.scheme).toLowerCase() === "https";
+    if (components.port === (secure ? 443 : 80) || components.port === "") {
+      components.port = void 0;
+    }
+    if (!components.path) {
+      components.path = "/";
+    }
+    return components;
+  }
+  function wsParse(wsComponents) {
+    wsComponents.secure = isSecure(wsComponents);
+    wsComponents.resourceName = (wsComponents.path || "/") + (wsComponents.query ? "?" + wsComponents.query : "");
+    wsComponents.path = void 0;
+    wsComponents.query = void 0;
+    return wsComponents;
+  }
+  function wsSerialize(wsComponents) {
+    if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") {
+      wsComponents.port = void 0;
+    }
+    if (typeof wsComponents.secure === "boolean") {
+      wsComponents.scheme = wsComponents.secure ? "wss" : "ws";
+      wsComponents.secure = void 0;
+    }
+    if (wsComponents.resourceName) {
+      const [path, query] = wsComponents.resourceName.split("?");
+      wsComponents.path = path && path !== "/" ? path : void 0;
+      wsComponents.query = query;
+      wsComponents.resourceName = void 0;
+    }
+    wsComponents.fragment = void 0;
+    return wsComponents;
+  }
+  function urnParse(urnComponents, options) {
+    if (!urnComponents.path) {
+      urnComponents.error = "URN can not be parsed";
+      return urnComponents;
+    }
+    const matches = urnComponents.path.match(URN_REG);
+    if (matches) {
+      const scheme = options.scheme || urnComponents.scheme || "urn";
+      urnComponents.nid = matches[1].toLowerCase();
+      urnComponents.nss = matches[2];
+      const urnScheme = `${scheme}:${options.nid || urnComponents.nid}`;
+      const schemeHandler = SCHEMES[urnScheme];
+      urnComponents.path = void 0;
+      if (schemeHandler) {
+        urnComponents = schemeHandler.parse(urnComponents, options);
+      }
+    } else {
+      urnComponents.error = urnComponents.error || "URN can not be parsed.";
+    }
+    return urnComponents;
+  }
+  function urnSerialize(urnComponents, options) {
+    const scheme = options.scheme || urnComponents.scheme || "urn";
+    const nid = urnComponents.nid.toLowerCase();
+    const urnScheme = `${scheme}:${options.nid || nid}`;
+    const schemeHandler = SCHEMES[urnScheme];
+    if (schemeHandler) {
+      urnComponents = schemeHandler.serialize(urnComponents, options);
+    }
+    const uriComponents = urnComponents;
+    const nss = urnComponents.nss;
+    uriComponents.path = `${nid || options.nid}:${nss}`;
+    options.skipEscape = true;
+    return uriComponents;
+  }
+  function urnuuidParse(urnComponents, options) {
+    const uuidComponents = urnComponents;
+    uuidComponents.uuid = uuidComponents.nss;
+    uuidComponents.nss = void 0;
+    if (!options.tolerant && (!uuidComponents.uuid || !UUID_REG.test(uuidComponents.uuid))) {
+      uuidComponents.error = uuidComponents.error || "UUID is not valid.";
+    }
+    return uuidComponents;
+  }
+  function urnuuidSerialize(uuidComponents) {
+    const urnComponents = uuidComponents;
+    urnComponents.nss = (uuidComponents.uuid || "").toLowerCase();
+    return urnComponents;
+  }
+  const http = {
+    scheme: "http",
+    domainHost: true,
+    parse: httpParse,
+    serialize: httpSerialize
+  };
+  const https = {
+    scheme: "https",
+    domainHost: http.domainHost,
+    parse: httpParse,
+    serialize: httpSerialize
+  };
+  const ws = {
+    scheme: "ws",
+    domainHost: true,
+    parse: wsParse,
+    serialize: wsSerialize
+  };
+  const wss = {
+    scheme: "wss",
+    domainHost: ws.domainHost,
+    parse: ws.parse,
+    serialize: ws.serialize
+  };
+  const urn = {
+    scheme: "urn",
+    parse: urnParse,
+    serialize: urnSerialize,
+    skipNormalize: true
+  };
+  const urnuuid = {
+    scheme: "urn:uuid",
+    parse: urnuuidParse,
+    serialize: urnuuidSerialize,
+    skipNormalize: true
+  };
+  const SCHEMES = {
+    http,
+    https,
+    ws,
+    wss,
+    urn,
+    "urn:uuid": urnuuid
+  };
+  schemes = SCHEMES;
+  return schemes;
+}
+exports.__require = requireSchemes;

package/dist/.external/cjs/fast-uri@3.0.6/fast-uri/lib/scopedChars.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var scopedChars;
+var hasRequiredScopedChars;
+function requireScopedChars() {
+  if (hasRequiredScopedChars) return scopedChars;
+  hasRequiredScopedChars = 1;
+  const HEX = {
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3,
+    4: 4,
+    5: 5,
+    6: 6,
+    7: 7,
+    8: 8,
+    9: 9,
+    a: 10,
+    A: 10,
+    b: 11,
+    B: 11,
+    c: 12,
+    C: 12,
+    d: 13,
+    D: 13,
+    e: 14,
+    E: 14,
+    f: 15,
+    F: 15
+  };
+  scopedChars = {
+    HEX
+  };
+  return scopedChars;
+}
+exports.__require = requireScopedChars;