fastapi-rtk 0.1.13 → 0.1.15

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

@@ -0,0 +1,20 @@
+import { __require as require_coreJsData } from "./_coreJsData.mjs";
+var _isMasked;
+var hasRequired_isMasked;
+function require_isMasked() {
+  if (hasRequired_isMasked) return _isMasked;
+  hasRequired_isMasked = 1;
+  var coreJsData = require_coreJsData();
+  var maskSrcKey = function() {
+    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+    return uid ? "Symbol(src)_1." + uid : "";
+  }();
+  function isMasked(func) {
+    return !!maskSrcKey && maskSrcKey in func;
+  }
+  _isMasked = isMasked;
+  return _isMasked;
+}
+export {
+  require_isMasked as __require
+};

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

@@ -0,0 +1,16 @@
+var _isPrototype;
+var hasRequired_isPrototype;
+function require_isPrototype() {
+  if (hasRequired_isPrototype) return _isPrototype;
+  hasRequired_isPrototype = 1;
+  var objectProto = Object.prototype;
+  function isPrototype(value) {
+    var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+    return value === proto;
+  }
+  _isPrototype = isPrototype;
+  return _isPrototype;
+}
+export {
+  require_isPrototype as __require
+};

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

@@ -0,0 +1,16 @@
+import { __require as requireIsObject } from "./isObject.mjs";
+var _isStrictComparable;
+var hasRequired_isStrictComparable;
+function require_isStrictComparable() {
+  if (hasRequired_isStrictComparable) return _isStrictComparable;
+  hasRequired_isStrictComparable = 1;
+  var isObject = requireIsObject();
+  function isStrictComparable(value) {
+    return value === value && !isObject(value);
+  }
+  _isStrictComparable = isStrictComparable;
+  return _isStrictComparable;
+}
+export {
+  require_isStrictComparable as __require
+};

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

@@ -0,0 +1,15 @@
+var _listCacheClear;
+var hasRequired_listCacheClear;
+function require_listCacheClear() {
+  if (hasRequired_listCacheClear) return _listCacheClear;
+  hasRequired_listCacheClear = 1;
+  function listCacheClear() {
+    this.__data__ = [];
+    this.size = 0;
+  }
+  _listCacheClear = listCacheClear;
+  return _listCacheClear;
+}
+export {
+  require_listCacheClear as __require
+};

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

@@ -0,0 +1,29 @@
+import { __require as require_assocIndexOf } from "./_assocIndexOf.mjs";
+var _listCacheDelete;
+var hasRequired_listCacheDelete;
+function require_listCacheDelete() {
+  if (hasRequired_listCacheDelete) return _listCacheDelete;
+  hasRequired_listCacheDelete = 1;
+  var assocIndexOf = require_assocIndexOf();
+  var arrayProto = Array.prototype;
+  var splice = arrayProto.splice;
+  function listCacheDelete(key) {
+    var data = this.__data__, index = assocIndexOf(data, key);
+    if (index < 0) {
+      return false;
+    }
+    var lastIndex = data.length - 1;
+    if (index == lastIndex) {
+      data.pop();
+    } else {
+      splice.call(data, index, 1);
+    }
+    --this.size;
+    return true;
+  }
+  _listCacheDelete = listCacheDelete;
+  return _listCacheDelete;
+}
+export {
+  require_listCacheDelete as __require
+};

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

@@ -0,0 +1,17 @@
+import { __require as require_assocIndexOf } from "./_assocIndexOf.mjs";
+var _listCacheGet;
+var hasRequired_listCacheGet;
+function require_listCacheGet() {
+  if (hasRequired_listCacheGet) return _listCacheGet;
+  hasRequired_listCacheGet = 1;
+  var assocIndexOf = require_assocIndexOf();
+  function listCacheGet(key) {
+    var data = this.__data__, index = assocIndexOf(data, key);
+    return index < 0 ? void 0 : data[index][1];
+  }
+  _listCacheGet = listCacheGet;
+  return _listCacheGet;
+}
+export {
+  require_listCacheGet as __require
+};

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

