fastapi-rtk 0.1.14 → 0.1.15

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

@@ -0,0 +1,149 @@
+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;
+}
+export {
+  requireSchemes as __require
+};

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

@@ -0,0 +1,37 @@
+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;
+}
+export {
+  requireScopedChars as __require
+};

package/dist/.external/esm/fast-uri@3.0.6/fast-uri/lib/utils.mjs

@@ -0,0 +1,235 @@
+import { __require as requireScopedChars } from "./scopedChars.mjs";
+var utils;
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  const { HEX } = requireScopedChars();
+  const IPV4_REG = /^(?:(?: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 normalizeIPv4(host) {
+    if (findToken(host, ".") < 3) {
+      return { host, isIPV4: false };
+    }
+    const matches = host.match(IPV4_REG) || [];
+    const [address] = matches;
+    if (address) {
+      return { host: stripLeadingZeros(address, "."), isIPV4: true };
+    } else {
+      return { host, isIPV4: false };
+    }
+  }
+  function stringArrayToHexStripped(input, keepZero = false) {
+    let acc = "";
+    let strip = true;
+    for (const c of input) {
+      if (HEX[c] === void 0) return void 0;
+      if (c !== "0" && strip === true) strip = false;
+      if (!strip) acc += c;
+    }
+    if (keepZero && acc.length === 0) acc = "0";
+    return acc;
+  }
+  function getIPV6(input) {
+    let tokenCount = 0;
+    const output = { error: false, address: "", zone: "" };
+    const address = [];
+    const buffer = [];
+    let isZone = false;
+    let endipv6Encountered = false;
+    let endIpv6 = false;
+    function consume() {
+      if (buffer.length) {
+        if (isZone === false) {
+          const hex = stringArrayToHexStripped(buffer);
+          if (hex !== void 0) {
+            address.push(hex);
+          } else {
+            output.error = true;
+            return false;
+          }
+        }
+        buffer.length = 0;
+      }
+      return true;
+    }
+    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()) {
+          break;
+        }
+        tokenCount++;
+        address.push(":");
+        if (tokenCount > 7) {
+          output.error = true;
+          break;
+        }
+        if (i - 1 >= 0 && input[i - 1] === ":") {
+          endipv6Encountered = true;
+        }
+        continue;
+      } else if (cursor === "%") {
+        if (!consume()) {
+          break;
+        }
+        isZone = true;
+      } else {
+        buffer.push(cursor);
+        continue;
+      }
+    }
+    if (buffer.length) {
+      if (isZone) {
+        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, escapedHost, isIPV6: true };
+    } else {
+      return { host, isIPV6: false };
+    }
+  }
+  function stripLeadingZeros(str, token) {
+    let out = "";
+    let skip = true;
+    const l = str.length;
+    for (let i = 0; i < l; i++) {
+      const c = str[i];
+      if (c === "0" && skip) {
+        if (i + 1 <= l && str[i + 1] === token || i + 1 === l) {
+          out += c;
+          skip = false;
+        }
+      } else {
+        if (c === token) {
+          skip = true;
+        } else {
+          skip = false;
+        }
+        out += c;
+      }
+    }
+    return out;
+  }
+  function findToken(str, token) {
+    let ind = 0;
+    for (let i = 0; i < str.length; i++) {
+      if (str[i] === token) ind++;
+    }
+    return ind;
+  }
+  const RDS1 = /^\.\.?\//u;
+  const RDS2 = /^\/\.(?:\/|$)/u;
+  const RDS3 = /^\/\.\.(?:\/|$)/u;
+  const RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/u;
+  function removeDotSegments(input) {
+    const output = [];
+    while (input.length) {
+      if (input.match(RDS1)) {
+        input = input.replace(RDS1, "");
+      } else if (input.match(RDS2)) {
+        input = input.replace(RDS2, "/");
+      } else if (input.match(RDS3)) {
+        input = input.replace(RDS3, "/");
+        output.pop();
+      } else if (input === "." || input === "..") {
+        input = "";
+      } else {
+        const im = input.match(RDS5);
+        if (im) {
+          const s = im[0];
+          input = input.slice(s.length);
+          output.push(s);
+        } else {
+          throw new Error("Unexpected dot segment condition");
+        }
+      }
+    }
+    return output.join("");
+  }
+  function normalizeComponentEncoding(components, esc) {
+    const func = esc !== true ? escape : unescape;
+    if (components.scheme !== void 0) {
+      components.scheme = func(components.scheme);
+    }
+    if (components.userinfo !== void 0) {
+      components.userinfo = func(components.userinfo);
+    }
+    if (components.host !== void 0) {
+      components.host = func(components.host);
+    }
+    if (components.path !== void 0) {
+      components.path = func(components.path);
+    }
+    if (components.query !== void 0) {
+      components.query = func(components.query);
+    }
+    if (components.fragment !== void 0) {
+      components.fragment = func(components.fragment);
+    }
+    return components;
+  }
+  function recomposeAuthority(components) {
+    const uriTokens = [];
+    if (components.userinfo !== void 0) {
+      uriTokens.push(components.userinfo);
+      uriTokens.push("@");
+    }
+    if (components.host !== void 0) {
+      let host = unescape(components.host);
+      const ipV4res = normalizeIPv4(host);
+      if (ipV4res.isIPV4) {
+        host = ipV4res.host;
+      } else {
+        const ipV6res = normalizeIPv6(ipV4res.host);
+        if (ipV6res.isIPV6 === true) {
+          host = `[${ipV6res.escapedHost}]`;
+        } else {
+          host = components.host;
+        }
+      }
+      uriTokens.push(host);
+    }
+    if (typeof components.port === "number" || typeof components.port === "string") {
+      uriTokens.push(":");
+      uriTokens.push(String(components.port));
+    }
+    return uriTokens.length ? uriTokens.join("") : void 0;
+  }
+  utils = {
+    recomposeAuthority,
+    normalizeComponentEncoding,
+    removeDotSegments,
+    normalizeIPv4,
+    normalizeIPv6,
+    stringArrayToHexStripped
+  };
+  return utils;
+}
+export {
+  requireUtils as __require
+};

