react-devtools-core/dist/backend.js

Use react-devtools outside of the browser

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["ReactDevToolsBackend"] = factory();
	else
		root["ReactDevToolsBackend"] = factory();
})(self, () => {
return /******/ (() => { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ 602:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
var __webpack_unused_export__;
/**
 * @license React
 * react-debug-tools.production.min.js
 *
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */


function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var h = __webpack_require__(206),
    k = __webpack_require__(189),
    q = Object.assign,
    v = k.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
    w = Symbol.for("react.context"),
    x = Symbol.for("react.memo_cache_sentinel"),
    y = [],
    z = null;

function A() {
  if (null === z) {
    var a = new Map();

    try {
      if (B.useContext({
        _currentValue: null
      }), B.useState(null), B.useReducer(function (e) {
        return e;
      }, null), B.useRef(null), "function" === typeof B.useCacheRefresh && B.useCacheRefresh(), B.useLayoutEffect(function () {}), B.useInsertionEffect(function () {}), B.useEffect(function () {}), B.useImperativeHandle(void 0, function () {
        return null;
      }), B.useDebugValue(null), B.useCallback(function () {}), B.useTransition(), B.useSyncExternalStore(function () {
        return function () {};
      }, function () {
        return null;
      }, function () {
        return null;
      }), B.useDeferredValue(null), B.useMemo(function () {
        return null;
      }), "function" === typeof B.useMemoCache && B.useMemoCache(0), "function" === typeof B.useOptimistic && B.useOptimistic(null, function (e) {
        return e;
      }), "function" === typeof B.useFormState && B.useFormState(function (e) {
        return e;
      }, null), "function" === typeof B.use) {
        B.use({
          $$typeof: w,
          _currentValue: null
        });
        B.use({
          then: function then() {},
          status: "fulfilled",
          value: null
        });

        try {
          B.use({
            then: function then() {}
          });
        } catch (e) {}
      }
    } finally {
      var b = y;
      y = [];
    }

    for (var c = 0; c < b.length; c++) {
      var d = b[c];
      a.set(d.primitive, h.parse(d.stackError));
    }

    z = a;
  }

  return z;
}

var C = null,
    D = null;

function E() {
  var a = D;
  null !== a && (D = a.next);
  return a;
}

var F = Error("Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render. You must either rethrow it immediately, or move the `use` call outside of the `try/catch` block. Capturing without rethrowing will lead to unexpected behavior.\n\nTo handle async errors, wrap your component in an error boundary, or call the promise's `.catch` method and pass the result to `use`"),
    B = {
  use: function use(a) {
    if (null !== a && "object" === _typeof(a)) {
      if ("function" === typeof a.then) {
        switch (a.status) {
          case "fulfilled":
            var b = a.value;
            y.push({
              displayName: null,
              primitive: "Promise",
              stackError: Error(),
              value: b,
              debugInfo: void 0 === a._debugInfo ? null : a._debugInfo
            });
            return b;

          case "rejected":
            throw a.reason;
        }

        y.push({
          displayName: null,
          primitive: "Unresolved",
          stackError: Error(),
          value: a,
          debugInfo: void 0 === a._debugInfo ? null : a._debugInfo
        });
        throw F;
      }

      if (a.$$typeof === w) return b = a._currentValue, y.push({
        displayName: a.displayName || "Context",
        primitive: "Context (use)",
        stackError: Error(),
        value: b,
        debugInfo: null
      }), b;
    }

    throw Error("An unsupported type was passed to use(): " + String(a));
  },
  readContext: function readContext(a) {
    return a._currentValue;
  },
  useCacheRefresh: function useCacheRefresh() {
    var a = E();
    y.push({
      displayName: null,
      primitive: "CacheRefresh",
      stackError: Error(),
      value: null !== a ? a.memoizedState : function () {},
      debugInfo: null
    });
    return function () {};
  },
  useCallback: function useCallback(a) {
    var b = E();
    y.push({
      displayName: null,
      primitive: "Callback",
      stackError: Error(),
      value: null !== b ? b.memoizedState[0] : a,
      debugInfo: null
    });
    return a;
  },
  useContext: function useContext(a) {
    y.push({
      displayName: a.displayName || null,
      primitive: "Context",
      stackError: Error(),
      value: a._currentValue,
      debugInfo: null
    });
    return a._currentValue;
  },
  useEffect: function useEffect(a) {
    E();
    y.push({
      displayName: null,
      primitive: "Effect",
      stackError: Error(),
      value: a,
      debugInfo: null
    });
  },
  useImperativeHandle: function useImperativeHandle(a) {
    E();
    var b = void 0;
    null !== a && "object" === _typeof(a) && (b = a.current);
    y.push({
      displayName: null,
      primitive: "ImperativeHandle",
      stackError: Error(),
      value: b,
      debugInfo: null
    });
  },
  useDebugValue: function useDebugValue(a, b) {
    y.push({
      displayName: null,
      primitive: "DebugValue",
      stackError: Error(),
      value: "function" === typeof b ? b(a) : a,
      debugInfo: null
    });
  },
  useLayoutEffect: function useLayoutEffect(a) {
    E();
    y.push({
      displayName: null,
      primitive: "LayoutEffect",
      stackError: Error(),
      value: a,
      debugInfo: null
    });
  },
  useInsertionEffect: function useInsertionEffect(a) {
    E();
    y.push({
      displayName: null,
      primitive: "InsertionEffect",
      stackError: Error(),
      value: a,
      debugInfo: null
    });
  },
  useMemo: function useMemo(a) {
    var b = E();
    a = null !== b ? b.memoizedState[0] : a();
    y.push({
      displayName: null,
      primitive: "Memo",
      stackError: Error(),
      value: a,
      debugInfo: null
    });
    return a;
  },
  useMemoCache: function useMemoCache(a) {
    var b = C;
    if (null == b) return [];
    var c;
    b = null == (c = b.updateQueue) ? void 0 : c.memoCache;
    if (null == b) return [];
    c = b.data[b.index];

    if (void 0 === c) {
      c = b.data[b.index] = Array(a);

      for (var d = 0; d < a; d++) {
        c[d] = x;
      }
    }

    b.index++;
    return c;
  },
  useOptimistic: function useOptimistic(a) {
    var b = E();
    a = null !== b ? b.memoizedState : a;
    y.push({
      displayName: null,
      primitive: "Optimistic",
      stackError: Error(),
      value: a,
      debugInfo: null
    });
    return [a, function () {}];
  },
  useReducer: function useReducer(a, b, c) {
    a = E();
    b = null !== a ? a.memoizedState : void 0 !== c ? c(b) : b;
    y.push({
      displayName: null,
      primitive: "Reducer",
      stackError: Error(),
      value: b,
      debugInfo: null
    });
    return [b, function () {}];
  },
  useRef: function useRef(a) {
    var b = E();
    a = null !== b ? b.memoizedState : {
      current: a
    };
    y.push({
      displayName: null,
      primitive: "Ref",
      stackError: Error(),
      value: a.current,
      debugInfo: null
    });
    return a;
  },
  useState: function useState(a) {
    var b = E();
    a = null !== b ? b.memoizedState : "function" === typeof a ? a() : a;
    y.push({
      displayName: null,
      primitive: "State",
      stackError: Error(),
      value: a,
      debugInfo: null
    });
    return [a, function () {}];
  },
  useTransition: function useTransition() {
    var a = E();
    E();
    a = null !== a ? a.memoizedState : !1;
    y.push({
      displayName: null,
      primitive: "Transition",
      stackError: Error(),
      value: a,
      debugInfo: null
    });
    return [a, function () {}];
  },
  useSyncExternalStore: function useSyncExternalStore(a, b) {
    E();
    E();
    a = b();
    y.push({
      displayName: null,
      primitive: "SyncExternalStore",
      stackError: Error(),
      value: a,
      debugInfo: null
    });
    return a;
  },
  useDeferredValue: function useDeferredValue(a) {
    var b = E();
    y.push({
      displayName: null,
      primitive: "DeferredValue",
      stackError: Error(),
      value: null !== b ? b.memoizedState : a,
      debugInfo: null
    });
    return a;
  },
  useId: function useId() {
    var a = E();
    a = null !== a ? a.memoizedState : "";
    y.push({
      displayName: null,
      primitive: "Id",
      stackError: Error(),
      value: a,
      debugInfo: null
    });
    return a;
  },
  useFormState: function useFormState(a, b) {
    var c = E();
    E();
    a = Error();
    var d = null,
        e = null;
    if (null !== c) {
      if (b = c.memoizedState, "object" === _typeof(b) && null !== b && "function" === typeof b.then) switch (b.status) {
        case "fulfilled":
          var m = b.value;
          d = void 0 === b._debugInfo ? null : b._debugInfo;
          break;

        case "rejected":
          e = b.reason;
          break;

        default:
          e = F, d = void 0 === b._debugInfo ? null : b._debugInfo, m = b;
      } else m = b;
    } else m = b;
    y.push({
      displayName: null,
      primitive: "FormState",
      stackError: a,
      value: m,
      debugInfo: d
    });
    if (null !== e) throw e;
    return [m, function () {}];
  }
},
    G = {
  get: function get(a, b) {
    if (a.hasOwnProperty(b)) return a[b];
    a = Error("Missing method in Dispatcher: " + b);
    a.name = "ReactDebugToolsUnsupportedHookError";
    throw a;
  }
},
    H = "undefined" === typeof Proxy ? B : new Proxy(B, G),
    I = 0;

function J(a, b, c) {
  var d = b[c].source,
      e = 0;

  a: for (; e < a.length; e++) {
    if (a[e].source === d) {
      for (var m = c + 1, r = e + 1; m < b.length && r < a.length; m++, r++) {
        if (a[r].source !== b[m].source) continue a;
      }

      return e;
    }
  }

  return -1;
}

function K(a, b) {
  if (!a) return !1;

  switch (b) {
    case "Context":
    case "Context (use)":
    case "Promise":
    case "Unresolved":
      if (a.endsWith("use")) return !0;
  }

  b = "use" + b;
  return a.length < b.length ? !1 : a.lastIndexOf(b) === a.length - b.length;
}

function L(a, b) {
  for (var c = [], d = null, e = c, m = 0, r = [], u = 0; u < b.length; u++) {
    var t = b[u];
    var f = a;
    var n = h.parse(t.stackError);

    b: {
      var g = n,
          p = J(g, f, I);
      if (-1 !== p) f = p;else {
        for (var l = 0; l < f.length && 5 > l; l++) {
          if (p = J(g, f, l), -1 !== p) {
            I = l;
            f = p;
            break b;
          }
        }

        f = -1;
      }
    }

    b: {
      g = n;
      p = A().get(t.primitive);
      if (void 0 !== p) for (l = 0; l < p.length && l < g.length; l++) {
        if (p[l].source !== g[l].source) {
          l < g.length - 1 && K(g[l].functionName, t.primitive) && l++;
          l < g.length - 1 && K(g[l].functionName, t.primitive) && l++;
          g = l;
          break b;
        }
      }
      g = -1;
    }

    n = -1 === f || -1 === g || 2 > f - g ? null : n.slice(g, f - 1);

    if (null !== n) {
      f = 0;

      if (null !== d) {
        for (; f < n.length && f < d.length && n[n.length - f - 1].source === d[d.length - f - 1].source;) {
          f++;
        }

        for (d = d.length - 1; d > f; d--) {
          e = r.pop();
        }
      }

      for (d = n.length - f - 1; 1 <= d; d--) {
        f = [], g = n[d], (p = n[d - 1].functionName) ? (l = p.lastIndexOf("."), -1 === l && (l = 0), "use" === p.slice(l, l + 3) && (l += 3), p = p.slice(l)) : p = "", e.push({
          id: null,
          isStateEditable: !1,
          name: p,
          value: void 0,
          subHooks: f,
          debugInfo: null,
          hookSource: {
            lineNumber: g.lineNumber,
            columnNumber: g.columnNumber,
            functionName: g.functionName,
            fileName: g.fileName
          }
        }), r.push(e), e = f;
      }

      d = n;
    }

    f = t.displayName;
    g = t.primitive;
    p = t.debugInfo;
    t = {
      id: "Context" === g || "Context (use)" === g || "DebugValue" === g || "Promise" === g || "Unresolved" === g ? null : m++,
      isStateEditable: "Reducer" === g || "State" === g,
      name: f || g,
      value: t.value,
      subHooks: [],
      debugInfo: p,
      hookSource: null
    };
    f = {
      lineNumber: null,
      functionName: null,
      fileName: null,
      columnNumber: null
    };
    n && 1 <= n.length && (n = n[0], f.lineNumber = n.lineNumber, f.functionName = n.functionName, f.fileName = n.fileName, f.columnNumber = n.columnNumber);
    t.hookSource = f;
    e.push(t);
  }

  M(c, null);
  return c;
}

function M(a, b) {
  for (var c = [], d = 0; d < a.length; d++) {
    var e = a[d];
    "DebugValue" === e.name && 0 === e.subHooks.length ? (a.splice(d, 1), d--, c.push(e)) : M(e.subHooks, e);
  }

  null !== b && (1 === c.length ? b.value = c[0].value : 1 < c.length && (b.value = c.map(function (m) {
    return m.value;
  })));
}

function N(a) {
  if (a !== F) {
    if (a instanceof Error && "ReactDebugToolsUnsupportedHookError" === a.name) throw a;
    var b = Error("Error rendering inspected component", {
      cause: a
    });
    b.name = "ReactDebugToolsRenderError";
    b.cause = a;
    throw b;
  }
}

function O(a, b, c) {
  null == c && (c = v.ReactCurrentDispatcher);
  var d = c.current;
  c.current = H;

  try {
    var e = Error();
    a(b);
  } catch (m) {
    N(m);
  } finally {
    a = y, y = [], c.current = d;
  }

  c = h.parse(e);
  return L(c, a);
}

function P(a) {
  a.forEach(function (b, c) {
    return c._currentValue = b;
  });
}

__webpack_unused_export__ = O;

exports.inspectHooksOfFiber = function (a, b) {
  null == b && (b = v.ReactCurrentDispatcher);
  if (0 !== a.tag && 15 !== a.tag && 11 !== a.tag) throw Error("Unknown Fiber. Needs to be a function component to inspect hooks.");
  A();
  D = a.memoizedState;
  C = a;
  var c = a.type,
      d = a.memoizedProps;

  if (c !== a.elementType && c && c.defaultProps) {
    d = q({}, d);
    var e = c.defaultProps;

    for (m in e) {
      void 0 === d[m] && (d[m] = e[m]);
    }
  }

  var m = new Map();

  try {
    for (e = a; e;) {
      if (10 === e.tag) {
        var r = e.type;
        void 0 !== r._context && (r = r._context);
        m.has(r) || (m.set(r, r._currentValue), r._currentValue = e.memoizedProps.value);
      }

      e = e.return;
    }

    if (11 === a.tag) {
      var u = c.render;
      c = d;
      var t = a.ref;
      a = b;
      var f = a.current;
      a.current = H;

      try {
        var n = Error();
        u(c, t);
      } catch (l) {
        N(l);
      } finally {
        var g = y;
        y = [];
        a.current = f;
      }

      var p = h.parse(n);
      return L(p, g);
    }

    return O(c, d, b);
  } finally {
    D = C = null, P(m);
  }
};

/***/ }),

/***/ 987:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


if (true) {
  module.exports = __webpack_require__(602);
} else {}

/***/ }),

