fastapi-rtk 2.0.1 → 2.0.3

package/dist/.external/cjs/lodash@4.17.23/lodash/_baseUnset.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _castPath = require("./_castPath.cjs");
+const last = require("./last.cjs");
+const _parent = require("./_parent.cjs");
+const _toKey = require("./_toKey.cjs");
+var _baseUnset;
+var hasRequired_baseUnset;
+function require_baseUnset() {
+  if (hasRequired_baseUnset) return _baseUnset;
+  hasRequired_baseUnset = 1;
+  var castPath = _castPath.__require(), last$1 = last.__require(), parent = _parent.__require(), toKey = _toKey.__require();
+  var objectProto = Object.prototype;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  function baseUnset(object, path) {
+    path = castPath(path, object);
+    var index = -1, length = path.length;
+    if (!length) {
+      return true;
+    }
+    var isRootPrimitive = object == null || typeof object !== "object" && typeof object !== "function";
+    while (++index < length) {
+      var key = path[index];
+      if (typeof key !== "string") {
+        continue;
+      }
+      if (key === "__proto__" && !hasOwnProperty.call(object, "__proto__")) {
+        return false;
+      }
+      if (key === "constructor" && index + 1 < length && typeof path[index + 1] === "string" && path[index + 1] === "prototype") {
+        if (isRootPrimitive && index === 0) {
+          continue;
+        }
+        return false;
+      }
+    }
+    var obj = parent(object, path);
+    return obj == null || delete obj[toKey(last$1(path))];
+  }
+  _baseUnset = baseUnset;
+  return _baseUnset;
+}
+exports.__require = require_baseUnset;

package/dist/.external/cjs/lodash@4.17.23/lodash/_cloneBuffer.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _cloneBuffer = require("../../../../jsonforms/cjs/_virtual/_cloneBuffer.cjs");
+const _root = require("./_root.cjs");
+_cloneBuffer.__module.exports;
+var hasRequired_cloneBuffer;
+function require_cloneBuffer() {
+  if (hasRequired_cloneBuffer) return _cloneBuffer.__module.exports;
+  hasRequired_cloneBuffer = 1;
+  (function(module2, exports$1) {
+    var root = _root.__require();
+    var freeExports = exports$1 && !exports$1.nodeType && exports$1;
+    var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var Buffer = moduleExports ? root.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+    function cloneBuffer(buffer, isDeep) {
+      if (isDeep) {
+        return buffer.slice();
+      }
+      var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+      buffer.copy(result);
+      return result;
+    }
+    module2.exports = cloneBuffer;
+  })(_cloneBuffer.__module, _cloneBuffer.__module.exports);
+  return _cloneBuffer.__module.exports;
+}
+exports.__require = require_cloneBuffer;

package/dist/.external/cjs/lodash@4.17.23/lodash/_nodeUtil.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _nodeUtil = require("../../../../jsonforms/cjs/_virtual/_nodeUtil.cjs");
+const _freeGlobal = require("./_freeGlobal.cjs");
+_nodeUtil.__module.exports;
+var hasRequired_nodeUtil;
+function require_nodeUtil() {
+  if (hasRequired_nodeUtil) return _nodeUtil.__module.exports;
+  hasRequired_nodeUtil = 1;
+  (function(module2, exports$1) {
+    var freeGlobal = _freeGlobal.__require();
+    var freeExports = exports$1 && !exports$1.nodeType && exports$1;
+    var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var freeProcess = moduleExports && freeGlobal.process;
+    var nodeUtil = (function() {
+      try {
+        var types = freeModule && freeModule.require && freeModule.require("util").types;
+        if (types) {
+          return types;
+        }
+        return freeProcess && freeProcess.binding && freeProcess.binding("util");
+      } catch (e) {
+      }
+    })();
+    module2.exports = nodeUtil;
+  })(_nodeUtil.__module, _nodeUtil.__module.exports);
+  return _nodeUtil.__module.exports;
+}
+exports.__require = require_nodeUtil;

package/dist/.external/cjs/lodash@4.17.23/lodash/fp/_mapping.cjs