package/dist/.external/esm/json-schema-traverse@1.0.0/json-schema-traverse/index.mjs

@@ -0,0 +1,91 @@
+import { __module as jsonSchemaTraverse } from "../../../../.bundled/jsonforms/esm/_virtual/index11.mjs";
+var hasRequiredJsonSchemaTraverse;
+function requireJsonSchemaTraverse() {
+  if (hasRequiredJsonSchemaTraverse) return jsonSchemaTraverse.exports;
+  hasRequiredJsonSchemaTraverse = 1;
+  var traverse = jsonSchemaTraverse.exports = function(schema, opts, cb) {
+    if (typeof opts == "function") {
+      cb = opts;
+      opts = {};
+    }
+    cb = opts.cb || cb;
+    var pre = typeof cb == "function" ? cb : cb.pre || function() {
+    };
+    var post = cb.post || function() {
+    };
+    _traverse(opts, pre, post, schema, "", schema);
+  };
+  traverse.keywords = {
+    additionalItems: true,
+    items: true,
+    contains: true,
+    additionalProperties: true,
+    propertyNames: true,
+    not: true,
+    if: true,
+    then: true,
+    else: true
+  };
+  traverse.arrayKeywords = {
+    items: true,
+    allOf: true,
+    anyOf: true,
+    oneOf: true
+  };
+  traverse.propsKeywords = {
+    $defs: true,
+    definitions: true,
+    properties: true,
+    patternProperties: true,
+    dependencies: true
+  };
+  traverse.skipKeywords = {
+    default: true,
+    enum: true,
+    const: true,
+    required: true,
+    maximum: true,
+    minimum: true,
+    exclusiveMaximum: true,
+    exclusiveMinimum: true,
+    multipleOf: true,
+    maxLength: true,
+    minLength: true,
+    pattern: true,
+    format: true,
+    maxItems: true,
+    minItems: true,
+    uniqueItems: true,
+    maxProperties: true,
+    minProperties: true
+  };
+  function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+    if (schema && typeof schema == "object" && !Array.isArray(schema)) {
+      pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+      for (var key in schema) {
+        var sch = schema[key];
+        if (Array.isArray(sch)) {
+          if (key in traverse.arrayKeywords) {
+            for (var i = 0; i < sch.length; i++)
+              _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
+          }
+        } else if (key in traverse.propsKeywords) {
+          if (sch && typeof sch == "object") {
+            for (var prop in sch)
+              _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
+          }
+        } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
+          _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
+        }
+      }
+      post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+    }
+  }
+  function escapeJsonPtr(str) {
+    return str.replace(/~/g, "~0").replace(/\//g, "~1");
+  }
+  return jsonSchemaTraverse.exports;
+}
+export {
+  requireJsonSchemaTraverse as __require
+};