@@ -0,0 +1,16 @@
+import { __require as require_assocIndexOf } from "./_assocIndexOf.mjs";
+var _listCacheHas;
+var hasRequired_listCacheHas;
+function require_listCacheHas() {
+  if (hasRequired_listCacheHas) return _listCacheHas;
+  hasRequired_listCacheHas = 1;
+  var assocIndexOf = require_assocIndexOf();
+  function listCacheHas(key) {
+    return assocIndexOf(this.__data__, key) > -1;
+  }
+  _listCacheHas = listCacheHas;
+  return _listCacheHas;
+}
+export {
+  require_listCacheHas as __require
+};

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

@@ -0,0 +1,23 @@
+import { __require as require_assocIndexOf } from "./_assocIndexOf.mjs";
+var _listCacheSet;
+var hasRequired_listCacheSet;
+function require_listCacheSet() {
+  if (hasRequired_listCacheSet) return _listCacheSet;
+  hasRequired_listCacheSet = 1;
+  var assocIndexOf = require_assocIndexOf();
+  function listCacheSet(key, value) {
+    var data = this.__data__, index = assocIndexOf(data, key);
+    if (index < 0) {
+      ++this.size;
+      data.push([key, value]);
+    } else {
+      data[index][1] = value;
+    }
+    return this;
+  }
+  _listCacheSet = listCacheSet;
+  return _listCacheSet;
+}
+export {
+  require_listCacheSet as __require
+};

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

@@ -0,0 +1,23 @@
+import { __require as require_Hash } from "./_Hash.mjs";
+import { __require as require_ListCache } from "./_ListCache.mjs";
+import { __require as require_Map } from "./_Map.mjs";
+var _mapCacheClear;
+var hasRequired_mapCacheClear;
+function require_mapCacheClear() {
+  if (hasRequired_mapCacheClear) return _mapCacheClear;
+  hasRequired_mapCacheClear = 1;
+  var Hash = require_Hash(), ListCache = require_ListCache(), Map = require_Map();
+  function mapCacheClear() {
+    this.size = 0;
+    this.__data__ = {
+      "hash": new Hash(),
+      "map": new (Map || ListCache)(),
+      "string": new Hash()
+    };
+  }
+  _mapCacheClear = mapCacheClear;
+  return _mapCacheClear;
+}
+export {
+  require_mapCacheClear as __require
+};

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

@@ -0,0 +1,18 @@
+import { __require as require_getMapData } from "./_getMapData.mjs";
+var _mapCacheDelete;
+var hasRequired_mapCacheDelete;
+function require_mapCacheDelete() {
+  if (hasRequired_mapCacheDelete) return _mapCacheDelete;
+  hasRequired_mapCacheDelete = 1;
+  var getMapData = require_getMapData();
+  function mapCacheDelete(key) {
+    var result = getMapData(this, key)["delete"](key);
+    this.size -= result ? 1 : 0;
+    return result;
+  }
+  _mapCacheDelete = mapCacheDelete;
+  return _mapCacheDelete;
+}
+export {
+  require_mapCacheDelete as __require
+};

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

@@ -0,0 +1,16 @@
+import { __require as require_getMapData } from "./_getMapData.mjs";
+var _mapCacheGet;
+var hasRequired_mapCacheGet;
+function require_mapCacheGet() {
+  if (hasRequired_mapCacheGet) return _mapCacheGet;
+  hasRequired_mapCacheGet = 1;
+  var getMapData = require_getMapData();
+  function mapCacheGet(key) {
+    return getMapData(this, key).get(key);
+  }
+  _mapCacheGet = mapCacheGet;
+  return _mapCacheGet;
+}
+export {
+  require_mapCacheGet as __require
+};

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

@@ -0,0 +1,16 @@
+import { __require as require_getMapData } from "./_getMapData.mjs";
+var _mapCacheHas;
+var hasRequired_mapCacheHas;
+function require_mapCacheHas() {
+  if (hasRequired_mapCacheHas) return _mapCacheHas;
+  hasRequired_mapCacheHas = 1;
+  var getMapData = require_getMapData();
+  function mapCacheHas(key) {
+    return getMapData(this, key).has(key);
+  }
+  _mapCacheHas = mapCacheHas;
+  return _mapCacheHas;
+}
+export {
+  require_mapCacheHas as __require
+};

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