/***/ 9:
/***/ ((__unused_webpack_module, exports) => {

"use strict";
var __webpack_unused_export__;
/*
 React
 react-is.production.min.js

 Copyright (c) Meta Platforms, Inc. and affiliates.

 This source code is licensed under the MIT license found in the
 LICENSE file in the root directory of this source tree.
*/


function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var b = Symbol.for("react.element"),
    c = Symbol.for("react.portal"),
    d = Symbol.for("react.fragment"),
    e = Symbol.for("react.strict_mode"),
    f = Symbol.for("react.profiler"),
    g = Symbol.for("react.provider"),
    h = Symbol.for("react.consumer"),
    k = Symbol.for("react.context"),
    l = Symbol.for("react.forward_ref"),
    m = Symbol.for("react.suspense"),
    n = Symbol.for("react.suspense_list"),
    p = Symbol.for("react.memo"),
    q = Symbol.for("react.lazy"),
    t = Symbol.for("react.offscreen"),
    u = Symbol.for("react.cache"),
    v = Symbol.for("react.client.reference");

function w(a) {
  if ("object" === _typeof(a) && null !== a) {
    var r = a.$$typeof;

    switch (r) {
      case b:
        switch (a = a.type, a) {
          case d:
          case f:
          case e:
          case m:
          case n:
            return a;

          default:
            switch (a = a && a.$$typeof, a) {
              case k:
              case l:
              case q:
              case p:
                return a;

              case h:
              case g:
                return a;

              default:
                return r;
            }

        }

      case c:
        return r;
    }
  }
}

exports.AI = k;
exports.HQ = g;
__webpack_unused_export__ = b;
exports.A4 = l;
exports.HY = d;
exports.oM = q;
exports._Y = p;
exports.h_ = c;
exports.Q1 = f;
exports.nF = e;
exports.n4 = m;
__webpack_unused_export__ = n;

__webpack_unused_export__ = function (a) {
  return w(a) === k;
};

__webpack_unused_export__ = function (a) {
  return w(a) === g;
};

exports.kK = function (a) {
  return "object" === _typeof(a) && null !== a && a.$$typeof === b;
};

__webpack_unused_export__ = function (a) {
  return w(a) === l;
};

__webpack_unused_export__ = function (a) {
  return w(a) === d;
};

__webpack_unused_export__ = function (a) {
  return w(a) === q;
};

__webpack_unused_export__ = function (a) {
  return w(a) === p;
};

__webpack_unused_export__ = function (a) {
  return w(a) === c;
};

__webpack_unused_export__ = function (a) {
  return w(a) === f;
};

__webpack_unused_export__ = function (a) {
  return w(a) === e;
};

__webpack_unused_export__ = function (a) {
  return w(a) === m;
};

__webpack_unused_export__ = function (a) {
  return w(a) === n;
};

__webpack_unused_export__ = function (a) {
  return "string" === typeof a || "function" === typeof a || a === d || a === f || a === e || a === m || a === n || a === t || a === u || "object" === _typeof(a) && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === k || a.$$typeof === g || a.$$typeof === l || a.$$typeof === v || void 0 !== a.getModuleId) ? !0 : !1;
};

exports.kM = w;

/***/ }),