package/dist/.external/esm/lodash@4.17.21/lodash/_LazyWrapper.mjs

@@ -0,0 +1,26 @@
+import { __require as require_baseCreate } from "./_baseCreate.mjs";
+import { __require as require_baseLodash } from "./_baseLodash.mjs";
+var _LazyWrapper;
+var hasRequired_LazyWrapper;
+function require_LazyWrapper() {
+  if (hasRequired_LazyWrapper) return _LazyWrapper;
+  hasRequired_LazyWrapper = 1;
+  var baseCreate = require_baseCreate(), baseLodash = require_baseLodash();
+  var MAX_ARRAY_LENGTH = 4294967295;
+  function LazyWrapper(value) {
+    this.__wrapped__ = value;
+    this.__actions__ = [];
+    this.__dir__ = 1;
+    this.__filtered__ = false;
+    this.__iteratees__ = [];
+    this.__takeCount__ = MAX_ARRAY_LENGTH;
+    this.__views__ = [];
+  }
+  LazyWrapper.prototype = baseCreate(baseLodash.prototype);
+  LazyWrapper.prototype.constructor = LazyWrapper;
+  _LazyWrapper = LazyWrapper;
+  return _LazyWrapper;
+}
+export {
+  require_LazyWrapper as __require
+};

package/dist/.external/esm/lodash@4.17.21/lodash/_LodashWrapper.mjs

@@ -0,0 +1,23 @@
+import { __require as require_baseCreate } from "./_baseCreate.mjs";
+import { __require as require_baseLodash } from "./_baseLodash.mjs";
+var _LodashWrapper;
+var hasRequired_LodashWrapper;
+function require_LodashWrapper() {
+  if (hasRequired_LodashWrapper) return _LodashWrapper;
+  hasRequired_LodashWrapper = 1;
+  var baseCreate = require_baseCreate(), baseLodash = require_baseLodash();
+  function LodashWrapper(value, chainAll) {
+    this.__wrapped__ = value;
+    this.__actions__ = [];
+    this.__chain__ = !!chainAll;
+    this.__index__ = 0;
+    this.__values__ = void 0;
+  }
+  LodashWrapper.prototype = baseCreate(baseLodash.prototype);
+  LodashWrapper.prototype.constructor = LodashWrapper;
+  _LodashWrapper = LodashWrapper;
+  return _LodashWrapper;
+}
+export {
+  require_LodashWrapper as __require
+};

package/dist/.external/esm/lodash@4.17.21/lodash/_arrayEach.mjs

@@ -0,0 +1,20 @@
+var _arrayEach;
+var hasRequired_arrayEach;
+function require_arrayEach() {
+  if (hasRequired_arrayEach) return _arrayEach;
+  hasRequired_arrayEach = 1;
+  function arrayEach(array, iteratee) {
+    var index = -1, length = array == null ? 0 : array.length;
+    while (++index < length) {
+      if (iteratee(array[index], index, array) === false) {
+        break;
+      }
+    }
+    return array;
+  }
+  _arrayEach = arrayEach;
+  return _arrayEach;
+}
+export {
+  require_arrayEach as __require
+};