@@ -0,0 +1,19 @@
+import { __require as require_getMapData } from "./_getMapData.mjs";
+var _mapCacheSet;
+var hasRequired_mapCacheSet;
+function require_mapCacheSet() {
+  if (hasRequired_mapCacheSet) return _mapCacheSet;
+  hasRequired_mapCacheSet = 1;
+  var getMapData = require_getMapData();
+  function mapCacheSet(key, value) {
+    var data = getMapData(this, key), size = data.size;
+    data.set(key, value);
+    this.size += data.size == size ? 0 : 1;
+    return this;
+  }
+  _mapCacheSet = mapCacheSet;
+  return _mapCacheSet;
+}
+export {
+  require_mapCacheSet as __require
+};

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

@@ -0,0 +1,18 @@
+var _mapToArray;
+var hasRequired_mapToArray;
+function require_mapToArray() {
+  if (hasRequired_mapToArray) return _mapToArray;
+  hasRequired_mapToArray = 1;
+  function mapToArray(map) {
+    var index = -1, result = Array(map.size);
+    map.forEach(function(value, key) {
+      result[++index] = [key, value];
+    });
+    return result;
+  }
+  _mapToArray = mapToArray;
+  return _mapToArray;
+}
+export {
+  require_mapToArray as __require
+};

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

@@ -0,0 +1,19 @@
+var _matchesStrictComparable;
+var hasRequired_matchesStrictComparable;
+function require_matchesStrictComparable() {
+  if (hasRequired_matchesStrictComparable) return _matchesStrictComparable;
+  hasRequired_matchesStrictComparable = 1;
+  function matchesStrictComparable(key, srcValue) {
+    return function(object) {
+      if (object == null) {
+        return false;
+      }
+      return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+    };
+  }
+  _matchesStrictComparable = matchesStrictComparable;
+  return _matchesStrictComparable;
+}
+export {
+  require_matchesStrictComparable as __require
+};

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

@@ -0,0 +1,24 @@
+import { __require as requireMemoize } from "./memoize.mjs";
+var _memoizeCapped;
+var hasRequired_memoizeCapped;
+function require_memoizeCapped() {
+  if (hasRequired_memoizeCapped) return _memoizeCapped;
+  hasRequired_memoizeCapped = 1;
+  var memoize = requireMemoize();
+  var MAX_MEMOIZE_SIZE = 500;
+  function memoizeCapped(func) {
+    var result = memoize(func, function(key) {
+      if (cache.size === MAX_MEMOIZE_SIZE) {
+        cache.clear();
+      }
+      return key;
+    });
+    var cache = result.cache;
+    return result;
+  }
+  _memoizeCapped = memoizeCapped;
+  return _memoizeCapped;
+}
+export {
+  require_memoizeCapped as __require
+};

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

@@ -0,0 +1,54 @@
+import { __require as require_composeArgs } from "./_composeArgs.mjs";
+import { __require as require_composeArgsRight } from "./_composeArgsRight.mjs";
+import { __require as require_replaceHolders } from "./_replaceHolders.mjs";
+var _mergeData;
+var hasRequired_mergeData;
+function require_mergeData() {
+  if (hasRequired_mergeData) return _mergeData;
+  hasRequired_mergeData = 1;
+  var composeArgs = require_composeArgs(), composeArgsRight = require_composeArgsRight(), replaceHolders = require_replaceHolders();
+  var PLACEHOLDER = "__lodash_placeholder__";
+  var WRAP_BIND_FLAG = 1, WRAP_BIND_KEY_FLAG = 2, WRAP_CURRY_BOUND_FLAG = 4, WRAP_CURRY_FLAG = 8, WRAP_ARY_FLAG = 128, WRAP_REARG_FLAG = 256;
+  var nativeMin = Math.min;
+  function mergeData(data, source) {
+    var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
+    var isCombo = srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG || srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_REARG_FLAG && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG;
+    if (!(isCommon || isCombo)) {
+      return data;
+    }
+    if (srcBitmask & WRAP_BIND_FLAG) {
+      data[2] = source[2];
+      newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
+    }
+    var value = source[3];
+    if (value) {
+      var partials = data[3];
+      data[3] = partials ? composeArgs(partials, value, source[4]) : value;
+      data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
+    }
+    value = source[5];
+    if (value) {
+      partials = data[5];
+      data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
+      data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
+    }
+    value = source[7];
+    if (value) {
+      data[7] = value;
+    }
+    if (srcBitmask & WRAP_ARY_FLAG) {
+      data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
+    }
+    if (data[9] == null) {
+      data[9] = source[9];
+    }
+    data[0] = source[0];
+    data[1] = newBitmask;
+    return data;
+  }
+  _mergeData = mergeData;
+  return _mergeData;
+}
+export {
+  require_mergeData as __require
+};

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