/***/ 978:
/***/ ((__unused_webpack_module, exports) => {

"use strict";
/*
 React
 react.production.min.js

 Copyright (c) Meta Platforms, Inc. and affiliates.

 This source code is licensed under the MIT license found in the
 LICENSE file in the root directory of this source tree.
*/


function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

var k = Symbol.for("react.element"),
    m = Symbol.for("react.portal"),
    n = Symbol.for("react.fragment"),
    p = Symbol.for("react.strict_mode"),
    q = Symbol.for("react.profiler"),
    r = Symbol.for("react.provider"),
    t = Symbol.for("react.context"),
    u = Symbol.for("react.forward_ref"),
    v = Symbol.for("react.suspense"),
    w = Symbol.for("react.suspense_list"),
    x = Symbol.for("react.memo"),
    y = Symbol.for("react.lazy"),
    z = Symbol.for("react.debug_trace_mode"),
    aa = Symbol.for("react.offscreen"),
    ba = Symbol.for("react.cache"),
    ca = Symbol.for("react.postpone"),
    A = Symbol.iterator;

function da(a) {
  if (null === a || "object" !== _typeof(a)) return null;
  a = A && a[A] || a["@@iterator"];
  return "function" === typeof a ? a : null;
}

var B = {
  isMounted: function isMounted() {
    return !1;
  },
  enqueueForceUpdate: function enqueueForceUpdate() {},
  enqueueReplaceState: function enqueueReplaceState() {},
  enqueueSetState: function enqueueSetState() {}
},
    C = Object.assign,
    D = {};

function E(a, b, c) {
  this.props = a;
  this.context = b;
  this.refs = D;
  this.updater = c || B;
}

E.prototype.isReactComponent = {};

E.prototype.setState = function (a, b) {
  if ("object" !== _typeof(a) && "function" !== typeof a && null != a) throw Error("takes an object of state variables to update or a function which returns an object of state variables.");
  this.updater.enqueueSetState(this, a, b, "setState");
};

E.prototype.forceUpdate = function (a) {
  this.updater.enqueueForceUpdate(this, a, "forceUpdate");
};

function F() {}

F.prototype = E.prototype;

function G(a, b, c) {
  this.props = a;
  this.context = b;
  this.refs = D;
  this.updater = c || B;
}

var H = G.prototype = new F();
H.constructor = G;
C(H, E.prototype);
H.isPureReactComponent = !0;
var I = Array.isArray,
    J = {
  current: null
},
    K = {
  current: null
},
    L = {
  transition: null
},
    M = {
  ReactCurrentDispatcher: J,
  ReactCurrentCache: K,
  ReactCurrentBatchConfig: L,
  ReactCurrentOwner: {
    current: null
  }
},
    N = Object.prototype.hasOwnProperty,
    O = M.ReactCurrentOwner;

function P(a, b, c, e, d, g, f) {
  c = f.ref;
  return {
    $$typeof: k,
    type: a,
    key: b,
    ref: void 0 !== c ? c : null,
    props: f,
    _owner: g
  };
}

function Q(a, b, c) {
  var e,
      d = {},
      g = null;
  if (null != b) for (e in void 0 !== b.key && (g = "" + b.key), b) {
    N.call(b, e) && "key" !== e && "__self" !== e && "__source" !== e && (d[e] = b[e]);
  }
  var f = arguments.length - 2;
  if (1 === f) d.children = c;else if (1 < f) {
    for (var h = Array(f), l = 0; l < f; l++) {
      h[l] = arguments[l + 2];
    }

    d.children = h;
  }
  if (a && a.defaultProps) for (e in f = a.defaultProps, f) {
    void 0 === d[e] && (d[e] = f[e]);
  }
  return P(a, g, null, void 0, void 0, O.current, d);
}

function ea(a, b) {
  return P(a.type, b, null, void 0, void 0, a._owner, a.props);
}

function R(a) {
  return "object" === _typeof(a) && null !== a && a.$$typeof === k;
}

function escape(a) {
  var b = {
    "=": "=0",
    ":": "=2"
  };
  return "$" + a.replace(/[=:]/g, function (c) {
    return b[c];
  });
}

var S = /\/+/g;

function T(a, b) {
  return "object" === _typeof(a) && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
}

function U() {}

function fa(a) {
  switch (a.status) {
    case "fulfilled":
      return a.value;

    case "rejected":
      throw a.reason;

    default:
      switch ("string" === typeof a.status ? a.then(U, U) : (a.status = "pending", a.then(function (b) {
        "pending" === a.status && (a.status = "fulfilled", a.value = b);
      }, function (b) {
        "pending" === a.status && (a.status = "rejected", a.reason = b);
      })), a.status) {
        case "fulfilled":
          return a.value;

        case "rejected":
          throw a.reason;
      }

  }

  throw a;
}

function V(a, b, c, e, d) {
  var g = _typeof(a);

  if ("undefined" === g || "boolean" === g) a = null;
  var f = !1;
  if (null === a) f = !0;else switch (g) {
    case "bigint":
    case "string":
    case "number":
      f = !0;
      break;

    case "object":
      switch (a.$$typeof) {
        case k:
        case m:
          f = !0;
          break;

        case y:
          return f = a._init, V(f(a._payload), b, c, e, d);
      }

  }
  if (f) return d = d(a), f = "" === e ? "." + T(a, 0) : e, I(d) ? (c = "", null != f && (c = f.replace(S, "$&/") + "/"), V(d, b, c, "", function (ha) {
    return ha;
  })) : null != d && (R(d) && (d = ea(d, c + (!d.key || a && a.key === d.key ? "" : ("" + d.key).replace(S, "$&/") + "/") + f)), b.push(d)), 1;
  f = 0;
  var h = "" === e ? "." : e + ":";
  if (I(a)) for (var l = 0; l < a.length; l++) {
    e = a[l], g = h + T(e, l), f += V(e, b, c, g, d);
  } else if (l = da(a), "function" === typeof l) for (a = l.call(a), l = 0; !(e = a.next()).done;) {
    e = e.value, g = h + T(e, l++), f += V(e, b, c, g, d);
  } else if ("object" === g) {
    if ("function" === typeof a.then) return V(fa(a), b, c, e, d);
    b = String(a);
    throw Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
  }
  return f;
}

function W(a, b, c) {
  if (null == a) return a;
  var e = [],
      d = 0;
  V(a, e, "", "", function (g) {
    return b.call(c, g, d++);
  });
  return e;
}

function ia(a) {
  if (-1 === a._status) {
    var b = a._result;
    b = b();
    b.then(function (c) {
      if (0 === a._status || -1 === a._status) a._status = 1, a._result = c;
    }, function (c) {
      if (0 === a._status || -1 === a._status) a._status = 2, a._result = c;
    });
    -1 === a._status && (a._status = 0, a._result = b);
  }

  if (1 === a._status) return a._result.default;
  throw a._result;
}

function ja() {
  return new WeakMap();
}

function X() {
  return {
    s: 0,
    v: void 0,
    o: null,
    p: null
  };
}

function Y(a, b) {
  return J.current.useOptimistic(a, b);
}

function ka() {}

var Z = "function" === typeof reportError ? reportError : function (a) {
  console.error(a);
};
exports.Children = {
  map: W,
  forEach: function forEach(a, b, c) {
    W(a, function () {
      b.apply(this, arguments);
    }, c);
  },
  count: function count(a) {
    var b = 0;
    W(a, function () {
      b++;
    });
    return b;
  },
  toArray: function toArray(a) {
    return W(a, function (b) {
      return b;
    }) || [];
  },
  only: function only(a) {
    if (!R(a)) throw Error("React.Children.only expected to receive a single React element child.");
    return a;
  }
};
exports.Component = E;
exports.Fragment = n;
exports.Profiler = q;
exports.PureComponent = G;
exports.StrictMode = p;
exports.Suspense = v;
exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = M;

exports.act = function () {
  throw Error("act(...) is not supported in production builds of React.");
};

exports.cache = function (a) {
  return function () {
    var b = K.current;
    if (!b) return a.apply(null, arguments);
    var c = b.getCacheForType(ja);
    b = c.get(a);
    void 0 === b && (b = X(), c.set(a, b));
    c = 0;

    for (var e = arguments.length; c < e; c++) {
      var d = arguments[c];

      if ("function" === typeof d || "object" === _typeof(d) && null !== d) {
        var g = b.o;
        null === g && (b.o = g = new WeakMap());
        b = g.get(d);
        void 0 === b && (b = X(), g.set(d, b));
      } else g = b.p, null === g && (b.p = g = new Map()), b = g.get(d), void 0 === b && (b = X(), g.set(d, b));
    }

    if (1 === b.s) return b.v;
    if (2 === b.s) throw b.v;

    try {
      var f = a.apply(null, arguments);
      c = b;
      c.s = 1;
      return c.v = f;
    } catch (h) {
      throw f = b, f.s = 2, f.v = h, h;
    }
  };
};

exports.cloneElement = function (a, b, c) {
  if (null === a || void 0 === a) throw Error("The argument must be a React element, but you passed " + a + ".");
  var e = C({}, a.props),
      d = a.key,
      g = a._owner;

  if (null != b) {
    void 0 !== b.ref && (g = O.current);
    void 0 !== b.key && (d = "" + b.key);
    if (a.type && a.type.defaultProps) var f = a.type.defaultProps;

    for (h in b) {
      !N.call(b, h) || "key" === h || "__self" === h || "__source" === h || "ref" === h && void 0 === b.ref || (e[h] = void 0 === b[h] && void 0 !== f ? f[h] : b[h]);
    }
  }

  var h = arguments.length - 2;
  if (1 === h) e.children = c;else if (1 < h) {
    f = Array(h);

    for (var l = 0; l < h; l++) {
      f[l] = arguments[l + 2];
    }

    e.children = f;
  }
  return P(a.type, d, null, void 0, void 0, g, e);
};

exports.createContext = function (a) {
  a = {
    $$typeof: t,
    _currentValue: a,
    _currentValue2: a,
    _threadCount: 0,
    Provider: null,
    Consumer: null
  };
  a.Provider = {
    $$typeof: r,
    _context: a
  };
  return a.Consumer = a;
};

exports.createElement = Q;

exports.createFactory = function (a) {
  var b = Q.bind(null, a);
  b.type = a;
  return b;
};

exports.createRef = function () {
  return {
    current: null
  };
};

exports.experimental_useEffectEvent = function (a) {
  return J.current.useEffectEvent(a);
};

exports.experimental_useOptimistic = function (a, b) {
  return Y(a, b);
};

exports.forwardRef = function (a) {
  return {
    $$typeof: u,
    render: a
  };
};

exports.isValidElement = R;

exports.lazy = function (a) {
  return {
    $$typeof: y,
    _payload: {
      _status: -1,
      _result: a
    },
    _init: ia
  };
};

exports.memo = function (a, b) {
  return {
    $$typeof: x,
    type: a,
    compare: void 0 === b ? null : b
  };
};

exports.startTransition = function (a) {
  var b = L.transition,
      c = new Set();
  L.transition = {
    _callbacks: c
  };
  var e = L.transition;

  try {
    var d = a();
    "object" === _typeof(d) && null !== d && "function" === typeof d.then && (c.forEach(function (g) {
      return g(e, d);
    }), d.then(ka, Z));
  } catch (g) {
    Z(g);
  } finally {
    L.transition = b;
  }
};

exports.unstable_Activity = aa;
exports.unstable_Cache = ba;
exports.unstable_DebugTracingMode = z;
exports.unstable_SuspenseList = w;

exports.unstable_getCacheForType = function (a) {
  var b = K.current;
  return b ? b.getCacheForType(a) : a();
};

exports.unstable_getCacheSignal = function () {
  var a = K.current;
  return a ? a.getCacheSignal() : (a = new AbortController(), a.abort(Error("This CacheSignal was requested outside React which means that it is immediately aborted.")), a.signal);
};

exports.unstable_postpone = function (a) {
  a = Error(a);
  a.$$typeof = ca;
  throw a;
};

exports.unstable_useCacheRefresh = function () {
  return J.current.useCacheRefresh();
};

exports.unstable_useMemoCache = function (a) {
  return J.current.useMemoCache(a);
};

exports.use = function (a) {
  return J.current.use(a);
};

exports.useCallback = function (a, b) {
  return J.current.useCallback(a, b);
};

exports.useContext = function (a) {
  return J.current.useContext(a);
};

exports.useDebugValue = function () {};

exports.useDeferredValue = function (a, b) {
  return J.current.useDeferredValue(a, b);
};

exports.useEffect = function (a, b) {
  return J.current.useEffect(a, b);
};

exports.useId = function () {
  return J.current.useId();
};

exports.useImperativeHandle = function (a, b, c) {
  return J.current.useImperativeHandle(a, b, c);
};

exports.useInsertionEffect = function (a, b) {
  return J.current.useInsertionEffect(a, b);
};

exports.useLayoutEffect = function (a, b) {
  return J.current.useLayoutEffect(a, b);
};

exports.useMemo = function (a, b) {
  return J.current.useMemo(a, b);
};

exports.useOptimistic = Y;

exports.useReducer = function (a, b, c) {
  return J.current.useReducer(a, b, c);
};

exports.useRef = function (a) {
  return J.current.useRef(a);
};

exports.useState = function (a) {
  return J.current.useState(a);
};

exports.useSyncExternalStore = function (a, b, c) {
  return J.current.useSyncExternalStore(a, b, c);
};

exports.useTransition = function () {
  return J.current.useTransition();
};

exports.version = "18.3.0-experimental-338dddc08-20240307";

/***/ }),