package/dist/.external/esm/lodash@4.17.21/lodash/_arrayFilter.mjs

@@ -0,0 +1,21 @@
+var _arrayFilter;
+var hasRequired_arrayFilter;
+function require_arrayFilter() {
+  if (hasRequired_arrayFilter) return _arrayFilter;
+  hasRequired_arrayFilter = 1;
+  function arrayFilter(array, predicate) {
+    var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+    while (++index < length) {
+      var value = array[index];
+      if (predicate(value, index, array)) {
+        result[resIndex++] = value;
+      }
+    }
+    return result;
+  }
+  _arrayFilter = arrayFilter;
+  return _arrayFilter;
+}
+export {
+  require_arrayFilter as __require
+};

package/dist/.external/esm/lodash@4.17.21/lodash/_arraySome.mjs

@@ -0,0 +1,20 @@
+var _arraySome;
+var hasRequired_arraySome;
+function require_arraySome() {
+  if (hasRequired_arraySome) return _arraySome;
+  hasRequired_arraySome = 1;
+  function arraySome(array, predicate) {
+    var index = -1, length = array == null ? 0 : array.length;
+    while (++index < length) {
+      if (predicate(array[index], index, array)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  _arraySome = arraySome;
+  return _arraySome;
+}
+export {
+  require_arraySome as __require
+};

package/dist/.external/esm/lodash@4.17.21/lodash/_baseAssign.mjs

@@ -0,0 +1,17 @@
+import { __require as require_copyObject } from "./_copyObject.mjs";
+import { __require as requireKeys } from "./keys.mjs";
+var _baseAssign;
+var hasRequired_baseAssign;
+function require_baseAssign() {
+  if (hasRequired_baseAssign) return _baseAssign;
+  hasRequired_baseAssign = 1;
+  var copyObject = require_copyObject(), keys = requireKeys();
+  function baseAssign(object, source) {
+    return object && copyObject(source, keys(source), object);
+  }
+  _baseAssign = baseAssign;
+  return _baseAssign;
+}
+export {
+  require_baseAssign as __require
+};

package/dist/.external/esm/lodash@4.17.21/lodash/_baseAssignIn.mjs

@@ -0,0 +1,17 @@
+import { __require as require_copyObject } from "./_copyObject.mjs";
+import { __require as requireKeysIn } from "./keysIn.mjs";
+var _baseAssignIn;
+var hasRequired_baseAssignIn;
+function require_baseAssignIn() {
+  if (hasRequired_baseAssignIn) return _baseAssignIn;
+  hasRequired_baseAssignIn = 1;
+  var copyObject = require_copyObject(), keysIn = requireKeysIn();
+  function baseAssignIn(object, source) {
+    return object && copyObject(source, keysIn(source), object);
+  }
+  _baseAssignIn = baseAssignIn;
+  return _baseAssignIn;
+}
+export {
+  require_baseAssignIn as __require
+};

package/dist/.external/esm/lodash@4.17.21/lodash/_baseClamp.mjs

@@ -0,0 +1,22 @@
+var _baseClamp;
+var hasRequired_baseClamp;
+function require_baseClamp() {
+  if (hasRequired_baseClamp) return _baseClamp;
+  hasRequired_baseClamp = 1;
+  function baseClamp(number, lower, upper) {
+    if (number === number) {
+      if (upper !== void 0) {
+        number = number <= upper ? number : upper;
+      }
+      if (lower !== void 0) {
+        number = number >= lower ? number : lower;
+      }
+    }
+    return number;
+  }
+  _baseClamp = baseClamp;
+  return _baseClamp;
+}
+export {
+  require_baseClamp as __require
+};