@rpcbase/client 0.401.0 → 0.402.0

package/dist/spatial-nav/index.js

@@ -0,0 +1,4342 @@
+import { c } from "react/compiler-runtime";
+import { createContext, useContext, useRef, useState, useEffect } from "react";
+import { g as getDefaultExportFromCjs, r as requireToString, a as requireDebounce, b as require_baseGetTag, c as requireIsObject, d as require_root, e as require_arrayMap, f as requireIsObjectLike, h as require_Symbol, i as requireIsArray, j as require_freeGlobal, k as requireIsSymbol, t as throttle } from "../throttle-CXOc9Dto.js";
+var noop_1;
+var hasRequiredNoop;
+function requireNoop() {
+  if (hasRequiredNoop) return noop_1;
+  hasRequiredNoop = 1;
+  function noop2() {
+  }
+  noop_1 = noop2;
+  return noop_1;
+}
+var noopExports = requireNoop();
+const noop = /* @__PURE__ */ getDefaultExportFromCjs(noopExports);
+var uniqueId_1;
+var hasRequiredUniqueId;
+function requireUniqueId() {
+  if (hasRequiredUniqueId) return uniqueId_1;
+  hasRequiredUniqueId = 1;
+  var toString = requireToString();
+  var idCounter = 0;
+  function uniqueId2(prefix) {
+    var id = ++idCounter;
+    return toString(prefix) + id;
+  }
+  uniqueId_1 = uniqueId2;
+  return uniqueId_1;
+}
+var uniqueIdExports = requireUniqueId();
+const uniqueId = /* @__PURE__ */ getDefaultExportFromCjs(uniqueIdExports);
+var debounceExports = requireDebounce();
+const debounce = /* @__PURE__ */ getDefaultExportFromCjs(debounceExports);
+var isFunction_1;
+var hasRequiredIsFunction;
+function requireIsFunction() {
+  if (hasRequiredIsFunction) return isFunction_1;
+  hasRequiredIsFunction = 1;
+  var baseGetTag = require_baseGetTag(), isObject = requireIsObject();
+  var asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+  function isFunction(value) {
+    if (!isObject(value)) {
+      return false;
+    }
+    var tag = baseGetTag(value);
+    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+  }
+  isFunction_1 = isFunction;
+  return isFunction_1;
+}
+var _coreJsData;
+var hasRequired_coreJsData;
+function require_coreJsData() {
+  if (hasRequired_coreJsData) return _coreJsData;
+  hasRequired_coreJsData = 1;
+  var root = require_root();
+  var coreJsData = root["__core-js_shared__"];
+  _coreJsData = coreJsData;
+  return _coreJsData;
+}
+var _isMasked;
+var hasRequired_isMasked;
+function require_isMasked() {
+  if (hasRequired_isMasked) return _isMasked;
+  hasRequired_isMasked = 1;
+  var coreJsData = require_coreJsData();
+  var maskSrcKey = (function() {
+    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+    return uid ? "Symbol(src)_1." + uid : "";
+  })();
+  function isMasked(func) {
+    return !!maskSrcKey && maskSrcKey in func;
+  }
+  _isMasked = isMasked;
+  return _isMasked;
+}
+var _toSource;
+var hasRequired_toSource;
+function require_toSource() {
+  if (hasRequired_toSource) return _toSource;
+  hasRequired_toSource = 1;
+  var funcProto = Function.prototype;
+  var funcToString = funcProto.toString;
+  function toSource(func) {
+    if (func != null) {
+      try {
+        return funcToString.call(func);
+      } catch (e) {
+      }
+      try {
+        return func + "";
+      } catch (e) {
+      }
+    }
+    return "";
+  }
+  _toSource = toSource;
+  return _toSource;
+}
+var _baseIsNative;
+var hasRequired_baseIsNative;
+function require_baseIsNative() {
+  if (hasRequired_baseIsNative) return _baseIsNative;
+  hasRequired_baseIsNative = 1;
+  var isFunction = requireIsFunction(), isMasked = require_isMasked(), isObject = requireIsObject(), toSource = require_toSource();
+  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+  var reIsHostCtor = /^\[object .+?Constructor\]$/;
+  var funcProto = Function.prototype, objectProto = Object.prototype;
+  var funcToString = funcProto.toString;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  var reIsNative = RegExp(
+    "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+  );
+  function baseIsNative(value) {
+    if (!isObject(value) || isMasked(value)) {
+      return false;
+    }
+    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+    return pattern.test(toSource(value));
+  }
+  _baseIsNative = baseIsNative;
+  return _baseIsNative;
+}
+var _getValue;
+var hasRequired_getValue;
+function require_getValue() {
+  if (hasRequired_getValue) return _getValue;
+  hasRequired_getValue = 1;
+  function getValue(object, key) {
+    return object == null ? void 0 : object[key];
+  }
+  _getValue = getValue;
+  return _getValue;
+}
+var _getNative;
+var hasRequired_getNative;
+function require_getNative() {
+  if (hasRequired_getNative) return _getNative;
+  hasRequired_getNative = 1;
+  var baseIsNative = require_baseIsNative(), getValue = require_getValue();
+  function getNative(object, key) {
+    var value = getValue(object, key);
+    return baseIsNative(value) ? value : void 0;
+  }
+  _getNative = getNative;
+  return _getNative;
+}
+var _nativeCreate;
+var hasRequired_nativeCreate;
+function require_nativeCreate() {
+  if (hasRequired_nativeCreate) return _nativeCreate;
+  hasRequired_nativeCreate = 1;
+  var getNative = require_getNative();
+  var nativeCreate = getNative(Object, "create");
+  _nativeCreate = nativeCreate;
+  return _nativeCreate;
+}
+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 objectProto = Object.prototype;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  function hashGet(key) {
+    var data = this.__data__;
+    if (nativeCreate) {
+      var result = data[key];
+      return result === HASH_UNDEFINED ? void 0 : result;
+    }
+    return hasOwnProperty.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 objectProto = Object.prototype;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  function hashHas(key) {
+    var data = this.__data__;
+    return nativeCreate ? data[key] !== void 0 : hasOwnProperty.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;
+}
+var _listCacheClear;
+var hasRequired_listCacheClear;
+function require_listCacheClear() {
+  if (hasRequired_listCacheClear) return _listCacheClear;
+  hasRequired_listCacheClear = 1;
+  function listCacheClear() {
+    this.__data__ = [];
+    this.size = 0;
+  }
+  _listCacheClear = listCacheClear;
+  return _listCacheClear;
+}
+var eq_1;
+var hasRequiredEq;
+function requireEq() {
+  if (hasRequiredEq) return eq_1;
+  hasRequiredEq = 1;
+  function eq(value, other) {
+    return value === other || value !== value && other !== other;
+  }
+  eq_1 = eq;
+  return eq_1;
+}
+var _assocIndexOf;
+var hasRequired_assocIndexOf;
+function require_assocIndexOf() {
+  if (hasRequired_assocIndexOf) return _assocIndexOf;
+  hasRequired_assocIndexOf = 1;
+  var eq = requireEq();
+  function assocIndexOf(array, key) {
+    var length = array.length;
+    while (length--) {
+      if (eq(array[length][0], key)) {
+        return length;
+      }
+    }
+    return -1;
+  }
+  _assocIndexOf = assocIndexOf;
+  return _assocIndexOf;
+}
+var _listCacheDelete;
+var hasRequired_listCacheDelete;
+function require_listCacheDelete() {
+  if (hasRequired_listCacheDelete) return _listCacheDelete;
+  hasRequired_listCacheDelete = 1;
+  var assocIndexOf = require_assocIndexOf();
+  var arrayProto = Array.prototype;
+  var splice = arrayProto.splice;
+  function listCacheDelete(key) {
+    var data = this.__data__, index = assocIndexOf(data, key);
+    if (index < 0) {
+      return false;
+    }
+    var lastIndex = data.length - 1;
+    if (index == lastIndex) {
+      data.pop();
+    } else {
+      splice.call(data, index, 1);
+    }
+    --this.size;
+    return true;
+  }
+  _listCacheDelete = listCacheDelete;
+  return _listCacheDelete;
+}
+var _listCacheGet;
+var hasRequired_listCacheGet;
+function require_listCacheGet() {
+  if (hasRequired_listCacheGet) return _listCacheGet;
+  hasRequired_listCacheGet = 1;
+  var assocIndexOf = require_assocIndexOf();
+  function listCacheGet(key) {
+    var data = this.__data__, index = assocIndexOf(data, key);
+    return index < 0 ? void 0 : data[index][1];
+  }
+  _listCacheGet = listCacheGet;
+  return _listCacheGet;
+}
+var _listCacheHas;
+var hasRequired_listCacheHas;
+function require_listCacheHas() {
+  if (hasRequired_listCacheHas) return _listCacheHas;
+  hasRequired_listCacheHas = 1;
+  var assocIndexOf = require_assocIndexOf();
+  function listCacheHas(key) {
+    return assocIndexOf(this.__data__, key) > -1;
+  }
+  _listCacheHas = listCacheHas;
+  return _listCacheHas;
+}
+var _listCacheSet;
+var hasRequired_listCacheSet;
+function require_listCacheSet() {
+  if (hasRequired_listCacheSet) return _listCacheSet;
+  hasRequired_listCacheSet = 1;
+  var assocIndexOf = require_assocIndexOf();
+  function listCacheSet(key, value) {
+    var data = this.__data__, index = assocIndexOf(data, key);
+    if (index < 0) {
+      ++this.size;
+      data.push([key, value]);
+    } else {
+      data[index][1] = value;
+    }
+    return this;
+  }
+  _listCacheSet = listCacheSet;
+  return _listCacheSet;
+}
+var _ListCache;
+var hasRequired_ListCache;
+function require_ListCache() {
+  if (hasRequired_ListCache) return _ListCache;
+  hasRequired_ListCache = 1;
+  var listCacheClear = require_listCacheClear(), listCacheDelete = require_listCacheDelete(), listCacheGet = require_listCacheGet(), listCacheHas = require_listCacheHas(), listCacheSet = require_listCacheSet();
+  function ListCache(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.prototype.clear = listCacheClear;
+  ListCache.prototype["delete"] = listCacheDelete;
+  ListCache.prototype.get = listCacheGet;
+  ListCache.prototype.has = listCacheHas;
+  ListCache.prototype.set = listCacheSet;
+  _ListCache = ListCache;
+  return _ListCache;
+}
+var _Map;
+var hasRequired_Map;
+function require_Map() {
+  if (hasRequired_Map) return _Map;
+  hasRequired_Map = 1;
+  var getNative = require_getNative(), root = require_root();
+  var Map = getNative(root, "Map");
+  _Map = Map;
+  return _Map;
+}
+var _mapCacheClear;
+var hasRequired_mapCacheClear;
+function require_mapCacheClear() {
+  if (hasRequired_mapCacheClear) return _mapCacheClear;
+  hasRequired_mapCacheClear = 1;
+  var Hash = require_Hash(), ListCache = require_ListCache(), Map = require_Map();
+  function mapCacheClear() {
+    this.size = 0;
+    this.__data__ = {
+      "hash": new Hash(),
+      "map": new (Map || ListCache)(),
+      "string": new Hash()
+    };
+  }
+  _mapCacheClear = mapCacheClear;
+  return _mapCacheClear;
+}
+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 MapCache(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]);
+    }
+  }
+  MapCache.prototype.clear = mapCacheClear;
+  MapCache.prototype["delete"] = mapCacheDelete;
+  MapCache.prototype.get = mapCacheGet;
+  MapCache.prototype.has = mapCacheHas;
+  MapCache.prototype.set = mapCacheSet;
+  _MapCache = MapCache;
+  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 MapCache = require_MapCache(), setCacheAdd = require_setCacheAdd(), setCacheHas = require_setCacheHas();
+  function SetCache(values) {
+    var index = -1, length = values == null ? 0 : values.length;
+    this.__data__ = new MapCache();
+    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;
+}
+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(), arrayMap = require_arrayMap(), baseUnary = require_baseUnary(), cacheHas = require_cacheHas();
+  var LARGE_ARRAY_SIZE = 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 = arrayMap(values, baseUnary(iteratee));
+    }
+    if (comparator) {
+      includes = arrayIncludesWith;
+      isCommon = false;
+    } else if (values.length >= LARGE_ARRAY_SIZE) {
+      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 arrayPush(array, values) {
+    var index = -1, length = values.length, offset = array.length;
+    while (++index < length) {
+      array[offset + index] = values[index];
+    }
+    return array;
+  }
+  _arrayPush = arrayPush;
+  return _arrayPush;
+}
+var _baseIsArguments;
+var hasRequired_baseIsArguments;
+function require_baseIsArguments() {
+  if (hasRequired_baseIsArguments) return _baseIsArguments;
+  hasRequired_baseIsArguments = 1;
+  var baseGetTag = require_baseGetTag(), isObjectLike = requireIsObjectLike();
+  var argsTag = "[object Arguments]";
+  function baseIsArguments(value) {
+    return isObjectLike(value) && baseGetTag(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 objectProto = Object.prototype;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+  var isArguments = baseIsArguments(/* @__PURE__ */ (function() {
+    return arguments;
+  })()) ? baseIsArguments : function(value) {
+    return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+  };
+  isArguments_1 = isArguments;
+  return isArguments_1;
+}
+var _isFlattenable;
+var hasRequired_isFlattenable;
+function require_isFlattenable() {
+  if (hasRequired_isFlattenable) return _isFlattenable;
+  hasRequired_isFlattenable = 1;
+  var Symbol2 = require_Symbol(), isArguments = requireIsArguments(), isArray = requireIsArray();
+  var spreadableSymbol = Symbol2 ? Symbol2.isConcatSpreadable : void 0;
+  function isFlattenable(value) {
+    return isArray(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 arrayPush = 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 {
+          arrayPush(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 getNative = require_getNative();
+  var defineProperty = (function() {
+    try {
+      var func = getNative(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 isFunction = requireIsFunction(), isLength = requireIsLength();
+  function isArrayLike(value) {
+    return value != null && isLength(value.length) && !isFunction(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 difference2 = baseRest(function(array, values) {
+    return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) : [];
+  });
+  difference_1 = difference2;
+  return difference_1;
+}
+var differenceExports = requireDifference();
+const difference = /* @__PURE__ */ getDefaultExportFromCjs(differenceExports);
+var _arrayFilter;
+var hasRequired_arrayFilter;
+function require_arrayFilter() {
+  if (hasRequired_arrayFilter) return _arrayFilter;
+  hasRequired_arrayFilter = 1;
+  function arrayFilter(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 = arrayFilter;
+  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: {} };
+var stubFalse_1;
+var hasRequiredStubFalse;
+function requireStubFalse() {
+  if (hasRequiredStubFalse) return stubFalse_1;
+  hasRequiredStubFalse = 1;
+  function stubFalse() {
+    return false;
+  }
+  stubFalse_1 = stubFalse;
+  return stubFalse_1;
+}
+isBuffer.exports;
+var hasRequiredIsBuffer;
+function requireIsBuffer() {
+  if (hasRequiredIsBuffer) return isBuffer.exports;
+  hasRequiredIsBuffer = 1;
+  (function(module, exports$1) {
+    var root = require_root(), stubFalse = requireStubFalse();
+    var freeExports = exports$1 && !exports$1.nodeType && exports$1;
+    var freeModule = freeExports && true && module && !module.nodeType && module;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var Buffer = moduleExports ? root.Buffer : void 0;
+    var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+    var isBuffer2 = nativeIsBuffer || stubFalse;
+    module.exports = isBuffer2;
+  })(isBuffer, isBuffer.exports);
+  return 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 baseGetTag = 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]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", weakMapTag = "[object WeakMap]";
+  var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[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[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+  function baseIsTypedArray(value) {
+    return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+  }
+  _baseIsTypedArray = baseIsTypedArray;
+  return _baseIsTypedArray;
+}
+var _nodeUtil = { exports: {} };
+_nodeUtil.exports;
+var hasRequired_nodeUtil;
+function require_nodeUtil() {
+  if (hasRequired_nodeUtil) return _nodeUtil.exports;
+  hasRequired_nodeUtil = 1;
+  (function(module, exports$1) {
+    var freeGlobal = require_freeGlobal();
+    var freeExports = exports$1 && !exports$1.nodeType && exports$1;
+    var freeModule = freeExports && true && module && !module.nodeType && module;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var freeProcess = moduleExports && freeGlobal.process;
+    var nodeUtil = (function() {
+      try {
+        var types = freeModule && freeModule.require && freeModule.require("util").types;
+        if (types) {
+          return types;
+        }
+        return freeProcess && freeProcess.binding && freeProcess.binding("util");
+      } catch (e) {
+      }
+    })();
+    module.exports = nodeUtil;
+  })(_nodeUtil, _nodeUtil.exports);
+  return _nodeUtil.exports;
+}
+var isTypedArray_1;
+var hasRequiredIsTypedArray;
+function requireIsTypedArray() {
+  if (hasRequiredIsTypedArray) return isTypedArray_1;
+  hasRequiredIsTypedArray = 1;
+  var baseIsTypedArray = require_baseIsTypedArray(), baseUnary = require_baseUnary(), nodeUtil = require_nodeUtil();
+  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(), isArray = requireIsArray(), isBuffer2 = requireIsBuffer(), isIndex = require_isIndex(), isTypedArray = requireIsTypedArray();
+  var objectProto = Object.prototype;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  function arrayLikeKeys(value, inherited) {
+    var isArr = isArray(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 || hasOwnProperty.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 _isPrototype;
+var hasRequired_isPrototype;
+function require_isPrototype() {
+  if (hasRequired_isPrototype) return _isPrototype;
+  hasRequired_isPrototype = 1;
+  var objectProto = Object.prototype;
+  function isPrototype(value) {
+    var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+    return value === proto;
+  }
+  _isPrototype = isPrototype;
+  return _isPrototype;
+}
+var _overArg;
+var hasRequired_overArg;
+function require_overArg() {
+  if (hasRequired_overArg) return _overArg;
+  hasRequired_overArg = 1;
+  function overArg(func, transform) {
+    return function(arg) {
+      return func(transform(arg));
+    };
+  }
+  _overArg = overArg;
+  return _overArg;
+}
+var _nativeKeys;
+var hasRequired_nativeKeys;
+function require_nativeKeys() {
+  if (hasRequired_nativeKeys) return _nativeKeys;
+  hasRequired_nativeKeys = 1;
+  var overArg = require_overArg();
+  var nativeKeys = overArg(Object.keys, Object);
+  _nativeKeys = nativeKeys;
+  return _nativeKeys;
+}
+var _baseKeys;
+var hasRequired_baseKeys;
+function require_baseKeys() {
+  if (hasRequired_baseKeys) return _baseKeys;
+  hasRequired_baseKeys = 1;
+  var isPrototype = require_isPrototype(), nativeKeys = require_nativeKeys();
+  var objectProto = Object.prototype;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  function baseKeys(object) {
+    if (!isPrototype(object)) {
+      return nativeKeys(object);
+    }
+    var result = [];
+    for (var key in Object(object)) {
+      if (hasOwnProperty.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 keys(object) {
+    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+  }
+  keys_1 = keys;
+  return keys_1;
+}
+var _baseForOwn;
+var hasRequired_baseForOwn;
+function require_baseForOwn() {
+  if (hasRequired_baseForOwn) return _baseForOwn;
+  hasRequired_baseForOwn = 1;
+  var baseFor = require_baseFor(), keys = requireKeys();
+  function baseForOwn(object, iteratee) {
+    return object && baseFor(object, iteratee, keys);
+  }
+  _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 _stackClear;
+var hasRequired_stackClear;
+function require_stackClear() {
+  if (hasRequired_stackClear) return _stackClear;
+  hasRequired_stackClear = 1;
+  var ListCache = require_ListCache();
+  function stackClear() {
+    this.__data__ = new ListCache();
+    this.size = 0;
+  }
+  _stackClear = stackClear;
+  return _stackClear;
+}
+var _stackDelete;
+var hasRequired_stackDelete;
+function require_stackDelete() {
+  if (hasRequired_stackDelete) return _stackDelete;
+  hasRequired_stackDelete = 1;
+  function stackDelete(key) {
+    var data = this.__data__, result = data["delete"](key);
+    this.size = data.size;
+    return result;
+  }
+  _stackDelete = stackDelete;
+  return _stackDelete;
+}
+var _stackGet;
+var hasRequired_stackGet;
+function require_stackGet() {
+  if (hasRequired_stackGet) return _stackGet;
+  hasRequired_stackGet = 1;
+  function stackGet(key) {
+    return this.__data__.get(key);
+  }
+  _stackGet = stackGet;
+  return _stackGet;
+}
+var _stackHas;
+var hasRequired_stackHas;
+function require_stackHas() {
+  if (hasRequired_stackHas) return _stackHas;
+  hasRequired_stackHas = 1;
+  function stackHas(key) {
+    return this.__data__.has(key);
+  }
+  _stackHas = stackHas;
+  return _stackHas;
+}
+var _stackSet;
+var hasRequired_stackSet;
+function require_stackSet() {
+  if (hasRequired_stackSet) return _stackSet;
+  hasRequired_stackSet = 1;
+  var ListCache = require_ListCache(), Map = require_Map(), MapCache = require_MapCache();
+  var LARGE_ARRAY_SIZE = 200;
+  function stackSet(key, value) {
+    var data = this.__data__;
+    if (data instanceof ListCache) {
+      var pairs = data.__data__;
+      if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+        pairs.push([key, value]);
+        this.size = ++data.size;
+        return this;
+      }
+      data = this.__data__ = new MapCache(pairs);
+    }
+    data.set(key, value);
+    this.size = data.size;
+    return this;
+  }
+  _stackSet = stackSet;
+  return _stackSet;
+}
+var _Stack;
+var hasRequired_Stack;
+function require_Stack() {
+  if (hasRequired_Stack) return _Stack;
+  hasRequired_Stack = 1;
+  var ListCache = require_ListCache(), stackClear = require_stackClear(), stackDelete = require_stackDelete(), stackGet = require_stackGet(), stackHas = require_stackHas(), stackSet = require_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;
+  _Stack = Stack;
+  return _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 _Uint8Array;
+var hasRequired_Uint8Array;
+function require_Uint8Array() {
+  if (hasRequired_Uint8Array) return _Uint8Array;
+  hasRequired_Uint8Array = 1;
+  var root = require_root();
+  var Uint8Array = root.Uint8Array;
+  _Uint8Array = Uint8Array;
+  return _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;
+}
+var _setToArray;
+var hasRequired_setToArray;
+function require_setToArray() {
+  if (hasRequired_setToArray) return _setToArray;
+  hasRequired_setToArray = 1;
+  function setToArray(set) {
+    var index = -1, result = Array(set.size);
+    set.forEach(function(value) {
+      result[++index] = value;
+    });
+    return result;
+  }
+  _setToArray = setToArray;
+  return _setToArray;
+}
+var _equalByTag;
+var hasRequired_equalByTag;
+function require_equalByTag() {
+  if (hasRequired_equalByTag) return _equalByTag;
+  hasRequired_equalByTag = 1;
+  var Symbol2 = require_Symbol(), Uint8Array = require_Uint8Array(), eq = requireEq(), equalArrays = require_equalArrays(), mapToArray = require_mapToArray(), setToArray = require_setToArray();
+  var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+  var boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]";
+  var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]";
+  var symbolProto = Symbol2 ? Symbol2.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+    switch (tag) {
+      case dataViewTag:
+        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 Uint8Array(object), new Uint8Array(other))) {
+          return false;
+        }
+        return true;
+      case boolTag:
+      case dateTag:
+      case numberTag:
+        return eq(+object, +other);
+      case errorTag:
+        return object.name == other.name && object.message == other.message;
+      case regexpTag:
+      case stringTag:
+        return object == other + "";
+      case mapTag:
+        var convert = mapToArray;
+      case setTag:
+        var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+        convert || (convert = setToArray);
+        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 _baseGetAllKeys;
+var hasRequired_baseGetAllKeys;
+function require_baseGetAllKeys() {
+  if (hasRequired_baseGetAllKeys) return _baseGetAllKeys;
+  hasRequired_baseGetAllKeys = 1;
+  var arrayPush = require_arrayPush(), isArray = requireIsArray();
+  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+    var result = keysFunc(object);
+    return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+  }
+  _baseGetAllKeys = baseGetAllKeys;
+  return _baseGetAllKeys;
+}
+var stubArray_1;
+var hasRequiredStubArray;
+function requireStubArray() {
+  if (hasRequiredStubArray) return stubArray_1;
+  hasRequiredStubArray = 1;
+  function stubArray() {
+    return [];
+  }
+  stubArray_1 = stubArray;
+  return stubArray_1;
+}
+var _getSymbols;
+var hasRequired_getSymbols;
+function require_getSymbols() {
+  if (hasRequired_getSymbols) return _getSymbols;
+  hasRequired_getSymbols = 1;
+  var arrayFilter = require_arrayFilter(), stubArray = requireStubArray();
+  var objectProto = Object.prototype;
+  var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+  var nativeGetSymbols = Object.getOwnPropertySymbols;
+  var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+    if (object == null) {
+      return [];
+    }
+    object = Object(object);
+    return arrayFilter(nativeGetSymbols(object), function(symbol) {
+      return propertyIsEnumerable.call(object, symbol);
+    });
+  };
+  _getSymbols = getSymbols;
+  return _getSymbols;
+}
+var _getAllKeys;
+var hasRequired_getAllKeys;
+function require_getAllKeys() {
+  if (hasRequired_getAllKeys) return _getAllKeys;
+  hasRequired_getAllKeys = 1;
+  var baseGetAllKeys = require_baseGetAllKeys(), getSymbols = require_getSymbols(), keys = requireKeys();
+  function getAllKeys(object) {
+    return baseGetAllKeys(object, keys, getSymbols);
+  }
+  _getAllKeys = getAllKeys;
+  return _getAllKeys;
+}
+var _equalObjects;
+var hasRequired_equalObjects;
+function require_equalObjects() {
+  if (hasRequired_equalObjects) return _equalObjects;
+  hasRequired_equalObjects = 1;
+  var getAllKeys = require_getAllKeys();
+  var COMPARE_PARTIAL_FLAG = 1;
+  var objectProto = Object.prototype;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+    if (objLength != othLength && !isPartial) {
+      return false;
+    }
+    var index = objLength;
+    while (index--) {
+      var key = objProps[index];
+      if (!(isPartial ? key in other : hasOwnProperty.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 _DataView;
+var hasRequired_DataView;
+function require_DataView() {
+  if (hasRequired_DataView) return _DataView;
+  hasRequired_DataView = 1;
+  var getNative = require_getNative(), root = require_root();
+  var DataView = getNative(root, "DataView");
+  _DataView = DataView;
+  return _DataView;
+}
+var _Promise;
+var hasRequired_Promise;
+function require_Promise() {
+  if (hasRequired_Promise) return _Promise;
+  hasRequired_Promise = 1;
+  var getNative = require_getNative(), root = require_root();
+  var Promise2 = getNative(root, "Promise");
+  _Promise = Promise2;
+  return _Promise;
+}
+var _Set;
+var hasRequired_Set;
+function require_Set() {
+  if (hasRequired_Set) return _Set;
+  hasRequired_Set = 1;
+  var getNative = require_getNative(), root = require_root();
+  var Set = getNative(root, "Set");
+  _Set = Set;
+  return _Set;
+}
+var _WeakMap;
+var hasRequired_WeakMap;
+function require_WeakMap() {
+  if (hasRequired_WeakMap) return _WeakMap;
+  hasRequired_WeakMap = 1;
+  var getNative = require_getNative(), root = require_root();
+  var WeakMap = getNative(root, "WeakMap");
+  _WeakMap = WeakMap;
+  return _WeakMap;
+}
+var _getTag;
+var hasRequired_getTag;
+function require_getTag() {
+  if (hasRequired_getTag) return _getTag;
+  hasRequired_getTag = 1;
+  var DataView = require_DataView(), Map = require_Map(), Promise2 = require_Promise(), Set = require_Set(), WeakMap = require_WeakMap(), baseGetTag = require_baseGetTag(), toSource = require_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(Promise2), setCtorString = toSource(Set), weakMapCtorString = toSource(WeakMap);
+  var getTag = baseGetTag;
+  if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise2 && getTag(Promise2.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;
+    };
+  }
+  _getTag = getTag;
+  return _getTag;
+}
+var _baseIsEqualDeep;
+var hasRequired_baseIsEqualDeep;
+function require_baseIsEqualDeep() {
+  if (hasRequired_baseIsEqualDeep) return _baseIsEqualDeep;
+  hasRequired_baseIsEqualDeep = 1;
+  var Stack = require_Stack(), equalArrays = require_equalArrays(), equalByTag = require_equalByTag(), equalObjects = require_equalObjects(), getTag = require_getTag(), isArray = requireIsArray(), isBuffer2 = requireIsBuffer(), isTypedArray = requireIsTypedArray();
+  var COMPARE_PARTIAL_FLAG = 1;
+  var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
+  var objectProto = Object.prototype;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+    var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+    objTag = objTag == argsTag ? objectTag : objTag;
+    othTag = othTag == argsTag ? objectTag : othTag;
+    var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+    if (isSameTag && isBuffer2(object)) {
+      if (!isBuffer2(other)) {
+        return false;
+      }
+      objIsArr = true;
+      objIsObj = false;
+    }
+    if (isSameTag && !objIsObj) {
+      stack || (stack = new Stack());
+      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 && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+      if (objIsWrapped || othIsWrapped) {
+        var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+        stack || (stack = new Stack());
+        return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+      }
+    }
+    if (!isSameTag) {
+      return false;
+    }
+    stack || (stack = new Stack());
+    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 Stack = require_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 Stack();
+        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 isObject = requireIsObject();
+  function isStrictComparable(value) {
+    return value === value && !isObject(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(), keys = requireKeys();
+  function getMatchData(object) {
+    var result = keys(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 isArray = requireIsArray(), isSymbol = requireIsSymbol();
+  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+  function isKey(value, object) {
+    if (isArray(value)) {
+      return false;
+    }
+    var type = typeof value;
+    if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
+      return true;
+    }
+    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+  }
+  _isKey = isKey;
+  return _isKey;
+}
+var memoize_1;
+var hasRequiredMemoize;
+function requireMemoize() {
+  if (hasRequiredMemoize) return memoize_1;
+  hasRequiredMemoize = 1;
+  var MapCache = require_MapCache();
+  var FUNC_ERROR_TEXT = "Expected a function";
+  function memoize(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.Cache || MapCache)();
+    return memoized;
+  }
+  memoize.Cache = MapCache;
+  memoize_1 = memoize;
+  return memoize_1;
+}
+var _memoizeCapped;
+var hasRequired_memoizeCapped;
+function require_memoizeCapped() {
+  if (hasRequired_memoizeCapped) return _memoizeCapped;
+  hasRequired_memoizeCapped = 1;
+  var memoize = requireMemoize();
+  var MAX_MEMOIZE_SIZE = 500;
+  function memoizeCapped(func) {
+    var result = memoize(func, function(key) {
+      if (cache.size === MAX_MEMOIZE_SIZE) {
+        cache.clear();
+      }
+      return key;
+    });
+    var cache = result.cache;
+    return result;
+  }
+  _memoizeCapped = memoizeCapped;
+  return _memoizeCapped;
+}
+var _stringToPath;
+var hasRequired_stringToPath;
+function require_stringToPath() {
+  if (hasRequired_stringToPath) return _stringToPath;
+  hasRequired_stringToPath = 1;
+  var memoizeCapped = require_memoizeCapped();
+  var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+  var reEscapeChar = /\\(\\)?/g;
+  var stringToPath = memoizeCapped(function(string) {
+    var result = [];
+    if (string.charCodeAt(0) === 46) {
+      result.push("");
+    }
+    string.replace(rePropName, function(match, number, quote, subString) {
+      result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+    });
+    return result;
+  });
+  _stringToPath = stringToPath;
+  return _stringToPath;
+}
+var _castPath;
+var hasRequired_castPath;
+function require_castPath() {
+  if (hasRequired_castPath) return _castPath;
+  hasRequired_castPath = 1;
+  var isArray = requireIsArray(), isKey = require_isKey(), stringToPath = require_stringToPath(), toString = requireToString();
+  function castPath(value, object) {
+    if (isArray(value)) {
+      return value;
+    }
+    return isKey(value, object) ? [value] : stringToPath(toString(value));
+  }
+  _castPath = castPath;
+  return _castPath;
+}
+var _toKey;
+var hasRequired_toKey;
+function require_toKey() {
+  if (hasRequired_toKey) return _toKey;
+  hasRequired_toKey = 1;
+  var isSymbol = requireIsSymbol();
+  function toKey(value) {
+    if (typeof value == "string" || isSymbol(value)) {
+      return value;
+    }
+    var result = value + "";
+    return result == "0" && 1 / value == -Infinity ? "-0" : result;
+  }
+  _toKey = toKey;
+  return _toKey;
+}
+var _baseGet;
+var hasRequired_baseGet;
+function require_baseGet() {
+  if (hasRequired_baseGet) return _baseGet;
+  hasRequired_baseGet = 1;
+  var castPath = require_castPath(), toKey = require_toKey();
+  function baseGet(object, path) {
+    path = castPath(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 castPath = require_castPath(), isArguments = requireIsArguments(), isArray = requireIsArray(), isIndex = require_isIndex(), isLength = requireIsLength(), toKey = require_toKey();
+  function hasPath(object, path, hasFunc) {
+    path = castPath(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) && (isArray(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(), isKey = 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 (isKey(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(), isKey = require_isKey(), toKey = require_toKey();
+  function property(path) {
+    return isKey(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(), isArray = requireIsArray(), property = requireProperty();
+  function baseIteratee(value) {
+    if (typeof value == "function") {
+      return value;
+    }
+    if (value == null) {
+      return identity;
+    }
+    if (typeof value == "object") {
+      return isArray(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 arrayFilter = require_arrayFilter(), baseFilter = require_baseFilter(), baseIteratee = require_baseIteratee(), isArray = requireIsArray();
+  function filter2(collection, predicate) {
+    var func = isArray(collection) ? arrayFilter : baseFilter;
+    return func(collection, baseIteratee(predicate, 3));
+  }
+  filter_1 = filter2;
+  return filter_1;
+}
+var filterExports = requireFilter();
+const filter = /* @__PURE__ */ getDefaultExportFromCjs(filterExports);
+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 findKey2(object, predicate) {
+    return baseFindKey(object, baseIteratee(predicate, 3), baseForOwn);
+  }
+  findKey_1 = findKey2;
+  return findKey_1;
+}
+var findKeyExports = requireFindKey();
+const findKey = /* @__PURE__ */ getDefaultExportFromCjs(findKeyExports);
+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$1;
+var hasRequiredFirst;
+function requireFirst() {
+  if (hasRequiredFirst) return first$1;
+  hasRequiredFirst = 1;
+  first$1 = requireHead();
+  return first$1;
+}
+var firstExports = requireFirst();
+const first = /* @__PURE__ */ getDefaultExportFromCjs(firstExports);
+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(), isArray = requireIsArray();
+  function forEach2(collection, iteratee) {
+    var func = isArray(collection) ? arrayEach : baseEach;
+    return func(collection, castFunction(iteratee));
+  }
+  forEach_1 = forEach2;
+  return forEach_1;
+}
+var forEachExports = requireForEach();
+const forEach = /* @__PURE__ */ getDefaultExportFromCjs(forEachExports);
+var forOwn_1;
+var hasRequiredForOwn;
+function requireForOwn() {
+  if (hasRequiredForOwn) return forOwn_1;
+  hasRequiredForOwn = 1;
+  var baseForOwn = require_baseForOwn(), castFunction = require_castFunction();
+  function forOwn2(object, iteratee) {
+    return object && baseForOwn(object, castFunction(iteratee));
+  }
+  forOwn_1 = forOwn2;
+  return forOwn_1;
+}
+var forOwnExports = requireForOwn();
+const forOwn = /* @__PURE__ */ getDefaultExportFromCjs(forOwnExports);
+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 arrayMap = require_arrayMap(), baseGet = require_baseGet(), baseIteratee = require_baseIteratee(), baseMap = require_baseMap(), baseSortBy = require_baseSortBy(), baseUnary = require_baseUnary(), compareMultiple = require_compareMultiple(), identity = requireIdentity(), isArray = requireIsArray();
+  function baseOrderBy(collection, iteratees, orders) {
+    if (iteratees.length) {
+      iteratees = arrayMap(iteratees, function(iteratee) {
+        if (isArray(iteratee)) {
+          return function(value) {
+            return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+          };
+        }
+        return iteratee;
+      });
+    } else {
+      iteratees = [identity];
+    }
+    var index = -1;
+    iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
+    var result = baseMap(collection, function(value, key, collection2) {
+      var criteria = arrayMap(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 eq = requireEq(), isArrayLike = requireIsArrayLike(), isIndex = require_isIndex(), isObject = requireIsObject();
+  function isIterateeCall(value, index, object) {
+    if (!isObject(object)) {
+      return false;
+    }
+    var type = typeof index;
+    if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
+      return eq(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 sortBy2 = 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 = sortBy2;
+  return sortBy_1;
+}
+var sortByExports = requireSortBy();
+const sortBy = /* @__PURE__ */ getDefaultExportFromCjs(sortByExports);
+var WritingDirection = /* @__PURE__ */ ((WritingDirection2) => {
+  WritingDirection2[WritingDirection2["LTR"] = 0] = "LTR";
+  WritingDirection2[WritingDirection2["RTL"] = 1] = "RTL";
+  return WritingDirection2;
+})(WritingDirection || {});
+const hasDOM = typeof window !== "undefined" && window.document;
+const MIN_PIXEL_RATIO = 2;
+class VisualDebugger {
+  debugCtx;
+  layoutsCtx;
+  writingDirection;
+  useViewportCoordinates;
+  constructor(writingDirection, useViewportCoordinates = false) {
+    this.debugCtx = null;
+    this.layoutsCtx = null;
+    this.writingDirection = writingDirection;
+    this.useViewportCoordinates = useViewportCoordinates;
+    if (!hasDOM) {
+      return;
+    }
+    this.debugCtx = VisualDebugger.createCanvas("sn-debug", "1010", writingDirection);
+    this.layoutsCtx = VisualDebugger.createCanvas("sn-layouts", "1000", writingDirection);
+  }
+  static getViewportSize() {
+    return {
+      width: window.innerWidth,
+      height: window.innerHeight
+    };
+  }
+  static getPixelRatio() {
+    const devicePixelRatio = window.devicePixelRatio || 1;
+    return Math.max(devicePixelRatio, MIN_PIXEL_RATIO);
+  }
+  static configureCanvas(canvas, ctx) {
+    const {
+      width,
+      height
+    } = VisualDebugger.getViewportSize();
+    const pixelRatio = VisualDebugger.getPixelRatio();
+    canvas.style.width = `${width}px`;
+    canvas.style.height = `${height}px`;
+    const scaledWidth = Math.round(width * pixelRatio);
+    const scaledHeight = Math.round(height * pixelRatio);
+    if (canvas.width !== scaledWidth) {
+      canvas.width = scaledWidth;
+    }
+    if (canvas.height !== scaledHeight) {
+      canvas.height = scaledHeight;
+    }
+    ctx.setTransform(pixelRatio, 0, 0, pixelRatio, 0, 0);
+  }
+  syncCanvasSizes() {
+    if (!hasDOM || !this.debugCtx || !this.layoutsCtx) {
+      return;
+    }
+    VisualDebugger.configureCanvas(this.debugCtx.canvas, this.debugCtx);
+    VisualDebugger.configureCanvas(this.layoutsCtx.canvas, this.layoutsCtx);
+  }
+  getViewportOffset() {
+    if (this.useViewportCoordinates) {
+      return {
+        x: 0,
+        y: 0
+      };
+    }
+    return {
+      x: window.scrollX,
+      y: window.scrollY
+    };
+  }
+  static createCanvas(id, zIndex, writingDirection) {
+    const existingCanvas = document.querySelector(`#${id}`);
+    const canvas = existingCanvas || document.createElement("canvas");
+    canvas.setAttribute("id", id);
+    canvas.setAttribute("dir", writingDirection === WritingDirection.LTR ? "ltr" : "rtl");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      return null;
+    }
+    canvas.style.zIndex = zIndex;
+    canvas.style.position = "fixed";
+    canvas.style.top = "0";
+    canvas.style.left = "0";
+    canvas.style.pointerEvents = "none";
+    if (!canvas.isConnected) {
+      document.body.appendChild(canvas);
+    }
+    VisualDebugger.configureCanvas(canvas, ctx);
+    return ctx;
+  }
+  clear() {
+    if (!hasDOM || !this.debugCtx) {
+      return;
+    }
+    this.syncCanvasSizes();
+    const {
+      width,
+      height
+    } = VisualDebugger.getViewportSize();
+    this.debugCtx.clearRect(0, 0, width, height);
+  }
+  clearLayouts() {
+    if (!hasDOM || !this.layoutsCtx) {
+      return;
+    }
+    this.syncCanvasSizes();
+    const {
+      width,
+      height
+    } = VisualDebugger.getViewportSize();
+    this.layoutsCtx.clearRect(0, 0, width, height);
+  }
+  drawLayout(layout, focusKey, parentFocusKey) {
+    if (!hasDOM || !this.layoutsCtx) {
+      return;
+    }
+    this.syncCanvasSizes();
+    const offset = this.getViewportOffset();
+    const left = layout.left - offset.x;
+    const top = layout.top - offset.y;
+    this.layoutsCtx.strokeStyle = "green";
+    this.layoutsCtx.strokeRect(left, top, layout.width, layout.height);
+    this.layoutsCtx.font = "11px monospace";
+    this.layoutsCtx.fillStyle = "red";
+    const horizontalStartDirection = this.writingDirection === WritingDirection.LTR ? "left" : "right";
+    const horizontalStartCoordinate = layout[horizontalStartDirection] - offset.x;
+    this.layoutsCtx.fillText(focusKey, horizontalStartCoordinate, top + 12);
+    this.layoutsCtx.fillText(parentFocusKey ?? "", horizontalStartCoordinate, top + 28);
+    this.layoutsCtx.fillText(`${horizontalStartDirection}: ${horizontalStartCoordinate}`, horizontalStartCoordinate, top + 44);
+    this.layoutsCtx.fillText(`top: ${top}`, horizontalStartCoordinate, top + 60);
+  }
+  drawPoint(x, y, color = "blue", size = 10) {
+    if (!hasDOM || !this.debugCtx) {
+      return;
+    }
+    this.syncCanvasSizes();
+    const offset = this.getViewportOffset();
+    const pointX = x - offset.x;
+    const pointY = y - offset.y;
+    this.debugCtx.strokeStyle = color;
+    this.debugCtx.lineWidth = 3;
+    this.debugCtx.strokeRect(pointX - size / 2, pointY - size / 2, size, size);
+  }
+}
+const ELEMENT_NODE = 1;
+const getRect = (node) => {
+  let offsetParent = node.offsetParent;
+  const height = node.offsetHeight;
+  const width = node.offsetWidth;
+  let left = node.offsetLeft;
+  let top = node.offsetTop;
+  while (offsetParent && offsetParent.nodeType === ELEMENT_NODE) {
+    left += offsetParent.offsetLeft - offsetParent.scrollLeft;
+    top += offsetParent.offsetTop - offsetParent.scrollTop;
+    offsetParent = offsetParent.offsetParent;
+  }
+  return {
+    height,
+    left,
+    top,
+    width
+  };
+};
+const measureLayout = (node) => {
+  const relativeNode = node && node.parentElement;
+  if (node && relativeNode) {
+    const relativeRect = getRect(relativeNode);
+    const {
+      height,
+      left,
+      top,
+      width
+    } = getRect(node);
+    const x = left - relativeRect.left;
+    const y = top - relativeRect.top;
+    return {
+      x,
+      y,
+      width,
+      height,
+      left,
+      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
+  };
+};
+const getBoundingClientRect = (node) => {
+  if (node && node.getBoundingClientRect) {
+    const rect = node.getBoundingClientRect();
+    return {
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height,
+      left: rect.left,
+      top: rect.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
+  };
+};
+const DIRECTION_LEFT = "left";
+const DIRECTION_RIGHT = "right";
+const DIRECTION_UP = "up";
+const DIRECTION_DOWN = "down";
+const KEY_ENTER = "enter";
+const DEFAULT_KEY_MAP = {
+  [DIRECTION_LEFT]: [37, "ArrowLeft"],
+  [DIRECTION_UP]: [38, "ArrowUp"],
+  [DIRECTION_RIGHT]: [39, "ArrowRight"],
+  [DIRECTION_DOWN]: [40, "ArrowDown"],
+  [KEY_ENTER]: [13, "Enter"]
+};
+const ROOT_FOCUS_KEY = "SN:ROOT";
+const FOCUSABLE_SELECTOR = ["a[href]", "button", "input", "select", "textarea", "summary", "iframe", "[contenteditable]", "[tabindex]"].join(",");
+const FORM_FIELD_SELECTOR = ["input", "select", "textarea", "[contenteditable]"].join(",");
+const CHECKBOX_LIKE_SELECTOR = 'input[type="checkbox"], input[type="radio"]';
+const ADJACENT_SLICE_THRESHOLD = 0.2;
+const ADJACENT_SLICE_WEIGHT = 5;
+const DIAGONAL_SLICE_WEIGHT = 1;
+const MAIN_COORDINATE_WEIGHT = 5;
+const CUT_OFF_COORDINATE_TOLERANCE_PX = 1;
+const PRIMARY_AXIS_PROXIMITY_TOLERANCE_PX = 24;
+const AUTO_RESTORE_FOCUS_DELAY = 300;
+const DEBUG_FN_COLORS = ["#0FF", "#FF0", "#F0F"];
+const THROTTLE_OPTIONS = {
+  leading: true,
+  trailing: false
+};
+const getChildClosestToOrigin = (children, writingDirection) => {
+  const comparator = writingDirection === WritingDirection.LTR ? ({
+    layout
+  }) => Math.abs(layout.left) + Math.abs(layout.top) : ({
+    layout
+  }) => Math.abs(window.innerWidth - layout.right) + Math.abs(layout.top);
+  const childrenClosestToOrigin = sortBy(children, comparator);
+  return first(childrenClosestToOrigin);
+};
+const normalizeKeyMap = (keyMap) => {
+  const newKeyMap = {};
+  Object.entries(keyMap).forEach(([key, value]) => {
+    newKeyMap[key] = Array.isArray(value) ? value : [value];
+  });
+  return newKeyMap;
+};
+const isFocusableByDefault = (node) => {
+  if (!node?.matches) {
+    return false;
+  }
+  return node.matches(FOCUSABLE_SELECTOR);
+};
+const isFormFieldElement = (target) => {
+  const element = target;
+  if (!element?.matches) {
+    return false;
+  }
+  return element.matches(FORM_FIELD_SELECTOR);
+};
+class SpatialNavigationService {
+  focusableComponents;
+  visualDebugger;
+  visualDebugAnimationFrame;
+  visualDebugEnabled;
+  /**
+   * Focus key of the currently focused element
+   */
+  focusKey;
+  shouldFocusDOMNode;
+  shouldUseNativeEvents;
+  trackNativeFocus;
+  blockNavigationOutOfFormFields;
+  /**
+   * This collection contains focus keys of the elements that are having a child focused
+   * Might be handy for styling of certain parent components if their child is focused.
+   */
+  parentsHavingFocusedChild;
+  /**
+   * When shouldFocusDOMNode is true, this prop specifies the focus options that should be passed to the element being focused.
+   */
+  domNodeFocusOptions;
+  enabled;
+  /**
+   * Used in the React Native environment
+   * In this mode, the library works as a "read-only" helper to sync focused
+   * states for the components when they are focused by the native focus engine
+   */
+  nativeMode;
+  /**
+   * Throttling delay for key presses in milliseconds
+   */
+  throttle;
+  /**
+   * Enables/disables throttling feature
+   */
+  throttleKeypresses;
+  /**
+   * Storing pressed keys counter by the eventType
+   */
+  pressedKeys;
+  /**
+   * Flag used to block key events from this service
+   */
+  paused;
+  /**
+   * Enables/disables getBoundingClientRect
+   */
+  useGetBoundingClientRect;
+  keyDownEventListener;
+  keyDownEventListenerThrottled;
+  keyUpEventListener;
+  focusInEventListener;
+  keyMap;
+  debug;
+  logIndex;
+  setFocusDebounced;
+  writingDirection;
+  distanceCalculationMethod;
+  customDistanceCalculationFunction;
+  /**
+   * Used to determine the coordinate that will be used to filter items that are over the "edge"
+   */
+  static getCutoffCoordinate(isVertical, isIncremental, isSibling, layout, writingDirection) {
+    const itemStart = isVertical ? layout.top : writingDirection === WritingDirection.LTR ? layout.left : layout.right;
+    const itemEnd = isVertical ? layout.bottom : writingDirection === WritingDirection.LTR ? layout.right : layout.left;
+    return isIncremental ? isSibling ? itemStart : itemEnd : isSibling ? itemEnd : itemStart;
+  }
+  /**
+   * Returns two corners (a and b) coordinates that are used as a reference points
+   * Where "a" is always leftmost and topmost corner, and "b" is rightmost bottommost corner
+   */
+  static getRefCorners(direction, isSibling, layout) {
+    const result = {
+      a: {
+        x: 0,
+        y: 0
+      },
+      b: {
+        x: 0,
+        y: 0
+      }
+    };
+    switch (direction) {
+      case DIRECTION_UP: {
+        const y = isSibling ? layout.bottom : layout.top;
+        result.a = {
+          x: layout.left,
+          y
+        };
+        result.b = {
+          x: layout.right,
+          y
+        };
+        break;
+      }
+      case DIRECTION_DOWN: {
+        const y = isSibling ? layout.top : layout.bottom;
+        result.a = {
+          x: layout.left,
+          y
+        };
+        result.b = {
+          x: layout.right,
+          y
+        };
+        break;
+      }
+      case DIRECTION_LEFT: {
+        const x = isSibling ? layout.right : layout.left;
+        result.a = {
+          x,
+          y: layout.top
+        };
+        result.b = {
+          x,
+          y: layout.bottom
+        };
+        break;
+      }
+      case DIRECTION_RIGHT: {
+        const x = isSibling ? layout.left : layout.right;
+        result.a = {
+          x,
+          y: layout.top
+        };
+        result.b = {
+          x,
+          y: layout.bottom
+        };
+        break;
+      }
+    }
+    return result;
+  }
+  /**
+   * Calculates if the sibling node is intersecting enough with the ref node by the secondary coordinate
+   */
+  static getAdjacentSliceMetrics(refCorners, siblingCorners, isVerticalDirection) {
+    const {
+      a: refA,
+      b: refB
+    } = refCorners;
+    const {
+      a: siblingA,
+      b: siblingB
+    } = siblingCorners;
+    const coordinate = isVerticalDirection ? "x" : "y";
+    const refCoordinateA = refA[coordinate];
+    const refCoordinateB = refB[coordinate];
+    const siblingCoordinateA = siblingA[coordinate];
+    const siblingCoordinateB = siblingB[coordinate];
+    const refLength = Math.abs(refCoordinateB - refCoordinateA);
+    const siblingLength = Math.abs(siblingCoordinateB - siblingCoordinateA);
+    const intersectionLength = Math.max(0, Math.min(refCoordinateB, siblingCoordinateB) - Math.max(refCoordinateA, siblingCoordinateA));
+    return {
+      refLength,
+      siblingLength,
+      intersectionLength
+    };
+  }
+  static isAdjacentSlice(refCorners, siblingCorners, isVerticalDirection) {
+    const {
+      refLength,
+      siblingLength,
+      intersectionLength
+    } = SpatialNavigationService.getAdjacentSliceMetrics(refCorners, siblingCorners, isVerticalDirection);
+    const thresholdDistance = Math.min(refLength, siblingLength) * ADJACENT_SLICE_THRESHOLD;
+    return intersectionLength >= thresholdDistance;
+  }
+  static getAdjacentSliceWeight(refCorners, siblingCorners, isVerticalDirection) {
+    const {
+      siblingLength,
+      intersectionLength
+    } = SpatialNavigationService.getAdjacentSliceMetrics(refCorners, siblingCorners, isVerticalDirection);
+    if (!siblingLength) {
+      return DIAGONAL_SLICE_WEIGHT;
+    }
+    const overlapRatioOnSibling = Math.min(1, Math.max(0, intersectionLength / siblingLength));
+    return DIAGONAL_SLICE_WEIGHT + (ADJACENT_SLICE_WEIGHT - DIAGONAL_SLICE_WEIGHT) * overlapRatioOnSibling;
+  }
+  static getPrimaryAxisDistance(refCorners, siblingCorners, isVerticalDirection) {
+    const {
+      a: refA
+    } = refCorners;
+    const {
+      a: siblingA
+    } = siblingCorners;
+    const coordinate = isVerticalDirection ? "y" : "x";
+    return Math.abs(siblingA[coordinate] - refA[coordinate]);
+  }
+  static getSecondaryAxisDistance(refCorners, siblingCorners, isVerticalDirection, distanceCalculationMethod, customDistanceCalculationFunction) {
+    if (customDistanceCalculationFunction) {
+      return customDistanceCalculationFunction(refCorners, siblingCorners, isVerticalDirection, distanceCalculationMethod);
+    }
+    const {
+      a: refA,
+      b: refB
+    } = refCorners;
+    const {
+      a: siblingA,
+      b: siblingB
+    } = siblingCorners;
+    const coordinate = isVerticalDirection ? "x" : "y";
+    const refCoordinateA = refA[coordinate];
+    const refCoordinateB = refB[coordinate];
+    const siblingCoordinateA = siblingA[coordinate];
+    const siblingCoordinateB = siblingB[coordinate];
+    if (distanceCalculationMethod === "center") {
+      const refCoordinateCenter = (refCoordinateA + refCoordinateB) / 2;
+      const siblingCoordinateCenter = (siblingCoordinateA + siblingCoordinateB) / 2;
+      return Math.abs(refCoordinateCenter - siblingCoordinateCenter);
+    }
+    if (distanceCalculationMethod === "edges") {
+      const refCoordinateEdgeMin = Math.min(refCoordinateA, refCoordinateB);
+      const siblingCoordinateEdgeMin = Math.min(siblingCoordinateA, siblingCoordinateB);
+      const refCoordinateEdgeMax = Math.max(refCoordinateA, refCoordinateB);
+      const siblingCoordinateEdgeMax = Math.max(siblingCoordinateA, siblingCoordinateB);
+      const minEdgeDistance = Math.abs(refCoordinateEdgeMin - siblingCoordinateEdgeMin);
+      const maxEdgeDistance = Math.abs(refCoordinateEdgeMax - siblingCoordinateEdgeMax);
+      return Math.min(minEdgeDistance, maxEdgeDistance);
+    }
+    const distancesToCompare = [Math.abs(siblingCoordinateA - refCoordinateA), Math.abs(siblingCoordinateA - refCoordinateB), Math.abs(siblingCoordinateB - refCoordinateA), Math.abs(siblingCoordinateB - refCoordinateB)];
+    return Math.min(...distancesToCompare);
+  }
+  /**
+   * Inspired by: https://developer.mozilla.org/en-US/docs/Mozilla/Firefox_OS_for_TV/TV_remote_control_navigation#Algorithm_design
+   * Ref Corners are the 2 corners of the current component in the direction of navigation
+   * They are used as a base to measure adjacent slices
+   */
+  sortSiblingsByPriority(siblings, currentLayout, direction, focusKey) {
+    const isVerticalDirection = direction === DIRECTION_DOWN || direction === DIRECTION_UP;
+    const refCorners = SpatialNavigationService.getRefCorners(direction, false, currentLayout);
+    return sortBy(siblings, (sibling) => {
+      const siblingCorners = SpatialNavigationService.getRefCorners(direction, true, sibling.layout);
+      const isAdjacentSlice = SpatialNavigationService.isAdjacentSlice(refCorners, siblingCorners, isVerticalDirection);
+      const adjacentSliceWeight = isAdjacentSlice ? SpatialNavigationService.getAdjacentSliceWeight(refCorners, siblingCorners, isVerticalDirection) : DIAGONAL_SLICE_WEIGHT;
+      const primaryAxisFunction = isAdjacentSlice ? SpatialNavigationService.getPrimaryAxisDistance : SpatialNavigationService.getSecondaryAxisDistance;
+      const secondaryAxisFunction = isAdjacentSlice ? SpatialNavigationService.getSecondaryAxisDistance : SpatialNavigationService.getPrimaryAxisDistance;
+      const primaryAxisDistance = primaryAxisFunction(refCorners, siblingCorners, isVerticalDirection, this.distanceCalculationMethod, this.customDistanceCalculationFunction);
+      const secondaryAxisDistance = secondaryAxisFunction(refCorners, siblingCorners, isVerticalDirection, this.distanceCalculationMethod, this.customDistanceCalculationFunction);
+      const totalDistancePoints = primaryAxisDistance * MAIN_COORDINATE_WEIGHT + secondaryAxisDistance;
+      const priority = (totalDistancePoints + 1) / adjacentSliceWeight;
+      this.log("smartNavigate", `distance (primary, secondary, total weighted) for ${sibling.focusKey} relative to ${focusKey} is`, primaryAxisDistance, secondaryAxisDistance, totalDistancePoints);
+      this.log("smartNavigate", `priority for ${sibling.focusKey} relative to ${focusKey} is`, priority, `(adjacentWeight: ${adjacentSliceWeight})`);
+      if (this.visualDebugger) {
+        this.visualDebugger.drawPoint(siblingCorners.a.x, siblingCorners.a.y, "yellow", 6);
+        this.visualDebugger.drawPoint(siblingCorners.b.x, siblingCorners.b.y, "yellow", 6);
+      }
+      return priority;
+    });
+  }
+  constructor() {
+    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 = true;
+    this.shouldUseNativeEvents = false;
+    this.trackNativeFocus = true;
+    this.blockNavigationOutOfFormFields = false;
+    this.writingDirection = WritingDirection.LTR;
+    this.pressedKeys = {};
+    this.paused = false;
+    this.keyDownEventListener = null;
+    this.keyDownEventListenerThrottled = null;
+    this.keyUpEventListener = null;
+    this.focusInEventListener = null;
+    this.keyMap = DEFAULT_KEY_MAP;
+    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.setVisualDebug = this.setVisualDebug.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 = debounce(this.setFocus, AUTO_RESTORE_FOCUS_DELAY, {
+      leading: false,
+      trailing: true
+    });
+    this.debug = false;
+    this.visualDebugger = null;
+    this.visualDebugAnimationFrame = null;
+    this.visualDebugEnabled = false;
+    this.logIndex = 0;
+    this.distanceCalculationMethod = "corners";
+  }
+  init({
+    debug = false,
+    visualDebug = false,
+    nativeMode = false,
+    throttle: throttleParam = 0,
+    throttleKeypresses = false,
+    useGetBoundingClientRect = false,
+    shouldFocusDOMNode,
+    nativeFocus = true,
+    domNodeFocusOptions = {},
+    shouldUseNativeEvents = false,
+    trackNativeFocus = true,
+    blockNavigationOutOfFormFields = false,
+    rtl = false,
+    distanceCalculationMethod = "corners",
+    customDistanceCalculationFunction
+  } = {}) {
+    if (!this.enabled) {
+      const resolvedShouldFocusDOMNode = typeof shouldFocusDOMNode === "boolean" ? shouldFocusDOMNode : nativeFocus;
+      this.domNodeFocusOptions = domNodeFocusOptions;
+      this.enabled = true;
+      this.nativeMode = nativeMode;
+      this.throttleKeypresses = throttleKeypresses;
+      this.useGetBoundingClientRect = useGetBoundingClientRect;
+      this.shouldFocusDOMNode = resolvedShouldFocusDOMNode && !nativeMode;
+      this.shouldUseNativeEvents = shouldUseNativeEvents;
+      this.trackNativeFocus = trackNativeFocus;
+      this.blockNavigationOutOfFormFields = blockNavigationOutOfFormFields;
+      this.writingDirection = rtl ? WritingDirection.RTL : WritingDirection.LTR;
+      this.distanceCalculationMethod = distanceCalculationMethod;
+      this.customDistanceCalculationFunction = customDistanceCalculationFunction;
+      this.debug = debug;
+      if (!this.nativeMode) {
+        if (Number.isInteger(throttleParam) && throttleParam > 0) {
+          this.throttle = throttleParam;
+        }
+        this.bindEventHandlers();
+        this.setVisualDebug(visualDebug);
+      }
+    }
+  }
+  startVisualDebugLoop() {
+    if (typeof window === "undefined" || !window.requestAnimationFrame || typeof document === "undefined") {
+      return;
+    }
+    if (!this.visualDebugger) {
+      this.visualDebugger = new VisualDebugger(this.writingDirection, this.useGetBoundingClientRect);
+    }
+    const draw = () => {
+      const visualDebugger = this.visualDebugger;
+      if (!this.visualDebugEnabled || !visualDebugger) {
+        return;
+      }
+      visualDebugger.clearLayouts();
+      forOwn(this.focusableComponents, (component, focusKey) => {
+        visualDebugger.drawLayout(component.layout, focusKey, component.parentFocusKey);
+      });
+      this.visualDebugAnimationFrame = window.requestAnimationFrame(draw);
+    };
+    if (this.visualDebugAnimationFrame === null) {
+      draw();
+    }
+  }
+  stopVisualDebugLoop() {
+    if (this.visualDebugAnimationFrame !== null && typeof window !== "undefined" && window.cancelAnimationFrame) {
+      window.cancelAnimationFrame(this.visualDebugAnimationFrame);
+    }
+    this.visualDebugAnimationFrame = null;
+    if (this.visualDebugger) {
+      this.visualDebugger.clear();
+      this.visualDebugger.clearLayouts();
+    }
+    if (typeof document !== "undefined") {
+      document.querySelector("#sn-debug")?.remove();
+      document.querySelector("#sn-layouts")?.remove();
+    }
+    this.visualDebugger = null;
+  }
+  setVisualDebug(visualDebug) {
+    this.visualDebugEnabled = visualDebug;
+    if (!this.enabled || this.nativeMode) {
+      return;
+    }
+    if (visualDebug) {
+      this.startVisualDebugLoop();
+    } else {
+      this.stopVisualDebugLoop();
+    }
+  }
+  setThrottle({
+    throttle: throttleParam = 0,
+    throttleKeypresses = false
+  } = {}) {
+    this.throttleKeypresses = throttleKeypresses;
+    if (!this.nativeMode) {
+      this.unbindEventHandlers();
+      if (Number.isInteger(throttleParam)) {
+        this.throttle = throttleParam;
+      }
+      this.bindEventHandlers();
+    }
+  }
+  destroy() {
+    if (this.enabled) {
+      this.setFocusDebounced.cancel();
+      this.enabled = false;
+      this.nativeMode = false;
+      this.throttle = 0;
+      this.throttleKeypresses = false;
+      this.focusKey = null;
+      this.parentsHavingFocusedChild = [];
+      this.focusableComponents = {};
+      this.paused = false;
+      this.keyMap = DEFAULT_KEY_MAP;
+      this.trackNativeFocus = true;
+      this.blockNavigationOutOfFormFields = false;
+      this.shouldFocusDOMNode = true;
+      this.shouldUseNativeEvents = false;
+      this.visualDebugEnabled = false;
+      this.stopVisualDebugLoop();
+      this.unbindEventHandlers();
+    }
+  }
+  getEventType(keyCode) {
+    return findKey(this.getKeyMap(), (codeList) => codeList.includes(keyCode));
+  }
+  static getKeyCode(event) {
+    return event.keyCode || event.code || event.key;
+  }
+  static isDirectionalEventType(eventType) {
+    return eventType === DIRECTION_LEFT || eventType === DIRECTION_RIGHT || eventType === DIRECTION_UP || eventType === DIRECTION_DOWN;
+  }
+  shouldBypassSpatialNavigationForTarget(target, eventType) {
+    return this.blockNavigationOutOfFormFields && (eventType === KEY_ENTER || SpatialNavigationService.isDirectionalEventType(eventType)) && isFormFieldElement(target);
+  }
+  makeNodeProgrammaticallyFocusable(component) {
+    if (!component?.node || !this.shouldFocusDOMNode) {
+      return;
+    }
+    const {
+      node,
+      focusable
+    } = component;
+    const hasAutoTabIndex = node.getAttribute?.("data-sn-auto-tabindex");
+    if (!focusable) {
+      if (hasAutoTabIndex) {
+        node.removeAttribute?.("tabindex");
+        node.removeAttribute?.("data-sn-auto-tabindex");
+      }
+      return;
+    }
+    if (isFocusableByDefault(node) || node.getAttribute?.("tabindex") !== null) {
+      return;
+    }
+    node.setAttribute?.("tabindex", "-1");
+    node.setAttribute?.("data-sn-auto-tabindex", "true");
+  }
+  getLayoutReferenceNode(node) {
+    if (!node) {
+      return null;
+    }
+    if (node.matches?.(CHECKBOX_LIKE_SELECTOR) && node.parentElement?.tagName === "LABEL") {
+      return node.parentElement;
+    }
+    return node;
+  }
+  findNativeFocusedComponent(target) {
+    const targetNode = target;
+    if (!targetNode) {
+      return null;
+    }
+    const matchingComponents = filter(this.focusableComponents, ({
+      node,
+      focusable
+    }) => focusable && !!node && (node === targetNode || Boolean(node.contains?.(targetNode))));
+    if (!matchingComponents.length) {
+      return null;
+    }
+    const sortedByDepth = sortBy(matchingComponents, ({
+      node
+    }) => {
+      let depth = 0;
+      let currentNode = node;
+      while (currentNode?.parentElement) {
+        depth += 1;
+        currentNode = currentNode.parentElement;
+      }
+      return depth * -1;
+    });
+    return first(sortedByDepth);
+  }
+  syncNativeFocus(event) {
+    if (this.paused || !this.enabled || this.nativeMode || !this.trackNativeFocus) {
+      return;
+    }
+    const component = this.findNativeFocusedComponent(event.target);
+    if (!component || component.focusKey === this.focusKey) {
+      return;
+    }
+    const focusDetails = {
+      event,
+      nativeEvent: event
+    };
+    this.setCurrentFocusedKey(component.focusKey, focusDetails);
+    this.updateParentsHasFocusedChild(component.focusKey, focusDetails);
+    this.updateParentsLastFocusedChild(component.focusKey);
+  }
+  bindEventHandlers() {
+    if (typeof window !== "undefined" && window.addEventListener) {
+      const keyDownEventListener = (event) => {
+        if (this.paused === true) {
+          return;
+        }
+        if (this.debug) {
+          this.logIndex += 1;
+        }
+        const keyCode = SpatialNavigationService.getKeyCode(event);
+        const eventType = this.getEventType(keyCode);
+        if (!eventType) {
+          return;
+        }
+        if (this.shouldBypassSpatialNavigationForTarget(event.target, eventType)) {
+          return;
+        }
+        this.pressedKeys[eventType] = this.pressedKeys[eventType] ? this.pressedKeys[eventType] + 1 : 1;
+        if (!this.shouldUseNativeEvents) {
+          event.preventDefault();
+          event.stopPropagation();
+        }
+        const keysDetails = {
+          pressedKeys: this.pressedKeys
+        };
+        if (eventType === KEY_ENTER && this.focusKey) {
+          this.onEnterPress(keysDetails);
+          return;
+        }
+        const preventDefaultNavigation = this.onArrowPress(eventType, keysDetails) === false;
+        this.visualDebugger?.clear();
+        if (preventDefaultNavigation) {
+          this.log("keyDownEventListener", "default navigation prevented");
+        } else {
+          this.smartNavigate(eventType, null, {
+            event,
+            nativeEvent: event
+          });
+        }
+      };
+      this.keyDownEventListener = keyDownEventListener;
+      let keyDownListener = keyDownEventListener;
+      if (this.throttle) {
+        const throttledListener = throttle(keyDownEventListener, this.throttle, THROTTLE_OPTIONS);
+        this.keyDownEventListenerThrottled = throttledListener;
+        keyDownListener = throttledListener;
+      } else {
+        this.keyDownEventListenerThrottled = null;
+      }
+      const keyUpEventListener = (event) => {
+        const keyCode = SpatialNavigationService.getKeyCode(event);
+        const eventType = this.getEventType(keyCode);
+        if (!eventType) {
+          return;
+        }
+        delete this.pressedKeys[eventType];
+        if (this.shouldBypassSpatialNavigationForTarget(event.target, eventType)) {
+          return;
+        }
+        if (this.throttle && !this.throttleKeypresses) {
+          this.keyDownEventListenerThrottled?.cancel();
+        }
+        if (eventType === KEY_ENTER && this.focusKey) {
+          this.onEnterRelease();
+        }
+        if (this.focusKey && (eventType === DIRECTION_LEFT || eventType === DIRECTION_RIGHT || eventType === DIRECTION_UP || eventType === DIRECTION_DOWN)) {
+          this.onArrowRelease(eventType);
+        }
+      };
+      this.keyUpEventListener = keyUpEventListener;
+      window.addEventListener("keyup", keyUpEventListener);
+      window.addEventListener("keydown", keyDownListener);
+    }
+    if (this.trackNativeFocus && typeof document !== "undefined" && document.addEventListener) {
+      this.focusInEventListener = (event) => this.syncNativeFocus(event);
+      document.addEventListener("focusin", this.focusInEventListener);
+    }
+  }
+  unbindEventHandlers() {
+    if (typeof window !== "undefined" && window.removeEventListener) {
+      if (this.keyUpEventListener) {
+        window.removeEventListener("keyup", this.keyUpEventListener);
+        this.keyUpEventListener = null;
+      }
+      const listener = this.throttle ? this.keyDownEventListenerThrottled : this.keyDownEventListener;
+      if (listener) {
+        window.removeEventListener("keydown", listener);
+      }
+      this.keyDownEventListener = null;
+      this.keyDownEventListenerThrottled = null;
+    }
+    if (typeof document !== "undefined" && document.removeEventListener) {
+      if (this.focusInEventListener) {
+        document.removeEventListener("focusin", this.focusInEventListener);
+      }
+      this.focusInEventListener = null;
+    }
+  }
+  onEnterPress(keysDetails) {
+    if (!this.focusKey) {
+      return;
+    }
+    const component = this.focusableComponents[this.focusKey];
+    if (!component) {
+      this.log("onEnterPress", "noComponent");
+      return;
+    }
+    if (!component.focusable) {
+      this.log("onEnterPress", "componentNotFocusable");
+      return;
+    }
+    if (component.onEnterPress) {
+      component.onEnterPress(keysDetails);
+    }
+  }
+  onEnterRelease() {
+    if (!this.focusKey) {
+      return;
+    }
+    const component = this.focusableComponents[this.focusKey];
+    if (!component) {
+      this.log("onEnterRelease", "noComponent");
+      return;
+    }
+    if (!component.focusable) {
+      this.log("onEnterRelease", "componentNotFocusable");
+      return;
+    }
+    if (component.onEnterRelease) {
+      component.onEnterRelease();
+    }
+  }
+  onArrowPress(direction, keysDetails) {
+    if (!this.focusKey) {
+      return void 0;
+    }
+    const component = this.focusableComponents[this.focusKey];
+    if (!component) {
+      this.log("onArrowPress", "noComponent");
+      return void 0;
+    }
+    return component && component.onArrowPress && component.onArrowPress(direction, keysDetails);
+  }
+  onArrowRelease(direction) {
+    if (!this.focusKey) {
+      return;
+    }
+    const component = this.focusableComponents[this.focusKey];
+    if (!component) {
+      this.log("onArrowRelease", "noComponent");
+      return;
+    }
+    if (!component.focusable) {
+      this.log("onArrowRelease", "componentNotFocusable");
+      return;
+    }
+    if (component.onArrowRelease) {
+      component.onArrowRelease(direction);
+    }
+  }
+  /**
+   * Move focus by direction, if you can't use buttons or focusing by key.
+   *
+   * @example
+   * navigateByDirection('right') // The focus is moved to right
+   */
+  navigateByDirection(direction, focusDetails) {
+    if (this.paused === true || !this.enabled || this.nativeMode) {
+      return;
+    }
+    const validDirections = [DIRECTION_DOWN, DIRECTION_UP, DIRECTION_LEFT, DIRECTION_RIGHT];
+    if (validDirections.includes(direction)) {
+      this.log("navigateByDirection", "direction", direction);
+      this.smartNavigate(direction, null, focusDetails);
+    } else {
+      this.log("navigateByDirection", `Invalid direction. You passed: \`${direction}\`, but you can use only these: `, validDirections);
+    }
+  }
+  /**
+   * This function navigates between siblings OR goes up by the Tree
+   * Based on the Direction
+   */
+  smartNavigate(direction, fromParentFocusKey, focusDetails) {
+    if (this.nativeMode) {
+      return;
+    }
+    const isVerticalDirection = direction === DIRECTION_DOWN || direction === DIRECTION_UP;
+    const isIncrementalDirection = direction === DIRECTION_DOWN || (this.writingDirection === WritingDirection.LTR ? direction === DIRECTION_RIGHT : direction === DIRECTION_LEFT);
+    this.log("smartNavigate", "direction", direction);
+    this.log("smartNavigate", "fromParentFocusKey", fromParentFocusKey);
+    this.log("smartNavigate", "this.focusKey", this.focusKey);
+    if (!fromParentFocusKey) {
+      forOwn(this.focusableComponents, (component) => {
+        component.layoutUpdated = false;
+      });
+    }
+    const currentFocusKey = fromParentFocusKey || this.focusKey;
+    const currentComponent = currentFocusKey ? this.focusableComponents[currentFocusKey] : void 0;
+    if (!fromParentFocusKey && !currentComponent) {
+      const forcedFocusKey = this.getForcedFocusKey();
+      if (forcedFocusKey) {
+        this.setFocus(forcedFocusKey);
+      }
+      return;
+    }
+    this.log("smartNavigate", "currentComponent", currentComponent ? currentComponent.focusKey : void 0, currentComponent ? currentComponent.node : void 0, currentComponent);
+    if (currentComponent) {
+      this.updateLayout(currentComponent.focusKey);
+      const {
+        parentFocusKey,
+        focusKey,
+        layout
+      } = currentComponent;
+      const currentCutoffCoordinate = SpatialNavigationService.getCutoffCoordinate(isVerticalDirection, isIncrementalDirection, false, layout, this.writingDirection);
+      const siblings = filter(this.focusableComponents, (component) => {
+        if (component.parentFocusKey === parentFocusKey && component.focusable) {
+          this.updateLayout(component.focusKey);
+          const siblingCutoffCoordinate = SpatialNavigationService.getCutoffCoordinate(isVerticalDirection, isIncrementalDirection, true, component.layout, this.writingDirection);
+          return isVerticalDirection ? isIncrementalDirection ? siblingCutoffCoordinate >= currentCutoffCoordinate - CUT_OFF_COORDINATE_TOLERANCE_PX : siblingCutoffCoordinate <= currentCutoffCoordinate + CUT_OFF_COORDINATE_TOLERANCE_PX : this.writingDirection === WritingDirection.LTR ? isIncrementalDirection ? siblingCutoffCoordinate >= currentCutoffCoordinate - CUT_OFF_COORDINATE_TOLERANCE_PX : siblingCutoffCoordinate <= currentCutoffCoordinate + CUT_OFF_COORDINATE_TOLERANCE_PX : isIncrementalDirection ? siblingCutoffCoordinate <= currentCutoffCoordinate + CUT_OFF_COORDINATE_TOLERANCE_PX : siblingCutoffCoordinate >= currentCutoffCoordinate - CUT_OFF_COORDINATE_TOLERANCE_PX;
+        }
+        return false;
+      });
+      if (this.debug) {
+        this.log("smartNavigate", "currentCutoffCoordinate", currentCutoffCoordinate);
+        this.log("smartNavigate", "siblings", `${siblings.length} elements:`, siblings.map((sibling) => sibling.focusKey).join(", "), siblings.map((sibling) => sibling.node), siblings.map((sibling) => sibling));
+      }
+      const refCorners = SpatialNavigationService.getRefCorners(direction, false, layout);
+      const primaryAxisDistanceThreshold = Math.max(isVerticalDirection ? layout.height : layout.width, PRIMARY_AXIS_PROXIMITY_TOLERANCE_PX);
+      const siblingsWithPrimaryAxisDistance = siblings.map((sibling) => {
+        const siblingCorners = SpatialNavigationService.getRefCorners(direction, true, sibling.layout);
+        return {
+          sibling,
+          primaryAxisDistance: SpatialNavigationService.getPrimaryAxisDistance(refCorners, siblingCorners, isVerticalDirection)
+        };
+      });
+      const minimumPrimaryAxisDistance = siblingsWithPrimaryAxisDistance.length ? Math.min(...siblingsWithPrimaryAxisDistance.map(({
+        primaryAxisDistance
+      }) => primaryAxisDistance)) : null;
+      const nearbySiblings = minimumPrimaryAxisDistance === null ? siblings : siblingsWithPrimaryAxisDistance.filter(({
+        primaryAxisDistance
+      }) => primaryAxisDistance <= minimumPrimaryAxisDistance + primaryAxisDistanceThreshold).map(({
+        sibling
+      }) => sibling);
+      if (this.debug) {
+        this.log("smartNavigate", "nearbySiblings", `${nearbySiblings.length} elements:`, nearbySiblings.map((sibling) => sibling.focusKey).join(", "), `minimumPrimaryAxisDistance: ${minimumPrimaryAxisDistance}`, `primaryAxisDistanceThreshold: ${primaryAxisDistanceThreshold}`);
+      }
+      if (this.visualDebugger) {
+        this.visualDebugger.drawPoint(refCorners.a.x, refCorners.a.y);
+        this.visualDebugger.drawPoint(refCorners.b.x, refCorners.b.y);
+      }
+      const sortedSiblings = this.sortSiblingsByPriority(nearbySiblings, layout, direction, focusKey);
+      const nextComponent = first(sortedSiblings);
+      this.log("smartNavigate", "nextComponent", nextComponent ? nextComponent.focusKey : void 0, nextComponent ? nextComponent.node : void 0, nextComponent);
+      if (nextComponent) {
+        this.setFocus(nextComponent.focusKey, focusDetails);
+      } else {
+        if (!parentFocusKey) {
+          return;
+        }
+        const parentComponent = this.focusableComponents[parentFocusKey];
+        const focusBoundaryDirections = parentComponent?.isFocusBoundary ? parentComponent.focusBoundaryDirections || [direction] : [];
+        if (!parentComponent || !focusBoundaryDirections.includes(direction)) {
+          this.smartNavigate(direction, parentFocusKey, focusDetails);
+        }
+      }
+    }
+  }
+  saveLastFocusedChildKey(component, focusKey) {
+    if (component) {
+      this.log("saveLastFocusedChildKey", `${component.focusKey} lastFocusedChildKey set`, focusKey);
+      component.lastFocusedChildKey = focusKey;
+    }
+  }
+  log(functionName, debugString, ...rest) {
+    if (this.debug) {
+      console.log(`%c${functionName}%c${debugString}`, `background: ${DEBUG_FN_COLORS[this.logIndex % DEBUG_FN_COLORS.length]}; color: black; padding: 1px 5px;`, "background: #333; color: #BADA55; padding: 1px 5px;", ...rest);
+    }
+  }
+  /**
+   * Returns the current focus key
+   */
+  getCurrentFocusKey() {
+    return this.focusKey;
+  }
+  /**
+   * Returns the focus key to which focus can be forced if there are force-focusable components.
+   * A component closest to the top left viewport corner (0,0) is returned.
+   */
+  getForcedFocusKey() {
+    const forceFocusableComponents = filter(this.focusableComponents, (component) => component.focusable && component.forceFocus);
+    const sortedForceFocusableComponents = this.sortSiblingsByPriority(forceFocusableComponents, {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      left: 0,
+      top: 0,
+      right: 0,
+      bottom: 0,
+      node: null
+    }, "down", ROOT_FOCUS_KEY);
+    return first(sortedForceFocusableComponents)?.focusKey;
+  }
+  /**
+   * This function tries to determine the next component to Focus
+   * It's either the target node OR the one down by the Tree if node has children components
+   * Based on "targetFocusKey" which means the "intended component to focus"
+   */
+  getNextFocusKey(targetFocusKey) {
+    const targetComponent = this.focusableComponents[targetFocusKey];
+    if (!targetComponent || this.nativeMode) {
+      return targetFocusKey;
+    }
+    const children = filter(this.focusableComponents, (component) => component.parentFocusKey === targetFocusKey && component.focusable);
+    if (children.length > 0) {
+      const {
+        lastFocusedChildKey,
+        preferredChildFocusKey
+      } = targetComponent;
+      this.log("getNextFocusKey", "lastFocusedChildKey is", lastFocusedChildKey);
+      this.log("getNextFocusKey", "preferredChildFocusKey is", preferredChildFocusKey);
+      if (lastFocusedChildKey && targetComponent.saveLastFocusedChild && this.isParticipatingFocusableComponent(lastFocusedChildKey)) {
+        this.log("getNextFocusKey", "lastFocusedChildKey will be focused", lastFocusedChildKey);
+        return this.getNextFocusKey(lastFocusedChildKey);
+      }
+      if (preferredChildFocusKey && this.isParticipatingFocusableComponent(preferredChildFocusKey)) {
+        this.log("getNextFocusKey", "preferredChildFocusKey will be focused", preferredChildFocusKey);
+        return this.getNextFocusKey(preferredChildFocusKey);
+      }
+      children.forEach((component) => this.updateLayout(component.focusKey));
+      const closestChild = getChildClosestToOrigin(children, this.writingDirection);
+      if (!closestChild) {
+        return targetFocusKey;
+      }
+      const {
+        focusKey: childKey
+      } = closestChild;
+      this.log("getNextFocusKey", "childKey will be focused", childKey);
+      return this.getNextFocusKey(childKey);
+    }
+    this.log("getNextFocusKey", "targetFocusKey", targetFocusKey);
+    return targetFocusKey;
+  }
+  addFocusable({
+    focusKey,
+    node,
+    parentFocusKey,
+    onEnterPress,
+    onEnterRelease,
+    onArrowPress,
+    onArrowRelease,
+    onFocus,
+    onBlur,
+    saveLastFocusedChild,
+    trackChildren,
+    onUpdateFocus,
+    onUpdateHasFocusedChild,
+    preferredChildFocusKey,
+    autoRestoreFocus,
+    forceFocus,
+    focusable,
+    isFocusBoundary,
+    focusBoundaryDirections
+  }) {
+    this.focusableComponents[focusKey] = {
+      focusKey,
+      node,
+      parentFocusKey,
+      onEnterPress,
+      onEnterRelease,
+      onArrowPress,
+      onArrowRelease,
+      onFocus,
+      onBlur,
+      onUpdateFocus,
+      onUpdateHasFocusedChild,
+      saveLastFocusedChild,
+      trackChildren,
+      preferredChildFocusKey,
+      focusable,
+      isFocusBoundary,
+      focusBoundaryDirections,
+      autoRestoreFocus,
+      forceFocus,
+      lastFocusedChildKey: null,
+      layout: {
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+        left: 0,
+        top: 0,
+        right: 0,
+        bottom: 0,
+        /**
+         * Node ref is also duplicated in layout to be reported in onFocus callback
+         */
+        node
+      },
+      layoutUpdated: false
+    };
+    if (!node) {
+      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[focusKey]);
+    }
+    if (this.nativeMode) {
+      return;
+    }
+    this.makeNodeProgrammaticallyFocusable(this.focusableComponents[focusKey]);
+    this.updateLayout(focusKey);
+    this.log("addFocusable", "Component added: ", this.focusableComponents[focusKey]);
+    if (focusKey === this.focusKey) {
+      this.setFocus(preferredChildFocusKey || focusKey);
+    }
+    const currentFocusKey = this.focusKey;
+    if (!currentFocusKey) {
+      return;
+    }
+    let currentComponent = this.focusableComponents[currentFocusKey];
+    while (currentComponent) {
+      if (currentComponent.parentFocusKey === focusKey) {
+        this.updateParentsHasFocusedChild(currentFocusKey, {});
+        this.updateParentsLastFocusedChild(currentFocusKey);
+        break;
+      }
+      if (!currentComponent.parentFocusKey) {
+        break;
+      }
+      currentComponent = this.focusableComponents[currentComponent.parentFocusKey];
+    }
+  }
+  removeFocusable({
+    focusKey,
+    skipFocusRestoration = false
+  }) {
+    const componentToRemove = this.focusableComponents[focusKey];
+    if (componentToRemove) {
+      const {
+        parentFocusKey,
+        onUpdateFocus
+      } = componentToRemove;
+      onUpdateFocus(false);
+      this.log("removeFocusable", "Component removed: ", componentToRemove);
+      delete this.focusableComponents[focusKey];
+      const hadFocusedChild = this.parentsHavingFocusedChild.includes(focusKey);
+      this.parentsHavingFocusedChild = this.parentsHavingFocusedChild.filter((parentWithFocusedChild) => parentWithFocusedChild !== focusKey);
+      const parentComponent = parentFocusKey ? this.focusableComponents[parentFocusKey] : void 0;
+      const isFocused = focusKey === this.focusKey;
+      if (parentComponent && parentComponent.lastFocusedChildKey === focusKey) {
+        parentComponent.lastFocusedChildKey = null;
+      }
+      if (this.nativeMode) {
+        return;
+      }
+      if (!skipFocusRestoration && (isFocused || hadFocusedChild) && parentComponent && parentComponent.autoRestoreFocus) {
+        this.log("removeFocusable", "Component removed: ", isFocused ? "Leaf component" : "Container component", "Auto restoring focus to: ", parentFocusKey);
+        this.setFocusDebounced(parentComponent.focusKey);
+      }
+    }
+  }
+  getNodeLayoutByFocusKey(focusKey) {
+    const component = this.focusableComponents[focusKey];
+    if (component) {
+      this.updateLayout(component.focusKey);
+      return component.layout;
+    }
+    return null;
+  }
+  setCurrentFocusedKey(newFocusKey, focusDetails) {
+    const oldFocusKey = this.focusKey;
+    if (oldFocusKey && this.isFocusableComponent(oldFocusKey) && newFocusKey !== oldFocusKey) {
+      const oldComponent = this.focusableComponents[oldFocusKey];
+      oldComponent.onUpdateFocus(false);
+      oldComponent.onBlur(this.getNodeLayoutByFocusKey(oldFocusKey), focusDetails);
+      oldComponent.node?.removeAttribute?.("data-focused");
+      this.log("setCurrentFocusedKey", "onBlur", oldComponent);
+    }
+    this.focusKey = newFocusKey;
+    if (this.isFocusableComponent(newFocusKey)) {
+      const newComponent = this.focusableComponents[newFocusKey];
+      this.makeNodeProgrammaticallyFocusable(newComponent);
+      if (this.shouldFocusDOMNode && newComponent.node && typeof newComponent.node.focus === "function" && (typeof document === "undefined" || newComponent.node !== document.activeElement)) {
+        newComponent.node.focus(this.domNodeFocusOptions);
+      }
+      newComponent.node?.setAttribute?.("data-focused", "true");
+      newComponent.onUpdateFocus(true);
+      newComponent.onFocus(this.getNodeLayoutByFocusKey(newFocusKey), focusDetails);
+      this.log("setCurrentFocusedKey", "onFocus", newComponent);
+    }
+  }
+  updateParentsHasFocusedChild(focusKey, focusDetails) {
+    const parents = [];
+    let currentComponent = this.focusableComponents[focusKey];
+    while (currentComponent) {
+      const parentFocusKey = currentComponent.parentFocusKey;
+      const parentComponent = parentFocusKey ? this.focusableComponents[parentFocusKey] : void 0;
+      if (parentComponent) {
+        parents.push(parentComponent.focusKey);
+      }
+      currentComponent = parentComponent;
+    }
+    const parentsToRemoveFlag = difference(this.parentsHavingFocusedChild, parents);
+    const parentsToAddFlag = difference(parents, this.parentsHavingFocusedChild);
+    forEach(parentsToRemoveFlag, (parentFocusKey) => {
+      const parentComponent = this.focusableComponents[parentFocusKey];
+      if (parentComponent && parentComponent.trackChildren) {
+        parentComponent.onUpdateHasFocusedChild(false);
+      }
+      this.onIntermediateNodeBecameBlurred(parentFocusKey, focusDetails);
+    });
+    forEach(parentsToAddFlag, (parentFocusKey) => {
+      const parentComponent = this.focusableComponents[parentFocusKey];
+      if (parentComponent && parentComponent.trackChildren) {
+        parentComponent.onUpdateHasFocusedChild(true);
+      }
+      this.onIntermediateNodeBecameFocused(parentFocusKey, focusDetails);
+    });
+    this.parentsHavingFocusedChild = parents;
+  }
+  updateParentsLastFocusedChild(focusKey) {
+    let currentComponent = this.focusableComponents[focusKey];
+    while (currentComponent) {
+      const parentFocusKey = currentComponent.parentFocusKey;
+      const parentComponent = parentFocusKey ? this.focusableComponents[parentFocusKey] : void 0;
+      if (parentComponent) {
+        this.saveLastFocusedChildKey(parentComponent, currentComponent.focusKey);
+      }
+      currentComponent = parentComponent;
+    }
+  }
+  getKeyMap() {
+    return this.keyMap;
+  }
+  setKeyMap(keyMap) {
+    this.keyMap = {
+      ...this.getKeyMap(),
+      ...normalizeKeyMap(keyMap)
+    };
+  }
+  isFocusableComponent(focusKey) {
+    return !!this.focusableComponents[focusKey];
+  }
+  /**
+   * Checks whether the focusableComponent is actually participating in spatial navigation (in other words, is a
+   * 'focusable' focusableComponent). Seems less confusing than calling it isFocusableFocusableComponent()
+   */
+  isParticipatingFocusableComponent(focusKey) {
+    return this.isFocusableComponent(focusKey) && this.focusableComponents[focusKey].focusable;
+  }
+  onIntermediateNodeBecameFocused(focusKey, focusDetails) {
+    if (this.isParticipatingFocusableComponent(focusKey)) {
+      const layout = this.getNodeLayoutByFocusKey(focusKey);
+      if (!layout) {
+        return;
+      }
+      this.focusableComponents[focusKey].onFocus(layout, focusDetails);
+    }
+  }
+  onIntermediateNodeBecameBlurred(focusKey, focusDetails) {
+    if (this.isParticipatingFocusableComponent(focusKey)) {
+      const layout = this.getNodeLayoutByFocusKey(focusKey);
+      if (!layout) {
+        return;
+      }
+      this.focusableComponents[focusKey].onBlur(layout, focusDetails);
+    }
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+  }
+  setFocus(focusKey, focusDetails = {}) {
+    this.setFocusDebounced.cancel();
+    if (!this.enabled) {
+      return;
+    }
+    this.log("setFocus", "focusKey", focusKey);
+    const focusKeyToSet = !focusKey || focusKey === ROOT_FOCUS_KEY ? this.getForcedFocusKey() : focusKey;
+    if (!focusKeyToSet) {
+      return;
+    }
+    const newFocusKey = this.getNextFocusKey(focusKeyToSet);
+    this.log("setFocus", "newFocusKey", newFocusKey);
+    this.setCurrentFocusedKey(newFocusKey, focusDetails);
+    this.updateParentsHasFocusedChild(newFocusKey, focusDetails);
+    this.updateParentsLastFocusedChild(newFocusKey);
+  }
+  updateAllLayouts() {
+    if (!this.enabled || this.nativeMode) {
+      return;
+    }
+    forOwn(this.focusableComponents, (component, focusKey) => {
+      this.updateLayout(focusKey);
+    });
+  }
+  updateLayout(focusKey) {
+    const component = this.focusableComponents[focusKey];
+    if (!component || this.nativeMode || component.layoutUpdated) {
+      return;
+    }
+    const {
+      node
+    } = component;
+    const layoutReferenceNode = this.getLayoutReferenceNode(node);
+    const layout = this.useGetBoundingClientRect ? getBoundingClientRect(layoutReferenceNode) : measureLayout(layoutReferenceNode);
+    component.layout = {
+      ...layout,
+      node
+    };
+    component.layoutUpdated = true;
+  }
+  updateFocusable(focusKey, {
+    node,
+    parentFocusKey,
+    preferredChildFocusKey,
+    saveLastFocusedChild,
+    trackChildren,
+    focusable,
+    isFocusBoundary,
+    focusBoundaryDirections,
+    autoRestoreFocus,
+    forceFocus,
+    onEnterPress,
+    onEnterRelease,
+    onArrowPress,
+    onArrowRelease,
+    onFocus,
+    onBlur
+  }) {
+    if (this.nativeMode) {
+      return;
+    }
+    const component = this.focusableComponents[focusKey];
+    if (component) {
+      const previousParentFocusKey = component.parentFocusKey;
+      component.parentFocusKey = parentFocusKey;
+      component.preferredChildFocusKey = preferredChildFocusKey;
+      component.saveLastFocusedChild = saveLastFocusedChild;
+      component.trackChildren = trackChildren;
+      component.focusable = focusable;
+      component.isFocusBoundary = isFocusBoundary;
+      component.focusBoundaryDirections = focusBoundaryDirections;
+      component.autoRestoreFocus = autoRestoreFocus;
+      component.forceFocus = forceFocus;
+      component.onEnterPress = onEnterPress;
+      component.onEnterRelease = onEnterRelease;
+      component.onArrowPress = onArrowPress;
+      component.onArrowRelease = onArrowRelease;
+      component.onFocus = onFocus;
+      component.onBlur = onBlur;
+      if (node) {
+        component.node = node;
+      }
+      if (previousParentFocusKey !== parentFocusKey) {
+        if (previousParentFocusKey) {
+          const previousParentComponent = this.focusableComponents[previousParentFocusKey];
+          if (previousParentComponent?.lastFocusedChildKey === focusKey) {
+            previousParentComponent.lastFocusedChildKey = null;
+          }
+        }
+        const currentFocusKey = this.focusKey;
+        let currentFocusedComponent = currentFocusKey ? this.focusableComponents[currentFocusKey] : void 0;
+        while (currentFocusKey && currentFocusedComponent) {
+          if (currentFocusedComponent.focusKey === focusKey) {
+            this.updateParentsHasFocusedChild(currentFocusKey, {});
+            this.updateParentsLastFocusedChild(currentFocusKey);
+            break;
+          }
+          if (!currentFocusedComponent.parentFocusKey) {
+            break;
+          }
+          currentFocusedComponent = this.focusableComponents[currentFocusedComponent.parentFocusKey];
+        }
+      }
+      component.layoutUpdated = false;
+      this.makeNodeProgrammaticallyFocusable(component);
+    }
+  }
+  isNativeMode() {
+    return this.nativeMode;
+  }
+  doesFocusableExist(focusKey) {
+    return !!this.focusableComponents[focusKey];
+  }
+  /**
+   * This function updates the writing direction
+   * @param rtl whether the writing direction is right-to-left
+   */
+  updateRtl(rtl) {
+    this.writingDirection = rtl ? WritingDirection.RTL : WritingDirection.LTR;
+  }
+}
+const SpatialNavigation = new SpatialNavigationService();
+const {
+  init,
+  setThrottle,
+  setVisualDebug,
+  destroy,
+  setKeyMap,
+  setFocus,
+  navigateByDirection,
+  pause,
+  resume,
+  updateAllLayouts,
+  getCurrentFocusKey,
+  doesFocusableExist,
+  updateRtl
+} = SpatialNavigation;
+const FocusContext = createContext(ROOT_FOCUS_KEY);
+FocusContext.displayName = "FocusContext";
+const useFocusContext = () => {
+  return useContext(FocusContext);
+};
+const useFocusableHook = (t0) => {
+  const $ = c(72);
+  let t1;
+  if ($[0] !== t0) {
+    t1 = t0 === void 0 ? {} : t0;
+    $[0] = t0;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const {
+    focusable: t2,
+    saveLastFocusedChild: t3,
+    trackChildren: t4,
+    autoRestoreFocus: t5,
+    forceFocus: t6,
+    isFocusBoundary: t7,
+    focusBoundaryDirections,
+    focusKey: propFocusKey,
+    preferredChildFocusKey,
+    onEnterPress: t8,
+    onEnterRelease: t9,
+    onArrowPress: t10,
+    onArrowRelease: t11,
+    onFocus: t12,
+    onBlur: t13,
+    extraProps
+  } = t1;
+  const focusable = t2 === void 0 ? true : t2;
+  const saveLastFocusedChild = t3 === void 0 ? true : t3;
+  const trackChildren = t4 === void 0 ? false : t4;
+  const autoRestoreFocus = t5 === void 0 ? true : t5;
+  const forceFocus = t6 === void 0 ? false : t6;
+  const isFocusBoundary = t7 === void 0 ? false : t7;
+  const onEnterPress = t8 === void 0 ? noop : t8;
+  const onEnterRelease = t9 === void 0 ? noop : t9;
+  let t14;
+  if ($[2] !== t10) {
+    t14 = t10 === void 0 ? _temp : t10;
+    $[2] = t10;
+    $[3] = t14;
+  } else {
+    t14 = $[3];
+  }
+  const onArrowPress = t14;
+  const onArrowRelease = t11 === void 0 ? noop : t11;
+  const onFocus = t12 === void 0 ? noop : t12;
+  const onBlur = t13 === void 0 ? noop : t13;
+  let t15;
+  if ($[4] !== extraProps || $[5] !== onEnterPress) {
+    t15 = (details) => {
+      if (!details) {
+        return;
+      }
+      onEnterPress(extraProps, details);
+    };
+    $[4] = extraProps;
+    $[5] = onEnterPress;
+    $[6] = t15;
+  } else {
+    t15 = $[6];
+  }
+  const onEnterPressHandler = t15;
+  let t16;
+  if ($[7] !== extraProps || $[8] !== onEnterRelease) {
+    t16 = () => {
+      onEnterRelease(extraProps);
+    };
+    $[7] = extraProps;
+    $[8] = onEnterRelease;
+    $[9] = t16;
+  } else {
+    t16 = $[9];
+  }
+  const onEnterReleaseHandler = t16;
+  let t17;
+  if ($[10] !== extraProps || $[11] !== onArrowPress) {
+    t17 = (direction, details_0) => onArrowPress(direction, extraProps, details_0);
+    $[10] = extraProps;
+    $[11] = onArrowPress;
+    $[12] = t17;
+  } else {
+    t17 = $[12];
+  }
+  const onArrowPressHandler = t17;
+  let t18;
+  if ($[13] !== extraProps || $[14] !== onArrowRelease) {
+    t18 = (direction_0) => {
+      onArrowRelease(direction_0, extraProps);
+    };
+    $[13] = extraProps;
+    $[14] = onArrowRelease;
+    $[15] = t18;
+  } else {
+    t18 = $[15];
+  }
+  const onArrowReleaseHandler = t18;
+  let t19;
+  if ($[16] !== extraProps || $[17] !== onFocus) {
+    t19 = (layout, details_1) => {
+      onFocus(layout, extraProps, details_1);
+    };
+    $[16] = extraProps;
+    $[17] = onFocus;
+    $[18] = t19;
+  } else {
+    t19 = $[18];
+  }
+  const onFocusHandler = t19;
+  let t20;
+  if ($[19] !== extraProps || $[20] !== onBlur) {
+    t20 = (layout_0, details_2) => {
+      onBlur(layout_0, extraProps, details_2);
+    };
+    $[19] = extraProps;
+    $[20] = onBlur;
+    $[21] = t20;
+  } else {
+    t20 = $[21];
+  }
+  const onBlurHandler = t20;
+  const ref = useRef(null);
+  const registeredFocusKeyRef = useRef(null);
+  const [focused, setFocused] = useState(false);
+  const [hasFocusedChild, setHasFocusedChild] = useState(false);
+  const parentFocusKey = useFocusContext();
+  let t21;
+  if ($[22] !== propFocusKey) {
+    t21 = propFocusKey || uniqueId("sn:focusable-item-");
+    $[22] = propFocusKey;
+    $[23] = t21;
+  } else {
+    t21 = $[23];
+  }
+  const focusKey = t21;
+  let t22;
+  if ($[24] !== focusKey) {
+    t22 = (t232) => {
+      const focusDetails = t232 === void 0 ? {} : t232;
+      SpatialNavigation.setFocus(focusKey, focusDetails);
+    };
+    $[24] = focusKey;
+    $[25] = t22;
+  } else {
+    t22 = $[25];
+  }
+  const focusSelf = t22;
+  let t23;
+  if ($[26] !== autoRestoreFocus || $[27] !== focusBoundaryDirections || $[28] !== focusable || $[29] !== forceFocus || $[30] !== isFocusBoundary || $[31] !== onArrowPressHandler || $[32] !== onArrowReleaseHandler || $[33] !== onBlurHandler || $[34] !== onEnterPressHandler || $[35] !== onEnterReleaseHandler || $[36] !== onFocusHandler || $[37] !== parentFocusKey || $[38] !== preferredChildFocusKey || $[39] !== saveLastFocusedChild || $[40] !== trackChildren) {
+    t23 = (registrationFocusKey) => {
+      const node = ref.current;
+      SpatialNavigation.addFocusable({
+        focusKey: registrationFocusKey,
+        node,
+        parentFocusKey,
+        preferredChildFocusKey,
+        onEnterPress: onEnterPressHandler,
+        onEnterRelease: onEnterReleaseHandler,
+        onArrowPress: onArrowPressHandler,
+        onArrowRelease: onArrowReleaseHandler,
+        onFocus: onFocusHandler,
+        onBlur: onBlurHandler,
+        onUpdateFocus: (t242) => {
+          const isFocused = t242 === void 0 ? false : t242;
+          return setFocused(isFocused);
+        },
+        onUpdateHasFocusedChild: (t252) => {
+          const isFocused_0 = t252 === void 0 ? false : t252;
+          return setHasFocusedChild(isFocused_0);
+        },
+        saveLastFocusedChild,
+        trackChildren,
+        isFocusBoundary,
+        focusBoundaryDirections,
+        autoRestoreFocus,
+        forceFocus,
+        focusable
+      });
+    };
+    $[26] = autoRestoreFocus;
+    $[27] = focusBoundaryDirections;
+    $[28] = focusable;
+    $[29] = forceFocus;
+    $[30] = isFocusBoundary;
+    $[31] = onArrowPressHandler;
+    $[32] = onArrowReleaseHandler;
+    $[33] = onBlurHandler;
+    $[34] = onEnterPressHandler;
+    $[35] = onEnterReleaseHandler;
+    $[36] = onFocusHandler;
+    $[37] = parentFocusKey;
+    $[38] = preferredChildFocusKey;
+    $[39] = saveLastFocusedChild;
+    $[40] = trackChildren;
+    $[41] = t23;
+  } else {
+    t23 = $[41];
+  }
+  const registerFocusable = t23;
+  let t24;
+  if ($[42] !== focusKey || $[43] !== registerFocusable) {
+    t24 = () => {
+      const registeredFocusKey = registeredFocusKeyRef.current;
+      if (!registeredFocusKey) {
+        registerFocusable(focusKey);
+        registeredFocusKeyRef.current = focusKey;
+        return;
+      }
+      if (registeredFocusKey === focusKey) {
+        return;
+      }
+      const wasFocused = SpatialNavigation.getCurrentFocusKey() === registeredFocusKey;
+      SpatialNavigation.removeFocusable({
+        focusKey: registeredFocusKey,
+        skipFocusRestoration: true
+      });
+      registerFocusable(focusKey);
+      registeredFocusKeyRef.current = focusKey;
+      if (wasFocused) {
+        SpatialNavigation.setFocus(focusKey);
+      }
+    };
+    $[42] = focusKey;
+    $[43] = registerFocusable;
+    $[44] = t24;
+  } else {
+    t24 = $[44];
+  }
+  let t25;
+  if ($[45] !== focusKey) {
+    t25 = [focusKey];
+    $[45] = focusKey;
+    $[46] = t25;
+  } else {
+    t25 = $[46];
+  }
+  useEffect(t24, t25);
+  let t26;
+  let t27;
+  if ($[47] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t26 = () => () => {
+      const registeredFocusKey_0 = registeredFocusKeyRef.current;
+      if (!registeredFocusKey_0) {
+        return;
+      }
+      SpatialNavigation.removeFocusable({
+        focusKey: registeredFocusKey_0
+      });
+      registeredFocusKeyRef.current = null;
+    };
+    t27 = [];
+    $[47] = t26;
+    $[48] = t27;
+  } else {
+    t26 = $[47];
+    t27 = $[48];
+  }
+  useEffect(t26, t27);
+  let t28;
+  let t29;
+  if ($[49] !== autoRestoreFocus || $[50] !== focusBoundaryDirections || $[51] !== focusKey || $[52] !== focusable || $[53] !== forceFocus || $[54] !== isFocusBoundary || $[55] !== onArrowPressHandler || $[56] !== onArrowReleaseHandler || $[57] !== onBlurHandler || $[58] !== onEnterPressHandler || $[59] !== onEnterReleaseHandler || $[60] !== onFocusHandler || $[61] !== parentFocusKey || $[62] !== preferredChildFocusKey || $[63] !== saveLastFocusedChild || $[64] !== trackChildren) {
+    t28 = () => {
+      const node_0 = ref.current;
+      SpatialNavigation.updateFocusable(focusKey, {
+        node: node_0,
+        parentFocusKey,
+        preferredChildFocusKey,
+        saveLastFocusedChild,
+        trackChildren,
+        focusable,
+        isFocusBoundary,
+        focusBoundaryDirections,
+        autoRestoreFocus,
+        forceFocus,
+        onEnterPress: onEnterPressHandler,
+        onEnterRelease: onEnterReleaseHandler,
+        onArrowPress: onArrowPressHandler,
+        onArrowRelease: onArrowReleaseHandler,
+        onFocus: onFocusHandler,
+        onBlur: onBlurHandler
+      });
+    };
+    t29 = [focusKey, parentFocusKey, preferredChildFocusKey, saveLastFocusedChild, trackChildren, focusable, isFocusBoundary, focusBoundaryDirections, autoRestoreFocus, forceFocus, onEnterPressHandler, onEnterReleaseHandler, onArrowPressHandler, onArrowReleaseHandler, onFocusHandler, onBlurHandler];
+    $[49] = autoRestoreFocus;
+    $[50] = focusBoundaryDirections;
+    $[51] = focusKey;
+    $[52] = focusable;
+    $[53] = forceFocus;
+    $[54] = isFocusBoundary;
+    $[55] = onArrowPressHandler;
+    $[56] = onArrowReleaseHandler;
+    $[57] = onBlurHandler;
+    $[58] = onEnterPressHandler;
+    $[59] = onEnterReleaseHandler;
+    $[60] = onFocusHandler;
+    $[61] = parentFocusKey;
+    $[62] = preferredChildFocusKey;
+    $[63] = saveLastFocusedChild;
+    $[64] = trackChildren;
+    $[65] = t28;
+    $[66] = t29;
+  } else {
+    t28 = $[65];
+    t29 = $[66];
+  }
+  useEffect(t28, t29);
+  let t30;
+  if ($[67] !== focusKey || $[68] !== focusSelf || $[69] !== focused || $[70] !== hasFocusedChild) {
+    t30 = {
+      ref,
+      focusSelf,
+      focused,
+      hasFocusedChild,
+      focusKey
+    };
+    $[67] = focusKey;
+    $[68] = focusSelf;
+    $[69] = focused;
+    $[70] = hasFocusedChild;
+    $[71] = t30;
+  } else {
+    t30 = $[71];
+  }
+  return t30;
+};
+const useFocusable = useFocusableHook;
+function _temp() {
+  return true;
+}
+export {
+  FocusContext,
+  ROOT_FOCUS_KEY,
+  SpatialNavigation,
+  destroy,
+  doesFocusableExist,
+  getCurrentFocusKey,
+  init,
+  navigateByDirection,
+  pause,
+  resume,
+  setFocus,
+  setKeyMap,
+  setThrottle,
+  setVisualDebug,
+  updateAllLayouts,
+  updateRtl,
+  useFocusContext,
+  useFocusable
+};
+//# sourceMappingURL=index.js.map