/***/ 189:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


if (true) {
  module.exports = __webpack_require__(978);
} else {}

/***/ }),

/***/ 206:
/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

(function (root, factory) {
  'use strict'; // Universal Module Definition (UMD) to support AMD, CommonJS/Node.js, Rhino, and browsers.

  /* istanbul ignore next */

  if (true) {
    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(430)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  } else {}
})(this, function ErrorStackParser(StackFrame) {
  'use strict';

  var FIREFOX_SAFARI_STACK_REGEXP = /(^|@)\S+:\d+/;
  var CHROME_IE_STACK_REGEXP = /^\s*at .*(\S+:\d+|\(native\))/m;
  var SAFARI_NATIVE_CODE_REGEXP = /^(eval@)?(\[native code])?$/;
  return {
    /**
     * Given an Error object, extract the most information from it.
     *
     * @param {Error} error object
     * @return {Array} of StackFrames
     */
    parse: function ErrorStackParser$$parse(error) {
      if (typeof error.stacktrace !== 'undefined' || typeof error['opera#sourceloc'] !== 'undefined') {
        return this.parseOpera(error);
      } else if (error.stack && error.stack.match(CHROME_IE_STACK_REGEXP)) {
        return this.parseV8OrIE(error);
      } else if (error.stack) {
        return this.parseFFOrSafari(error);
      } else {
        throw new Error('Cannot parse given Error object');
      }
    },
    // Separate line and column numbers from a string of the form: (URI:Line:Column)
    extractLocation: function ErrorStackParser$$extractLocation(urlLike) {
      // Fail-fast but return locations like "(native)"
      if (urlLike.indexOf(':') === -1) {
        return [urlLike];
      }

      var regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
      var parts = regExp.exec(urlLike.replace(/[()]/g, ''));
      return [parts[1], parts[2] || undefined, parts[3] || undefined];
    },
    parseV8OrIE: function ErrorStackParser$$parseV8OrIE(error) {
      var filtered = error.stack.split('\n').filter(function (line) {
        return !!line.match(CHROME_IE_STACK_REGEXP);
      }, this);
      return filtered.map(function (line) {
        if (line.indexOf('(eval ') > -1) {
          // Throw away eval information until we implement stacktrace.js/stackframe#8
          line = line.replace(/eval code/g, 'eval').replace(/(\(eval at [^()]*)|(\),.*$)/g, '');
        }

        var sanitizedLine = line.replace(/^\s+/, '').replace(/\(eval code/g, '('); // capture and preseve the parenthesized location "(/foo/my bar.js:12:87)" in
        // case it has spaces in it, as the string is split on \s+ later on

        var location = sanitizedLine.match(/ (\((.+):(\d+):(\d+)\)$)/); // remove the parenthesized location from the line, if it was matched

        sanitizedLine = location ? sanitizedLine.replace(location[0], '') : sanitizedLine;
        var tokens = sanitizedLine.split(/\s+/).slice(1); // if a location was matched, pass it to extractLocation() otherwise pop the last token

        var locationParts = this.extractLocation(location ? location[1] : tokens.pop());
        var functionName = tokens.join(' ') || undefined;
        var fileName = ['eval', '<anonymous>'].indexOf(locationParts[0]) > -1 ? undefined : locationParts[0];
        return new StackFrame({
          functionName: functionName,
          fileName: fileName,
          lineNumber: locationParts[1],
          columnNumber: locationParts[2],
          source: line
        });
      }, this);
    },
    parseFFOrSafari: function ErrorStackParser$$parseFFOrSafari(error) {
      var filtered = error.stack.split('\n').filter(function (line) {
        return !line.match(SAFARI_NATIVE_CODE_REGEXP);
      }, this);
      return filtered.map(function (line) {
        // Throw away eval information until we implement stacktrace.js/stackframe#8
        if (line.indexOf(' > eval') > -1) {
          line = line.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g, ':$1');
        }

        if (line.indexOf('@') === -1 && line.indexOf(':') === -1) {
          // Safari eval frames only have function names and nothing else
          return new StackFrame({
            functionName: line
          });
        } else {
          var functionNameRegex = /((.*".+"[^@]*)?[^@]*)(?:@)/;
          var matches = line.match(functionNameRegex);
          var functionName = matches && matches[1] ? matches[1] : undefined;
          var locationParts = this.extractLocation(line.replace(functionNameRegex, ''));
          return new StackFrame({
            functionName: functionName,
            fileName: locationParts[0],
            lineNumber: locationParts[1],
            columnNumber: locationParts[2],
            source: line
          });
        }
      }, this);
    },
    parseOpera: function ErrorStackParser$$parseOpera(e) {
      if (!e.stacktrace || e.message.indexOf('\n') > -1 && e.message.split('\n').length > e.stacktrace.split('\n').length) {
        return this.parseOpera9(e);
      } else if (!e.stack) {
        return this.parseOpera10(e);
      } else {
        return this.parseOpera11(e);
      }
    },
    parseOpera9: function ErrorStackParser$$parseOpera9(e) {
      var lineRE = /Line (\d+).*script (?:in )?(\S+)/i;
      var lines = e.message.split('\n');
      var result = [];

      for (var i = 2, len = lines.length; i < len; i += 2) {
        var match = lineRE.exec(lines[i]);

        if (match) {
          result.push(new StackFrame({
            fileName: match[2],
            lineNumber: match[1],
            source: lines[i]
          }));
        }
      }

      return result;
    },
    parseOpera10: function ErrorStackParser$$parseOpera10(e) {
      var lineRE = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i;
      var lines = e.stacktrace.split('\n');
      var result = [];

      for (var i = 0, len = lines.length; i < len; i += 2) {
        var match = lineRE.exec(lines[i]);

        if (match) {
          result.push(new StackFrame({
            functionName: match[3] || undefined,
            fileName: match[2],
            lineNumber: match[1],
            source: lines[i]
          }));
        }
      }

      return result;
    },
    // Opera 10.65+ Error.stack very similar to FF/Safari
    parseOpera11: function ErrorStackParser$$parseOpera11(error) {
      var filtered = error.stack.split('\n').filter(function (line) {
        return !!line.match(FIREFOX_SAFARI_STACK_REGEXP) && !line.match(/^Error created at/);
      }, this);
      return filtered.map(function (line) {
        var tokens = line.split('@');
        var locationParts = this.extractLocation(tokens.pop());
        var functionCall = tokens.shift() || '';
        var functionName = functionCall.replace(/<anonymous function(: (\w+))?>/, '$2').replace(/\([^)]*\)/g, '') || undefined;
        var argsRaw;

        if (functionCall.match(/\(([^)]*)\)/)) {
          argsRaw = functionCall.replace(/^[^(]+\(([^)]*)\)$/, '$1');
        }

        var args = argsRaw === undefined || argsRaw === '[arguments not available]' ? undefined : argsRaw.split(',');
        return new StackFrame({
          functionName: functionName,
          args: args,
          fileName: locationParts[0],
          lineNumber: locationParts[1],
          columnNumber: locationParts[2],
          source: line
        });
      }, this);
    }
  };
});