@@ -0,0 +1,14 @@
+import { __require as require_WeakMap } from "./_WeakMap.mjs";
+var _metaMap;
+var hasRequired_metaMap;
+function require_metaMap() {
+  if (hasRequired_metaMap) return _metaMap;
+  hasRequired_metaMap = 1;
+  var WeakMap = require_WeakMap();
+  var metaMap = WeakMap && new WeakMap();
+  _metaMap = metaMap;
+  return _metaMap;
+}
+export {
+  require_metaMap as __require
+};

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

@@ -0,0 +1,14 @@
+import { __require as require_getNative } from "./_getNative.mjs";
+var _nativeCreate;
+var hasRequired_nativeCreate;
+function require_nativeCreate() {
+  if (hasRequired_nativeCreate) return _nativeCreate;
+  hasRequired_nativeCreate = 1;
+  var getNative = require_getNative();
+  var nativeCreate = getNative(Object, "create");
+  _nativeCreate = nativeCreate;
+  return _nativeCreate;
+}
+export {
+  require_nativeCreate as __require
+};

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

@@ -0,0 +1,14 @@
+import { __require as require_overArg } from "./_overArg.mjs";
+var _nativeKeys;
+var hasRequired_nativeKeys;
+function require_nativeKeys() {
+  if (hasRequired_nativeKeys) return _nativeKeys;
+  hasRequired_nativeKeys = 1;
+  var overArg = require_overArg();
+  var nativeKeys = overArg(Object.keys, Object);
+  _nativeKeys = nativeKeys;
+  return _nativeKeys;
+}
+export {
+  require_nativeKeys as __require
+};

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

@@ -0,0 +1,20 @@
+var _nativeKeysIn;
+var hasRequired_nativeKeysIn;
+function require_nativeKeysIn() {
+  if (hasRequired_nativeKeysIn) return _nativeKeysIn;
+  hasRequired_nativeKeysIn = 1;
+  function nativeKeysIn(object) {
+    var result = [];
+    if (object != null) {
+      for (var key in Object(object)) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+  _nativeKeysIn = nativeKeysIn;
+  return _nativeKeysIn;
+}
+export {
+  require_nativeKeysIn as __require
+};

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

@@ -0,0 +1,30 @@
+import { __module as _nodeUtil } from "../../../../jsonforms/esm/_virtual/_nodeUtil.mjs";
+import { __require as require_freeGlobal } from "./_freeGlobal.mjs";
+_nodeUtil.exports;
+var hasRequired_nodeUtil;
+function require_nodeUtil() {
+  if (hasRequired_nodeUtil) return _nodeUtil.exports;
+  hasRequired_nodeUtil = 1;
+  (function(module, exports) {
+    var freeGlobal = require_freeGlobal();
+    var freeExports = exports && !exports.nodeType && exports;
+    var freeModule = freeExports && true && module && !module.nodeType && module;
+    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) {
+      }
+    }();
+    module.exports = nodeUtil;
+  })(_nodeUtil, _nodeUtil.exports);
+  return _nodeUtil.exports;
+}
+export {
+  require_nodeUtil as __require
+};

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

@@ -0,0 +1,16 @@
+var _objectToString;
+var hasRequired_objectToString;
+function require_objectToString() {
+  if (hasRequired_objectToString) return _objectToString;
+  hasRequired_objectToString = 1;
+  var objectProto = Object.prototype;
+  var nativeObjectToString = objectProto.toString;
+  function objectToString(value) {
+    return nativeObjectToString.call(value);
+  }
+  _objectToString = objectToString;
+  return _objectToString;
+}
+export {
+  require_objectToString as __require
+};

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

@@ -0,0 +1,16 @@
+var _overArg;
+var hasRequired_overArg;
+function require_overArg() {
+  if (hasRequired_overArg) return _overArg;
+  hasRequired_overArg = 1;
+  function overArg(func, transform) {
+    return function(arg) {
+      return func(transform(arg));
+    };
+  }
+  _overArg = overArg;
+  return _overArg;
+}
+export {
+  require_overArg as __require
+};

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

