fastapi-rtk 0.1.14 → 0.1.16

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

@@ -0,0 +1,25 @@
+import { __require as requireIsArray } from "./isArray.mjs";
+import { __require as requireIsSymbol } from "./isSymbol.mjs";
+var _isKey;
+var hasRequired_isKey;
+function require_isKey() {
+  if (hasRequired_isKey) return _isKey;
+  hasRequired_isKey = 1;
+  var isArray = requireIsArray(), isSymbol = requireIsSymbol();
+  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+  function isKey(value, object) {
+    if (isArray(value)) {
+      return false;
+    }
+    var type = typeof value;
+    if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
+      return true;
+    }
+    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+  }
+  _isKey = isKey;
+  return _isKey;
+}
+export {
+  require_isKey as __require
+};

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

@@ -0,0 +1,27 @@
+import { __require as require_LazyWrapper } from "./_LazyWrapper.mjs";
+import { __require as require_getData } from "./_getData.mjs";
+import { __require as require_getFuncName } from "./_getFuncName.mjs";
+import { __require as requireWrapperLodash } from "./wrapperLodash.mjs";
+var _isLaziable;
+var hasRequired_isLaziable;
+function require_isLaziable() {
+  if (hasRequired_isLaziable) return _isLaziable;
+  hasRequired_isLaziable = 1;
+  var LazyWrapper = require_LazyWrapper(), getData = require_getData(), getFuncName = require_getFuncName(), lodash = requireWrapperLodash();
+  function isLaziable(func) {
+    var funcName = getFuncName(func), other = lodash[funcName];
+    if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) {
+      return false;
+    }
+    if (func === other) {
+      return true;
+    }
+    var data = getData(other);
+    return !!data && func === data[0];
+  }
+  _isLaziable = isLaziable;
+  return _isLaziable;
+}
+export {
+  require_isLaziable 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/_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/_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/_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/_setData.mjs

@@ -0,0 +1,15 @@
+import { __require as require_baseSetData } from "./_baseSetData.mjs";
+import { __require as require_shortOut } from "./_shortOut.mjs";
+var _setData;
+var hasRequired_setData;
+function require_setData() {
+  if (hasRequired_setData) return _setData;
+  hasRequired_setData = 1;
+  var baseSetData = require_baseSetData(), shortOut = require_shortOut();
+  var setData = shortOut(baseSetData);
+  _setData = setData;
+  return _setData;
+}
+export {
+  require_setData as __require
+};

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

@@ -0,0 +1,18 @@
+var _setToPairs;
+var hasRequired_setToPairs;
+function require_setToPairs() {
+  if (hasRequired_setToPairs) return _setToPairs;
+  hasRequired_setToPairs = 1;
+  function setToPairs(set) {
+    var index = -1, result = Array(set.size);
+    set.forEach(function(value) {
+      result[++index] = [value, value];
+    });
+    return result;
+  }
+  _setToPairs = setToPairs;
+  return _setToPairs;
+}
+export {
+  require_setToPairs as __require
+};

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

@@ -0,0 +1,20 @@
+import { __require as require_getWrapDetails } from "./_getWrapDetails.mjs";
+import { __require as require_insertWrapDetails } from "./_insertWrapDetails.mjs";
+import { __require as require_setToString } from "./_setToString.mjs";
+import { __require as require_updateWrapDetails } from "./_updateWrapDetails.mjs";
+var _setWrapToString;
+var hasRequired_setWrapToString;
+function require_setWrapToString() {
+  if (hasRequired_setWrapToString) return _setWrapToString;
+  hasRequired_setWrapToString = 1;
+  var getWrapDetails = require_getWrapDetails(), insertWrapDetails = require_insertWrapDetails(), setToString = require_setToString(), updateWrapDetails = require_updateWrapDetails();
+  function setWrapToString(wrapper, reference, bitmask) {
+    var source = reference + "";
+    return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
+  }
+  _setWrapToString = setWrapToString;
+  return _setWrapToString;
+}
+export {
+  require_setWrapToString as __require
+};

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

@@ -0,0 +1,25 @@
+import { __require as require_memoizeCapped } from "./_memoizeCapped.mjs";
+var _stringToPath;
+var hasRequired_stringToPath;
+function require_stringToPath() {
+  if (hasRequired_stringToPath) return _stringToPath;
+  hasRequired_stringToPath = 1;
+  var memoizeCapped = require_memoizeCapped();
+  var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+  var reEscapeChar = /\\(\\)?/g;
+  var stringToPath = memoizeCapped(function(string) {
+    var result = [];
+    if (string.charCodeAt(0) === 46) {
+      result.push("");
+    }
+    string.replace(rePropName, function(match, number, quote, subString) {
+      result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+    });
+    return result;
+  });
+  _stringToPath = stringToPath;
+  return _stringToPath;
+}
+export {
+  require_stringToPath as __require
+};

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

@@ -0,0 +1,20 @@
+import { __require as requireIsSymbol } from "./isSymbol.mjs";
+var _toKey;
+var hasRequired_toKey;
+function require_toKey() {
+  if (hasRequired_toKey) return _toKey;
+  hasRequired_toKey = 1;
+  var isSymbol = requireIsSymbol();
+  function toKey(value) {
+    if (typeof value == "string" || isSymbol(value)) {
+      return value;
+    }
+    var result = value + "";
+    return result == "0" && 1 / value == -Infinity ? "-0" : result;
+  }
+  _toKey = toKey;
+  return _toKey;
+}
+export {
+  require_toKey as __require
+};

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

@@ -0,0 +1,35 @@
+import { __require as require_arrayEach } from "./_arrayEach.mjs";
+import { __require as require_arrayIncludes } from "./_arrayIncludes.mjs";
+var _updateWrapDetails;
+var hasRequired_updateWrapDetails;
+function require_updateWrapDetails() {
+  if (hasRequired_updateWrapDetails) return _updateWrapDetails;
+  hasRequired_updateWrapDetails = 1;
+  var arrayEach = require_arrayEach(), arrayIncludes = require_arrayIncludes();
+  var WRAP_BIND_FLAG = 1, WRAP_BIND_KEY_FLAG = 2, WRAP_CURRY_FLAG = 8, WRAP_CURRY_RIGHT_FLAG = 16, WRAP_PARTIAL_FLAG = 32, WRAP_PARTIAL_RIGHT_FLAG = 64, WRAP_ARY_FLAG = 128, WRAP_REARG_FLAG = 256, WRAP_FLIP_FLAG = 512;
+  var wrapFlags = [
+    ["ary", WRAP_ARY_FLAG],
+    ["bind", WRAP_BIND_FLAG],
+    ["bindKey", WRAP_BIND_KEY_FLAG],
+    ["curry", WRAP_CURRY_FLAG],
+    ["curryRight", WRAP_CURRY_RIGHT_FLAG],
+    ["flip", WRAP_FLIP_FLAG],
+    ["partial", WRAP_PARTIAL_FLAG],
+    ["partialRight", WRAP_PARTIAL_RIGHT_FLAG],
+    ["rearg", WRAP_REARG_FLAG]
+  ];
+  function updateWrapDetails(details, bitmask) {
+    arrayEach(wrapFlags, function(pair) {
+      var value = "_." + pair[0];
+      if (bitmask & pair[1] && !arrayIncludes(details, value)) {
+        details.push(value);
+      }
+    });
+    return details.sort();
+  }
+  _updateWrapDetails = updateWrapDetails;
+  return _updateWrapDetails;
+}
+export {
+  require_updateWrapDetails as __require
+};

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

@@ -0,0 +1,25 @@
+import { __require as require_LazyWrapper } from "./_LazyWrapper.mjs";
+import { __require as require_LodashWrapper } from "./_LodashWrapper.mjs";
+import { __require as require_copyArray } from "./_copyArray.mjs";
+var _wrapperClone;
+var hasRequired_wrapperClone;
+function require_wrapperClone() {
+  if (hasRequired_wrapperClone) return _wrapperClone;
+  hasRequired_wrapperClone = 1;
+  var LazyWrapper = require_LazyWrapper(), LodashWrapper = require_LodashWrapper(), copyArray = require_copyArray();
+  function wrapperClone(wrapper) {
+    if (wrapper instanceof LazyWrapper) {
+      return wrapper.clone();
+    }
+    var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
+    result.__actions__ = copyArray(wrapper.__actions__);
+    result.__index__ = wrapper.__index__;
+    result.__values__ = wrapper.__values__;
+    return result;
+  }
+  _wrapperClone = wrapperClone;
+  return _wrapperClone;
+}
+export {
+  require_wrapperClone as __require
+};

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

@@ -0,0 +1,19 @@
+import { __require as require_createWrap } from "./_createWrap.mjs";
+var ary_1;
+var hasRequiredAry;
+function requireAry() {
+  if (hasRequiredAry) return ary_1;
+  hasRequiredAry = 1;
+  var createWrap = require_createWrap();
+  var WRAP_ARY_FLAG = 128;
+  function ary(func, n, guard) {
+    n = guard ? void 0 : n;
+    n = func && n == null ? func.length : n;
+    return createWrap(func, WRAP_ARY_FLAG, void 0, void 0, void 0, void 0, n);
+  }
+  ary_1 = ary;
+  return ary_1;
+}
+export {
+  requireAry as __require
+};

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

@@ -0,0 +1,17 @@
+import { __require as require_baseClone } from "./_baseClone.mjs";
+var clone_1;
+var hasRequiredClone;
+function requireClone() {
+  if (hasRequiredClone) return clone_1;
+  hasRequiredClone = 1;
+  var baseClone = require_baseClone();
+  var CLONE_SYMBOLS_FLAG = 4;
+  function clone(value) {
+    return baseClone(value, CLONE_SYMBOLS_FLAG);
+  }
+  clone_1 = clone;
+  return clone_1;
+}
+export {
+  requireClone as __require
+};

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

@@ -0,0 +1,17 @@
+import { __require as require_baseClone } from "./_baseClone.mjs";
+var cloneDeep_1;
+var hasRequiredCloneDeep;
+function requireCloneDeep() {
+  if (hasRequiredCloneDeep) return cloneDeep_1;
+  hasRequiredCloneDeep = 1;
+  var baseClone = require_baseClone();
+  var CLONE_DEEP_FLAG = 1, CLONE_SYMBOLS_FLAG = 4;
+  function cloneDeep(value) {
+    return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+  }
+  cloneDeep_1 = cloneDeep;
+  return cloneDeep_1;
+}
+export {
+  requireCloneDeep as __require
+};

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

@@ -0,0 +1,21 @@
+import { __require as require_createWrap } from "./_createWrap.mjs";
+var curry_1;
+var hasRequiredCurry;
+function requireCurry() {
+  if (hasRequiredCurry) return curry_1;
+  hasRequiredCurry = 1;
+  var createWrap = require_createWrap();
+  var WRAP_CURRY_FLAG = 8;
+  function curry(func, arity, guard) {
+    arity = guard ? void 0 : arity;
+    var result = createWrap(func, WRAP_CURRY_FLAG, void 0, void 0, void 0, void 0, void 0, arity);
+    result.placeholder = curry.placeholder;
+    return result;
+  }
+  curry.placeholder = {};
+  curry_1 = curry;
+  return curry_1;
+}
+export {
+  requireCurry as __require
+};

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

@@ -0,0 +1,98 @@
+import { __require as requireIsObject } from "./isObject.mjs";
+import { __require as requireNow } from "./now.mjs";
+import { __require as requireToNumber } from "./toNumber.mjs";
+var debounce_1;
+var hasRequiredDebounce;
+function requireDebounce() {
+  if (hasRequiredDebounce) return debounce_1;
+  hasRequiredDebounce = 1;
+  var isObject = requireIsObject(), now = requireNow(), toNumber = requireToNumber();
+  var FUNC_ERROR_TEXT = "Expected a function";
+  var nativeMax = Math.max, nativeMin = Math.min;
+  function debounce(func, wait, options) {
+    var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+    if (typeof func != "function") {
+      throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    wait = toNumber(wait) || 0;
+    if (isObject(options)) {
+      leading = !!options.leading;
+      maxing = "maxWait" in options;
+      maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+      trailing = "trailing" in options ? !!options.trailing : trailing;
+    }
+    function invokeFunc(time) {
+      var args = lastArgs, thisArg = lastThis;
+      lastArgs = lastThis = void 0;
+      lastInvokeTime = time;
+      result = func.apply(thisArg, args);
+      return result;
+    }
+    function leadingEdge(time) {
+      lastInvokeTime = time;
+      timerId = setTimeout(timerExpired, wait);
+      return leading ? invokeFunc(time) : result;
+    }
+    function remainingWait(time) {
+      var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+      return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+    }
+    function shouldInvoke(time) {
+      var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+      return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+    }
+    function timerExpired() {
+      var time = now();
+      if (shouldInvoke(time)) {
+        return trailingEdge(time);
+      }
+      timerId = setTimeout(timerExpired, remainingWait(time));
+    }
+    function trailingEdge(time) {
+      timerId = void 0;
+      if (trailing && lastArgs) {
+        return invokeFunc(time);
+      }
+      lastArgs = lastThis = void 0;
+      return result;
+    }
+    function cancel() {
+      if (timerId !== void 0) {
+        clearTimeout(timerId);
+      }
+      lastInvokeTime = 0;
+      lastArgs = lastCallTime = lastThis = timerId = void 0;
+    }
+    function flush() {
+      return timerId === void 0 ? result : trailingEdge(now());
+    }
+    function debounced() {
+      var time = now(), isInvoking = shouldInvoke(time);
+      lastArgs = arguments;
+      lastThis = this;
+      lastCallTime = time;
+      if (isInvoking) {
+        if (timerId === void 0) {
+          return leadingEdge(lastCallTime);
+        }
+        if (maxing) {
+          clearTimeout(timerId);
+          timerId = setTimeout(timerExpired, wait);
+          return invokeFunc(lastCallTime);
+        }
+      }
+      if (timerId === void 0) {
+        timerId = setTimeout(timerExpired, wait);
+      }
+      return result;
+    }
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    return debounced;
+  }
+  debounce_1 = debounce;
+  return debounce_1;
+}
+export {
+  requireDebounce as __require
+};