/***/ }),

/***/ 172:
/***/ ((module) => {

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

/**
 * lodash (Custom Build) <https://lodash.com/>
 * Build: `lodash modularize exports="npm" -o ./`
 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
 * Released under MIT license <https://lodash.com/license>
 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 */

/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';
/** Used as references for various `Number` constants. */

var NAN = 0 / 0;
/** `Object#toString` result references. */

var symbolTag = '[object Symbol]';
/** Used to match leading and trailing whitespace. */

var reTrim = /^\s+|\s+$/g;
/** Used to detect bad signed hexadecimal string values. */

var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
/** Used to detect binary string values. */

var reIsBinary = /^0b[01]+$/i;
/** Used to detect octal string values. */

var reIsOctal = /^0o[0-7]+$/i;
/** Built-in method references without a dependency on `root`. */

var freeParseInt = parseInt;
/** Detect free variable `global` from Node.js. */

var freeGlobal = (typeof global === "undefined" ? "undefined" : _typeof(global)) == 'object' && global && global.Object === Object && global;
/** Detect free variable `self`. */

var freeSelf = (typeof self === "undefined" ? "undefined" : _typeof(self)) == 'object' && self && self.Object === Object && self;
/** Used as a reference to the global object. */

var root = freeGlobal || freeSelf || Function('return this')();
/** Used for built-in method references. */

var objectProto = Object.prototype;
/**
 * Used to resolve the
 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
 * of values.
 */

var objectToString = objectProto.toString;
/* Built-in method references for those with the same name as other `lodash` methods. */

var nativeMax = Math.max,
    nativeMin = Math.min;
/**
 * Gets the timestamp of the number of milliseconds that have elapsed since
 * the Unix epoch (1 January 1970 00:00:00 UTC).
 *
 * @static
 * @memberOf _
 * @since 2.4.0
 * @category Date
 * @returns {number} Returns the timestamp.
 * @example
 *
 * _.defer(function(stamp) {
 *   console.log(_.now() - stamp);
 * }, _.now());
 * // => Logs the number of milliseconds it took for the deferred invocation.
 */

var now = function now() {
  return root.Date.now();
};
/**
 * Creates a debounced function that delays invoking `func` until after `wait`
 * milliseconds have elapsed since the last time the debounced function was
 * invoked. The debounced function comes with a `cancel` method to cancel
 * delayed `func` invocations and a `flush` method to immediately invoke them.
 * Provide `options` to indicate whether `func` should be invoked on the
 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
 * with the last arguments provided to the debounced function. Subsequent
 * calls to the debounced function return the result of the last `func`
 * invocation.
 *
 * **Note:** If `leading` and `trailing` options are `true`, `func` is
 * invoked on the trailing edge of the timeout only if the debounced function
 * is invoked more than once during the `wait` timeout.
 *
 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
 *
 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
 * for details over the differences between `_.debounce` and `_.throttle`.
 *
 * @static
 * @memberOf _
 * @since 0.1.0
 * @category Function
 * @param {Function} func The function to debounce.
 * @param {number} [wait=0] The number of milliseconds to delay.
 * @param {Object} [options={}] The options object.
 * @param {boolean} [options.leading=false]
 *  Specify invoking on the leading edge of the timeout.
 * @param {number} [options.maxWait]
 *  The maximum time `func` is allowed to be delayed before it's invoked.
 * @param {boolean} [options.trailing=true]
 *  Specify invoking on the trailing edge of the timeout.
 * @returns {Function} Returns the new debounced function.
 * @example
 *
 * // Avoid costly calculations while the window size is in flux.
 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
 *
 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
 * jQuery(element).on('click', _.debounce(sendMail, 300, {
 *   'leading': true,
 *   'trailing': false
 * }));
 *
 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
 * var source = new EventSource('/stream');
 * jQuery(source).on('message', debounced);
 *
 * // Cancel the trailing debounced invocation.
 * jQuery(window).on('popstate', debounced.cancel);
 */


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 = undefined;
    lastInvokeTime = time;
    result = func.apply(thisArg, args);
    return result;
  }

  function leadingEdge(time) {
    // Reset any `maxWait` timer.
    lastInvokeTime = time; // Start the timer for the trailing edge.

    timerId = setTimeout(timerExpired, wait); // Invoke the leading edge.

    return leading ? invokeFunc(time) : result;
  }

  function remainingWait(time) {
    var timeSinceLastCall = time - lastCallTime,
        timeSinceLastInvoke = time - lastInvokeTime,
        result = wait - timeSinceLastCall;
    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
  }

  function shouldInvoke(time) {
    var timeSinceLastCall = time - lastCallTime,
        timeSinceLastInvoke = time - lastInvokeTime; // Either this is the first call, activity has stopped and we're at the
    // trailing edge, the system time has gone backwards and we're treating
    // it as the trailing edge, or we've hit the `maxWait` limit.

    return lastCallTime === undefined || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
  }

  function timerExpired() {
    var time = now();

    if (shouldInvoke(time)) {
      return trailingEdge(time);
    } // Restart the timer.


    timerId = setTimeout(timerExpired, remainingWait(time));
  }

  function trailingEdge(time) {
    timerId = undefined; // Only invoke if we have `lastArgs` which means `func` has been
    // debounced at least once.

    if (trailing && lastArgs) {
      return invokeFunc(time);
    }

    lastArgs = lastThis = undefined;
    return result;
  }

  function cancel() {
    if (timerId !== undefined) {
      clearTimeout(timerId);
    }

    lastInvokeTime = 0;
    lastArgs = lastCallTime = lastThis = timerId = undefined;
  }

  function flush() {
    return timerId === undefined ? result : trailingEdge(now());
  }

  function debounced() {
    var time = now(),
        isInvoking = shouldInvoke(time);
    lastArgs = arguments;
    lastThis = this;
    lastCallTime = time;

    if (isInvoking) {
      if (timerId === undefined) {
        return leadingEdge(lastCallTime);
      }

      if (maxing) {
        // Handle invocations in a tight loop.
        timerId = setTimeout(timerExpired, wait);
        return invokeFunc(lastCallTime);
      }
    }

    if (timerId === undefined) {
      timerId = setTimeout(timerExpired, wait);
    }

    return result;
  }

  debounced.cancel = cancel;
  debounced.flush = flush;
  return debounced;
}
/**
 * Creates a throttled function that only invokes `func` at most once per
 * every `wait` milliseconds. The throttled function comes with a `cancel`
 * method to cancel delayed `func` invocations and a `flush` method to
 * immediately invoke them. Provide `options` to indicate whether `func`
 * should be invoked on the leading and/or trailing edge of the `wait`
 * timeout. The `func` is invoked with the last arguments provided to the
 * throttled function. Subsequent calls to the throttled function return the
 * result of the last `func` invocation.
 *
 * **Note:** If `leading` and `trailing` options are `true`, `func` is
 * invoked on