@@ -0,0 +1,30 @@
+import { __require as require_apply } from "./_apply.mjs";
+var _overRest;
+var hasRequired_overRest;
+function require_overRest() {
+  if (hasRequired_overRest) return _overRest;
+  hasRequired_overRest = 1;
+  var apply = require_apply();
+  var nativeMax = Math.max;
+  function overRest(func, start, transform) {
+    start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+    return function() {
+      var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+      while (++index < length) {
+        array[index] = args[start + index];
+      }
+      index = -1;
+      var otherArgs = Array(start + 1);
+      while (++index < start) {
+        otherArgs[index] = args[index];
+      }
+      otherArgs[start] = transform(array);
+      return apply(func, this, otherArgs);
+    };
+  }
+  _overRest = overRest;
+  return _overRest;
+}
+export {
+  require_overRest as __require
+};

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

@@ -0,0 +1,17 @@
+import { __require as require_baseGet } from "./_baseGet.mjs";
+import { __require as require_baseSlice } from "./_baseSlice.mjs";
+var _parent;
+var hasRequired_parent;
+function require_parent() {
+  if (hasRequired_parent) return _parent;
+  hasRequired_parent = 1;
+  var baseGet = require_baseGet(), baseSlice = require_baseSlice();
+  function parent(object, path) {
+    return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
+  }
+  _parent = parent;
+  return _parent;
+}
+export {
+  require_parent as __require
+};

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

@@ -0,0 +1,12 @@
+var _realNames;
+var hasRequired_realNames;
+function require_realNames() {
+  if (hasRequired_realNames) return _realNames;
+  hasRequired_realNames = 1;
+  var realNames = {};
+  _realNames = realNames;
+  return _realNames;
+}
+export {
+  require_realNames as __require
+};

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

@@ -0,0 +1,23 @@
+import { __require as require_copyArray } from "./_copyArray.mjs";
+import { __require as require_isIndex } from "./_isIndex.mjs";
+var _reorder;
+var hasRequired_reorder;
+function require_reorder() {
+  if (hasRequired_reorder) return _reorder;
+  hasRequired_reorder = 1;
+  var copyArray = require_copyArray(), isIndex = require_isIndex();
+  var nativeMin = Math.min;
+  function reorder(array, indexes) {
+    var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array);
+    while (length--) {
+      var index = indexes[length];
+      array[length] = isIndex(index, arrLength) ? oldArray[index] : void 0;
+    }
+    return array;
+  }
+  _reorder = reorder;
+  return _reorder;
+}
+export {
+  require_reorder as __require
+};

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

@@ -0,0 +1,23 @@
+var _replaceHolders;
+var hasRequired_replaceHolders;
+function require_replaceHolders() {
+  if (hasRequired_replaceHolders) return _replaceHolders;
+  hasRequired_replaceHolders = 1;
+  var PLACEHOLDER = "__lodash_placeholder__";
+  function replaceHolders(array, placeholder) {
+    var index = -1, length = array.length, resIndex = 0, result = [];
+    while (++index < length) {
+      var value = array[index];
+      if (value === placeholder || value === PLACEHOLDER) {
+        array[index] = PLACEHOLDER;
+        result[resIndex++] = index;
+      }
+    }
+    return result;
+  }
+  _replaceHolders = replaceHolders;
+  return _replaceHolders;
+}
+export {
+  require_replaceHolders as __require
+};

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

@@ -0,0 +1,15 @@
+import { __require as require_freeGlobal } from "./_freeGlobal.mjs";
+var _root;
+var hasRequired_root;
+function require_root() {
+  if (hasRequired_root) return _root;
+  hasRequired_root = 1;
+  var freeGlobal = require_freeGlobal();
+  var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+  var root = freeGlobal || freeSelf || Function("return this")();
+  _root = root;
+  return _root;
+}
+export {
+  require_root as __require
+};

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

@@ -0,0 +1,20 @@
+var _safeGet;
+var hasRequired_safeGet;
+function require_safeGet() {
+  if (hasRequired_safeGet) return _safeGet;
+  hasRequired_safeGet = 1;
+  function safeGet(object, key) {
+    if (key === "constructor" && typeof object[key] === "function") {
+      return;
+    }
+    if (key == "__proto__") {
+      return;
+    }
+    return object[key];
+  }
+  _safeGet = safeGet;
+  return _safeGet;
+}
+export {
+  require_safeGet as __require
+};