@streamlayer/react 1.23.0 → 1.23.2

package/lib/classic/es/index11.js

@@ -1,183 +1,3099 @@
-import { s } from "./sl-types.js";
-import { Q as n } from "./useStreamLayerApp2.js";
-import { jsxs as a, jsx as i, Fragment as O } from "react/jsx-runtime";
-import { memo as b, useMemo as x } from "react";
-import { E as C } from "./index8.js";
-import { B as H } from "./index4.js";
-const ae = {
-  [n.TWEET]: { label: "Insight", iconName: "icon-insight" },
-  [n.PROMOTION]: { label: "Insight", iconName: "icon-insight" },
-  [n.UNSET]: void 0,
-  [n.FACTOID]: { label: "Insight", iconName: "icon-insight" },
-  [n.POLL]: { label: "Poll", iconName: "icon-poll" },
-  [n.TRIVIA]: { label: "Trivia", iconName: "icon-trivia" },
-  [n.PREDICTION]: { label: "Prediction", iconName: "icon-prediction" }
-}, ne = {
-  [n.TWEET]: "Learn more",
-  [n.FACTOID]: "Learn more",
-  [n.POLL]: "Answer",
-  [n.TRIVIA]: "Answer",
-  [n.PREDICTION]: "Answer",
-  [n.PROMOTION]: "",
-  [n.UNSET]: ""
-}, le = (t) => t.split(/\s+/).map((l) => l[0]).join("").toUpperCase(), oe = (t) => t ? t.toLocaleString("en-US") : "0", P = (t) => {
-  const l = new Date(t);
-  if (!l)
-    return "";
-  const m = /* @__PURE__ */ new Date(), o = Math.floor(m.getTime() - l.getTime());
-  return o < 6e4 ? `${Math.floor(o / 1e3)}s` : o < 36e5 ? `${Math.floor(o / 6e4)}m` : o < 864e5 ? `${Math.floor(o / 36e5)}h` : l.getFullYear() === m.getFullYear() ? `${l.toLocaleDateString("en-US", {
-    month: "short",
-    day: "numeric"
-  })}` : `${l.toLocaleDateString("en-US", {
-    month: "2-digit",
-    day: "2-digit",
-    year: "2-digit"
-  })}`;
-}, M = /* @__PURE__ */ s("div")({
-  name: "Container",
-  class: "cjq447q",
-  propsAsIs: !1
-}), R = /* @__PURE__ */ s("div")({
-  name: "ImageContainer",
-  class: "i14egogb",
-  propsAsIs: !1
-}), F = /* @__PURE__ */ s("img")({
-  name: "Image",
-  class: "i2g9g4l",
-  propsAsIs: !1
-}), j = () => H, V = /* @__PURE__ */ s(j())({
-  name: "TwitterIcon",
-  class: "t1c454nm",
-  propsAsIs: !0
-}), _ = /* @__PURE__ */ s("div")({
-  name: "Details",
-  class: "d11nigc3",
-  propsAsIs: !1
-}), z = /* @__PURE__ */ s("div")({
-  name: "Name",
-  class: "nrxa4k8",
-  propsAsIs: !1
-}), B = /* @__PURE__ */ s("div")({
-  name: "UserNameAndDate",
-  class: "u1p051g3",
-  propsAsIs: !1
-}), k = ({ image: t, name: l, userName: m, verified: o, createdTweet: p }) => {
-  const r = p && P(p);
-  return /* @__PURE__ */ a(M, { children: [
-    t && /* @__PURE__ */ a(R, { children: [
-      /* @__PURE__ */ i(F, { className: "SL_AccountImage", src: t }),
-      /* @__PURE__ */ i(V, { name: "twitter" })
-    ] }),
-    /* @__PURE__ */ a(_, { children: [
-      l && /* @__PURE__ */ a(z, { className: "SL_TweetAccountName", children: [
-        l,
-        " ",
-        o && /* @__PURE__ */ i(H, { name: "icon-twitter-verified" })
-      ] }),
-      m && /* @__PURE__ */ a(B, { className: "SL_TweetAccountUserName", children: [
-        "@",
-        m,
-        " ",
-        r && `･ ${r}`
-      ] })
-    ] })
-  ] });
-}, q = /* @__PURE__ */ s("div")({
-  name: "Container",
-  class: "c1kzqw87",
-  propsAsIs: !1
-}), Q = /* @__PURE__ */ s("div")({
-  name: "Details",
-  class: "d9r1hf9",
-  propsAsIs: !1
-}), W = /* @__PURE__ */ s("div")({
-  name: "Body",
-  class: "bezygt5",
-  propsAsIs: !1
-}), d = /* @__PURE__ */ s("div")({
-  name: "ImagesContainer",
-  class: "i1y8f7ym",
-  propsAsIs: !1
-}), v = /* @__PURE__ */ s("div")({
-  name: "ImagesBlock",
-  class: "i18gwonx",
-  propsAsIs: !1
-}), L = /* @__PURE__ */ s("img")({
-  name: "Image",
-  class: "i3g0xjd",
-  propsAsIs: !1
-}), Y = () => L, c = /* @__PURE__ */ s(Y())({
-  name: "ImageFullSize",
-  class: "io8rt7p",
-  propsAsIs: !0
-}), G = () => L, I = /* @__PURE__ */ s(G())({
-  name: "ImageHalfSize",
-  class: "i4hn3ox",
-  propsAsIs: !0
-}), J = new RegExp("\\s?https?://t.co[^\\s]+(\\s+)?$"), K = (t) => t == null ? void 0 : t.replace(J, ""), re = b(
-  ({ image: t, body: l, muted: m, account: o, accountVerified: p, tweet: r, isDetail: h, controlVideo: S }) => {
-    var A, f, T, N, U;
-    const e = (f = (A = r == null ? void 0 : r.meta) == null ? void 0 : A.extendedEntities) == null ? void 0 : f.media, g = e == null ? void 0 : e.find(({ type: u }) => u === "photo"), $ = x(() => {
-      var u, w, D, y;
-      return (y = (D = (w = (u = e == null ? void 0 : e[0]) == null ? void 0 : u.videoInfo) == null ? void 0 : w.variants) == null ? void 0 : D.findLast(({ contentType: E }) => E === "video/mp4")) == null ? void 0 : y.url;
-    }, [e]);
-    return /* @__PURE__ */ a(q, { children: [
-      /* @__PURE__ */ a(Q, { children: [
-        /* @__PURE__ */ i(
-          k,
-          {
-            image: t,
-            name: (T = r == null ? void 0 : r.meta) == null ? void 0 : T.accountName,
-            userName: o,
-            verified: p,
-            createdTweet: r == null ? void 0 : r.date
-          }
-        ),
-        /* @__PURE__ */ i(W, { children: K(l) }),
-        !h && g && /* @__PURE__ */ i(d, { children: /* @__PURE__ */ i(c, { src: e == null ? void 0 : e[0].mediaUrlHttps }) }),
-        h && g && /* @__PURE__ */ a(O, { children: [
-          (e == null ? void 0 : e.length) === 1 && /* @__PURE__ */ i(d, { children: /* @__PURE__ */ i(c, { src: e[0].mediaUrlHttps }) }),
-          (e == null ? void 0 : e.length) === 2 && /* @__PURE__ */ a(d, { children: [
-            /* @__PURE__ */ i(I, { src: e[0].mediaUrlHttps }),
-            /* @__PURE__ */ i(I, { src: e[1].mediaUrlHttps })
-          ] }),
-          (e == null ? void 0 : e.length) === 3 && /* @__PURE__ */ a(d, { children: [
-            /* @__PURE__ */ i(I, { src: e[0].mediaUrlHttps }),
-            /* @__PURE__ */ a(v, { children: [
-              /* @__PURE__ */ i(c, { src: e[1].mediaUrlHttps }),
-              /* @__PURE__ */ i(c, { src: e[2].mediaUrlHttps })
-            ] })
-          ] }),
-          (e == null ? void 0 : e.length) === 4 && /* @__PURE__ */ a(d, { children: [
-            /* @__PURE__ */ a(v, { children: [
-              /* @__PURE__ */ i(c, { src: e[0].mediaUrlHttps }),
-              /* @__PURE__ */ i(c, { src: e[1].mediaUrlHttps })
-            ] }),
-            /* @__PURE__ */ a(v, { children: [
-              /* @__PURE__ */ i(c, { src: e[2].mediaUrlHttps }),
-              /* @__PURE__ */ i(c, { src: e[3].mediaUrlHttps })
-            ] })
-          ] })
-        ] })
-      ] }),
-      !g && (((N = e == null ? void 0 : e[0]) == null ? void 0 : N.type) === "video" || ((U = e == null ? void 0 : e[0]) == null ? void 0 : U.type) === "animated_gif") && $ && /* @__PURE__ */ i(
-        C,
-        {
-          muted: m,
-          source: $,
-          poster: e[0].mediaUrlHttps,
-          controlVideo: S
-        }
-      )
-    ] });
+import React36__default from "react";
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+  if (typeof f == "function") {
+    var a = function a2() {
+      if (this instanceof a2) {
+        return Reflect.construct(f, arguments, this.constructor);
+      }
+      return f.apply(this, arguments);
+    };
+    a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
+      get: function() {
+        return n[k];
+      }
+    });
+  });
+  return a;
+}
+var dist = { exports: {} };
+var isObject_1;
+var hasRequiredIsObject;
+function requireIsObject() {
+  if (hasRequiredIsObject) return isObject_1;
+  hasRequiredIsObject = 1;
+  function isObject2(value) {
+    var type = typeof value;
+    return value != null && (type == "object" || type == "function");
+  }
+  isObject_1 = isObject2;
+  return isObject_1;
+}
+var _freeGlobal;
+var hasRequired_freeGlobal;
+function require_freeGlobal() {
+  if (hasRequired_freeGlobal) return _freeGlobal;
+  hasRequired_freeGlobal = 1;
+  var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+  _freeGlobal = freeGlobal;
+  return _freeGlobal;
+}
+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 root2 = freeGlobal || freeSelf || Function("return this")();
+  _root = root2;
+  return _root;
+}
+var now_1;
+var hasRequiredNow;
+function requireNow() {
+  if (hasRequiredNow) return now_1;
+  hasRequiredNow = 1;
+  var root2 = require_root();
+  var now = function() {
+    return root2.Date.now();
+  };
+  now_1 = now;
+  return now_1;
+}
+var _trimmedEndIndex;
+var hasRequired_trimmedEndIndex;
+function require_trimmedEndIndex() {
+  if (hasRequired_trimmedEndIndex) return _trimmedEndIndex;
+  hasRequired_trimmedEndIndex = 1;
+  var reWhitespace = /\s/;
+  function trimmedEndIndex(string) {
+    var index = string.length;
+    while (index-- && reWhitespace.test(string.charAt(index))) {
+    }
+    return index;
+  }
+  _trimmedEndIndex = trimmedEndIndex;
+  return _trimmedEndIndex;
+}
+var _baseTrim;
+var hasRequired_baseTrim;
+function require_baseTrim() {
+  if (hasRequired_baseTrim) return _baseTrim;
+  hasRequired_baseTrim = 1;
+  var trimmedEndIndex = require_trimmedEndIndex();
+  var reTrimStart = /^\s+/;
+  function baseTrim(string) {
+    return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+  }
+  _baseTrim = baseTrim;
+  return _baseTrim;
+}
+var _Symbol;
+var hasRequired_Symbol;
+function require_Symbol() {
+  if (hasRequired_Symbol) return _Symbol;
+  hasRequired_Symbol = 1;
+  var root2 = require_root();
+  var Symbol = root2.Symbol;
+  _Symbol = Symbol;
+  return _Symbol;
+}
+var _getRawTag;
+var hasRequired_getRawTag;
+function require_getRawTag() {
+  if (hasRequired_getRawTag) return _getRawTag;
+  hasRequired_getRawTag = 1;
+  var Symbol = require_Symbol();
+  var objectProto2 = Object.prototype;
+  var hasOwnProperty2 = objectProto2.hasOwnProperty;
+  var nativeObjectToString = objectProto2.toString;
+  var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+  function getRawTag(value) {
+    var isOwn = hasOwnProperty2.call(value, symToStringTag), tag = value[symToStringTag];
+    try {
+      value[symToStringTag] = void 0;
+      var unmasked = true;
+    } catch (e) {
+    }
+    var result = nativeObjectToString.call(value);
+    if (unmasked) {
+      if (isOwn) {
+        value[symToStringTag] = tag;
+      } else {
+        delete value[symToStringTag];
+      }
+    }
+    return result;
+  }
+  _getRawTag = getRawTag;
+  return _getRawTag;
+}
+var _objectToString;
+var hasRequired_objectToString;
+function require_objectToString() {
+  if (hasRequired_objectToString) return _objectToString;
+  hasRequired_objectToString = 1;
+  var objectProto2 = Object.prototype;
+  var nativeObjectToString = objectProto2.toString;
+  function objectToString(value) {
+    return nativeObjectToString.call(value);
+  }
+  _objectToString = objectToString;
+  return _objectToString;
+}
+var _baseGetTag;
+var hasRequired_baseGetTag;
+function require_baseGetTag() {
+  if (hasRequired_baseGetTag) return _baseGetTag;
+  hasRequired_baseGetTag = 1;
+  var Symbol = require_Symbol(), getRawTag = require_getRawTag(), objectToString = require_objectToString();
+  var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+  var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+  function baseGetTag2(value) {
+    if (value == null) {
+      return value === void 0 ? undefinedTag : nullTag;
+    }
+    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+  }
+  _baseGetTag = baseGetTag2;
+  return _baseGetTag;
+}
+var isObjectLike_1;
+var hasRequiredIsObjectLike;
+function requireIsObjectLike() {
+  if (hasRequiredIsObjectLike) return isObjectLike_1;
+  hasRequiredIsObjectLike = 1;
+  function isObjectLike(value) {
+    return value != null && typeof value == "object";
+  }
+  isObjectLike_1 = isObjectLike;
+  return isObjectLike_1;
+}
+var isSymbol_1;
+var hasRequiredIsSymbol;
+function requireIsSymbol() {
+  if (hasRequiredIsSymbol) return isSymbol_1;
+  hasRequiredIsSymbol = 1;
+  var baseGetTag2 = require_baseGetTag(), isObjectLike = requireIsObjectLike();
+  var symbolTag = "[object Symbol]";
+  function isSymbol(value) {
+    return typeof value == "symbol" || isObjectLike(value) && baseGetTag2(value) == symbolTag;
+  }
+  isSymbol_1 = isSymbol;
+  return isSymbol_1;
+}
+var toNumber_1;
+var hasRequiredToNumber;
+function requireToNumber() {
+  if (hasRequiredToNumber) return toNumber_1;
+  hasRequiredToNumber = 1;
+  var baseTrim = require_baseTrim(), isObject2 = requireIsObject(), isSymbol = requireIsSymbol();
+  var NAN = 0 / 0;
+  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+  var reIsBinary = /^0b[01]+$/i;
+  var reIsOctal = /^0o[0-7]+$/i;
+  var freeParseInt = parseInt;
+  function toNumber(value) {
+    if (typeof value == "number") {
+      return value;
+    }
+    if (isSymbol(value)) {
+      return NAN;
+    }
+    if (isObject2(value)) {
+      var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+      value = isObject2(other) ? other + "" : other;
+    }
+    if (typeof value != "string") {
+      return value === 0 ? value : +value;
+    }
+    value = baseTrim(value);
+    var isBinary = reIsBinary.test(value);
+    return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
   }
+  toNumber_1 = toNumber;
+  return toNumber_1;
+}
+var debounce_1;
+var hasRequiredDebounce;
+function requireDebounce() {
+  if (hasRequiredDebounce) return debounce_1;
+  hasRequiredDebounce = 1;
+  var isObject2 = requireIsObject(), now = requireNow(), toNumber = requireToNumber();
+  var FUNC_ERROR_TEXT2 = "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_TEXT2);
+    }
+    wait = toNumber(wait) || 0;
+    if (isObject2(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;
+}
+var isFunction_1;
+var hasRequiredIsFunction;
+function requireIsFunction() {
+  if (hasRequiredIsFunction) return isFunction_1;
+  hasRequiredIsFunction = 1;
+  var baseGetTag2 = require_baseGetTag(), isObject2 = requireIsObject();
+  var asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+  function isFunction2(value) {
+    if (!isObject2(value)) {
+      return false;
+    }
+    var tag = baseGetTag2(value);
+    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+  }
+  isFunction_1 = isFunction2;
+  return isFunction_1;
+}
+var root$6 = require_root();
+var coreJsData$1 = root$6["__core-js_shared__"];
+var _coreJsData = coreJsData$1;
+var coreJsData = _coreJsData;
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked$1(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked = isMasked$1;
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource$2(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var _toSource = toSource$2;
+var isFunction = requireIsFunction(), isMasked = _isMasked, isObject = requireIsObject(), toSource$1 = _toSource;
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto$2 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty = objectProto$2.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
 );
+function baseIsNative$1(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource$1(value));
+}
+var _baseIsNative = baseIsNative$1;
+function getValue$1(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var _getValue = getValue$1;
+var baseIsNative = _baseIsNative, getValue = _getValue;
+function getNative$5(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var _getNative = getNative$5;
+var _nativeCreate;
+var hasRequired_nativeCreate;
+function require_nativeCreate() {
+  if (hasRequired_nativeCreate) return _nativeCreate;
+  hasRequired_nativeCreate = 1;
+  var getNative2 = _getNative;
+  var nativeCreate = getNative2(Object, "create");
+  _nativeCreate = nativeCreate;
+  return _nativeCreate;
+}
+var _hashClear;
+var hasRequired_hashClear;
+function require_hashClear() {
+  if (hasRequired_hashClear) return _hashClear;
+  hasRequired_hashClear = 1;
+  var nativeCreate = require_nativeCreate();
+  function hashClear() {
+    this.__data__ = nativeCreate ? nativeCreate(null) : {};
+    this.size = 0;
+  }
+  _hashClear = hashClear;
+  return _hashClear;
+}
+var _hashDelete;
+var hasRequired_hashDelete;
+function require_hashDelete() {
+  if (hasRequired_hashDelete) return _hashDelete;
+  hasRequired_hashDelete = 1;
+  function hashDelete(key) {
+    var result = this.has(key) && delete this.__data__[key];
+    this.size -= result ? 1 : 0;
+    return result;
+  }
+  _hashDelete = hashDelete;
+  return _hashDelete;
+}
+var _hashGet;
+var hasRequired_hashGet;
+function require_hashGet() {
+  if (hasRequired_hashGet) return _hashGet;
+  hasRequired_hashGet = 1;
+  var nativeCreate = require_nativeCreate();
+  var HASH_UNDEFINED = "__lodash_hash_undefined__";
+  var objectProto2 = Object.prototype;
+  var hasOwnProperty2 = objectProto2.hasOwnProperty;
+  function hashGet(key) {
+    var data = this.__data__;
+    if (nativeCreate) {
+      var result = data[key];
+      return result === HASH_UNDEFINED ? void 0 : result;
+    }
+    return hasOwnProperty2.call(data, key) ? data[key] : void 0;
+  }
+  _hashGet = hashGet;
+  return _hashGet;
+}
+var _hashHas;
+var hasRequired_hashHas;
+function require_hashHas() {
+  if (hasRequired_hashHas) return _hashHas;
+  hasRequired_hashHas = 1;
+  var nativeCreate = require_nativeCreate();
+  var objectProto2 = Object.prototype;
+  var hasOwnProperty2 = objectProto2.hasOwnProperty;
+  function hashHas(key) {
+    var data = this.__data__;
+    return nativeCreate ? data[key] !== void 0 : hasOwnProperty2.call(data, key);
+  }
+  _hashHas = hashHas;
+  return _hashHas;
+}
+var _hashSet;
+var hasRequired_hashSet;
+function require_hashSet() {
+  if (hasRequired_hashSet) return _hashSet;
+  hasRequired_hashSet = 1;
+  var nativeCreate = require_nativeCreate();
+  var HASH_UNDEFINED = "__lodash_hash_undefined__";
+  function hashSet(key, value) {
+    var data = this.__data__;
+    this.size += this.has(key) ? 0 : 1;
+    data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+    return this;
+  }
+  _hashSet = hashSet;
+  return _hashSet;
+}
+var _Hash;
+var hasRequired_Hash;
+function require_Hash() {
+  if (hasRequired_Hash) return _Hash;
+  hasRequired_Hash = 1;
+  var hashClear = require_hashClear(), hashDelete = require_hashDelete(), hashGet = require_hashGet(), hashHas = require_hashHas(), hashSet = require_hashSet();
+  function Hash(entries) {
+    var index = -1, length = entries == null ? 0 : entries.length;
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+  Hash.prototype.clear = hashClear;
+  Hash.prototype["delete"] = hashDelete;
+  Hash.prototype.get = hashGet;
+  Hash.prototype.has = hashHas;
+  Hash.prototype.set = hashSet;
+  _Hash = Hash;
+  return _Hash;
+}
+function listCacheClear$1() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear = listCacheClear$1;
+var eq_1;
+var hasRequiredEq;
+function requireEq() {
+  if (hasRequiredEq) return eq_1;
+  hasRequiredEq = 1;
+  function eq2(value, other) {
+    return value === other || value !== value && other !== other;
+  }
+  eq_1 = eq2;
+  return eq_1;
+}
+var eq = requireEq();
+function assocIndexOf$4(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf = assocIndexOf$4;
+var assocIndexOf$3 = _assocIndexOf;
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete$1(key) {
+  var data = this.__data__, index = assocIndexOf$3(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;
+}
+var _listCacheDelete = listCacheDelete$1;
+var assocIndexOf$2 = _assocIndexOf;
+function listCacheGet$1(key) {
+  var data = this.__data__, index = assocIndexOf$2(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var _listCacheGet = listCacheGet$1;
+var assocIndexOf$1 = _assocIndexOf;
+function listCacheHas$1(key) {
+  return assocIndexOf$1(this.__data__, key) > -1;
+}
+var _listCacheHas = listCacheHas$1;
+var assocIndexOf = _assocIndexOf;
+function listCacheSet$1(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;
+}
+var _listCacheSet = listCacheSet$1;
+var listCacheClear = _listCacheClear, listCacheDelete = _listCacheDelete, listCacheGet = _listCacheGet, listCacheHas = _listCacheHas, listCacheSet = _listCacheSet;
+function ListCache$3(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache$3.prototype.clear = listCacheClear;
+ListCache$3.prototype["delete"] = listCacheDelete;
+ListCache$3.prototype.get = listCacheGet;
+ListCache$3.prototype.has = listCacheHas;
+ListCache$3.prototype.set = listCacheSet;
+var _ListCache = ListCache$3;
+var getNative$4 = _getNative, root$5 = require_root();
+var Map$2 = getNative$4(root$5, "Map");
+var _Map = Map$2;
+var _mapCacheClear;
+var hasRequired_mapCacheClear;
+function require_mapCacheClear() {
+  if (hasRequired_mapCacheClear) return _mapCacheClear;
+  hasRequired_mapCacheClear = 1;
+  var Hash = require_Hash(), ListCache2 = _ListCache, Map2 = _Map;
+  function mapCacheClear() {
+    this.size = 0;
+    this.__data__ = {
+      "hash": new Hash(),
+      "map": new (Map2 || ListCache2)(),
+      "string": new Hash()
+    };
+  }
+  _mapCacheClear = mapCacheClear;
+  return _mapCacheClear;
+}
+var _isKeyable;
+var hasRequired_isKeyable;
+function require_isKeyable() {
+  if (hasRequired_isKeyable) return _isKeyable;
+  hasRequired_isKeyable = 1;
+  function isKeyable(value) {
+    var type = typeof value;
+    return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+  }
+  _isKeyable = isKeyable;
+  return _isKeyable;
+}
+var _getMapData;
+var hasRequired_getMapData;
+function require_getMapData() {
+  if (hasRequired_getMapData) return _getMapData;
+  hasRequired_getMapData = 1;
+  var isKeyable = require_isKeyable();
+  function getMapData(map, key) {
+    var data = map.__data__;
+    return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+  }
+  _getMapData = getMapData;
+  return _getMapData;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+var _MapCache;
+var hasRequired_MapCache;
+function require_MapCache() {
+  if (hasRequired_MapCache) return _MapCache;
+  hasRequired_MapCache = 1;
+  var mapCacheClear = require_mapCacheClear(), mapCacheDelete = require_mapCacheDelete(), mapCacheGet = require_mapCacheGet(), mapCacheHas = require_mapCacheHas(), mapCacheSet = require_mapCacheSet();
+  function MapCache2(entries) {
+    var index = -1, length = entries == null ? 0 : entries.length;
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+  MapCache2.prototype.clear = mapCacheClear;
+  MapCache2.prototype["delete"] = mapCacheDelete;
+  MapCache2.prototype.get = mapCacheGet;
+  MapCache2.prototype.has = mapCacheHas;
+  MapCache2.prototype.set = mapCacheSet;
+  _MapCache = MapCache2;
+  return _MapCache;
+}
+var _setCacheAdd;
+var hasRequired_setCacheAdd;
+function require_setCacheAdd() {
+  if (hasRequired_setCacheAdd) return _setCacheAdd;
+  hasRequired_setCacheAdd = 1;
+  var HASH_UNDEFINED = "__lodash_hash_undefined__";
+  function setCacheAdd(value) {
+    this.__data__.set(value, HASH_UNDEFINED);
+    return this;
+  }
+  _setCacheAdd = setCacheAdd;
+  return _setCacheAdd;
+}
+var _setCacheHas;
+var hasRequired_setCacheHas;
+function require_setCacheHas() {
+  if (hasRequired_setCacheHas) return _setCacheHas;
+  hasRequired_setCacheHas = 1;
+  function setCacheHas(value) {
+    return this.__data__.has(value);
+  }
+  _setCacheHas = setCacheHas;
+  return _setCacheHas;
+}
+var _SetCache;
+var hasRequired_SetCache;
+function require_SetCache() {
+  if (hasRequired_SetCache) return _SetCache;
+  hasRequired_SetCache = 1;
+  var MapCache2 = require_MapCache(), setCacheAdd = require_setCacheAdd(), setCacheHas = require_setCacheHas();
+  function SetCache(values) {
+    var index = -1, length = values == null ? 0 : values.length;
+    this.__data__ = new MapCache2();
+    while (++index < length) {
+      this.add(values[index]);
+    }
+  }
+  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+  SetCache.prototype.has = setCacheHas;
+  _SetCache = SetCache;
+  return _SetCache;
+}
+var _baseFindIndex;
+var hasRequired_baseFindIndex;
+function require_baseFindIndex() {
+  if (hasRequired_baseFindIndex) return _baseFindIndex;
+  hasRequired_baseFindIndex = 1;
+  function baseFindIndex(array, predicate, fromIndex, fromRight) {
+    var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
+    while (fromRight ? index-- : ++index < length) {
+      if (predicate(array[index], index, array)) {
+        return index;
+      }
+    }
+    return -1;
+  }
+  _baseFindIndex = baseFindIndex;
+  return _baseFindIndex;
+}
+var _baseIsNaN;
+var hasRequired_baseIsNaN;
+function require_baseIsNaN() {
+  if (hasRequired_baseIsNaN) return _baseIsNaN;
+  hasRequired_baseIsNaN = 1;
+  function baseIsNaN(value) {
+    return value !== value;
+  }
+  _baseIsNaN = baseIsNaN;
+  return _baseIsNaN;
+}
+var _strictIndexOf;
+var hasRequired_strictIndexOf;
+function require_strictIndexOf() {
+  if (hasRequired_strictIndexOf) return _strictIndexOf;
+  hasRequired_strictIndexOf = 1;
+  function strictIndexOf(array, value, fromIndex) {
+    var index = fromIndex - 1, length = array.length;
+    while (++index < length) {
+      if (array[index] === value) {
+        return index;
+      }
+    }
+    return -1;
+  }
+  _strictIndexOf = strictIndexOf;
+  return _strictIndexOf;
+}
+var _baseIndexOf;
+var hasRequired_baseIndexOf;
+function require_baseIndexOf() {
+  if (hasRequired_baseIndexOf) return _baseIndexOf;
+  hasRequired_baseIndexOf = 1;
+  var baseFindIndex = require_baseFindIndex(), baseIsNaN = require_baseIsNaN(), strictIndexOf = require_strictIndexOf();
+  function baseIndexOf(array, value, fromIndex) {
+    return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
+  }
+  _baseIndexOf = baseIndexOf;
+  return _baseIndexOf;
+}
+var _arrayIncludes;
+var hasRequired_arrayIncludes;
+function require_arrayIncludes() {
+  if (hasRequired_arrayIncludes) return _arrayIncludes;
+  hasRequired_arrayIncludes = 1;
+  var baseIndexOf = require_baseIndexOf();
+  function arrayIncludes(array, value) {
+    var length = array == null ? 0 : array.length;
+    return !!length && baseIndexOf(array, value, 0) > -1;
+  }
+  _arrayIncludes = arrayIncludes;
+  return _arrayIncludes;
+}
+var _arrayIncludesWith;
+var hasRequired_arrayIncludesWith;
+function require_arrayIncludesWith() {
+  if (hasRequired_arrayIncludesWith) return _arrayIncludesWith;
+  hasRequired_arrayIncludesWith = 1;
+  function arrayIncludesWith(array, value, comparator) {
+    var index = -1, length = array == null ? 0 : array.length;
+    while (++index < length) {
+      if (comparator(value, array[index])) {
+        return true;
+      }
+    }
+    return false;
+  }
+  _arrayIncludesWith = arrayIncludesWith;
+  return _arrayIncludesWith;
+}
+function arrayMap(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+var _arrayMap = arrayMap;
+var _baseUnary;
+var hasRequired_baseUnary;
+function require_baseUnary() {
+  if (hasRequired_baseUnary) return _baseUnary;
+  hasRequired_baseUnary = 1;
+  function baseUnary(func) {
+    return function(value) {
+      return func(value);
+    };
+  }
+  _baseUnary = baseUnary;
+  return _baseUnary;
+}
+var _cacheHas;
+var hasRequired_cacheHas;
+function require_cacheHas() {
+  if (hasRequired_cacheHas) return _cacheHas;
+  hasRequired_cacheHas = 1;
+  function cacheHas(cache, key) {
+    return cache.has(key);
+  }
+  _cacheHas = cacheHas;
+  return _cacheHas;
+}
+var _baseDifference;
+var hasRequired_baseDifference;
+function require_baseDifference() {
+  if (hasRequired_baseDifference) return _baseDifference;
+  hasRequired_baseDifference = 1;
+  var SetCache = require_SetCache(), arrayIncludes = require_arrayIncludes(), arrayIncludesWith = require_arrayIncludesWith(), arrayMap2 = _arrayMap, baseUnary = require_baseUnary(), cacheHas = require_cacheHas();
+  var LARGE_ARRAY_SIZE2 = 200;
+  function baseDifference(array, values, iteratee, comparator) {
+    var index = -1, includes = arrayIncludes, isCommon = true, length = array.length, result = [], valuesLength = values.length;
+    if (!length) {
+      return result;
+    }
+    if (iteratee) {
+      values = arrayMap2(values, baseUnary(iteratee));
+    }
+    if (comparator) {
+      includes = arrayIncludesWith;
+      isCommon = false;
+    } else if (values.length >= LARGE_ARRAY_SIZE2) {
+      includes = cacheHas;
+      isCommon = false;
+      values = new SetCache(values);
+    }
+    outer:
+      while (++index < length) {
+        var value = array[index], computed = iteratee == null ? value : iteratee(value);
+        value = comparator || value !== 0 ? value : 0;
+        if (isCommon && computed === computed) {
+          var valuesIndex = valuesLength;
+          while (valuesIndex--) {
+            if (values[valuesIndex] === computed) {
+              continue outer;
+            }
+          }
+          result.push(value);
+        } else if (!includes(values, computed, comparator)) {
+          result.push(value);
+        }
+      }
+    return result;
+  }
+  _baseDifference = baseDifference;
+  return _baseDifference;
+}
+var _arrayPush;
+var hasRequired_arrayPush;
+function require_arrayPush() {
+  if (hasRequired_arrayPush) return _arrayPush;
+  hasRequired_arrayPush = 1;
+  function arrayPush2(array, values) {
+    var index = -1, length = values.length, offset = array.length;
+    while (++index < length) {
+      array[offset + index] = values[index];
+    }
+    return array;
+  }
+  _arrayPush = arrayPush2;
+  return _arrayPush;
+}
+var _baseIsArguments;
+var hasRequired_baseIsArguments;
+function require_baseIsArguments() {
+  if (hasRequired_baseIsArguments) return _baseIsArguments;
+  hasRequired_baseIsArguments = 1;
+  var baseGetTag2 = require_baseGetTag(), isObjectLike = requireIsObjectLike();
+  var argsTag = "[object Arguments]";
+  function baseIsArguments(value) {
+    return isObjectLike(value) && baseGetTag2(value) == argsTag;
+  }
+  _baseIsArguments = baseIsArguments;
+  return _baseIsArguments;
+}
+var isArguments_1;
+var hasRequiredIsArguments;
+function requireIsArguments() {
+  if (hasRequiredIsArguments) return isArguments_1;
+  hasRequiredIsArguments = 1;
+  var baseIsArguments = require_baseIsArguments(), isObjectLike = requireIsObjectLike();
+  var objectProto2 = Object.prototype;
+  var hasOwnProperty2 = objectProto2.hasOwnProperty;
+  var propertyIsEnumerable2 = objectProto2.propertyIsEnumerable;
+  var isArguments = baseIsArguments(/* @__PURE__ */ function() {
+    return arguments;
+  }()) ? baseIsArguments : function(value) {
+    return isObjectLike(value) && hasOwnProperty2.call(value, "callee") && !propertyIsEnumerable2.call(value, "callee");
+  };
+  isArguments_1 = isArguments;
+  return isArguments_1;
+}
+var isArray_1;
+var hasRequiredIsArray;
+function requireIsArray() {
+  if (hasRequiredIsArray) return isArray_1;
+  hasRequiredIsArray = 1;
+  var isArray2 = Array.isArray;
+  isArray_1 = isArray2;
+  return isArray_1;
+}
+var _isFlattenable;
+var hasRequired_isFlattenable;
+function require_isFlattenable() {
+  if (hasRequired_isFlattenable) return _isFlattenable;
+  hasRequired_isFlattenable = 1;
+  var Symbol = require_Symbol(), isArguments = requireIsArguments(), isArray2 = requireIsArray();
+  var spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : void 0;
+  function isFlattenable(value) {
+    return isArray2(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
+  }
+  _isFlattenable = isFlattenable;
+  return _isFlattenable;
+}
+var _baseFlatten;
+var hasRequired_baseFlatten;
+function require_baseFlatten() {
+  if (hasRequired_baseFlatten) return _baseFlatten;
+  hasRequired_baseFlatten = 1;
+  var arrayPush2 = require_arrayPush(), isFlattenable = require_isFlattenable();
+  function baseFlatten(array, depth, predicate, isStrict, result) {
+    var index = -1, length = array.length;
+    predicate || (predicate = isFlattenable);
+    result || (result = []);
+    while (++index < length) {
+      var value = array[index];
+      if (depth > 0 && predicate(value)) {
+        if (depth > 1) {
+          baseFlatten(value, depth - 1, predicate, isStrict, result);
+        } else {
+          arrayPush2(result, value);
+        }
+      } else if (!isStrict) {
+        result[result.length] = value;
+      }
+    }
+    return result;
+  }
+  _baseFlatten = baseFlatten;
+  return _baseFlatten;
+}
+var identity_1;
+var hasRequiredIdentity;
+function requireIdentity() {
+  if (hasRequiredIdentity) return identity_1;
+  hasRequiredIdentity = 1;
+  function identity(value) {
+    return value;
+  }
+  identity_1 = identity;
+  return identity_1;
+}
+var _apply;
+var hasRequired_apply;
+function require_apply() {
+  if (hasRequired_apply) return _apply;
+  hasRequired_apply = 1;
+  function apply(func, thisArg, args) {
+    switch (args.length) {
+      case 0:
+        return func.call(thisArg);
+      case 1:
+        return func.call(thisArg, args[0]);
+      case 2:
+        return func.call(thisArg, args[0], args[1]);
+      case 3:
+        return func.call(thisArg, args[0], args[1], args[2]);
+    }
+    return func.apply(thisArg, args);
+  }
+  _apply = apply;
+  return _apply;
+}
+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;
+}
+var constant_1;
+var hasRequiredConstant;
+function requireConstant() {
+  if (hasRequiredConstant) return constant_1;
+  hasRequiredConstant = 1;
+  function constant(value) {
+    return function() {
+      return value;
+    };
+  }
+  constant_1 = constant;
+  return constant_1;
+}
+var _defineProperty;
+var hasRequired_defineProperty;
+function require_defineProperty() {
+  if (hasRequired_defineProperty) return _defineProperty;
+  hasRequired_defineProperty = 1;
+  var getNative2 = _getNative;
+  var defineProperty = function() {
+    try {
+      var func = getNative2(Object, "defineProperty");
+      func({}, "", {});
+      return func;
+    } catch (e) {
+    }
+  }();
+  _defineProperty = defineProperty;
+  return _defineProperty;
+}
+var _baseSetToString;
+var hasRequired_baseSetToString;
+function require_baseSetToString() {
+  if (hasRequired_baseSetToString) return _baseSetToString;
+  hasRequired_baseSetToString = 1;
+  var constant = requireConstant(), defineProperty = require_defineProperty(), identity = requireIdentity();
+  var baseSetToString = !defineProperty ? identity : function(func, string) {
+    return defineProperty(func, "toString", {
+      "configurable": true,
+      "enumerable": false,
+      "value": constant(string),
+      "writable": true
+    });
+  };
+  _baseSetToString = baseSetToString;
+  return _baseSetToString;
+}
+var _shortOut;
+var hasRequired_shortOut;
+function require_shortOut() {
+  if (hasRequired_shortOut) return _shortOut;
+  hasRequired_shortOut = 1;
+  var HOT_COUNT = 800, HOT_SPAN = 16;
+  var nativeNow = Date.now;
+  function shortOut(func) {
+    var count = 0, lastCalled = 0;
+    return function() {
+      var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+      lastCalled = stamp;
+      if (remaining > 0) {
+        if (++count >= HOT_COUNT) {
+          return arguments[0];
+        }
+      } else {
+        count = 0;
+      }
+      return func.apply(void 0, arguments);
+    };
+  }
+  _shortOut = shortOut;
+  return _shortOut;
+}
+var _setToString;
+var hasRequired_setToString;
+function require_setToString() {
+  if (hasRequired_setToString) return _setToString;
+  hasRequired_setToString = 1;
+  var baseSetToString = require_baseSetToString(), shortOut = require_shortOut();
+  var setToString = shortOut(baseSetToString);
+  _setToString = setToString;
+  return _setToString;
+}
+var _baseRest;
+var hasRequired_baseRest;
+function require_baseRest() {
+  if (hasRequired_baseRest) return _baseRest;
+  hasRequired_baseRest = 1;
+  var identity = requireIdentity(), overRest = require_overRest(), setToString = require_setToString();
+  function baseRest(func, start) {
+    return setToString(overRest(func, start, identity), func + "");
+  }
+  _baseRest = baseRest;
+  return _baseRest;
+}
+var isLength_1;
+var hasRequiredIsLength;
+function requireIsLength() {
+  if (hasRequiredIsLength) return isLength_1;
+  hasRequiredIsLength = 1;
+  var MAX_SAFE_INTEGER = 9007199254740991;
+  function isLength(value) {
+    return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+  }
+  isLength_1 = isLength;
+  return isLength_1;
+}
+var isArrayLike_1;
+var hasRequiredIsArrayLike;
+function requireIsArrayLike() {
+  if (hasRequiredIsArrayLike) return isArrayLike_1;
+  hasRequiredIsArrayLike = 1;
+  var isFunction2 = requireIsFunction(), isLength = requireIsLength();
+  function isArrayLike(value) {
+    return value != null && isLength(value.length) && !isFunction2(value);
+  }
+  isArrayLike_1 = isArrayLike;
+  return isArrayLike_1;
+}
+var isArrayLikeObject_1;
+var hasRequiredIsArrayLikeObject;
+function requireIsArrayLikeObject() {
+  if (hasRequiredIsArrayLikeObject) return isArrayLikeObject_1;
+  hasRequiredIsArrayLikeObject = 1;
+  var isArrayLike = requireIsArrayLike(), isObjectLike = requireIsObjectLike();
+  function isArrayLikeObject(value) {
+    return isObjectLike(value) && isArrayLike(value);
+  }
+  isArrayLikeObject_1 = isArrayLikeObject;
+  return isArrayLikeObject_1;
+}
+var difference_1;
+var hasRequiredDifference;
+function requireDifference() {
+  if (hasRequiredDifference) return difference_1;
+  hasRequiredDifference = 1;
+  var baseDifference = require_baseDifference(), baseFlatten = require_baseFlatten(), baseRest = require_baseRest(), isArrayLikeObject = requireIsArrayLikeObject();
+  var difference = baseRest(function(array, values) {
+    return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) : [];
+  });
+  difference_1 = difference;
+  return difference_1;
+}
+var _arrayFilter;
+var hasRequired_arrayFilter;
+function require_arrayFilter() {
+  if (hasRequired_arrayFilter) return _arrayFilter;
+  hasRequired_arrayFilter = 1;
+  function arrayFilter2(array, predicate) {
+    var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+    while (++index < length) {
+      var value = array[index];
+      if (predicate(value, index, array)) {
+        result[resIndex++] = value;
+      }
+    }
+    return result;
+  }
+  _arrayFilter = arrayFilter2;
+  return _arrayFilter;
+}
+var _createBaseFor;
+var hasRequired_createBaseFor;
+function require_createBaseFor() {
+  if (hasRequired_createBaseFor) return _createBaseFor;
+  hasRequired_createBaseFor = 1;
+  function createBaseFor(fromRight) {
+    return function(object, iteratee, keysFunc) {
+      var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+      while (length--) {
+        var key = props[fromRight ? length : ++index];
+        if (iteratee(iterable[key], key, iterable) === false) {
+          break;
+        }
+      }
+      return object;
+    };
+  }
+  _createBaseFor = createBaseFor;
+  return _createBaseFor;
+}
+var _baseFor;
+var hasRequired_baseFor;
+function require_baseFor() {
+  if (hasRequired_baseFor) return _baseFor;
+  hasRequired_baseFor = 1;
+  var createBaseFor = require_createBaseFor();
+  var baseFor = createBaseFor();
+  _baseFor = baseFor;
+  return _baseFor;
+}
+var _baseTimes;
+var hasRequired_baseTimes;
+function require_baseTimes() {
+  if (hasRequired_baseTimes) return _baseTimes;
+  hasRequired_baseTimes = 1;
+  function baseTimes(n, iteratee) {
+    var index = -1, result = Array(n);
+    while (++index < n) {
+      result[index] = iteratee(index);
+    }
+    return result;
+  }
+  _baseTimes = baseTimes;
+  return _baseTimes;
+}
+var isBuffer = { exports: {} };
+function stubFalse() {
+  return false;
+}
+var stubFalse_1 = stubFalse;
+isBuffer.exports;
+(function(module, exports) {
+  var root2 = require_root(), stubFalse2 = stubFalse_1;
+  var freeExports = exports && !exports.nodeType && exports;
+  var freeModule = freeExports && true && module && !module.nodeType && module;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var Buffer = moduleExports ? root2.Buffer : void 0;
+  var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+  var isBuffer2 = nativeIsBuffer || stubFalse2;
+  module.exports = isBuffer2;
+})(isBuffer, isBuffer.exports);
+var isBufferExports = isBuffer.exports;
+var _isIndex;
+var hasRequired_isIndex;
+function require_isIndex() {
+  if (hasRequired_isIndex) return _isIndex;
+  hasRequired_isIndex = 1;
+  var MAX_SAFE_INTEGER = 9007199254740991;
+  var reIsUint = /^(?:0|[1-9]\d*)$/;
+  function isIndex(value, length) {
+    var type = typeof value;
+    length = length == null ? MAX_SAFE_INTEGER : length;
+    return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+  }
+  _isIndex = isIndex;
+  return _isIndex;
+}
+var _baseIsTypedArray;
+var hasRequired_baseIsTypedArray;
+function require_baseIsTypedArray() {
+  if (hasRequired_baseIsTypedArray) return _baseIsTypedArray;
+  hasRequired_baseIsTypedArray = 1;
+  var baseGetTag2 = require_baseGetTag(), isLength = requireIsLength(), isObjectLike = requireIsObjectLike();
+  var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", mapTag2 = "[object Map]", numberTag = "[object Number]", objectTag2 = "[object Object]", regexpTag = "[object RegExp]", setTag2 = "[object Set]", stringTag = "[object String]", weakMapTag2 = "[object WeakMap]";
+  var arrayBufferTag = "[object ArrayBuffer]", dataViewTag2 = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+  var typedArrayTags = {};
+  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+  typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag2] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag2] = typedArrayTags[numberTag] = typedArrayTags[objectTag2] = typedArrayTags[regexpTag] = typedArrayTags[setTag2] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag2] = false;
+  function baseIsTypedArray(value) {
+    return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag2(value)];
+  }
+  _baseIsTypedArray = baseIsTypedArray;
+  return _baseIsTypedArray;
+}
+var _nodeUtil = { exports: {} };
+_nodeUtil.exports;
+(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);
+var _nodeUtilExports = _nodeUtil.exports;
+var isTypedArray_1;
+var hasRequiredIsTypedArray;
+function requireIsTypedArray() {
+  if (hasRequiredIsTypedArray) return isTypedArray_1;
+  hasRequiredIsTypedArray = 1;
+  var baseIsTypedArray = require_baseIsTypedArray(), baseUnary = require_baseUnary(), nodeUtil = _nodeUtilExports;
+  var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+  var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+  isTypedArray_1 = isTypedArray;
+  return isTypedArray_1;
+}
+var _arrayLikeKeys;
+var hasRequired_arrayLikeKeys;
+function require_arrayLikeKeys() {
+  if (hasRequired_arrayLikeKeys) return _arrayLikeKeys;
+  hasRequired_arrayLikeKeys = 1;
+  var baseTimes = require_baseTimes(), isArguments = requireIsArguments(), isArray2 = requireIsArray(), isBuffer2 = isBufferExports, isIndex = require_isIndex(), isTypedArray = requireIsTypedArray();
+  var objectProto2 = Object.prototype;
+  var hasOwnProperty2 = objectProto2.hasOwnProperty;
+  function arrayLikeKeys(value, inherited) {
+    var isArr = isArray2(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer2(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+    for (var key in value) {
+      if ((inherited || hasOwnProperty2.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+      (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+      isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+      isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+      isIndex(key, length)))) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+  _arrayLikeKeys = arrayLikeKeys;
+  return _arrayLikeKeys;
+}
+var objectProto$1 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$1;
+  return value === proto;
+}
+var _isPrototype = isPrototype;
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var _overArg = overArg;
+var _nativeKeys;
+var hasRequired_nativeKeys;
+function require_nativeKeys() {
+  if (hasRequired_nativeKeys) return _nativeKeys;
+  hasRequired_nativeKeys = 1;
+  var overArg2 = _overArg;
+  var nativeKeys = overArg2(Object.keys, Object);
+  _nativeKeys = nativeKeys;
+  return _nativeKeys;
+}
+var _baseKeys;
+var hasRequired_baseKeys;
+function require_baseKeys() {
+  if (hasRequired_baseKeys) return _baseKeys;
+  hasRequired_baseKeys = 1;
+  var isPrototype2 = _isPrototype, nativeKeys = require_nativeKeys();
+  var objectProto2 = Object.prototype;
+  var hasOwnProperty2 = objectProto2.hasOwnProperty;
+  function baseKeys(object) {
+    if (!isPrototype2(object)) {
+      return nativeKeys(object);
+    }
+    var result = [];
+    for (var key in Object(object)) {
+      if (hasOwnProperty2.call(object, key) && key != "constructor") {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+  _baseKeys = baseKeys;
+  return _baseKeys;
+}
+var keys_1;
+var hasRequiredKeys;
+function requireKeys() {
+  if (hasRequiredKeys) return keys_1;
+  hasRequiredKeys = 1;
+  var arrayLikeKeys = require_arrayLikeKeys(), baseKeys = require_baseKeys(), isArrayLike = requireIsArrayLike();
+  function keys2(object) {
+    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+  }
+  keys_1 = keys2;
+  return keys_1;
+}
+var _baseForOwn;
+var hasRequired_baseForOwn;
+function require_baseForOwn() {
+  if (hasRequired_baseForOwn) return _baseForOwn;
+  hasRequired_baseForOwn = 1;
+  var baseFor = require_baseFor(), keys2 = requireKeys();
+  function baseForOwn(object, iteratee) {
+    return object && baseFor(object, iteratee, keys2);
+  }
+  _baseForOwn = baseForOwn;
+  return _baseForOwn;
+}
+var _createBaseEach;
+var hasRequired_createBaseEach;
+function require_createBaseEach() {
+  if (hasRequired_createBaseEach) return _createBaseEach;
+  hasRequired_createBaseEach = 1;
+  var isArrayLike = requireIsArrayLike();
+  function createBaseEach(eachFunc, fromRight) {
+    return function(collection, iteratee) {
+      if (collection == null) {
+        return collection;
+      }
+      if (!isArrayLike(collection)) {
+        return eachFunc(collection, iteratee);
+      }
+      var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
+      while (fromRight ? index-- : ++index < length) {
+        if (iteratee(iterable[index], index, iterable) === false) {
+          break;
+        }
+      }
+      return collection;
+    };
+  }
+  _createBaseEach = createBaseEach;
+  return _createBaseEach;
+}
+var _baseEach;
+var hasRequired_baseEach;
+function require_baseEach() {
+  if (hasRequired_baseEach) return _baseEach;
+  hasRequired_baseEach = 1;
+  var baseForOwn = require_baseForOwn(), createBaseEach = require_createBaseEach();
+  var baseEach = createBaseEach(baseForOwn);
+  _baseEach = baseEach;
+  return _baseEach;
+}
+var _baseFilter;
+var hasRequired_baseFilter;
+function require_baseFilter() {
+  if (hasRequired_baseFilter) return _baseFilter;
+  hasRequired_baseFilter = 1;
+  var baseEach = require_baseEach();
+  function baseFilter(collection, predicate) {
+    var result = [];
+    baseEach(collection, function(value, index, collection2) {
+      if (predicate(value, index, collection2)) {
+        result.push(value);
+      }
+    });
+    return result;
+  }
+  _baseFilter = baseFilter;
+  return _baseFilter;
+}
+var ListCache$2 = _ListCache;
+function stackClear$1() {
+  this.__data__ = new ListCache$2();
+  this.size = 0;
+}
+var _stackClear = stackClear$1;
+function stackDelete$1(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var _stackDelete = stackDelete$1;
+function stackGet$1(key) {
+  return this.__data__.get(key);
+}
+var _stackGet = stackGet$1;
+function stackHas$1(key) {
+  return this.__data__.has(key);
+}
+var _stackHas = stackHas$1;
+var ListCache$1 = _ListCache, Map$1 = _Map, MapCache$1 = require_MapCache();
+var LARGE_ARRAY_SIZE = 200;
+function stackSet$1(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache$1) {
+    var pairs = data.__data__;
+    if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache$1(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var _stackSet = stackSet$1;
+var ListCache = _ListCache, stackClear = _stackClear, stackDelete = _stackDelete, stackGet = _stackGet, stackHas = _stackHas, stackSet = _stackSet;
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear;
+Stack.prototype["delete"] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+var _Stack = Stack;
+var _arraySome;
+var hasRequired_arraySome;
+function require_arraySome() {
+  if (hasRequired_arraySome) return _arraySome;
+  hasRequired_arraySome = 1;
+  function arraySome(array, predicate) {
+    var index = -1, length = array == null ? 0 : array.length;
+    while (++index < length) {
+      if (predicate(array[index], index, array)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  _arraySome = arraySome;
+  return _arraySome;
+}
+var _equalArrays;
+var hasRequired_equalArrays;
+function require_equalArrays() {
+  if (hasRequired_equalArrays) return _equalArrays;
+  hasRequired_equalArrays = 1;
+  var SetCache = require_SetCache(), arraySome = require_arraySome(), cacheHas = require_cacheHas();
+  var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+  function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+    if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+      return false;
+    }
+    var arrStacked = stack.get(array);
+    var othStacked = stack.get(other);
+    if (arrStacked && othStacked) {
+      return arrStacked == other && othStacked == array;
+    }
+    var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
+    stack.set(array, other);
+    stack.set(other, array);
+    while (++index < arrLength) {
+      var arrValue = array[index], othValue = other[index];
+      if (customizer) {
+        var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+      }
+      if (compared !== void 0) {
+        if (compared) {
+          continue;
+        }
+        result = false;
+        break;
+      }
+      if (seen) {
+        if (!arraySome(other, function(othValue2, othIndex) {
+          if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+            return seen.push(othIndex);
+          }
+        })) {
+          result = false;
+          break;
+        }
+      } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+        result = false;
+        break;
+      }
+    }
+    stack["delete"](array);
+    stack["delete"](other);
+    return result;
+  }
+  _equalArrays = equalArrays;
+  return _equalArrays;
+}
+var root$4 = require_root();
+var Uint8Array = root$4.Uint8Array;
+var _Uint8Array = Uint8Array;
+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;
+}
+function setToArray(set) {
+  var index = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var _setToArray = setToArray;
+var _equalByTag;
+var hasRequired_equalByTag;
+function require_equalByTag() {
+  if (hasRequired_equalByTag) return _equalByTag;
+  hasRequired_equalByTag = 1;
+  var Symbol = require_Symbol(), Uint8Array2 = _Uint8Array, eq2 = requireEq(), equalArrays = require_equalArrays(), mapToArray = require_mapToArray(), setToArray2 = _setToArray;
+  var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+  var boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag2 = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag2 = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]";
+  var arrayBufferTag = "[object ArrayBuffer]", dataViewTag2 = "[object DataView]";
+  var symbolProto = Symbol ? Symbol.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+    switch (tag) {
+      case dataViewTag2:
+        if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+          return false;
+        }
+        object = object.buffer;
+        other = other.buffer;
+      case arrayBufferTag:
+        if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
+          return false;
+        }
+        return true;
+      case boolTag:
+      case dateTag:
+      case numberTag:
+        return eq2(+object, +other);
+      case errorTag:
+        return object.name == other.name && object.message == other.message;
+      case regexpTag:
+      case stringTag:
+        return object == other + "";
+      case mapTag2:
+        var convert = mapToArray;
+      case setTag2:
+        var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+        convert || (convert = setToArray2);
+        if (object.size != other.size && !isPartial) {
+          return false;
+        }
+        var stacked = stack.get(object);
+        if (stacked) {
+          return stacked == other;
+        }
+        bitmask |= COMPARE_UNORDERED_FLAG;
+        stack.set(object, other);
+        var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+        stack["delete"](object);
+        return result;
+      case symbolTag:
+        if (symbolValueOf) {
+          return symbolValueOf.call(object) == symbolValueOf.call(other);
+        }
+    }
+    return false;
+  }
+  _equalByTag = equalByTag;
+  return _equalByTag;
+}
+var arrayPush = require_arrayPush(), isArray$1 = requireIsArray();
+function baseGetAllKeys$1(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray$1(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+var _baseGetAllKeys = baseGetAllKeys$1;
+function stubArray$1() {
+  return [];
+}
+var stubArray_1 = stubArray$1;
+var arrayFilter = require_arrayFilter(), stubArray = stubArray_1;
+var objectProto = Object.prototype;
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols$1 = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+var _getSymbols = getSymbols$1;
+var baseGetAllKeys = _baseGetAllKeys, getSymbols = _getSymbols, keys = requireKeys();
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+var _getAllKeys = getAllKeys;
+var _equalObjects;
+var hasRequired_equalObjects;
+function require_equalObjects() {
+  if (hasRequired_equalObjects) return _equalObjects;
+  hasRequired_equalObjects = 1;
+  var getAllKeys2 = _getAllKeys;
+  var COMPARE_PARTIAL_FLAG = 1;
+  var objectProto2 = Object.prototype;
+  var hasOwnProperty2 = objectProto2.hasOwnProperty;
+  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys2(object), objLength = objProps.length, othProps = getAllKeys2(other), othLength = othProps.length;
+    if (objLength != othLength && !isPartial) {
+      return false;
+    }
+    var index = objLength;
+    while (index--) {
+      var key = objProps[index];
+      if (!(isPartial ? key in other : hasOwnProperty2.call(other, key))) {
+        return false;
+      }
+    }
+    var objStacked = stack.get(object);
+    var othStacked = stack.get(other);
+    if (objStacked && othStacked) {
+      return objStacked == other && othStacked == object;
+    }
+    var result = true;
+    stack.set(object, other);
+    stack.set(other, object);
+    var skipCtor = isPartial;
+    while (++index < objLength) {
+      key = objProps[index];
+      var objValue = object[key], othValue = other[key];
+      if (customizer) {
+        var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+      }
+      if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+        result = false;
+        break;
+      }
+      skipCtor || (skipCtor = key == "constructor");
+    }
+    if (result && !skipCtor) {
+      var objCtor = object.constructor, othCtor = other.constructor;
+      if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+        result = false;
+      }
+    }
+    stack["delete"](object);
+    stack["delete"](other);
+    return result;
+  }
+  _equalObjects = equalObjects;
+  return _equalObjects;
+}
+var getNative$3 = _getNative, root$3 = require_root();
+var DataView$1 = getNative$3(root$3, "DataView");
+var _DataView = DataView$1;
+var getNative$2 = _getNative, root$2 = require_root();
+var Promise$2 = getNative$2(root$2, "Promise");
+var _Promise = Promise$2;
+var getNative$1 = _getNative, root$1 = require_root();
+var Set$1 = getNative$1(root$1, "Set");
+var _Set = Set$1;
+var getNative = _getNative, root = require_root();
+var WeakMap$1 = getNative(root, "WeakMap");
+var _WeakMap = WeakMap$1;
+var DataView = _DataView, Map = _Map, Promise$1 = _Promise, Set = _Set, WeakMap = _WeakMap, baseGetTag = require_baseGetTag(), toSource = _toSource;
+var mapTag = "[object Map]", objectTag = "[object Object]", promiseTag = "[object Promise]", setTag = "[object Set]", weakMapTag = "[object WeakMap]";
+var dataViewTag = "[object DataView]";
+var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set), weakMapCtorString = toSource(WeakMap);
+var getTag = baseGetTag;
+if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+  getTag = function(value) {
+    var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag;
+        case mapCtorString:
+          return mapTag;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag;
+        case weakMapCtorString:
+          return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+var _getTag = getTag;
+var _baseIsEqualDeep;
+var hasRequired_baseIsEqualDeep;
+function require_baseIsEqualDeep() {
+  if (hasRequired_baseIsEqualDeep) return _baseIsEqualDeep;
+  hasRequired_baseIsEqualDeep = 1;
+  var Stack2 = _Stack, equalArrays = require_equalArrays(), equalByTag = require_equalByTag(), equalObjects = require_equalObjects(), getTag2 = _getTag, isArray2 = requireIsArray(), isBuffer2 = isBufferExports, isTypedArray = requireIsTypedArray();
+  var COMPARE_PARTIAL_FLAG = 1;
+  var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag2 = "[object Object]";
+  var objectProto2 = Object.prototype;
+  var hasOwnProperty2 = objectProto2.hasOwnProperty;
+  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+    var objIsArr = isArray2(object), othIsArr = isArray2(other), objTag = objIsArr ? arrayTag : getTag2(object), othTag = othIsArr ? arrayTag : getTag2(other);
+    objTag = objTag == argsTag ? objectTag2 : objTag;
+    othTag = othTag == argsTag ? objectTag2 : othTag;
+    var objIsObj = objTag == objectTag2, othIsObj = othTag == objectTag2, isSameTag = objTag == othTag;
+    if (isSameTag && isBuffer2(object)) {
+      if (!isBuffer2(other)) {
+        return false;
+      }
+      objIsArr = true;
+      objIsObj = false;
+    }
+    if (isSameTag && !objIsObj) {
+      stack || (stack = new Stack2());
+      return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+    }
+    if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+      var objIsWrapped = objIsObj && hasOwnProperty2.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty2.call(other, "__wrapped__");
+      if (objIsWrapped || othIsWrapped) {
+        var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+        stack || (stack = new Stack2());
+        return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+      }
+    }
+    if (!isSameTag) {
+      return false;
+    }
+    stack || (stack = new Stack2());
+    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+  }
+  _baseIsEqualDeep = baseIsEqualDeep;
+  return _baseIsEqualDeep;
+}
+var _baseIsEqual;
+var hasRequired_baseIsEqual;
+function require_baseIsEqual() {
+  if (hasRequired_baseIsEqual) return _baseIsEqual;
+  hasRequired_baseIsEqual = 1;
+  var baseIsEqualDeep = require_baseIsEqualDeep(), isObjectLike = requireIsObjectLike();
+  function baseIsEqual(value, other, bitmask, customizer, stack) {
+    if (value === other) {
+      return true;
+    }
+    if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+      return value !== value && other !== other;
+    }
+    return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+  }
+  _baseIsEqual = baseIsEqual;
+  return _baseIsEqual;
+}
+var _baseIsMatch;
+var hasRequired_baseIsMatch;
+function require_baseIsMatch() {
+  if (hasRequired_baseIsMatch) return _baseIsMatch;
+  hasRequired_baseIsMatch = 1;
+  var Stack2 = _Stack, baseIsEqual = require_baseIsEqual();
+  var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+  function baseIsMatch(object, source, matchData, customizer) {
+    var index = matchData.length, length = index, noCustomizer = !customizer;
+    if (object == null) {
+      return !length;
+    }
+    object = Object(object);
+    while (index--) {
+      var data = matchData[index];
+      if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+        return false;
+      }
+    }
+    while (++index < length) {
+      data = matchData[index];
+      var key = data[0], objValue = object[key], srcValue = data[1];
+      if (noCustomizer && data[2]) {
+        if (objValue === void 0 && !(key in object)) {
+          return false;
+        }
+      } else {
+        var stack = new Stack2();
+        if (customizer) {
+          var result = customizer(objValue, srcValue, key, object, source, stack);
+        }
+        if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  _baseIsMatch = baseIsMatch;
+  return _baseIsMatch;
+}
+var _isStrictComparable;
+var hasRequired_isStrictComparable;
+function require_isStrictComparable() {
+  if (hasRequired_isStrictComparable) return _isStrictComparable;
+  hasRequired_isStrictComparable = 1;
+  var isObject2 = requireIsObject();
+  function isStrictComparable(value) {
+    return value === value && !isObject2(value);
+  }
+  _isStrictComparable = isStrictComparable;
+  return _isStrictComparable;
+}
+var _getMatchData;
+var hasRequired_getMatchData;
+function require_getMatchData() {
+  if (hasRequired_getMatchData) return _getMatchData;
+  hasRequired_getMatchData = 1;
+  var isStrictComparable = require_isStrictComparable(), keys2 = requireKeys();
+  function getMatchData(object) {
+    var result = keys2(object), length = result.length;
+    while (length--) {
+      var key = result[length], value = object[key];
+      result[length] = [key, value, isStrictComparable(value)];
+    }
+    return result;
+  }
+  _getMatchData = getMatchData;
+  return _getMatchData;
+}
+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;
+}
+var _baseMatches;
+var hasRequired_baseMatches;
+function require_baseMatches() {
+  if (hasRequired_baseMatches) return _baseMatches;
+  hasRequired_baseMatches = 1;
+  var baseIsMatch = require_baseIsMatch(), getMatchData = require_getMatchData(), matchesStrictComparable = require_matchesStrictComparable();
+  function baseMatches(source) {
+    var matchData = getMatchData(source);
+    if (matchData.length == 1 && matchData[0][2]) {
+      return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+    }
+    return function(object) {
+      return object === source || baseIsMatch(object, source, matchData);
+    };
+  }
+  _baseMatches = baseMatches;
+  return _baseMatches;
+}
+var _isKey;
+var hasRequired_isKey;
+function require_isKey() {
+  if (hasRequired_isKey) return _isKey;
+  hasRequired_isKey = 1;
+  var isArray2 = requireIsArray(), isSymbol = requireIsSymbol();
+  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+  function isKey2(value, object) {
+    if (isArray2(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 = isKey2;
+  return _isKey;
+}
+var MapCache = require_MapCache();
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize$1(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize$1.Cache || MapCache)();
+  return memoized;
+}
+memoize$1.Cache = MapCache;
+var memoize_1 = memoize$1;
+var memoize = memoize_1;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped$1(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var _memoizeCapped = memoizeCapped$1;
+var memoizeCapped = _memoizeCapped;
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath$1 = 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;
+});
+var _stringToPath = stringToPath$1;
+var _baseToString;
+var hasRequired_baseToString;
+function require_baseToString() {
+  if (hasRequired_baseToString) return _baseToString;
+  hasRequired_baseToString = 1;
+  var Symbol = require_Symbol(), arrayMap2 = _arrayMap, isArray2 = requireIsArray(), isSymbol = requireIsSymbol();
+  var INFINITY = 1 / 0;
+  var symbolProto = Symbol ? Symbol.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+  function baseToString(value) {
+    if (typeof value == "string") {
+      return value;
+    }
+    if (isArray2(value)) {
+      return arrayMap2(value, baseToString) + "";
+    }
+    if (isSymbol(value)) {
+      return symbolToString ? symbolToString.call(value) : "";
+    }
+    var result = value + "";
+    return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+  }
+  _baseToString = baseToString;
+  return _baseToString;
+}
+var toString_1;
+var hasRequiredToString;
+function requireToString() {
+  if (hasRequiredToString) return toString_1;
+  hasRequiredToString = 1;
+  var baseToString = require_baseToString();
+  function toString2(value) {
+    return value == null ? "" : baseToString(value);
+  }
+  toString_1 = toString2;
+  return toString_1;
+}
+var isArray = requireIsArray(), isKey = require_isKey(), stringToPath = _stringToPath, toString = requireToString();
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+var _castPath = castPath;
+var _toKey;
+var hasRequired_toKey;
+function require_toKey() {
+  if (hasRequired_toKey) return _toKey;
+  hasRequired_toKey = 1;
+  var isSymbol = requireIsSymbol();
+  var INFINITY = 1 / 0;
+  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;
+}
+var _baseGet;
+var hasRequired_baseGet;
+function require_baseGet() {
+  if (hasRequired_baseGet) return _baseGet;
+  hasRequired_baseGet = 1;
+  var castPath2 = _castPath, toKey = require_toKey();
+  function baseGet(object, path) {
+    path = castPath2(path, object);
+    var index = 0, length = path.length;
+    while (object != null && index < length) {
+      object = object[toKey(path[index++])];
+    }
+    return index && index == length ? object : void 0;
+  }
+  _baseGet = baseGet;
+  return _baseGet;
+}
+var get_1;
+var hasRequiredGet;
+function requireGet() {
+  if (hasRequiredGet) return get_1;
+  hasRequiredGet = 1;
+  var baseGet = require_baseGet();
+  function get(object, path, defaultValue) {
+    var result = object == null ? void 0 : baseGet(object, path);
+    return result === void 0 ? defaultValue : result;
+  }
+  get_1 = get;
+  return get_1;
+}
+var _baseHasIn;
+var hasRequired_baseHasIn;
+function require_baseHasIn() {
+  if (hasRequired_baseHasIn) return _baseHasIn;
+  hasRequired_baseHasIn = 1;
+  function baseHasIn(object, key) {
+    return object != null && key in Object(object);
+  }
+  _baseHasIn = baseHasIn;
+  return _baseHasIn;
+}
+var _hasPath;
+var hasRequired_hasPath;
+function require_hasPath() {
+  if (hasRequired_hasPath) return _hasPath;
+  hasRequired_hasPath = 1;
+  var castPath2 = _castPath, isArguments = requireIsArguments(), isArray2 = requireIsArray(), isIndex = require_isIndex(), isLength = requireIsLength(), toKey = require_toKey();
+  function hasPath(object, path, hasFunc) {
+    path = castPath2(path, object);
+    var index = -1, length = path.length, result = false;
+    while (++index < length) {
+      var key = toKey(path[index]);
+      if (!(result = object != null && hasFunc(object, key))) {
+        break;
+      }
+      object = object[key];
+    }
+    if (result || ++index != length) {
+      return result;
+    }
+    length = object == null ? 0 : object.length;
+    return !!length && isLength(length) && isIndex(key, length) && (isArray2(object) || isArguments(object));
+  }
+  _hasPath = hasPath;
+  return _hasPath;
+}
+var hasIn_1;
+var hasRequiredHasIn;
+function requireHasIn() {
+  if (hasRequiredHasIn) return hasIn_1;
+  hasRequiredHasIn = 1;
+  var baseHasIn = require_baseHasIn(), hasPath = require_hasPath();
+  function hasIn(object, path) {
+    return object != null && hasPath(object, path, baseHasIn);
+  }
+  hasIn_1 = hasIn;
+  return hasIn_1;
+}
+var _baseMatchesProperty;
+var hasRequired_baseMatchesProperty;
+function require_baseMatchesProperty() {
+  if (hasRequired_baseMatchesProperty) return _baseMatchesProperty;
+  hasRequired_baseMatchesProperty = 1;
+  var baseIsEqual = require_baseIsEqual(), get = requireGet(), hasIn = requireHasIn(), isKey2 = require_isKey(), isStrictComparable = require_isStrictComparable(), matchesStrictComparable = require_matchesStrictComparable(), toKey = require_toKey();
+  var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+  function baseMatchesProperty(path, srcValue) {
+    if (isKey2(path) && isStrictComparable(srcValue)) {
+      return matchesStrictComparable(toKey(path), srcValue);
+    }
+    return function(object) {
+      var objValue = get(object, path);
+      return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+    };
+  }
+  _baseMatchesProperty = baseMatchesProperty;
+  return _baseMatchesProperty;
+}
+var _baseProperty;
+var hasRequired_baseProperty;
+function require_baseProperty() {
+  if (hasRequired_baseProperty) return _baseProperty;
+  hasRequired_baseProperty = 1;
+  function baseProperty(key) {
+    return function(object) {
+      return object == null ? void 0 : object[key];
+    };
+  }
+  _baseProperty = baseProperty;
+  return _baseProperty;
+}
+var _basePropertyDeep;
+var hasRequired_basePropertyDeep;
+function require_basePropertyDeep() {
+  if (hasRequired_basePropertyDeep) return _basePropertyDeep;
+  hasRequired_basePropertyDeep = 1;
+  var baseGet = require_baseGet();
+  function basePropertyDeep(path) {
+    return function(object) {
+      return baseGet(object, path);
+    };
+  }
+  _basePropertyDeep = basePropertyDeep;
+  return _basePropertyDeep;
+}
+var property_1;
+var hasRequiredProperty;
+function requireProperty() {
+  if (hasRequiredProperty) return property_1;
+  hasRequiredProperty = 1;
+  var baseProperty = require_baseProperty(), basePropertyDeep = require_basePropertyDeep(), isKey2 = require_isKey(), toKey = require_toKey();
+  function property(path) {
+    return isKey2(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+  }
+  property_1 = property;
+  return property_1;
+}
+var _baseIteratee;
+var hasRequired_baseIteratee;
+function require_baseIteratee() {
+  if (hasRequired_baseIteratee) return _baseIteratee;
+  hasRequired_baseIteratee = 1;
+  var baseMatches = require_baseMatches(), baseMatchesProperty = require_baseMatchesProperty(), identity = requireIdentity(), isArray2 = requireIsArray(), property = requireProperty();
+  function baseIteratee(value) {
+    if (typeof value == "function") {
+      return value;
+    }
+    if (value == null) {
+      return identity;
+    }
+    if (typeof value == "object") {
+      return isArray2(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+    }
+    return property(value);
+  }
+  _baseIteratee = baseIteratee;
+  return _baseIteratee;
+}
+var filter_1;
+var hasRequiredFilter;
+function requireFilter() {
+  if (hasRequiredFilter) return filter_1;
+  hasRequiredFilter = 1;
+  var arrayFilter2 = require_arrayFilter(), baseFilter = require_baseFilter(), baseIteratee = require_baseIteratee(), isArray2 = requireIsArray();
+  function filter(collection, predicate) {
+    var func = isArray2(collection) ? arrayFilter2 : baseFilter;
+    return func(collection, baseIteratee(predicate, 3));
+  }
+  filter_1 = filter;
+  return filter_1;
+}
+var _baseFindKey;
+var hasRequired_baseFindKey;
+function require_baseFindKey() {
+  if (hasRequired_baseFindKey) return _baseFindKey;
+  hasRequired_baseFindKey = 1;
+  function baseFindKey(collection, predicate, eachFunc) {
+    var result;
+    eachFunc(collection, function(value, key, collection2) {
+      if (predicate(value, key, collection2)) {
+        result = key;
+        return false;
+      }
+    });
+    return result;
+  }
+  _baseFindKey = baseFindKey;
+  return _baseFindKey;
+}
+var findKey_1;
+var hasRequiredFindKey;
+function requireFindKey() {
+  if (hasRequiredFindKey) return findKey_1;
+  hasRequiredFindKey = 1;
+  var baseFindKey = require_baseFindKey(), baseForOwn = require_baseForOwn(), baseIteratee = require_baseIteratee();
+  function findKey(object, predicate) {
+    return baseFindKey(object, baseIteratee(predicate, 3), baseForOwn);
+  }
+  findKey_1 = findKey;
+  return findKey_1;
+}
+var head_1;
+var hasRequiredHead;
+function requireHead() {
+  if (hasRequiredHead) return head_1;
+  hasRequiredHead = 1;
+  function head(array) {
+    return array && array.length ? array[0] : void 0;
+  }
+  head_1 = head;
+  return head_1;
+}
+var first;
+var hasRequiredFirst;
+function requireFirst() {
+  if (hasRequiredFirst) return first;
+  hasRequiredFirst = 1;
+  first = requireHead();
+  return first;
+}
+var _arrayEach;
+var hasRequired_arrayEach;
+function require_arrayEach() {
+  if (hasRequired_arrayEach) return _arrayEach;
+  hasRequired_arrayEach = 1;
+  function arrayEach(array, iteratee) {
+    var index = -1, length = array == null ? 0 : array.length;
+    while (++index < length) {
+      if (iteratee(array[index], index, array) === false) {
+        break;
+      }
+    }
+    return array;
+  }
+  _arrayEach = arrayEach;
+  return _arrayEach;
+}
+var _castFunction;
+var hasRequired_castFunction;
+function require_castFunction() {
+  if (hasRequired_castFunction) return _castFunction;
+  hasRequired_castFunction = 1;
+  var identity = requireIdentity();
+  function castFunction(value) {
+    return typeof value == "function" ? value : identity;
+  }
+  _castFunction = castFunction;
+  return _castFunction;
+}
+var forEach_1;
+var hasRequiredForEach;
+function requireForEach() {
+  if (hasRequiredForEach) return forEach_1;
+  hasRequiredForEach = 1;
+  var arrayEach = require_arrayEach(), baseEach = require_baseEach(), castFunction = require_castFunction(), isArray2 = requireIsArray();
+  function forEach(collection, iteratee) {
+    var func = isArray2(collection) ? arrayEach : baseEach;
+    return func(collection, castFunction(iteratee));
+  }
+  forEach_1 = forEach;
+  return forEach_1;
+}
+var forOwn_1;
+var hasRequiredForOwn;
+function requireForOwn() {
+  if (hasRequiredForOwn) return forOwn_1;
+  hasRequiredForOwn = 1;
+  var baseForOwn = require_baseForOwn(), castFunction = require_castFunction();
+  function forOwn(object, iteratee) {
+    return object && baseForOwn(object, castFunction(iteratee));
+  }
+  forOwn_1 = forOwn;
+  return forOwn_1;
+}
+var noop_1;
+var hasRequiredNoop;
+function requireNoop() {
+  if (hasRequiredNoop) return noop_1;
+  hasRequiredNoop = 1;
+  function noop() {
+  }
+  noop_1 = noop;
+  return noop_1;
+}
+var _baseMap;
+var hasRequired_baseMap;
+function require_baseMap() {
+  if (hasRequired_baseMap) return _baseMap;
+  hasRequired_baseMap = 1;
+  var baseEach = require_baseEach(), isArrayLike = requireIsArrayLike();
+  function baseMap(collection, iteratee) {
+    var index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
+    baseEach(collection, function(value, key, collection2) {
+      result[++index] = iteratee(value, key, collection2);
+    });
+    return result;
+  }
+  _baseMap = baseMap;
+  return _baseMap;
+}
+var _baseSortBy;
+var hasRequired_baseSortBy;
+function require_baseSortBy() {
+  if (hasRequired_baseSortBy) return _baseSortBy;
+  hasRequired_baseSortBy = 1;
+  function baseSortBy(array, comparer) {
+    var length = array.length;
+    array.sort(comparer);
+    while (length--) {
+      array[length] = array[length].value;
+    }
+    return array;
+  }
+  _baseSortBy = baseSortBy;
+  return _baseSortBy;
+}
+var _compareAscending;
+var hasRequired_compareAscending;
+function require_compareAscending() {
+  if (hasRequired_compareAscending) return _compareAscending;
+  hasRequired_compareAscending = 1;
+  var isSymbol = requireIsSymbol();
+  function compareAscending(value, other) {
+    if (value !== other) {
+      var valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
+      var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
+      if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
+        return 1;
+      }
+      if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
+        return -1;
+      }
+    }
+    return 0;
+  }
+  _compareAscending = compareAscending;
+  return _compareAscending;
+}
+var _compareMultiple;
+var hasRequired_compareMultiple;
+function require_compareMultiple() {
+  if (hasRequired_compareMultiple) return _compareMultiple;
+  hasRequired_compareMultiple = 1;
+  var compareAscending = require_compareAscending();
+  function compareMultiple(object, other, orders) {
+    var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
+    while (++index < length) {
+      var result = compareAscending(objCriteria[index], othCriteria[index]);
+      if (result) {
+        if (index >= ordersLength) {
+          return result;
+        }
+        var order = orders[index];
+        return result * (order == "desc" ? -1 : 1);
+      }
+    }
+    return object.index - other.index;
+  }
+  _compareMultiple = compareMultiple;
+  return _compareMultiple;
+}
+var _baseOrderBy;
+var hasRequired_baseOrderBy;
+function require_baseOrderBy() {
+  if (hasRequired_baseOrderBy) return _baseOrderBy;
+  hasRequired_baseOrderBy = 1;
+  var arrayMap2 = _arrayMap, baseGet = require_baseGet(), baseIteratee = require_baseIteratee(), baseMap = require_baseMap(), baseSortBy = require_baseSortBy(), baseUnary = require_baseUnary(), compareMultiple = require_compareMultiple(), identity = requireIdentity(), isArray2 = requireIsArray();
+  function baseOrderBy(collection, iteratees, orders) {
+    if (iteratees.length) {
+      iteratees = arrayMap2(iteratees, function(iteratee) {
+        if (isArray2(iteratee)) {
+          return function(value) {
+            return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+          };
+        }
+        return iteratee;
+      });
+    } else {
+      iteratees = [identity];
+    }
+    var index = -1;
+    iteratees = arrayMap2(iteratees, baseUnary(baseIteratee));
+    var result = baseMap(collection, function(value, key, collection2) {
+      var criteria = arrayMap2(iteratees, function(iteratee) {
+        return iteratee(value);
+      });
+      return { "criteria": criteria, "index": ++index, "value": value };
+    });
+    return baseSortBy(result, function(object, other) {
+      return compareMultiple(object, other, orders);
+    });
+  }
+  _baseOrderBy = baseOrderBy;
+  return _baseOrderBy;
+}
+var _isIterateeCall;
+var hasRequired_isIterateeCall;
+function require_isIterateeCall() {
+  if (hasRequired_isIterateeCall) return _isIterateeCall;
+  hasRequired_isIterateeCall = 1;
+  var eq2 = requireEq(), isArrayLike = requireIsArrayLike(), isIndex = require_isIndex(), isObject2 = requireIsObject();
+  function isIterateeCall(value, index, object) {
+    if (!isObject2(object)) {
+      return false;
+    }
+    var type = typeof index;
+    if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
+      return eq2(object[index], value);
+    }
+    return false;
+  }
+  _isIterateeCall = isIterateeCall;
+  return _isIterateeCall;
+}
+var sortBy_1;
+var hasRequiredSortBy;
+function requireSortBy() {
+  if (hasRequiredSortBy) return sortBy_1;
+  hasRequiredSortBy = 1;
+  var baseFlatten = require_baseFlatten(), baseOrderBy = require_baseOrderBy(), baseRest = require_baseRest(), isIterateeCall = require_isIterateeCall();
+  var sortBy = baseRest(function(collection, iteratees) {
+    if (collection == null) {
+      return [];
+    }
+    var length = iteratees.length;
+    if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
+      iteratees = [];
+    } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
+      iteratees = [iteratees[0]];
+    }
+    return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
+  });
+  sortBy_1 = sortBy;
+  return sortBy_1;
+}
+var throttle_1;
+var hasRequiredThrottle;
+function requireThrottle() {
+  if (hasRequiredThrottle) return throttle_1;
+  hasRequiredThrottle = 1;
+  var debounce = requireDebounce(), isObject2 = requireIsObject();
+  var FUNC_ERROR_TEXT2 = "Expected a function";
+  function throttle(func, wait, options) {
+    var leading = true, trailing = true;
+    if (typeof func != "function") {
+      throw new TypeError(FUNC_ERROR_TEXT2);
+    }
+    if (isObject2(options)) {
+      leading = "leading" in options ? !!options.leading : leading;
+      trailing = "trailing" in options ? !!options.trailing : trailing;
+    }
+    return debounce(func, wait, {
+      "leading": leading,
+      "maxWait": wait,
+      "trailing": trailing
+    });
+  }
+  throttle_1 = throttle;
+  return throttle_1;
+}
+var uniqueId_1;
+var hasRequiredUniqueId;
+function requireUniqueId() {
+  if (hasRequiredUniqueId) return uniqueId_1;
+  hasRequiredUniqueId = 1;
+  var toString2 = requireToString();
+  var idCounter = 0;
+  function uniqueId(prefix) {
+    var id = ++idCounter;
+    return toString2(prefix) + id;
+  }
+  uniqueId_1 = uniqueId;
+  return uniqueId_1;
+}
+(function(module, exports) {
+  !function(e, t) {
+    module.exports = t(requireDebounce(), requireDifference(), requireFilter(), requireFindKey(), requireFirst(), requireForEach(), requireForOwn(), requireNoop(), requireSortBy(), requireThrottle(), requireUniqueId(), React36__default);
+  }(commonjsGlobal, function(e, t, o, s, i, n, r, a, u, c, l, d) {
+    return function() {
+      var h = { 654: function(e2, t2, o2) {
+        var s2, i2 = this && this.__assign || function() {
+          return i2 = Object.assign || function(e3) {
+            for (var t3, o3 = 1, s3 = arguments.length; o3 < s3; o3++) for (var i3 in t3 = arguments[o3]) Object.prototype.hasOwnProperty.call(t3, i3) && (e3[i3] = t3[i3]);
+            return e3;
+          }, i2.apply(this, arguments);
+        }, n2 = this && this.__createBinding || (Object.create ? function(e3, t3, o3, s3) {
+          void 0 === s3 && (s3 = o3);
+          var i3 = Object.getOwnPropertyDescriptor(t3, o3);
+          i3 && !("get" in i3 ? !t3.__esModule : i3.writable || i3.configurable) || (i3 = { enumerable: true, get: function() {
+            return t3[o3];
+          } }), Object.defineProperty(e3, s3, i3);
+        } : function(e3, t3, o3, s3) {
+          void 0 === s3 && (s3 = o3), e3[s3] = t3[o3];
+        }), r2 = this && this.__setModuleDefault || (Object.create ? function(e3, t3) {
+          Object.defineProperty(e3, "default", { enumerable: true, value: t3 });
+        } : function(e3, t3) {
+          e3.default = t3;
+        }), a2 = this && this.__importStar || function(e3) {
+          if (e3 && e3.__esModule) return e3;
+          var t3 = {};
+          if (null != e3) for (var o3 in e3) "default" !== o3 && Object.prototype.hasOwnProperty.call(e3, o3) && n2(t3, e3, o3);
+          return r2(t3, e3), t3;
+        }, u2 = this && this.__spreadArray || function(e3, t3, o3) {
+          if (o3 || 2 === arguments.length) for (var s3, i3 = 0, n3 = t3.length; i3 < n3; i3++) !s3 && i3 in t3 || (s3 || (s3 = Array.prototype.slice.call(t3, 0, i3)), s3[i3] = t3[i3]);
+          return e3.concat(s3 || Array.prototype.slice.call(t3));
+        }, c2 = this && this.__importDefault || function(e3) {
+          return e3 && e3.__esModule ? e3 : { default: e3 };
+        };
+        Object.defineProperty(t2, "__esModule", { value: true }), t2.updateRtl = t2.doesFocusableExist = t2.getCurrentFocusKey = t2.updateAllLayouts = t2.resume = t2.pause = t2.navigateByDirection = t2.setFocus = t2.setKeyMap = t2.destroy = t2.setThrottle = t2.init = t2.SpatialNavigation = t2.ROOT_FOCUS_KEY = void 0;
+        var l2 = c2(o2(150)), d2 = c2(o2(117)), h2 = c2(o2(747)), f2 = c2(o2(23)), p = c2(o2(842)), y = c2(o2(682)), v = c2(o2(784)), g = c2(o2(432)), b = c2(o2(67)), F = c2(o2(35)), C = c2(o2(119)), m = a2(o2(964)), K = "left", w = "right", x = "up", E = "down", D = "enter", L = ((s2 = {}).left = [37, "ArrowLeft"], s2.up = [38, "ArrowUp"], s2.right = [39, "ArrowRight"], s2.down = [40, "ArrowDown"], s2.enter = [13, "Enter"], s2);
+        t2.ROOT_FOCUS_KEY = "SN:ROOT";
+        var M = ["#0FF", "#FF0", "#F0F"], R = { leading: true, trailing: false }, N = function() {
+          function e3() {
+            this.focusableComponents = {}, this.focusKey = null, this.parentsHavingFocusedChild = [], this.domNodeFocusOptions = {}, this.enabled = false, this.nativeMode = false, this.throttle = 0, this.throttleKeypresses = false, this.useGetBoundingClientRect = false, this.shouldFocusDOMNode = false, this.shouldUseNativeEvents = false, this.writingDirection = C.default.LTR, this.pressedKeys = {}, this.paused = false, this.keyDownEventListener = null, this.keyUpEventListener = null, this.keyMap = L, this.pause = this.pause.bind(this), this.resume = this.resume.bind(this), this.setFocus = this.setFocus.bind(this), this.updateAllLayouts = this.updateAllLayouts.bind(this), this.navigateByDirection = this.navigateByDirection.bind(this), this.init = this.init.bind(this), this.setThrottle = this.setThrottle.bind(this), this.destroy = this.destroy.bind(this), this.setKeyMap = this.setKeyMap.bind(this), this.getCurrentFocusKey = this.getCurrentFocusKey.bind(this), this.doesFocusableExist = this.doesFocusableExist.bind(this), this.updateRtl = this.updateRtl.bind(this), this.setFocusDebounced = (0, l2.default)(this.setFocus, 300, { leading: false, trailing: true }), this.debug = false, this.visualDebugger = null, this.logIndex = 0, this.distanceCalculationMethod = "corners";
+          }
+          return e3.getCutoffCoordinate = function(e4, t3, o3, s3, i3) {
+            var n3 = e4 ? s3.top : i3 === C.default.LTR ? s3.left : s3.right, r3 = e4 ? s3.bottom : i3 === C.default.LTR ? s3.right : s3.left;
+            return t3 ? o3 ? n3 : r3 : o3 ? r3 : n3;
+          }, e3.getRefCorners = function(e4, t3, o3) {
+            var s3 = { a: { x: 0, y: 0 }, b: { x: 0, y: 0 } };
+            switch (e4) {
+              case x:
+                var i3 = t3 ? o3.bottom : o3.top;
+                s3.a = { x: o3.left, y: i3 }, s3.b = { x: o3.right, y: i3 };
+                break;
+              case E:
+                i3 = t3 ? o3.top : o3.bottom, s3.a = { x: o3.left, y: i3 }, s3.b = { x: o3.right, y: i3 };
+                break;
+              case K:
+                var n3 = t3 ? o3.right : o3.left;
+                s3.a = { x: n3, y: o3.top }, s3.b = { x: n3, y: o3.bottom };
+                break;
+              case w:
+                n3 = t3 ? o3.left : o3.right, s3.a = { x: n3, y: o3.top }, s3.b = { x: n3, y: o3.bottom };
+            }
+            return s3;
+          }, e3.isAdjacentSlice = function(e4, t3, o3) {
+            var s3 = e4.a, i3 = e4.b, n3 = t3.a, r3 = t3.b, a3 = o3 ? "x" : "y", u3 = s3[a3], c3 = i3[a3], l3 = n3[a3], d3 = r3[a3], h3 = 0.2 * (c3 - u3);
+            return Math.max(0, Math.min(c3, d3) - Math.max(u3, l3)) >= h3;
+          }, e3.getPrimaryAxisDistance = function(e4, t3, o3) {
+            var s3 = e4.a, i3 = t3.a, n3 = o3 ? "y" : "x";
+            return Math.abs(i3[n3] - s3[n3]);
+          }, e3.getSecondaryAxisDistance = function(e4, t3, o3, s3, i3) {
+            if (i3) return i3(e4, t3, o3, s3);
+            var n3 = e4.a, r3 = e4.b, a3 = t3.a, u3 = t3.b, c3 = o3 ? "x" : "y", l3 = n3[c3], d3 = r3[c3], h3 = a3[c3], f3 = u3[c3];
+            if ("center" === s3) {
+              var p2 = (l3 + d3) / 2, y2 = (h3 + f3) / 2;
+              return Math.abs(p2 - y2);
+            }
+            if ("edges" === s3) {
+              var v2 = Math.min(l3, d3), g2 = Math.min(h3, f3), b2 = Math.max(l3, d3), F2 = Math.max(h3, f3), C2 = Math.abs(v2 - g2), m2 = Math.abs(b2 - F2);
+              return Math.min(C2, m2);
+            }
+            var K2 = [Math.abs(h3 - l3), Math.abs(h3 - d3), Math.abs(f3 - l3), Math.abs(f3 - d3)];
+            return Math.min.apply(Math, K2);
+          }, e3.prototype.sortSiblingsByPriority = function(t3, o3, s3, i3) {
+            var n3 = this, r3 = s3 === E || s3 === x, a3 = e3.getRefCorners(s3, false, o3);
+            return (0, g.default)(t3, function(t4) {
+              var o4 = e3.getRefCorners(s3, true, t4.layout), u3 = e3.isAdjacentSlice(a3, o4, r3), c3 = u3 ? e3.getPrimaryAxisDistance : e3.getSecondaryAxisDistance, l3 = u3 ? e3.getSecondaryAxisDistance : e3.getPrimaryAxisDistance, d3 = c3(a3, o4, r3, n3.distanceCalculationMethod, n3.customDistanceCalculationFunction), h3 = l3(a3, o4, r3, n3.distanceCalculationMethod, n3.customDistanceCalculationFunction), f3 = 5 * d3 + h3, p2 = (f3 + 1) / (u3 ? 5 : 1);
+              return n3.log("smartNavigate", "distance (primary, secondary, total weighted) for ".concat(t4.focusKey, " relative to ").concat(i3, " is"), d3, h3, f3), n3.log("smartNavigate", "priority for ".concat(t4.focusKey, " relative to ").concat(i3, " is"), p2), n3.visualDebugger && (n3.visualDebugger.drawPoint(o4.a.x, o4.a.y, "yellow", 6), n3.visualDebugger.drawPoint(o4.b.x, o4.b.y, "yellow", 6)), p2;
+            });
+          }, e3.prototype.init = function(e4) {
+            var t3 = this, o3 = void 0 === e4 ? {} : e4, s3 = o3.debug, i3 = void 0 !== s3 && s3, n3 = o3.visualDebug, r3 = void 0 !== n3 && n3, a3 = o3.nativeMode, u3 = void 0 !== a3 && a3, c3 = o3.throttle, l3 = void 0 === c3 ? 0 : c3, d3 = o3.throttleKeypresses, h3 = void 0 !== d3 && d3, f3 = o3.useGetBoundingClientRect, p2 = void 0 !== f3 && f3, y2 = o3.shouldFocusDOMNode, g2 = void 0 !== y2 && y2, b2 = o3.domNodeFocusOptions, m2 = void 0 === b2 ? {} : b2, K2 = o3.shouldUseNativeEvents, w2 = void 0 !== K2 && K2, x2 = o3.rtl, E2 = void 0 !== x2 && x2, D2 = o3.distanceCalculationMethod, L2 = void 0 === D2 ? "corners" : D2, M2 = o3.customDistanceCalculationFunction, R2 = void 0 === M2 ? void 0 : M2;
+            if (!this.enabled && (this.domNodeFocusOptions = m2, this.enabled = true, this.nativeMode = u3, this.throttleKeypresses = h3, this.useGetBoundingClientRect = p2, this.shouldFocusDOMNode = g2 && !u3, this.shouldUseNativeEvents = w2, this.writingDirection = E2 ? C.default.RTL : C.default.LTR, this.distanceCalculationMethod = L2, this.customDistanceCalculationFunction = R2, this.debug = i3, !this.nativeMode && (Number.isInteger(l3) && l3 > 0 && (this.throttle = l3), this.bindEventHandlers(), r3))) {
+              this.visualDebugger = new F.default(this.writingDirection);
+              var N2 = function() {
+                requestAnimationFrame(function() {
+                  t3.visualDebugger.clearLayouts(), (0, v.default)(t3.focusableComponents, function(e5, o4) {
+                    t3.visualDebugger.drawLayout(e5.layout, o4, e5.parentFocusKey);
+                  }), N2();
+                });
+              };
+              N2();
+            }
+          }, e3.prototype.setThrottle = function(e4) {
+            var t3 = void 0 === e4 ? {} : e4, o3 = t3.throttle, s3 = void 0 === o3 ? 0 : o3, i3 = t3.throttleKeypresses, n3 = void 0 !== i3 && i3;
+            this.throttleKeypresses = n3, this.nativeMode || (this.unbindEventHandlers(), Number.isInteger(s3) && (this.throttle = s3), this.bindEventHandlers());
+          }, e3.prototype.destroy = function() {
+            this.enabled && (this.enabled = false, this.nativeMode = false, this.throttle = 0, this.throttleKeypresses = false, this.focusKey = null, this.parentsHavingFocusedChild = [], this.focusableComponents = {}, this.paused = false, this.keyMap = L, this.unbindEventHandlers());
+          }, e3.prototype.getEventType = function(e4) {
+            return (0, f2.default)(this.getKeyMap(), function(t3) {
+              return t3.includes(e4);
+            });
+          }, e3.getKeyCode = function(e4) {
+            return e4.keyCode || e4.code || e4.key;
+          }, e3.prototype.bindEventHandlers = function() {
+            var t3 = this;
+            "undefined" != typeof window && window.addEventListener && (this.keyDownEventListener = function(o3) {
+              if (true !== t3.paused) {
+                t3.debug && (t3.logIndex += 1);
+                var s3 = e3.getKeyCode(o3), i3 = t3.getEventType(s3);
+                if (i3) {
+                  t3.pressedKeys[i3] = t3.pressedKeys[i3] ? t3.pressedKeys[i3] + 1 : 1, t3.shouldUseNativeEvents || (o3.preventDefault(), o3.stopPropagation());
+                  var n3 = { pressedKeys: t3.pressedKeys };
+                  if (i3 === D && t3.focusKey) t3.onEnterPress(n3);
+                  else {
+                    var r3 = false === t3.onArrowPress(i3, n3);
+                    if (t3.visualDebugger && t3.visualDebugger.clear(), r3) t3.log("keyDownEventListener", "default navigation prevented");
+                    else {
+                      var a3 = (0, f2.default)(t3.getKeyMap(), function(e4) {
+                        return e4.includes(s3);
+                      });
+                      t3.smartNavigate(a3, null, { event: o3 });
+                    }
+                  }
+                }
+              }
+            }, this.throttle && (this.keyDownEventListenerThrottled = (0, b.default)(this.keyDownEventListener.bind(this), this.throttle, R)), this.keyUpEventListener = function(o3) {
+              var s3 = e3.getKeyCode(o3), i3 = t3.getEventType(s3);
+              delete t3.pressedKeys[i3], t3.throttle && !t3.throttleKeypresses && t3.keyDownEventListenerThrottled.cancel(), i3 === D && t3.focusKey && t3.onEnterRelease(), !t3.focusKey || i3 !== K && i3 !== w && i3 !== x && i3 !== E || t3.onArrowRelease(i3);
+            }, window.addEventListener("keyup", this.keyUpEventListener), window.addEventListener("keydown", this.throttle ? this.keyDownEventListenerThrottled : this.keyDownEventListener));
+          }, e3.prototype.unbindEventHandlers = function() {
+            if ("undefined" != typeof window && window.removeEventListener) {
+              window.removeEventListener("keyup", this.keyUpEventListener), this.keyUpEventListener = null;
+              var e4 = this.throttle ? this.keyDownEventListenerThrottled : this.keyDownEventListener;
+              window.removeEventListener("keydown", e4), this.keyDownEventListener = null;
+            }
+          }, e3.prototype.onEnterPress = function(e4) {
+            var t3 = this.focusableComponents[this.focusKey];
+            t3 ? t3.focusable ? t3.onEnterPress && t3.onEnterPress(e4) : this.log("onEnterPress", "componentNotFocusable") : this.log("onEnterPress", "noComponent");
+          }, e3.prototype.onEnterRelease = function() {
+            var e4 = this.focusableComponents[this.focusKey];
+            e4 ? e4.focusable ? e4.onEnterRelease && e4.onEnterRelease() : this.log("onEnterRelease", "componentNotFocusable") : this.log("onEnterRelease", "noComponent");
+          }, e3.prototype.onArrowPress = function(e4, t3) {
+            var o3 = this.focusableComponents[this.focusKey];
+            if (o3) return o3 && o3.onArrowPress && o3.onArrowPress(e4, t3);
+            this.log("onArrowPress", "noComponent");
+          }, e3.prototype.onArrowRelease = function(e4) {
+            var t3 = this.focusableComponents[this.focusKey];
+            t3 ? t3.focusable ? t3.onArrowRelease && t3.onArrowRelease(e4) : this.log("onArrowRelease", "componentNotFocusable") : this.log("onArrowRelease", "noComponent");
+          }, e3.prototype.navigateByDirection = function(e4, t3) {
+            if (true !== this.paused && this.enabled && !this.nativeMode) {
+              var o3 = [E, x, K, w];
+              o3.includes(e4) ? (this.log("navigateByDirection", "direction", e4), this.smartNavigate(e4, null, t3)) : this.log("navigateByDirection", "Invalid direction. You passed: `".concat(e4, "`, but you can use only these: "), o3);
+            }
+          }, e3.prototype.smartNavigate = function(t3, o3, s3) {
+            var i3 = this;
+            if (!this.nativeMode) {
+              var n3 = t3 === E || t3 === x, r3 = t3 === E || (this.writingDirection === C.default.LTR ? t3 === w : t3 === K);
+              this.log("smartNavigate", "direction", t3), this.log("smartNavigate", "fromParentFocusKey", o3), this.log("smartNavigate", "this.focusKey", this.focusKey), o3 || (0, v.default)(this.focusableComponents, function(e4) {
+                e4.layoutUpdated = false;
+              });
+              var a3 = this.focusableComponents[o3 || this.focusKey];
+              if (o3 || a3) {
+                if (this.log("smartNavigate", "currentComponent", a3 ? a3.focusKey : void 0, a3 ? a3.node : void 0, a3), a3) {
+                  this.updateLayout(a3.focusKey);
+                  var u3 = a3.parentFocusKey, c3 = a3.focusKey, l3 = a3.layout, d3 = e3.getCutoffCoordinate(n3, r3, false, l3, this.writingDirection), f3 = (0, h2.default)(this.focusableComponents, function(t4) {
+                    if (t4.parentFocusKey === u3 && t4.focusable) {
+                      i3.updateLayout(t4.focusKey);
+                      var o4 = e3.getCutoffCoordinate(n3, r3, true, t4.layout, i3.writingDirection);
+                      return n3 || i3.writingDirection === C.default.LTR ? r3 ? o4 >= d3 : o4 <= d3 : r3 ? o4 <= d3 : o4 >= d3;
+                    }
+                    return false;
+                  });
+                  if (this.debug && (this.log("smartNavigate", "currentCutoffCoordinate", d3), this.log("smartNavigate", "siblings", "".concat(f3.length, " elements:"), f3.map(function(e4) {
+                    return e4.focusKey;
+                  }).join(", "), f3.map(function(e4) {
+                    return e4.node;
+                  }), f3.map(function(e4) {
+                    return e4;
+                  }))), this.visualDebugger) {
+                    var y2 = e3.getRefCorners(t3, false, l3);
+                    this.visualDebugger.drawPoint(y2.a.x, y2.a.y), this.visualDebugger.drawPoint(y2.b.x, y2.b.y);
+                  }
+                  var g2 = this.sortSiblingsByPriority(f3, l3, t3, c3), b2 = (0, p.default)(g2);
+                  if (this.log("smartNavigate", "nextComponent", b2 ? b2.focusKey : void 0, b2 ? b2.node : void 0, b2), b2) this.setFocus(b2.focusKey, s3);
+                  else {
+                    var F2 = this.focusableComponents[u3], m2 = (null == F2 ? void 0 : F2.isFocusBoundary) ? F2.focusBoundaryDirections || [t3] : [];
+                    F2 && m2.includes(t3) || this.smartNavigate(t3, u3, s3);
+                  }
+                }
+              } else this.setFocus(this.getForcedFocusKey());
+            }
+          }, e3.prototype.saveLastFocusedChildKey = function(e4, t3) {
+            e4 && (this.log("saveLastFocusedChildKey", "".concat(e4.focusKey, " lastFocusedChildKey set"), t3), e4.lastFocusedChildKey = t3);
+          }, e3.prototype.log = function(e4, t3) {
+            for (var o3 = [], s3 = 2; s3 < arguments.length; s3++) o3[s3 - 2] = arguments[s3];
+            this.debug && console.log.apply(console, u2(["%c".concat(e4, "%c").concat(t3), "background: ".concat(M[this.logIndex % M.length], "; color: black; padding: 1px 5px;"), "background: #333; color: #BADA55; padding: 1px 5px;"], o3, false));
+          }, e3.prototype.getCurrentFocusKey = function() {
+            return this.focusKey;
+          }, e3.prototype.getForcedFocusKey = function() {
+            var e4, o3 = (0, h2.default)(this.focusableComponents, function(e5) {
+              return e5.focusable && e5.forceFocus;
+            }), s3 = this.sortSiblingsByPriority(o3, { x: 0, y: 0, width: 0, height: 0, left: 0, top: 0, right: 0, bottom: 0, node: null }, "down", t2.ROOT_FOCUS_KEY);
+            return null === (e4 = (0, p.default)(s3)) || void 0 === e4 ? void 0 : e4.focusKey;
+          }, e3.prototype.getNextFocusKey = function(e4) {
+            var t3 = this, o3 = this.focusableComponents[e4];
+            if (!o3 || this.nativeMode) return e4;
+            var s3 = (0, h2.default)(this.focusableComponents, function(t4) {
+              return t4.parentFocusKey === e4 && t4.focusable;
+            });
+            if (s3.length > 0) {
+              var i3 = o3.lastFocusedChildKey, n3 = o3.preferredChildFocusKey;
+              if (this.log("getNextFocusKey", "lastFocusedChildKey is", i3), this.log("getNextFocusKey", "preferredChildFocusKey is", n3), i3 && o3.saveLastFocusedChild && this.isParticipatingFocusableComponent(i3)) return this.log("getNextFocusKey", "lastFocusedChildKey will be focused", i3), this.getNextFocusKey(i3);
+              if (n3 && this.isParticipatingFocusableComponent(n3)) return this.log("getNextFocusKey", "preferredChildFocusKey will be focused", n3), this.getNextFocusKey(n3);
+              s3.forEach(function(e5) {
+                return t3.updateLayout(e5.focusKey);
+              });
+              var r3 = function(e5, t4) {
+                var o4 = t4 === C.default.LTR ? function(e6) {
+                  var t5 = e6.layout;
+                  return Math.abs(t5.left) + Math.abs(t5.top);
+                } : function(e6) {
+                  var t5 = e6.layout;
+                  return Math.abs(window.innerWidth - t5.right) + Math.abs(t5.top);
+                }, s4 = (0, g.default)(e5, o4);
+                return (0, p.default)(s4);
+              }(s3, this.writingDirection).focusKey;
+              return this.log("getNextFocusKey", "childKey will be focused", r3), this.getNextFocusKey(r3);
+            }
+            return this.log("getNextFocusKey", "targetFocusKey", e4), e4;
+          }, e3.prototype.addFocusable = function(e4) {
+            var t3 = e4.focusKey, o3 = e4.node, s3 = e4.parentFocusKey, i3 = e4.onEnterPress, n3 = e4.onEnterRelease, r3 = e4.onArrowPress, a3 = e4.onArrowRelease, u3 = e4.onFocus, c3 = e4.onBlur, l3 = e4.saveLastFocusedChild, d3 = e4.trackChildren, h3 = e4.onUpdateFocus, f3 = e4.onUpdateHasFocusedChild, p2 = e4.preferredChildFocusKey, y2 = e4.autoRestoreFocus, v2 = e4.forceFocus, g2 = e4.focusable, b2 = e4.isFocusBoundary, F2 = e4.focusBoundaryDirections;
+            if (this.focusableComponents[t3] = { focusKey: t3, node: o3, parentFocusKey: s3, onEnterPress: i3, onEnterRelease: n3, onArrowPress: r3, onArrowRelease: a3, onFocus: u3, onBlur: c3, onUpdateFocus: h3, onUpdateHasFocusedChild: f3, saveLastFocusedChild: l3, trackChildren: d3, preferredChildFocusKey: p2, focusable: g2, isFocusBoundary: b2, focusBoundaryDirections: F2, autoRestoreFocus: y2, forceFocus: v2, lastFocusedChildKey: null, layout: { x: 0, y: 0, width: 0, height: 0, left: 0, top: 0, right: 0, bottom: 0, node: o3 }, layoutUpdated: false }, o3 || console.warn('Component added without a node reference. This will result in its coordinates being empty and may cause lost focus. Check the "ref" passed to "useFocusable": ', this.focusableComponents[t3]), !this.nativeMode) {
+              this.updateLayout(t3), this.log("addFocusable", "Component added: ", this.focusableComponents[t3]), t3 === this.focusKey && this.setFocus(p2 || t3);
+              for (var C2 = this.focusableComponents[this.focusKey]; C2; ) {
+                if (C2.parentFocusKey === t3) {
+                  this.updateParentsHasFocusedChild(this.focusKey, {}), this.updateParentsLastFocusedChild(this.focusKey);
+                  break;
+                }
+                C2 = this.focusableComponents[C2.parentFocusKey];
+              }
+            }
+          }, e3.prototype.removeFocusable = function(e4) {
+            var t3 = e4.focusKey, o3 = this.focusableComponents[t3];
+            if (o3) {
+              var s3 = o3.parentFocusKey;
+              (0, o3.onUpdateFocus)(false), this.log("removeFocusable", "Component removed: ", o3), delete this.focusableComponents[t3];
+              var i3 = this.parentsHavingFocusedChild.includes(t3);
+              this.parentsHavingFocusedChild = this.parentsHavingFocusedChild.filter(function(e5) {
+                return e5 !== t3;
+              });
+              var n3 = this.focusableComponents[s3], r3 = t3 === this.focusKey;
+              if (n3 && n3.lastFocusedChildKey === t3 && (n3.lastFocusedChildKey = null), this.nativeMode) return;
+              (r3 || i3) && n3 && n3.autoRestoreFocus && (this.log("removeFocusable", "Component removed: ", r3 ? "Leaf component" : "Container component", "Auto restoring focus to: ", s3), this.setFocusDebounced(s3));
+            }
+          }, e3.prototype.getNodeLayoutByFocusKey = function(e4) {
+            var t3 = this.focusableComponents[e4];
+            return t3 ? (this.updateLayout(t3.focusKey), t3.layout) : null;
+          }, e3.prototype.setCurrentFocusedKey = function(e4, t3) {
+            var o3, s3, i3, n3;
+            if (this.isFocusableComponent(this.focusKey) && e4 !== this.focusKey) {
+              var r3 = this.focusableComponents[this.focusKey];
+              r3.onUpdateFocus(false), r3.onBlur(this.getNodeLayoutByFocusKey(this.focusKey), t3), null === (s3 = null === (o3 = r3.node) || void 0 === o3 ? void 0 : o3.removeAttribute) || void 0 === s3 || s3.call(o3, "data-focused"), this.log("setCurrentFocusedKey", "onBlur", r3);
+            }
+            if (this.focusKey = e4, this.isFocusableComponent(this.focusKey)) {
+              var a3 = this.focusableComponents[this.focusKey];
+              this.shouldFocusDOMNode && a3.node && a3.node.focus(this.domNodeFocusOptions), null === (n3 = null === (i3 = a3.node) || void 0 === i3 ? void 0 : i3.setAttribute) || void 0 === n3 || n3.call(i3, "data-focused", "true"), a3.onUpdateFocus(true), a3.onFocus(this.getNodeLayoutByFocusKey(this.focusKey), t3), this.log("setCurrentFocusedKey", "onFocus", a3);
+            }
+          }, e3.prototype.updateParentsHasFocusedChild = function(e4, t3) {
+            for (var o3 = this, s3 = [], i3 = this.focusableComponents[e4]; i3; ) {
+              var n3 = i3.parentFocusKey, r3 = this.focusableComponents[n3];
+              if (r3) {
+                var a3 = r3.focusKey;
+                s3.push(a3);
+              }
+              i3 = r3;
+            }
+            var u3 = (0, d2.default)(this.parentsHavingFocusedChild, s3), c3 = (0, d2.default)(s3, this.parentsHavingFocusedChild);
+            (0, y.default)(u3, function(e5) {
+              var s4 = o3.focusableComponents[e5];
+              s4 && s4.trackChildren && s4.onUpdateHasFocusedChild(false), o3.onIntermediateNodeBecameBlurred(e5, t3);
+            }), (0, y.default)(c3, function(e5) {
+              var s4 = o3.focusableComponents[e5];
+              s4 && s4.trackChildren && s4.onUpdateHasFocusedChild(true), o3.onIntermediateNodeBecameFocused(e5, t3);
+            }), this.parentsHavingFocusedChild = s3;
+          }, e3.prototype.updateParentsLastFocusedChild = function(e4) {
+            for (var t3 = this.focusableComponents[e4]; t3; ) {
+              var o3 = t3.parentFocusKey, s3 = this.focusableComponents[o3];
+              s3 && this.saveLastFocusedChildKey(s3, t3.focusKey), t3 = s3;
+            }
+          }, e3.prototype.getKeyMap = function() {
+            return this.keyMap;
+          }, e3.prototype.setKeyMap = function(e4) {
+            this.keyMap = i2(i2({}, this.getKeyMap()), function(e5) {
+              var t3 = {};
+              return Object.entries(e5).forEach(function(e6) {
+                var o3 = e6[0], s3 = e6[1];
+                t3[o3] = Array.isArray(s3) ? s3 : [s3];
+              }), t3;
+            }(e4));
+          }, e3.prototype.isFocusableComponent = function(e4) {
+            return !!this.focusableComponents[e4];
+          }, e3.prototype.isParticipatingFocusableComponent = function(e4) {
+            return this.isFocusableComponent(e4) && this.focusableComponents[e4].focusable;
+          }, e3.prototype.onIntermediateNodeBecameFocused = function(e4, t3) {
+            this.isParticipatingFocusableComponent(e4) && this.focusableComponents[e4].onFocus(this.getNodeLayoutByFocusKey(e4), t3);
+          }, e3.prototype.onIntermediateNodeBecameBlurred = function(e4, t3) {
+            this.isParticipatingFocusableComponent(e4) && this.focusableComponents[e4].onBlur(this.getNodeLayoutByFocusKey(e4), t3);
+          }, e3.prototype.pause = function() {
+            this.paused = true;
+          }, e3.prototype.resume = function() {
+            this.paused = false;
+          }, e3.prototype.setFocus = function(e4, o3) {
+            if (void 0 === o3 && (o3 = {}), this.setFocusDebounced.cancel(), this.enabled) {
+              this.log("setFocus", "focusKey", e4), e4 && e4 !== t2.ROOT_FOCUS_KEY || (e4 = this.getForcedFocusKey());
+              var s3 = this.getNextFocusKey(e4);
+              this.log("setFocus", "newFocusKey", s3), this.setCurrentFocusedKey(s3, o3), this.updateParentsHasFocusedChild(s3, o3), this.updateParentsLastFocusedChild(s3);
+            }
+          }, e3.prototype.updateAllLayouts = function() {
+            var e4 = this;
+            this.enabled && !this.nativeMode && (0, v.default)(this.focusableComponents, function(t3, o3) {
+              e4.updateLayout(o3);
+            });
+          }, e3.prototype.updateLayout = function(e4) {
+            var t3 = this.focusableComponents[e4];
+            if (t3 && !this.nativeMode && !t3.layoutUpdated) {
+              var o3 = t3.node, s3 = this.useGetBoundingClientRect ? (0, m.getBoundingClientRect)(o3) : (0, m.default)(o3);
+              t3.layout = i2(i2({}, s3), { node: o3 });
+            }
+          }, e3.prototype.updateFocusable = function(e4, t3) {
+            var o3 = t3.node, s3 = t3.preferredChildFocusKey, i3 = t3.focusable, n3 = t3.isFocusBoundary, r3 = t3.focusBoundaryDirections, a3 = t3.onEnterPress, u3 = t3.onEnterRelease, c3 = t3.onArrowPress, l3 = t3.onFocus, d3 = t3.onBlur;
+            if (!this.nativeMode) {
+              var h3 = this.focusableComponents[e4];
+              h3 && (h3.preferredChildFocusKey = s3, h3.focusable = i3, h3.isFocusBoundary = n3, h3.focusBoundaryDirections = r3, h3.onEnterPress = a3, h3.onEnterRelease = u3, h3.onArrowPress = c3, h3.onFocus = l3, h3.onBlur = d3, o3 && (h3.node = o3));
+            }
+          }, e3.prototype.isNativeMode = function() {
+            return this.nativeMode;
+          }, e3.prototype.doesFocusableExist = function(e4) {
+            return !!this.focusableComponents[e4];
+          }, e3.prototype.updateRtl = function(e4) {
+            this.writingDirection = e4 ? C.default.RTL : C.default.LTR;
+          }, e3;
+        }();
+        t2.SpatialNavigation = new N(), t2.init = t2.SpatialNavigation.init, t2.setThrottle = t2.SpatialNavigation.setThrottle, t2.destroy = t2.SpatialNavigation.destroy, t2.setKeyMap = t2.SpatialNavigation.setKeyMap, t2.setFocus = t2.SpatialNavigation.setFocus, t2.navigateByDirection = t2.SpatialNavigation.navigateByDirection, t2.pause = t2.SpatialNavigation.pause, t2.resume = t2.SpatialNavigation.resume, t2.updateAllLayouts = t2.SpatialNavigation.updateAllLayouts, t2.getCurrentFocusKey = t2.SpatialNavigation.getCurrentFocusKey, t2.doesFocusableExist = t2.SpatialNavigation.doesFocusableExist, t2.updateRtl = t2.SpatialNavigation.updateRtl;
+      }, 35: function(e2, t2, o2) {
+        var s2 = this && this.__importDefault || function(e3) {
+          return e3 && e3.__esModule ? e3 : { default: e3 };
+        };
+        Object.defineProperty(t2, "__esModule", { value: true });
+        var i2 = s2(o2(119)), n2 = "undefined" != typeof window && window.document, r2 = n2 ? window.innerWidth : 0, a2 = n2 ? window.innerHeight : 0, u2 = function() {
+          function e3(t3) {
+            n2 && (this.debugCtx = e3.createCanvas("sn-debug", "1010", t3), this.layoutsCtx = e3.createCanvas("sn-layouts", "1000", t3), this.writingDirection = t3);
+          }
+          return e3.createCanvas = function(e4, t3, o3) {
+            var s3 = document.querySelector("#".concat(e4)) || document.createElement("canvas");
+            s3.setAttribute("id", e4), s3.setAttribute("dir", o3 === i2.default.LTR ? "ltr" : "rtl");
+            var n3 = s3.getContext("2d");
+            return s3.style.zIndex = t3, s3.style.position = "fixed", s3.style.top = "0", s3.style.left = "0", document.body.appendChild(s3), s3.width = r2, s3.height = a2, n3;
+          }, e3.prototype.clear = function() {
+            n2 && this.debugCtx.clearRect(0, 0, r2, a2);
+          }, e3.prototype.clearLayouts = function() {
+            n2 && this.layoutsCtx.clearRect(0, 0, r2, a2);
+          }, e3.prototype.drawLayout = function(e4, t3, o3) {
+            if (n2) {
+              this.layoutsCtx.strokeStyle = "green", this.layoutsCtx.strokeRect(e4.left, e4.top, e4.width, e4.height), this.layoutsCtx.font = "8px monospace", this.layoutsCtx.fillStyle = "red";
+              var s3 = this.writingDirection === i2.default.LTR ? "left" : "right", r3 = e4[s3];
+              this.layoutsCtx.fillText(t3, r3, e4.top + 10), this.layoutsCtx.fillText(o3, r3, e4.top + 25), this.layoutsCtx.fillText("".concat(s3, ": ").concat(r3), r3, e4.top + 40), this.layoutsCtx.fillText("top: ".concat(e4.top), r3, e4.top + 55);
+            }
+          }, e3.prototype.drawPoint = function(e4, t3, o3, s3) {
+            void 0 === o3 && (o3 = "blue"), void 0 === s3 && (s3 = 10), n2 && (this.debugCtx.strokeStyle = o3, this.debugCtx.lineWidth = 3, this.debugCtx.strokeRect(e4 - s3 / 2, t3 - s3 / 2, s3, s3));
+          }, e3;
+        }();
+        t2.default = u2;
+      }, 119: function(e2, t2) {
+        var o2;
+        Object.defineProperty(t2, "__esModule", { value: true }), function(e3) {
+          e3[e3.LTR = 0] = "LTR", e3[e3.RTL = 1] = "RTL";
+        }(o2 || (o2 = {})), t2.default = o2;
+      }, 607: function(e2, t2, o2) {
+        var s2 = this && this.__createBinding || (Object.create ? function(e3, t3, o3, s3) {
+          void 0 === s3 && (s3 = o3);
+          var i3 = Object.getOwnPropertyDescriptor(t3, o3);
+          i3 && !("get" in i3 ? !t3.__esModule : i3.writable || i3.configurable) || (i3 = { enumerable: true, get: function() {
+            return t3[o3];
+          } }), Object.defineProperty(e3, s3, i3);
+        } : function(e3, t3, o3, s3) {
+          void 0 === s3 && (s3 = o3), e3[s3] = t3[o3];
+        }), i2 = this && this.__exportStar || function(e3, t3) {
+          for (var o3 in e3) "default" === o3 || Object.prototype.hasOwnProperty.call(t3, o3) || s2(t3, e3, o3);
+        };
+        Object.defineProperty(t2, "__esModule", { value: true }), i2(o2(79), t2), i2(o2(445), t2), i2(o2(654), t2);
+      }, 964: function(e2, t2) {
+        Object.defineProperty(t2, "__esModule", { value: true }), t2.getBoundingClientRect = void 0;
+        var o2 = function(e3) {
+          for (var t3 = e3.offsetParent, o3 = e3.offsetHeight, s2 = e3.offsetWidth, i2 = e3.offsetLeft, n2 = e3.offsetTop; t3 && 1 === t3.nodeType; ) i2 += t3.offsetLeft - t3.scrollLeft, n2 += t3.offsetTop - t3.scrollTop, t3 = t3.offsetParent;
+          return { height: o3, left: i2, top: n2, width: s2 };
+        };
+        t2.default = function(e3) {
+          var t3 = e3 && e3.parentElement;
+          if (e3 && t3) {
+            var s2 = o2(t3), i2 = o2(e3), n2 = i2.height, r2 = i2.left, a2 = i2.top, u2 = i2.width;
+            return { x: r2 - s2.left, y: a2 - s2.top, width: u2, height: n2, left: r2, top: a2, get right() {
+              return this.left + this.width;
+            }, get bottom() {
+              return this.top + this.height;
+            } };
+          }
+          return { x: 0, y: 0, width: 0, height: 0, left: 0, top: 0, right: 0, bottom: 0 };
+        }, t2.getBoundingClientRect = function(e3) {
+          if (e3 && e3.getBoundingClientRect) {
+            var t3 = e3.getBoundingClientRect();
+            return { x: t3.x, y: t3.y, width: t3.width, height: t3.height, left: t3.left, top: t3.top, get right() {
+              return this.left + this.width;
+            }, get bottom() {
+              return this.top + this.height;
+            } };
+          }
+          return { x: 0, y: 0, width: 0, height: 0, left: 0, top: 0, right: 0, bottom: 0 };
+        };
+      }, 445: function(e2, t2, o2) {
+        Object.defineProperty(t2, "__esModule", { value: true }), t2.useFocusContext = t2.FocusContext = void 0;
+        var s2 = o2(156), i2 = o2(654);
+        t2.FocusContext = (0, s2.createContext)(i2.ROOT_FOCUS_KEY), t2.FocusContext.displayName = "FocusContext", t2.useFocusContext = function() {
+          return (0, s2.useContext)(t2.FocusContext);
+        };
+      }, 79: function(e2, t2, o2) {
+        var s2 = this && this.__importDefault || function(e3) {
+          return e3 && e3.__esModule ? e3 : { default: e3 };
+        };
+        Object.defineProperty(t2, "__esModule", { value: true }), t2.useFocusable = void 0;
+        var i2 = o2(156), n2 = s2(o2(604)), r2 = s2(o2(461)), a2 = o2(654), u2 = o2(445);
+        t2.useFocusable = function(e3) {
+          var t3 = void 0 === e3 ? {} : e3, o3 = t3.focusable, s3 = void 0 === o3 || o3, c2 = t3.saveLastFocusedChild, l2 = void 0 === c2 || c2, d2 = t3.trackChildren, h2 = void 0 !== d2 && d2, f2 = t3.autoRestoreFocus, p = void 0 === f2 || f2, y = t3.forceFocus, v = void 0 !== y && y, g = t3.isFocusBoundary, b = void 0 !== g && g, F = t3.focusBoundaryDirections, C = t3.focusKey, m = t3.preferredChildFocusKey, K = t3.onEnterPress, w = void 0 === K ? n2.default : K, x = t3.onEnterRelease, E = void 0 === x ? n2.default : x, D = t3.onArrowPress, L = void 0 === D ? function() {
+            return true;
+          } : D, M = t3.onArrowRelease, R = void 0 === M ? n2.default : M, N = t3.onFocus, P = void 0 === N ? n2.default : N, B = t3.onBlur, _ = void 0 === B ? n2.default : B, A = t3.extraProps, O = (0, i2.useCallback)(function(e4) {
+            w(A, e4);
+          }, [w, A]), k = (0, i2.useCallback)(function() {
+            E(A);
+          }, [E, A]), T = (0, i2.useCallback)(function(e4, t4) {
+            return L(e4, A, t4);
+          }, [A, L]), S = (0, i2.useCallback)(function(e4) {
+            R(e4, A);
+          }, [R, A]), q = (0, i2.useCallback)(function(e4, t4) {
+            P(e4, A, t4);
+          }, [A, P]), U = (0, i2.useCallback)(function(e4, t4) {
+            _(e4, A, t4);
+          }, [A, _]), j = (0, i2.useRef)(null), H = (0, i2.useState)(false), I = H[0], Y = H[1], G = (0, i2.useState)(false), W = G[0], z = G[1], J = (0, u2.useFocusContext)(), Q = (0, i2.useMemo)(function() {
+            return C || (0, r2.default)("sn:focusable-item-");
+          }, [C]), V = (0, i2.useCallback)(function(e4) {
+            void 0 === e4 && (e4 = {}), a2.SpatialNavigation.setFocus(Q, e4);
+          }, [Q]);
+          return (0, i2.useEffect)(function() {
+            var e4 = j.current;
+            return a2.SpatialNavigation.addFocusable({ focusKey: Q, node: e4, parentFocusKey: J, preferredChildFocusKey: m, onEnterPress: O, onEnterRelease: k, onArrowPress: T, onArrowRelease: S, onFocus: q, onBlur: U, onUpdateFocus: function(e5) {
+              return void 0 === e5 && (e5 = false), Y(e5);
+            }, onUpdateHasFocusedChild: function(e5) {
+              return void 0 === e5 && (e5 = false), z(e5);
+            }, saveLastFocusedChild: l2, trackChildren: h2, isFocusBoundary: b, focusBoundaryDirections: F, autoRestoreFocus: p, forceFocus: v, focusable: s3 }), function() {
+              a2.SpatialNavigation.removeFocusable({ focusKey: Q });
+            };
+          }, []), (0, i2.useEffect)(function() {
+            var e4 = j.current;
+            a2.SpatialNavigation.updateFocusable(Q, { node: e4, preferredChildFocusKey: m, focusable: s3, isFocusBoundary: b, focusBoundaryDirections: F, onEnterPress: O, onEnterRelease: k, onArrowPress: T, onArrowRelease: S, onFocus: q, onBlur: U });
+          }, [Q, m, s3, b, F, O, k, T, S, q, U]), { ref: j, focusSelf: V, focused: I, hasFocusedChild: W, focusKey: Q };
+        };
+      }, 150: function(t2) {
+        t2.exports = e;
+      }, 117: function(e2) {
+        e2.exports = t;
+      }, 747: function(e2) {
+        e2.exports = o;
+      }, 23: function(e2) {
+        e2.exports = s;
+      }, 842: function(e2) {
+        e2.exports = i;
+      }, 682: function(e2) {
+        e2.exports = n;
+      }, 784: function(e2) {
+        e2.exports = r;
+      }, 604: function(e2) {
+        e2.exports = a;
+      }, 432: function(e2) {
+        e2.exports = u;
+      }, 67: function(e2) {
+        e2.exports = c;
+      }, 461: function(e2) {
+        e2.exports = l;
+      }, 156: function(e2) {
+        e2.exports = d;
+      } }, f = {};
+      return function e2(t2) {
+        var o2 = f[t2];
+        if (void 0 !== o2) return o2.exports;
+        var s2 = f[t2] = { exports: {} };
+        return h[t2].call(s2.exports, s2, s2.exports, e2), s2.exports;
+      }(607);
+    }();
+  });
+})(dist);
+var distExports = dist.exports;
 export {
-  k as D,
-  le as I,
-  K as a,
-  re as b,
-  ae as e,
-  ne as o,
-  oe as s
+  getAugmentedNamespace as a,
+  commonjsGlobal as c,
+  distExports as d,
+  getDefaultExportFromCjs as g
 };