@@ -0,0 +1,528 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _mapping = require("../../../../../.bundled/jsonforms/cjs/_virtual/_mapping.cjs");
+var hasRequired_mapping;
+function require_mapping() {
+  if (hasRequired_mapping) return _mapping.__exports;
+  hasRequired_mapping = 1;
+  (function(exports$1) {
+    exports$1.aliasToReal = {
+      // Lodash aliases.
+      "each": "forEach",
+      "eachRight": "forEachRight",
+      "entries": "toPairs",
+      "entriesIn": "toPairsIn",
+      "extend": "assignIn",
+      "extendAll": "assignInAll",
+      "extendAllWith": "assignInAllWith",
+      "extendWith": "assignInWith",
+      "first": "head",
+      // Methods that are curried variants of others.
+      "conforms": "conformsTo",
+      "matches": "isMatch",
+      "property": "get",
+      // Ramda aliases.
+      "__": "placeholder",
+      "F": "stubFalse",
+      "T": "stubTrue",
+      "all": "every",
+      "allPass": "overEvery",
+      "always": "constant",
+      "any": "some",
+      "anyPass": "overSome",
+      "apply": "spread",
+      "assoc": "set",
+      "assocPath": "set",
+      "complement": "negate",
+      "compose": "flowRight",
+      "contains": "includes",
+      "dissoc": "unset",
+      "dissocPath": "unset",
+      "dropLast": "dropRight",
+      "dropLastWhile": "dropRightWhile",
+      "equals": "isEqual",
+      "identical": "eq",
+      "indexBy": "keyBy",
+      "init": "initial",
+      "invertObj": "invert",
+      "juxt": "over",
+      "omitAll": "omit",
+      "nAry": "ary",
+      "path": "get",
+      "pathEq": "matchesProperty",
+      "pathOr": "getOr",
+      "paths": "at",
+      "pickAll": "pick",
+      "pipe": "flow",
+      "pluck": "map",
+      "prop": "get",
+      "propEq": "matchesProperty",
+      "propOr": "getOr",
+      "props": "at",
+      "symmetricDifference": "xor",
+      "symmetricDifferenceBy": "xorBy",
+      "symmetricDifferenceWith": "xorWith",
+      "takeLast": "takeRight",
+      "takeLastWhile": "takeRightWhile",
+      "unapply": "rest",
+      "unnest": "flatten",
+      "useWith": "overArgs",
+      "where": "conformsTo",
+      "whereEq": "isMatch",
+      "zipObj": "zipObject"
+    };
+    exports$1.aryMethod = {
+      "1": [
+        "assignAll",
+        "assignInAll",
+        "attempt",
+        "castArray",
+        "ceil",
+        "create",
+        "curry",
+        "curryRight",
+        "defaultsAll",
+        "defaultsDeepAll",
+        "floor",
+        "flow",
+        "flowRight",
+        "fromPairs",
+        "invert",
+        "iteratee",
+        "memoize",
+        "method",
+        "mergeAll",
+        "methodOf",
+        "mixin",
+        "nthArg",
+        "over",
+        "overEvery",
+        "overSome",
+        "rest",
+        "reverse",
+        "round",
+        "runInContext",
+        "spread",
+        "template",
+        "trim",
+        "trimEnd",
+        "trimStart",
+        "uniqueId",
+        "words",
+        "zipAll"
+      ],
+      "2": [
+        "add",
+        "after",
+        "ary",
+        "assign",
+        "assignAllWith",
+        "assignIn",
+        "assignInAllWith",
+        "at",
+        "before",
+        "bind",
+        "bindAll",
+        "bindKey",
+        "chunk",
+        "cloneDeepWith",
+        "cloneWith",
+        "concat",
+        "conformsTo",
+        "countBy",
+        "curryN",
+        "curryRightN",
+        "debounce",
+        "defaults",
+        "defaultsDeep",
+        "defaultTo",
+        "delay",
+        "difference",
+        "divide",
+        "drop",
+        "dropRight",
+        "dropRightWhile",
+        "dropWhile",
+        "endsWith",
+        "eq",
+        "every",
+        "filter",
+        "find",
+        "findIndex",
+        "findKey",
+        "findLast",
+        "findLastIndex",
+        "findLastKey",
+        "flatMap",
+        "flatMapDeep",
+        "flattenDepth",
+        "forEach",
+        "forEachRight",
+        "forIn",
+        "forInRight",
+        "forOwn",
+        "forOwnRight",
+        "get",
+        "groupBy",
+        "gt",
+        "gte",
+        "has",
+        "hasIn",
+        "includes",
+        "indexOf",
+        "intersection",
+        "invertBy",
+        "invoke",
+        "invokeMap",
+        "isEqual",
+        "isMatch",
+        "join",
+        "keyBy",
+        "lastIndexOf",
+        "lt",
+        "lte",
+        "map",
+        "mapKeys",
+        "mapValues",
+        "matchesProperty",
+        "maxBy",
+        "meanBy",
+        "merge",
+        "mergeAllWith",
+        "minBy",
+        "multiply",
+        "nth",
+        "omit",
+        "omitBy",
+        "overArgs",
+        "pad",
+        "padEnd",
+        "padStart",
+        "parseInt",
+        "partial",
+        "partialRight",
+        "partition",
+        "pick",
+        "pickBy",
+        "propertyOf",
+        "pull",
+        "pullAll",
+        "pullAt",
+        "random",
+        "range",
+        "rangeRight",
+        "rearg",
+        "reject",
+        "remove",
+        "repeat",
+        "restFrom",
+        "result",
+        "sampleSize",
+        "some",
+        "sortBy",
+        "sortedIndex",
+        "sortedIndexOf",
+        "sortedLastIndex",
+        "sortedLastIndexOf",
+        "sortedUniqBy",
+        "split",
+        "spreadFrom",
+        "startsWith",
+        "subtract",
+        "sumBy",
+        "take",
+        "takeRight",
+        "takeRightWhile",
+        "takeWhile",
+        "tap",
+        "throttle",
+        "thru",
+        "times",
+        "trimChars",
+        "trimCharsEnd",
+        "trimCharsStart",
+        "truncate",
+        "union",
+        "uniqBy",
+        "uniqWith",
+        "unset",
+        "unzipWith",
+        "without",
+        "wrap",
+        "xor",
+        "zip",
+        "zipObject",
+        "zipObjectDeep"
+      ],
+      "3": [
+        "assignInWith",
+        "assignWith",
+        "clamp",
+        "differenceBy",
+        "differenceWith",
+        "findFrom",
+        "findIndexFrom",
+        "findLastFrom",
+        "findLastIndexFrom",
+        "getOr",
+        "includesFrom",
+        "indexOfFrom",
+        "inRange",
+        "intersectionBy",
+        "intersectionWith",
+        "invokeArgs",
+        "invokeArgsMap",
+        "isEqualWith",
+        "isMatchWith",
+        "flatMapDepth",
+        "lastIndexOfFrom",
+        "mergeWith",
+        "orderBy",
+        "padChars",
+        "padCharsEnd",
+        "padCharsStart",
+        "pullAllBy",
+        "pullAllWith",
+        "rangeStep",
+        "rangeStepRight",
+        "reduce",
+        "reduceRight",
+        "replace",
+        "set",
+        "slice",
+        "sortedIndexBy",
+        "sortedLastIndexBy",
+        "transform",
+        "unionBy",
+        "unionWith",
+        "update",
+        "xorBy",
+        "xorWith",
+        "zipWith"
+      ],
+      "4": [
+        "fill",
+        "setWith",
+        "updateWith"
+      ]
+    };
+    exports$1.aryRearg = {
+      "2": [1, 0],
+      "3": [2, 0, 1],
+      "4": [3, 2, 0, 1]
+    };
+    exports$1.iterateeAry = {
+      "dropRightWhile": 1,
+      "dropWhile": 1,
+      "every": 1,
+      "filter": 1,
+      "find": 1,
+      "findFrom": 1,
+      "findIndex": 1,
+      "findIndexFrom": 1,
+      "findKey": 1,
+      "findLast": 1,
+      "findLastFrom": 1,
+      "findLastIndex": 1,
+      "findLastIndexFrom": 1,
+      "findLastKey": 1,
+      "flatMap": 1,
+      "flatMapDeep": 1,
+      "flatMapDepth": 1,
+      "forEach": 1,
+      "forEachRight": 1,
+      "forIn": 1,
+      "forInRight": 1,
+      "forOwn": 1,
+      "forOwnRight": 1,
+      "map": 1,
+      "mapKeys": 1,
+      "mapValues": 1,
+      "partition": 1,
+      "reduce": 2,
+      "reduceRight": 2,
+      "reject": 1,
+      "remove": 1,
+      "some": 1,
+      "takeRightWhile": 1,
+      "takeWhile": 1,
+      "times": 1,
+      "transform": 2
+    };
+    exports$1.iterateeRearg = {
+      "mapKeys": [1],
+      "reduceRight": [1, 0]
+    };
+    exports$1.methodRearg = {
+      "assignInAllWith": [1, 0],
+      "assignInWith": [1, 2, 0],
+      "assignAllWith": [1, 0],
+      "assignWith": [1, 2, 0],
+      "differenceBy": [1, 2, 0],
+      "differenceWith": [1, 2, 0],
+      "getOr": [2, 1, 0],
+      "intersectionBy": [1, 2, 0],
+      "intersectionWith": [1, 2, 0],
+      "isEqualWith": [1, 2, 0],
+      "isMatchWith": [2, 1, 0],
+      "mergeAllWith": [1, 0],
+      "mergeWith": [1, 2, 0],
+      "padChars": [2, 1, 0],
+      "padCharsEnd": [2, 1, 0],
+      "padCharsStart": [2, 1, 0],
+      "pullAllBy": [2, 1, 0],
+      "pullAllWith": [2, 1, 0],
+      "rangeStep": [1, 2, 0],
+      "rangeStepRight": [1, 2, 0],
+      "setWith": [3, 1, 2, 0],
+      "sortedIndexBy": [2, 1, 0],
+      "sortedLastIndexBy": [2, 1, 0],
+      "unionBy": [1, 2, 0],
+      "unionWith": [1, 2, 0],
+      "updateWith": [3, 1, 2, 0],
+      "xorBy": [1, 2, 0],
+      "xorWith": [1, 2, 0],
+      "zipWith": [1, 2, 0]
+    };
+    exports$1.methodSpread = {
+      "assignAll": { "start": 0 },
+      "assignAllWith": { "start": 0 },
+      "assignInAll": { "start": 0 },
+      "assignInAllWith": { "start": 0 },
+      "defaultsAll": { "start": 0 },
+      "defaultsDeepAll": { "start": 0 },
+      "invokeArgs": { "start": 2 },
+      "invokeArgsMap": { "start": 2 },
+      "mergeAll": { "start": 0 },
+      "mergeAllWith": { "start": 0 },
+      "partial": { "start": 1 },
+      "partialRight": { "start": 1 },
+      "without": { "start": 1 },
+      "zipAll": { "start": 0 }
+    };
+    exports$1.mutate = {
+      "array": {
+        "fill": true,
+        "pull": true,
+        "pullAll": true,
+        "pullAllBy": true,
+        "pullAllWith": true,
+        "pullAt": true,
+        "remove": true,
+        "reverse": true
+      },
+      "object": {
+        "assign": true,
+        "assignAll": true,
+        "assignAllWith": true,
+        "assignIn": true,
+        "assignInAll": true,
+        "assignInAllWith": true,
+        "assignInWith": true,
+        "assignWith": true,
+        "defaults": true,
+        "defaultsAll": true,
+        "defaultsDeep": true,
+        "defaultsDeepAll": true,
+        "merge": true,
+        "mergeAll": true,
+        "mergeAllWith": true,
+        "mergeWith": true
+      },
+      "set": {
+        "set": true,
+        "setWith": true,
+        "unset": true,
+        "update": true,
+        "updateWith": true
+      }
+    };
+    exports$1.realToAlias = (function() {
+      var hasOwnProperty = Object.prototype.hasOwnProperty, object = exports$1.aliasToReal, result = {};
+      for (var key in object) {
+        var value = object[key];
+        if (hasOwnProperty.call(result, value)) {
+          result[value].push(key);
+        } else {
+          result[value] = [key];
+        }
+      }
+      return result;
+    })();
+    exports$1.remap = {
+      "assignAll": "assign",
+      "assignAllWith": "assignWith",
+      "assignInAll": "assignIn",
+      "assignInAllWith": "assignInWith",
+      "curryN": "curry",
+      "curryRightN": "curryRight",
+      "defaultsAll": "defaults",
+      "defaultsDeepAll": "defaultsDeep",
+      "findFrom": "find",
+      "findIndexFrom": "findIndex",
+      "findLastFrom": "findLast",
+      "findLastIndexFrom": "findLastIndex",
+      "getOr": "get",
+      "includesFrom": "includes",
+      "indexOfFrom": "indexOf",
+      "invokeArgs": "invoke",
+      "invokeArgsMap": "invokeMap",
+      "lastIndexOfFrom": "lastIndexOf",
+      "mergeAll": "merge",
+      "mergeAllWith": "mergeWith",
+      "padChars": "pad",
+      "padCharsEnd": "padEnd",
+      "padCharsStart": "padStart",
+      "propertyOf": "get",
+      "rangeStep": "range",
+      "rangeStepRight": "rangeRight",
+      "restFrom": "rest",
+      "spreadFrom": "spread",
+      "trimChars": "trim",
+      "trimCharsEnd": "trimEnd",
+      "trimCharsStart": "trimStart",
+      "zipAll": "zip"
+    };
+    exports$1.skipFixed = {
+      "castArray": true,
+      "flow": true,
+      "flowRight": true,
+      "iteratee": true,
+      "mixin": true,
+      "rearg": true,
+      "runInContext": true
+    };
+    exports$1.skipRearg = {
+      "add": true,
+      "assign": true,
+      "assignIn": true,
+      "bind": true,
+      "bindKey": true,
+      "concat": true,
+      "difference": true,
+      "divide": true,
+      "eq": true,
+      "gt": true,
+      "gte": true,
+      "isEqual": true,
+      "lt": true,
+      "lte": true,
+      "matchesProperty": true,
+      "merge": true,
+      "multiply": true,
+      "overArgs": true,
+      "partial": true,
+      "partialRight": true,
+      "propertyOf": true,
+      "random": true,
+      "range": true,
+      "rangeRight": true,
+      "subtract": true,
+      "zip": true,
+      "zipObject": true,
+      "zipObjectDeep": true
+    };
+  })(_mapping.__exports);
+  return _mapping.__exports;
+}
+exports.__require = require_mapping;

package/dist/.external/cjs/lodash@4.17.23/lodash/isBuffer.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isBuffer = require("../../../../jsonforms/cjs/_virtual/isBuffer.cjs");
+const _root = require("./_root.cjs");
+const stubFalse = require("./stubFalse.cjs");
+isBuffer.__module.exports;
+var hasRequiredIsBuffer;
+function requireIsBuffer() {
+  if (hasRequiredIsBuffer) return isBuffer.__module.exports;
+  hasRequiredIsBuffer = 1;
+  (function(module2, exports$1) {
+    var root = _root.__require(), stubFalse$1 = stubFalse.__require();
+    var freeExports = exports$1 && !exports$1.nodeType && exports$1;
+    var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var Buffer = moduleExports ? root.Buffer : void 0;
+    var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+    var isBuffer2 = nativeIsBuffer || stubFalse$1;
+    module2.exports = isBuffer2;
+  })(isBuffer.__module, isBuffer.__module.exports);
+  return isBuffer.__module.exports;
+}
+exports.__require = requireIsBuffer;