@tatsuokaniwa/swr-firestore 0.1.0

package/dist/index.js

@@ -0,0 +1,4427 @@
+import { collection, getFirestore, query, where, orderBy, limit, onSnapshot, getCountFromServer, collectionGroup, doc } from "firebase/firestore";
+import React, { createContext, useContext, useEffect, useLayoutEffect, useRef, useMemo, useCallback, useDebugValue } from "react";
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+var isArray$c = Array.isArray;
+var isArray_1 = isArray$c;
+var freeGlobal$1 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var _freeGlobal = freeGlobal$1;
+var freeGlobal = _freeGlobal;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root$c = freeGlobal || freeSelf || Function("return this")();
+var _root = root$c;
+var root$b = _root;
+var Symbol$7 = root$b.Symbol;
+var _Symbol = Symbol$7;
+var Symbol$6 = _Symbol;
+var objectProto$g = Object.prototype;
+var hasOwnProperty$d = objectProto$g.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$g.toString;
+var symToStringTag$1 = Symbol$6 ? Symbol$6.toStringTag : void 0;
+function getRawTag$1(value) {
+  var isOwn = hasOwnProperty$d.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var _getRawTag = getRawTag$1;
+var objectProto$f = Object.prototype;
+var nativeObjectToString = objectProto$f.toString;
+function objectToString$1(value) {
+  return nativeObjectToString.call(value);
+}
+var _objectToString = objectToString$1;
+var Symbol$5 = _Symbol, getRawTag = _getRawTag, objectToString = _objectToString;
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$5 ? Symbol$5.toStringTag : void 0;
+function baseGetTag$7(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+var _baseGetTag = baseGetTag$7;
+function isObjectLike$b(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_1 = isObjectLike$b;
+var baseGetTag$6 = _baseGetTag, isObjectLike$a = isObjectLike_1;
+var symbolTag$3 = "[object Symbol]";
+function isSymbol$5(value) {
+  return typeof value == "symbol" || isObjectLike$a(value) && baseGetTag$6(value) == symbolTag$3;
+}
+var isSymbol_1 = isSymbol$5;
+var isArray$b = isArray_1, isSymbol$4 = isSymbol_1;
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey$3(value, object) {
+  if (isArray$b(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol$4(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var _isKey = isKey$3;
+function isObject$8(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_1 = isObject$8;
+var baseGetTag$5 = _baseGetTag, isObject$7 = isObject_1;
+var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction$3(value) {
+  if (!isObject$7(value)) {
+    return false;
+  }
+  var tag = baseGetTag$5(value);
+  return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_1 = isFunction$3;
+var root$a = _root;
+var coreJsData$1 = root$a["__core-js_shared__"];
+var _coreJsData = coreJsData$1;
+var coreJsData = _coreJsData;
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked$1(func2) {
+  return !!maskSrcKey && maskSrcKey in func2;
+}
+var _isMasked = isMasked$1;
+var funcProto$2 = Function.prototype;
+var funcToString$2 = funcProto$2.toString;
+function toSource$2(func2) {
+  if (func2 != null) {
+    try {
+      return funcToString$2.call(func2);
+    } catch (e) {
+    }
+    try {
+      return func2 + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var _toSource = toSource$2;
+var isFunction$2 = isFunction_1, isMasked = _isMasked, isObject$6 = isObject_1, toSource$1 = _toSource;
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto$1 = Function.prototype, objectProto$e = Object.prototype;
+var funcToString$1 = funcProto$1.toString;
+var hasOwnProperty$c = objectProto$e.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString$1.call(hasOwnProperty$c).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative$1(value) {
+  if (!isObject$6(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction$2(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource$1(value));
+}
+var _baseIsNative = baseIsNative$1;
+function getValue$1(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var _getValue = getValue$1;
+var baseIsNative = _baseIsNative, getValue = _getValue;
+function getNative$7(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var _getNative = getNative$7;
+var getNative$6 = _getNative;
+var nativeCreate$4 = getNative$6(Object, "create");
+var _nativeCreate = nativeCreate$4;
+var nativeCreate$3 = _nativeCreate;
+function hashClear$1() {
+  this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
+  this.size = 0;
+}
+var _hashClear = hashClear$1;
+function hashDelete$1(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete = hashDelete$1;
+var nativeCreate$2 = _nativeCreate;
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+var objectProto$d = Object.prototype;
+var hasOwnProperty$b = objectProto$d.hasOwnProperty;
+function hashGet$1(key) {
+  var data = this.__data__;
+  if (nativeCreate$2) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$2 ? void 0 : result;
+  }
+  return hasOwnProperty$b.call(data, key) ? data[key] : void 0;
+}
+var _hashGet = hashGet$1;
+var nativeCreate$1 = _nativeCreate;
+var objectProto$c = Object.prototype;
+var hasOwnProperty$a = objectProto$c.hasOwnProperty;
+function hashHas$1(key) {
+  var data = this.__data__;
+  return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty$a.call(data, key);
+}
+var _hashHas = hashHas$1;
+var nativeCreate = _nativeCreate;
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet$1(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value;
+  return this;
+}
+var _hashSet = hashSet$1;
+var hashClear = _hashClear, hashDelete = _hashDelete, hashGet = _hashGet, hashHas = _hashHas, hashSet = _hashSet;
+function Hash$1(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$1.prototype.clear = hashClear;
+Hash$1.prototype["delete"] = hashDelete;
+Hash$1.prototype.get = hashGet;
+Hash$1.prototype.has = hashHas;
+Hash$1.prototype.set = hashSet;
+var _Hash = Hash$1;
+function listCacheClear$1() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear = listCacheClear$1;
+var eq_1;
+var hasRequiredEq;
+function requireEq() {
+  if (hasRequiredEq)
+    return eq_1;
+  hasRequiredEq = 1;
+  function eq2(value, other) {
+    return value === other || value !== value && other !== other;
+  }
+  eq_1 = eq2;
+  return eq_1;
+}
+var eq$1 = requireEq();
+function assocIndexOf$4(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq$1(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf = assocIndexOf$4;
+var assocIndexOf$3 = _assocIndexOf;
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete$1(key) {
+  var data = this.__data__, index = assocIndexOf$3(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var _listCacheDelete = listCacheDelete$1;
+var assocIndexOf$2 = _assocIndexOf;
+function listCacheGet$1(key) {
+  var data = this.__data__, index = assocIndexOf$2(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var _listCacheGet = listCacheGet$1;
+var assocIndexOf$1 = _assocIndexOf;
+function listCacheHas$1(key) {
+  return assocIndexOf$1(this.__data__, key) > -1;
+}
+var _listCacheHas = listCacheHas$1;
+var assocIndexOf = _assocIndexOf;
+function listCacheSet$1(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var _listCacheSet = listCacheSet$1;
+var listCacheClear = _listCacheClear, listCacheDelete = _listCacheDelete, listCacheGet = _listCacheGet, listCacheHas = _listCacheHas, listCacheSet = _listCacheSet;
+function ListCache$4(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$4.prototype.clear = listCacheClear;
+ListCache$4.prototype["delete"] = listCacheDelete;
+ListCache$4.prototype.get = listCacheGet;
+ListCache$4.prototype.has = listCacheHas;
+ListCache$4.prototype.set = listCacheSet;
+var _ListCache = ListCache$4;
+var getNative$5 = _getNative, root$9 = _root;
+var Map$4 = getNative$5(root$9, "Map");
+var _Map = Map$4;
+var Hash = _Hash, ListCache$3 = _ListCache, Map$3 = _Map;
+function mapCacheClear$1() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$3 || ListCache$3)(),
+    "string": new Hash()
+  };
+}
+var _mapCacheClear = mapCacheClear$1;
+function isKeyable$1(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable = isKeyable$1;
+var isKeyable = _isKeyable;
+function getMapData$4(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData = getMapData$4;
+var getMapData$3 = _getMapData;
+function mapCacheDelete$1(key) {
+  var result = getMapData$3(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _mapCacheDelete = mapCacheDelete$1;
+var getMapData$2 = _getMapData;
+function mapCacheGet$1(key) {
+  return getMapData$2(this, key).get(key);
+}
+var _mapCacheGet = mapCacheGet$1;
+var getMapData$1 = _getMapData;
+function mapCacheHas$1(key) {
+  return getMapData$1(this, key).has(key);
+}
+var _mapCacheHas = mapCacheHas$1;
+var getMapData = _getMapData;
+function mapCacheSet$1(key, value) {
+  var data = getMapData(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var _mapCacheSet = mapCacheSet$1;
+var mapCacheClear = _mapCacheClear, mapCacheDelete = _mapCacheDelete, mapCacheGet = _mapCacheGet, mapCacheHas = _mapCacheHas, mapCacheSet = _mapCacheSet;
+function MapCache$3(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache$3.prototype.clear = mapCacheClear;
+MapCache$3.prototype["delete"] = mapCacheDelete;
+MapCache$3.prototype.get = mapCacheGet;
+MapCache$3.prototype.has = mapCacheHas;
+MapCache$3.prototype.set = mapCacheSet;
+var _MapCache = MapCache$3;
+var MapCache$2 = _MapCache;
+var FUNC_ERROR_TEXT$1 = "Expected a function";
+function memoize$1(func2, resolver) {
+  if (typeof func2 != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT$1);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
+    if (cache2.has(key)) {
+      return cache2.get(key);
+    }
+    var result = func2.apply(this, args);
+    memoized.cache = cache2.set(key, result) || cache2;
+    return result;
+  };
+  memoized.cache = new (memoize$1.Cache || MapCache$2)();
+  return memoized;
+}
+memoize$1.Cache = MapCache$2;
+var memoize_1 = memoize$1;
+var memoize = memoize_1;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped$1(func2) {
+  var result = memoize(func2, function(key) {
+    if (cache2.size === MAX_MEMOIZE_SIZE) {
+      cache2.clear();
+    }
+    return key;
+  });
+  var cache2 = result.cache;
+  return result;
+}
+var _memoizeCapped = memoizeCapped$1;
+var memoizeCapped = _memoizeCapped;
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath$2 = memoizeCapped(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+var _stringToPath = stringToPath$2;
+function arrayMap$2(array, iteratee2) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee2(array[index], index, array);
+  }
+  return result;
+}
+var _arrayMap = arrayMap$2;
+var Symbol$4 = _Symbol, arrayMap$1 = _arrayMap, isArray$a = isArray_1, isSymbol$3 = isSymbol_1;
+var INFINITY$2 = 1 / 0;
+var symbolProto$2 = Symbol$4 ? Symbol$4.prototype : void 0, symbolToString = symbolProto$2 ? symbolProto$2.toString : void 0;
+function baseToString$1(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray$a(value)) {
+    return arrayMap$1(value, baseToString$1) + "";
+  }
+  if (isSymbol$3(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY$2 ? "-0" : result;
+}
+var _baseToString = baseToString$1;
+var baseToString = _baseToString;
+function toString$2(value) {
+  return value == null ? "" : baseToString(value);
+}
+var toString_1 = toString$2;
+var isArray$9 = isArray_1, isKey$2 = _isKey, stringToPath$1 = _stringToPath, toString$1 = toString_1;
+function castPath$2(value, object) {
+  if (isArray$9(value)) {
+    return value;
+  }
+  return isKey$2(value, object) ? [value] : stringToPath$1(toString$1(value));
+}
+var _castPath = castPath$2;
+var isSymbol$2 = isSymbol_1;
+var INFINITY$1 = 1 / 0;
+function toKey$5(value) {
+  if (typeof value == "string" || isSymbol$2(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+}
+var _toKey = toKey$5;
+var castPath$1 = _castPath, toKey$4 = _toKey;
+function baseGet$2(object, path) {
+  path = castPath$1(path, object);
+  var index = 0, length = path.length;
+  while (object != null && index < length) {
+    object = object[toKey$4(path[index++])];
+  }
+  return index && index == length ? object : void 0;
+}
+var _baseGet = baseGet$2;
+var baseGet$1 = _baseGet;
+function get$1(object, path, defaultValue) {
+  var result = object == null ? void 0 : baseGet$1(object, path);
+  return result === void 0 ? defaultValue : result;
+}
+var get_1 = get$1;
+var _mapping = {};
+(function(exports) {
+  exports.aliasToReal = {
+    // Lodash aliases.
+    "each": "forEach",
+    "eachRight": "forEachRight",
+    "entries": "toPairs",
+    "entriesIn": "toPairsIn",
+    "extend": "assignIn",
+    "extendAll": "assignInAll",
+    "extendAllWith": "assignInAllWith",
+    "extendWith": "assignInWith",
+    "first": "head",
+    // Methods that are curried variants of others.
+    "conforms": "conformsTo",
+    "matches": "isMatch",
+    "property": "get",
+    // Ramda aliases.
+    "__": "placeholder",
+    "F": "stubFalse",
+    "T": "stubTrue",
+    "all": "every",
+    "allPass": "overEvery",
+    "always": "constant",
+    "any": "some",
+    "anyPass": "overSome",
+    "apply": "spread",
+    "assoc": "set",
+    "assocPath": "set",
+    "complement": "negate",
+    "compose": "flowRight",
+    "contains": "includes",
+    "dissoc": "unset",
+    "dissocPath": "unset",
+    "dropLast": "dropRight",
+    "dropLastWhile": "dropRightWhile",
+    "equals": "isEqual",
+    "identical": "eq",
+    "indexBy": "keyBy",
+    "init": "initial",
+    "invertObj": "invert",
+    "juxt": "over",
+    "omitAll": "omit",
+    "nAry": "ary",
+    "path": "get",
+    "pathEq": "matchesProperty",
+    "pathOr": "getOr",
+    "paths": "at",
+    "pickAll": "pick",
+    "pipe": "flow",
+    "pluck": "map",
+    "prop": "get",
+    "propEq": "matchesProperty",
+    "propOr": "getOr",
+    "props": "at",
+    "symmetricDifference": "xor",
+    "symmetricDifferenceBy": "xorBy",
+    "symmetricDifferenceWith": "xorWith",
+    "takeLast": "takeRight",
+    "takeLastWhile": "takeRightWhile",
+    "unapply": "rest",
+    "unnest": "flatten",
+    "useWith": "overArgs",
+    "where": "conformsTo",
+    "whereEq": "isMatch",
+    "zipObj": "zipObject"
+  };
+  exports.aryMethod = {
+    "1": [
+      "assignAll",
+      "assignInAll",
+      "attempt",
+      "castArray",
+      "ceil",
+      "create",
+      "curry",
+      "curryRight",
+      "defaultsAll",
+      "defaultsDeepAll",
+      "floor",
+      "flow",
+      "flowRight",
+      "fromPairs",
+      "invert",
+      "iteratee",
+      "memoize",
+      "method",
+      "mergeAll",
+      "methodOf",
+      "mixin",
+      "nthArg",
+      "over",
+      "overEvery",
+      "overSome",
+      "rest",
+      "reverse",
+      "round",
+      "runInContext",
+      "spread",
+      "template",
+      "trim",
+      "trimEnd",
+      "trimStart",
+      "uniqueId",
+      "words",
+      "zipAll"
+    ],
+    "2": [
+      "add",
+      "after",
+      "ary",
+      "assign",
+      "assignAllWith",
+      "assignIn",
+      "assignInAllWith",
+      "at",
+      "before",
+      "bind",
+      "bindAll",
+      "bindKey",
+      "chunk",
+      "cloneDeepWith",
+      "cloneWith",
+      "concat",
+      "conformsTo",
+      "countBy",
+      "curryN",
+      "curryRightN",
+      "debounce",
+      "defaults",
+      "defaultsDeep",
+      "defaultTo",
+      "delay",
+      "difference",
+      "divide",
+      "drop",
+      "dropRight",
+      "dropRightWhile",
+      "dropWhile",
+      "endsWith",
+      "eq",
+      "every",
+      "filter",
+      "find",
+      "findIndex",
+      "findKey",
+      "findLast",
+      "findLastIndex",
+      "findLastKey",
+      "flatMap",
+      "flatMapDeep",
+      "flattenDepth",
+      "forEach",
+      "forEachRight",
+      "forIn",
+      "forInRight",
+      "forOwn",
+      "forOwnRight",
+      "get",
+      "groupBy",
+      "gt",
+      "gte",
+      "has",
+      "hasIn",
+      "includes",
+      "indexOf",
+      "intersection",
+      "invertBy",
+      "invoke",
+      "invokeMap",
+      "isEqual",
+      "isMatch",
+      "join",
+      "keyBy",
+      "lastIndexOf",
+      "lt",
+      "lte",
+      "map",
+      "mapKeys",
+      "mapValues",
+      "matchesProperty",
+      "maxBy",
+      "meanBy",
+      "merge",
+      "mergeAllWith",
+      "minBy",
+      "multiply",
+      "nth",
+      "omit",
+      "omitBy",
+      "overArgs",
+      "pad",
+      "padEnd",
+      "padStart",
+      "parseInt",
+      "partial",
+      "partialRight",
+      "partition",
+      "pick",
+      "pickBy",
+      "propertyOf",
+      "pull",
+      "pullAll",
+      "pullAt",
+      "random",
+      "range",
+      "rangeRight",
+      "rearg",
+      "reject",
+      "remove",
+      "repeat",
+      "restFrom",
+      "result",
+      "sampleSize",
+      "some",
+      "sortBy",
+      "sortedIndex",
+      "sortedIndexOf",
+      "sortedLastIndex",
+      "sortedLastIndexOf",
+      "sortedUniqBy",
+      "split",
+      "spreadFrom",
+      "startsWith",
+      "subtract",
+      "sumBy",
+      "take",
+      "takeRight",
+      "takeRightWhile",
+      "takeWhile",
+      "tap",
+      "throttle",
+      "thru",
+      "times",
+      "trimChars",
+      "trimCharsEnd",
+      "trimCharsStart",
+      "truncate",
+      "union",
+      "uniqBy",
+      "uniqWith",
+      "unset",
+      "unzipWith",
+      "without",
+      "wrap",
+      "xor",
+      "zip",
+      "zipObject",
+      "zipObjectDeep"
+    ],
+    "3": [
+      "assignInWith",
+      "assignWith",
+      "clamp",
+      "differenceBy",
+      "differenceWith",
+      "findFrom",
+      "findIndexFrom",
+      "findLastFrom",
+      "findLastIndexFrom",
+      "getOr",
+      "includesFrom",
+      "indexOfFrom",
+      "inRange",
+      "intersectionBy",
+      "intersectionWith",
+      "invokeArgs",
+      "invokeArgsMap",
+      "isEqualWith",
+      "isMatchWith",
+      "flatMapDepth",
+      "lastIndexOfFrom",
+      "mergeWith",
+      "orderBy",
+      "padChars",
+      "padCharsEnd",
+      "padCharsStart",
+      "pullAllBy",
+      "pullAllWith",
+      "rangeStep",
+      "rangeStepRight",
+      "reduce",
+      "reduceRight",
+      "replace",
+      "set",
+      "slice",
+      "sortedIndexBy",
+      "sortedLastIndexBy",
+      "transform",
+      "unionBy",
+      "unionWith",
+      "update",
+      "xorBy",
+      "xorWith",
+      "zipWith"
+    ],
+    "4": [
+      "fill",
+      "setWith",
+      "updateWith"
+    ]
+  };
+  exports.aryRearg = {
+    "2": [1, 0],
+    "3": [2, 0, 1],
+    "4": [3, 2, 0, 1]
+  };
+  exports.iterateeAry = {
+    "dropRightWhile": 1,
+    "dropWhile": 1,
+    "every": 1,
+    "filter": 1,
+    "find": 1,
+    "findFrom": 1,
+    "findIndex": 1,
+    "findIndexFrom": 1,
+    "findKey": 1,
+    "findLast": 1,
+    "findLastFrom": 1,
+    "findLastIndex": 1,
+    "findLastIndexFrom": 1,
+    "findLastKey": 1,
+    "flatMap": 1,
+    "flatMapDeep": 1,
+    "flatMapDepth": 1,
+    "forEach": 1,
+    "forEachRight": 1,
+    "forIn": 1,
+    "forInRight": 1,
+    "forOwn": 1,
+    "forOwnRight": 1,
+    "map": 1,
+    "mapKeys": 1,
+    "mapValues": 1,
+    "partition": 1,
+    "reduce": 2,
+    "reduceRight": 2,
+    "reject": 1,
+    "remove": 1,
+    "some": 1,
+    "takeRightWhile": 1,
+    "takeWhile": 1,
+    "times": 1,
+    "transform": 2
+  };
+  exports.iterateeRearg = {
+    "mapKeys": [1],
+    "reduceRight": [1, 0]
+  };
+  exports.methodRearg = {
+    "assignInAllWith": [1, 0],
+    "assignInWith": [1, 2, 0],
+    "assignAllWith": [1, 0],
+    "assignWith": [1, 2, 0],
+    "differenceBy": [1, 2, 0],
+    "differenceWith": [1, 2, 0],
+    "getOr": [2, 1, 0],
+    "intersectionBy": [1, 2, 0],
+    "intersectionWith": [1, 2, 0],
+    "isEqualWith": [1, 2, 0],
+    "isMatchWith": [2, 1, 0],
+    "mergeAllWith": [1, 0],
+    "mergeWith": [1, 2, 0],
+    "padChars": [2, 1, 0],
+    "padCharsEnd": [2, 1, 0],
+    "padCharsStart": [2, 1, 0],
+    "pullAllBy": [2, 1, 0],
+    "pullAllWith": [2, 1, 0],
+    "rangeStep": [1, 2, 0],
+    "rangeStepRight": [1, 2, 0],
+    "setWith": [3, 1, 2, 0],
+    "sortedIndexBy": [2, 1, 0],
+    "sortedLastIndexBy": [2, 1, 0],
+    "unionBy": [1, 2, 0],
+    "unionWith": [1, 2, 0],
+    "updateWith": [3, 1, 2, 0],
+    "xorBy": [1, 2, 0],
+    "xorWith": [1, 2, 0],
+    "zipWith": [1, 2, 0]
+  };
+  exports.methodSpread = {
+    "assignAll": { "start": 0 },
+    "assignAllWith": { "start": 0 },
+    "assignInAll": { "start": 0 },
+    "assignInAllWith": { "start": 0 },
+    "defaultsAll": { "start": 0 },
+    "defaultsDeepAll": { "start": 0 },
+    "invokeArgs": { "start": 2 },
+    "invokeArgsMap": { "start": 2 },
+    "mergeAll": { "start": 0 },
+    "mergeAllWith": { "start": 0 },
+    "partial": { "start": 1 },
+    "partialRight": { "start": 1 },
+    "without": { "start": 1 },
+    "zipAll": { "start": 0 }
+  };
+  exports.mutate = {
+    "array": {
+      "fill": true,
+      "pull": true,
+      "pullAll": true,
+      "pullAllBy": true,
+      "pullAllWith": true,
+      "pullAt": true,
+      "remove": true,
+      "reverse": true
+    },
+    "object": {
+      "assign": true,
+      "assignAll": true,
+      "assignAllWith": true,
+      "assignIn": true,
+      "assignInAll": true,
+      "assignInAllWith": true,
+      "assignInWith": true,
+      "assignWith": true,
+      "defaults": true,
+      "defaultsAll": true,
+      "defaultsDeep": true,
+      "defaultsDeepAll": true,
+      "merge": true,
+      "mergeAll": true,
+      "mergeAllWith": true,
+      "mergeWith": true
+    },
+    "set": {
+      "set": true,
+      "setWith": true,
+      "unset": true,
+      "update": true,
+      "updateWith": true
+    }
+  };
+  exports.realToAlias = function() {
+    var hasOwnProperty2 = Object.prototype.hasOwnProperty, object = exports.aliasToReal, result = {};
+    for (var key in object) {
+      var value = object[key];
+      if (hasOwnProperty2.call(result, value)) {
+        result[value].push(key);
+      } else {
+        result[value] = [key];
+      }
+    }
+    return result;
+  }();
+  exports.remap = {
+    "assignAll": "assign",
+    "assignAllWith": "assignWith",
+    "assignInAll": "assignIn",
+    "assignInAllWith": "assignInWith",
+    "curryN": "curry",
+    "curryRightN": "curryRight",
+    "defaultsAll": "defaults",
+    "defaultsDeepAll": "defaultsDeep",
+    "findFrom": "find",
+    "findIndexFrom": "findIndex",
+    "findLastFrom": "findLast",
+    "findLastIndexFrom": "findLastIndex",
+    "getOr": "get",
+    "includesFrom": "includes",
+    "indexOfFrom": "indexOf",
+    "invokeArgs": "invoke",
+    "invokeArgsMap": "invokeMap",
+    "lastIndexOfFrom": "lastIndexOf",
+    "mergeAll": "merge",
+    "mergeAllWith": "mergeWith",
+    "padChars": "pad",
+    "padCharsEnd": "padEnd",
+    "padCharsStart": "padStart",
+    "propertyOf": "get",
+    "rangeStep": "range",
+    "rangeStepRight": "rangeRight",
+    "restFrom": "rest",
+    "spreadFrom": "spread",
+    "trimChars": "trim",
+    "trimCharsEnd": "trimEnd",
+    "trimCharsStart": "trimStart",
+    "zipAll": "zip"
+  };
+  exports.skipFixed = {
+    "castArray": true,
+    "flow": true,
+    "flowRight": true,
+    "iteratee": true,
+    "mixin": true,
+    "rearg": true,
+    "runInContext": true
+  };
+  exports.skipRearg = {
+    "add": true,
+    "assign": true,
+    "assignIn": true,
+    "bind": true,
+    "bindKey": true,
+    "concat": true,
+    "difference": true,
+    "divide": true,
+    "eq": true,
+    "gt": true,
+    "gte": true,
+    "isEqual": true,
+    "lt": true,
+    "lte": true,
+    "matchesProperty": true,
+    "merge": true,
+    "multiply": true,
+    "overArgs": true,
+    "partial": true,
+    "partialRight": true,
+    "propertyOf": true,
+    "random": true,
+    "range": true,
+    "rangeRight": true,
+    "subtract": true,
+    "zip": true,
+    "zipObject": true,
+    "zipObjectDeep": true
+  };
+})(_mapping);
+var placeholder;
+var hasRequiredPlaceholder;
+function requirePlaceholder() {
+  if (hasRequiredPlaceholder)
+    return placeholder;
+  hasRequiredPlaceholder = 1;
+  placeholder = {};
+  return placeholder;
+}
+var mapping = _mapping, fallbackHolder = requirePlaceholder();
+var push = Array.prototype.push;
+function baseArity(func2, n) {
+  return n == 2 ? function(a, b) {
+    return func2.apply(void 0, arguments);
+  } : function(a) {
+    return func2.apply(void 0, arguments);
+  };
+}
+function baseAry(func2, n) {
+  return n == 2 ? function(a, b) {
+    return func2(a, b);
+  } : function(a) {
+    return func2(a);
+  };
+}
+function cloneArray(array) {
+  var length = array ? array.length : 0, result = Array(length);
+  while (length--) {
+    result[length] = array[length];
+  }
+  return result;
+}
+function createCloner(func2) {
+  return function(object) {
+    return func2({}, object);
+  };
+}
+function flatSpread(func2, start) {
+  return function() {
+    var length = arguments.length, lastIndex = length - 1, args = Array(length);
+    while (length--) {
+      args[length] = arguments[length];
+    }
+    var array = args[start], otherArgs = args.slice(0, start);
+    if (array) {
+      push.apply(otherArgs, array);
+    }
+    if (start != lastIndex) {
+      push.apply(otherArgs, args.slice(start + 1));
+    }
+    return func2.apply(this, otherArgs);
+  };
+}
+function wrapImmutable(func2, cloner) {
+  return function() {
+    var length = arguments.length;
+    if (!length) {
+      return;
+    }
+    var args = Array(length);
+    while (length--) {
+      args[length] = arguments[length];
+    }
+    var result = args[0] = cloner.apply(void 0, args);
+    func2.apply(void 0, args);
+    return result;
+  };
+}
+function baseConvert$1(util2, name, func2, options) {
+  var isLib = typeof name == "function", isObj = name === Object(name);
+  if (isObj) {
+    options = func2;
+    func2 = name;
+    name = void 0;
+  }
+  if (func2 == null) {
+    throw new TypeError();
+  }
+  options || (options = {});
+  var config = {
+    "cap": "cap" in options ? options.cap : true,
+    "curry": "curry" in options ? options.curry : true,
+    "fixed": "fixed" in options ? options.fixed : true,
+    "immutable": "immutable" in options ? options.immutable : true,
+    "rearg": "rearg" in options ? options.rearg : true
+  };
+  var defaultHolder = isLib ? func2 : fallbackHolder, forceCurry = "curry" in options && options.curry, forceFixed = "fixed" in options && options.fixed, forceRearg = "rearg" in options && options.rearg, pristine = isLib ? func2.runInContext() : void 0;
+  var helpers = isLib ? func2 : {
+    "ary": util2.ary,
+    "assign": util2.assign,
+    "clone": util2.clone,
+    "curry": util2.curry,
+    "forEach": util2.forEach,
+    "isArray": util2.isArray,
+    "isError": util2.isError,
+    "isFunction": util2.isFunction,
+    "isWeakMap": util2.isWeakMap,
+    "iteratee": util2.iteratee,
+    "keys": util2.keys,
+    "rearg": util2.rearg,
+    "toInteger": util2.toInteger,
+    "toPath": util2.toPath
+  };
+  var ary2 = helpers.ary, assign = helpers.assign, clone2 = helpers.clone, curry2 = helpers.curry, each = helpers.forEach, isArray2 = helpers.isArray, isError2 = helpers.isError, isFunction2 = helpers.isFunction, isWeakMap2 = helpers.isWeakMap, keys2 = helpers.keys, rearg2 = helpers.rearg, toInteger2 = helpers.toInteger, toPath2 = helpers.toPath;
+  var aryMethodKeys = keys2(mapping.aryMethod);
+  var wrappers = {
+    "castArray": function(castArray) {
+      return function() {
+        var value = arguments[0];
+        return isArray2(value) ? castArray(cloneArray(value)) : castArray.apply(void 0, arguments);
+      };
+    },
+    "iteratee": function(iteratee2) {
+      return function() {
+        var func3 = arguments[0], arity = arguments[1], result = iteratee2(func3, arity), length = result.length;
+        if (config.cap && typeof arity == "number") {
+          arity = arity > 2 ? arity - 2 : 1;
+          return length && length <= arity ? result : baseAry(result, arity);
+        }
+        return result;
+      };
+    },
+    "mixin": function(mixin) {
+      return function(source) {
+        var func3 = this;
+        if (!isFunction2(func3)) {
+          return mixin(func3, Object(source));
+        }
+        var pairs2 = [];
+        each(keys2(source), function(key) {
+          if (isFunction2(source[key])) {
+            pairs2.push([key, func3.prototype[key]]);
+          }
+        });
+        mixin(func3, Object(source));
+        each(pairs2, function(pair) {
+          var value = pair[1];
+          if (isFunction2(value)) {
+            func3.prototype[pair[0]] = value;
+          } else {
+            delete func3.prototype[pair[0]];
+          }
+        });
+        return func3;
+      };
+    },
+    "nthArg": function(nthArg) {
+      return function(n) {
+        var arity = n < 0 ? 1 : toInteger2(n) + 1;
+        return curry2(nthArg(n), arity);
+      };
+    },
+    "rearg": function(rearg3) {
+      return function(func3, indexes) {
+        var arity = indexes ? indexes.length : 0;
+        return curry2(rearg3(func3, indexes), arity);
+      };
+    },
+    "runInContext": function(runInContext) {
+      return function(context) {
+        return baseConvert$1(util2, runInContext(context), options);
+      };
+    }
+  };
+  function castCap(name2, func3) {
+    if (config.cap) {
+      var indexes = mapping.iterateeRearg[name2];
+      if (indexes) {
+        return iterateeRearg(func3, indexes);
+      }
+      var n = !isLib && mapping.iterateeAry[name2];
+      if (n) {
+        return iterateeAry(func3, n);
+      }
+    }
+    return func3;
+  }
+  function castCurry(name2, func3, n) {
+    return forceCurry || config.curry && n > 1 ? curry2(func3, n) : func3;
+  }
+  function castFixed(name2, func3, n) {
+    if (config.fixed && (forceFixed || !mapping.skipFixed[name2])) {
+      var data = mapping.methodSpread[name2], start = data && data.start;
+      return start === void 0 ? ary2(func3, n) : flatSpread(func3, start);
+    }
+    return func3;
+  }
+  function castRearg(name2, func3, n) {
+    return config.rearg && n > 1 && (forceRearg || !mapping.skipRearg[name2]) ? rearg2(func3, mapping.methodRearg[name2] || mapping.aryRearg[n]) : func3;
+  }
+  function cloneByPath(object, path) {
+    path = toPath2(path);
+    var index = -1, length = path.length, lastIndex = length - 1, result = clone2(Object(object)), nested = result;
+    while (nested != null && ++index < length) {
+      var key = path[index], value = nested[key];
+      if (value != null && !(isFunction2(value) || isError2(value) || isWeakMap2(value))) {
+        nested[key] = clone2(index == lastIndex ? value : Object(value));
+      }
+      nested = nested[key];
+    }
+    return result;
+  }
+  function convertLib(options2) {
+    return _.runInContext.convert(options2)(void 0);
+  }
+  function createConverter(name2, func3) {
+    var realName = mapping.aliasToReal[name2] || name2, methodName = mapping.remap[realName] || realName, oldOptions = options;
+    return function(options2) {
+      var newUtil = isLib ? pristine : helpers, newFunc = isLib ? pristine[methodName] : func3, newOptions = assign(assign({}, oldOptions), options2);
+      return baseConvert$1(newUtil, realName, newFunc, newOptions);
+    };
+  }
+  function iterateeAry(func3, n) {
+    return overArg2(func3, function(func4) {
+      return typeof func4 == "function" ? baseAry(func4, n) : func4;
+    });
+  }
+  function iterateeRearg(func3, indexes) {
+    return overArg2(func3, function(func4) {
+      var n = indexes.length;
+      return baseArity(rearg2(baseAry(func4, n), indexes), n);
+    });
+  }
+  function overArg2(func3, transform) {
+    return function() {
+      var length = arguments.length;
+      if (!length) {
+        return func3();
+      }
+      var args = Array(length);
+      while (length--) {
+        args[length] = arguments[length];
+      }
+      var index = config.rearg ? 0 : length - 1;
+      args[index] = transform(args[index]);
+      return func3.apply(void 0, args);
+    };
+  }
+  function wrap(name2, func3, placeholder2) {
+    var result, realName = mapping.aliasToReal[name2] || name2, wrapped = func3, wrapper = wrappers[realName];
+    if (wrapper) {
+      wrapped = wrapper(func3);
+    } else if (config.immutable) {
+      if (mapping.mutate.array[realName]) {
+        wrapped = wrapImmutable(func3, cloneArray);
+      } else if (mapping.mutate.object[realName]) {
+        wrapped = wrapImmutable(func3, createCloner(func3));
+      } else if (mapping.mutate.set[realName]) {
+        wrapped = wrapImmutable(func3, cloneByPath);
+      }
+    }
+    each(aryMethodKeys, function(aryKey) {
+      each(mapping.aryMethod[aryKey], function(otherName) {
+        if (realName == otherName) {
+          var data = mapping.methodSpread[realName], afterRearg = data && data.afterRearg;
+          result = afterRearg ? castFixed(realName, castRearg(realName, wrapped, aryKey), aryKey) : castRearg(realName, castFixed(realName, wrapped, aryKey), aryKey);
+          result = castCap(realName, result);
+          result = castCurry(realName, result, aryKey);
+          return false;
+        }
+      });
+      return !result;
+    });
+    result || (result = wrapped);
+    if (result == func3) {
+      result = forceCurry ? curry2(result, 1) : function() {
+        return func3.apply(this, arguments);
+      };
+    }
+    result.convert = createConverter(realName, func3);
+    result.placeholder = func3.placeholder = placeholder2;
+    return result;
+  }
+  if (!isObj) {
+    return wrap(name, func2, defaultHolder);
+  }
+  var _ = func2;
+  var pairs = [];
+  each(aryMethodKeys, function(aryKey) {
+    each(mapping.aryMethod[aryKey], function(key) {
+      var func3 = _[mapping.remap[key] || key];
+      if (func3) {
+        pairs.push([key, wrap(key, func3, _)]);
+      }
+    });
+  });
+  each(keys2(_), function(key) {
+    var func3 = _[key];
+    if (typeof func3 == "function") {
+      var length = pairs.length;
+      while (length--) {
+        if (pairs[length][0] == key) {
+          return;
+        }
+      }
+      func3.convert = createConverter(key, func3);
+      pairs.push([key, func3]);
+    }
+  });
+  each(pairs, function(pair) {
+    _[pair[0]] = pair[1];
+  });
+  _.convert = convertLib;
+  _.placeholder = _;
+  each(keys2(_), function(key) {
+    each(mapping.realToAlias[key] || [], function(alias) {
+      _[alias] = _[key];
+    });
+  });
+  return _;
+}
+var _baseConvert = baseConvert$1;
+function identity$3(value) {
+  return value;
+}
+var identity_1 = identity$3;
+var getNative$4 = _getNative, root$8 = _root;
+var WeakMap$3 = getNative$4(root$8, "WeakMap");
+var _WeakMap = WeakMap$3;
+var WeakMap$2 = _WeakMap;
+var metaMap$2 = WeakMap$2 && new WeakMap$2();
+var _metaMap = metaMap$2;
+var identity$2 = identity_1, metaMap$1 = _metaMap;
+var baseSetData$2 = !metaMap$1 ? identity$2 : function(func2, data) {
+  metaMap$1.set(func2, data);
+  return func2;
+};
+var _baseSetData = baseSetData$2;
+var isObject$5 = isObject_1;
+var objectCreate = Object.create;
+var baseCreate$4 = function() {
+  function object() {
+  }
+  return function(proto) {
+    if (!isObject$5(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object();
+    object.prototype = void 0;
+    return result;
+  };
+}();
+var _baseCreate = baseCreate$4;
+var baseCreate$3 = _baseCreate, isObject$4 = isObject_1;
+function createCtor$4(Ctor) {
+  return function() {
+    var args = arguments;
+    switch (args.length) {
+      case 0:
+        return new Ctor();
+      case 1:
+        return new Ctor(args[0]);
+      case 2:
+        return new Ctor(args[0], args[1]);
+      case 3:
+        return new Ctor(args[0], args[1], args[2]);
+      case 4:
+        return new Ctor(args[0], args[1], args[2], args[3]);
+      case 5:
+        return new Ctor(args[0], args[1], args[2], args[3], args[4]);
+      case 6:
+        return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
+      case 7:
+        return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+    }
+    var thisBinding = baseCreate$3(Ctor.prototype), result = Ctor.apply(thisBinding, args);
+    return isObject$4(result) ? result : thisBinding;
+  };
+}
+var _createCtor = createCtor$4;
+var createCtor$3 = _createCtor, root$7 = _root;
+var WRAP_BIND_FLAG$6 = 1;
+function createBind$1(func2, bitmask, thisArg) {
+  var isBind = bitmask & WRAP_BIND_FLAG$6, Ctor = createCtor$3(func2);
+  function wrapper() {
+    var fn = this && this !== root$7 && this instanceof wrapper ? Ctor : func2;
+    return fn.apply(isBind ? thisArg : this, arguments);
+  }
+  return wrapper;
+}
+var _createBind = createBind$1;
+function apply$3(func2, thisArg, args) {
+  switch (args.length) {
+    case 0:
+      return func2.call(thisArg);
+    case 1:
+      return func2.call(thisArg, args[0]);
+    case 2:
+      return func2.call(thisArg, args[0], args[1]);
+    case 3:
+      return func2.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func2.apply(thisArg, args);
+}
+var _apply = apply$3;
+var nativeMax$3 = Math.max;
+function composeArgs$2(args, partials, holders, isCurried) {
+  var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax$3(argsLength - holdersLength, 0), result = Array(leftLength + rangeLength), isUncurried = !isCurried;
+  while (++leftIndex < leftLength) {
+    result[leftIndex] = partials[leftIndex];
+  }
+  while (++argsIndex < holdersLength) {
+    if (isUncurried || argsIndex < argsLength) {
+      result[holders[argsIndex]] = args[argsIndex];
+    }
+  }
+  while (rangeLength--) {
+    result[leftIndex++] = args[argsIndex++];
+  }
+  return result;
+}
+var _composeArgs = composeArgs$2;
+var nativeMax$2 = Math.max;
+function composeArgsRight$2(args, partials, holders, isCurried) {
+  var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax$2(argsLength - holdersLength, 0), result = Array(rangeLength + rightLength), isUncurried = !isCurried;
+  while (++argsIndex < rangeLength) {
+    result[argsIndex] = args[argsIndex];
+  }
+  var offset = argsIndex;
+  while (++rightIndex < rightLength) {
+    result[offset + rightIndex] = partials[rightIndex];
+  }
+  while (++holdersIndex < holdersLength) {
+    if (isUncurried || argsIndex < argsLength) {
+      result[offset + holders[holdersIndex]] = args[argsIndex++];
+    }
+  }
+  return result;
+}
+var _composeArgsRight = composeArgsRight$2;
+function countHolders$1(array, placeholder2) {
+  var length = array.length, result = 0;
+  while (length--) {
+    if (array[length] === placeholder2) {
+      ++result;
+    }
+  }
+  return result;
+}
+var _countHolders = countHolders$1;
+function baseLodash$3() {
+}
+var _baseLodash = baseLodash$3;
+var baseCreate$2 = _baseCreate, baseLodash$2 = _baseLodash;
+var MAX_ARRAY_LENGTH = 4294967295;
+function LazyWrapper$3(value) {
+  this.__wrapped__ = value;
+  this.__actions__ = [];
+  this.__dir__ = 1;
+  this.__filtered__ = false;
+  this.__iteratees__ = [];
+  this.__takeCount__ = MAX_ARRAY_LENGTH;
+  this.__views__ = [];
+}
+LazyWrapper$3.prototype = baseCreate$2(baseLodash$2.prototype);
+LazyWrapper$3.prototype.constructor = LazyWrapper$3;
+var _LazyWrapper = LazyWrapper$3;
+function noop$2() {
+}
+var noop_1 = noop$2;
+var metaMap = _metaMap, noop$1 = noop_1;
+var getData$2 = !metaMap ? noop$1 : function(func2) {
+  return metaMap.get(func2);
+};
+var _getData = getData$2;
+var realNames$1 = {};
+var _realNames = realNames$1;
+var realNames = _realNames;
+var objectProto$b = Object.prototype;
+var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
+function getFuncName$1(func2) {
+  var result = func2.name + "", array = realNames[result], length = hasOwnProperty$9.call(realNames, result) ? array.length : 0;
+  while (length--) {
+    var data = array[length], otherFunc = data.func;
+    if (otherFunc == null || otherFunc == func2) {
+      return data.name;
+    }
+  }
+  return result;
+}
+var _getFuncName = getFuncName$1;
+var baseCreate$1 = _baseCreate, baseLodash$1 = _baseLodash;
+function LodashWrapper$2(value, chainAll) {
+  this.__wrapped__ = value;
+  this.__actions__ = [];
+  this.__chain__ = !!chainAll;
+  this.__index__ = 0;
+  this.__values__ = void 0;
+}
+LodashWrapper$2.prototype = baseCreate$1(baseLodash$1.prototype);
+LodashWrapper$2.prototype.constructor = LodashWrapper$2;
+var _LodashWrapper = LodashWrapper$2;
+function copyArray$4(source, array) {
+  var index = -1, length = source.length;
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+var _copyArray = copyArray$4;
+var LazyWrapper$2 = _LazyWrapper, LodashWrapper$1 = _LodashWrapper, copyArray$3 = _copyArray;
+function wrapperClone$1(wrapper) {
+  if (wrapper instanceof LazyWrapper$2) {
+    return wrapper.clone();
+  }
+  var result = new LodashWrapper$1(wrapper.__wrapped__, wrapper.__chain__);
+  result.__actions__ = copyArray$3(wrapper.__actions__);
+  result.__index__ = wrapper.__index__;
+  result.__values__ = wrapper.__values__;
+  return result;
+}
+var _wrapperClone = wrapperClone$1;
+var LazyWrapper$1 = _LazyWrapper, LodashWrapper = _LodashWrapper, baseLodash = _baseLodash, isArray$8 = isArray_1, isObjectLike$9 = isObjectLike_1, wrapperClone = _wrapperClone;
+var objectProto$a = Object.prototype;
+var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
+function lodash$1(value) {
+  if (isObjectLike$9(value) && !isArray$8(value) && !(value instanceof LazyWrapper$1)) {
+    if (value instanceof LodashWrapper) {
+      return value;
+    }
+    if (hasOwnProperty$8.call(value, "__wrapped__")) {
+      return wrapperClone(value);
+    }
+  }
+  return new LodashWrapper(value);
+}
+lodash$1.prototype = baseLodash.prototype;
+lodash$1.prototype.constructor = lodash$1;
+var wrapperLodash = lodash$1;
+var LazyWrapper = _LazyWrapper, getData$1 = _getData, getFuncName = _getFuncName, lodash = wrapperLodash;
+function isLaziable$1(func2) {
+  var funcName = getFuncName(func2), other = lodash[funcName];
+  if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) {
+    return false;
+  }
+  if (func2 === other) {
+    return true;
+  }
+  var data = getData$1(other);
+  return !!data && func2 === data[0];
+}
+var _isLaziable = isLaziable$1;
+var HOT_COUNT = 800, HOT_SPAN = 16;
+var nativeNow = Date.now;
+function shortOut$2(func2) {
+  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 func2.apply(void 0, arguments);
+  };
+}
+var _shortOut = shortOut$2;
+var baseSetData$1 = _baseSetData, shortOut$1 = _shortOut;
+var setData$2 = shortOut$1(baseSetData$1);
+var _setData = setData$2;
+var reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, reSplitDetails = /,? & /;
+function getWrapDetails$1(source) {
+  var match = source.match(reWrapDetails);
+  return match ? match[1].split(reSplitDetails) : [];
+}
+var _getWrapDetails = getWrapDetails$1;
+var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/;
+function insertWrapDetails$1(source, details) {
+  var length = details.length;
+  if (!length) {
+    return source;
+  }
+  var lastIndex = length - 1;
+  details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex];
+  details = details.join(length > 2 ? ", " : " ");
+  return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n");
+}
+var _insertWrapDetails = insertWrapDetails$1;
+function constant$1(value) {
+  return function() {
+    return value;
+  };
+}
+var constant_1 = constant$1;
+var getNative$3 = _getNative;
+var defineProperty$2 = function() {
+  try {
+    var func2 = getNative$3(Object, "defineProperty");
+    func2({}, "", {});
+    return func2;
+  } catch (e) {
+  }
+}();
+var _defineProperty = defineProperty$2;
+var constant = constant_1, defineProperty$1 = _defineProperty, identity$1 = identity_1;
+var baseSetToString$1 = !defineProperty$1 ? identity$1 : function(func2, string) {
+  return defineProperty$1(func2, "toString", {
+    "configurable": true,
+    "enumerable": false,
+    "value": constant(string),
+    "writable": true
+  });
+};
+var _baseSetToString = baseSetToString$1;
+var baseSetToString = _baseSetToString, shortOut = _shortOut;
+var setToString$2 = shortOut(baseSetToString);
+var _setToString = setToString$2;
+function arrayEach$2(array, iteratee2) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (iteratee2(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+var _arrayEach = arrayEach$2;
+function baseFindIndex$1(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;
+}
+var _baseFindIndex = baseFindIndex$1;
+function baseIsNaN$1(value) {
+  return value !== value;
+}
+var _baseIsNaN = baseIsNaN$1;
+function strictIndexOf$1(array, value, fromIndex) {
+  var index = fromIndex - 1, length = array.length;
+  while (++index < length) {
+    if (array[index] === value) {
+      return index;
+    }
+  }
+  return -1;
+}
+var _strictIndexOf = strictIndexOf$1;
+var baseFindIndex = _baseFindIndex, baseIsNaN = _baseIsNaN, strictIndexOf = _strictIndexOf;
+function baseIndexOf$1(array, value, fromIndex) {
+  return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
+}
+var _baseIndexOf = baseIndexOf$1;
+var baseIndexOf = _baseIndexOf;
+function arrayIncludes$1(array, value) {
+  var length = array == null ? 0 : array.length;
+  return !!length && baseIndexOf(array, value, 0) > -1;
+}
+var _arrayIncludes = arrayIncludes$1;
+var arrayEach$1 = _arrayEach, arrayIncludes = _arrayIncludes;
+var WRAP_BIND_FLAG$5 = 1, WRAP_BIND_KEY_FLAG$4 = 2, WRAP_CURRY_FLAG$5 = 8, WRAP_CURRY_RIGHT_FLAG$2 = 16, WRAP_PARTIAL_FLAG$2 = 32, WRAP_PARTIAL_RIGHT_FLAG$2 = 64, WRAP_ARY_FLAG$3 = 128, WRAP_REARG_FLAG$2 = 256, WRAP_FLIP_FLAG$1 = 512;
+var wrapFlags = [
+  ["ary", WRAP_ARY_FLAG$3],
+  ["bind", WRAP_BIND_FLAG$5],
+  ["bindKey", WRAP_BIND_KEY_FLAG$4],
+  ["curry", WRAP_CURRY_FLAG$5],
+  ["curryRight", WRAP_CURRY_RIGHT_FLAG$2],
+  ["flip", WRAP_FLIP_FLAG$1],
+  ["partial", WRAP_PARTIAL_FLAG$2],
+  ["partialRight", WRAP_PARTIAL_RIGHT_FLAG$2],
+  ["rearg", WRAP_REARG_FLAG$2]
+];
+function updateWrapDetails$1(details, bitmask) {
+  arrayEach$1(wrapFlags, function(pair) {
+    var value = "_." + pair[0];
+    if (bitmask & pair[1] && !arrayIncludes(details, value)) {
+      details.push(value);
+    }
+  });
+  return details.sort();
+}
+var _updateWrapDetails = updateWrapDetails$1;
+var getWrapDetails = _getWrapDetails, insertWrapDetails = _insertWrapDetails, setToString$1 = _setToString, updateWrapDetails = _updateWrapDetails;
+function setWrapToString$2(wrapper, reference, bitmask) {
+  var source = reference + "";
+  return setToString$1(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
+}
+var _setWrapToString = setWrapToString$2;
+var isLaziable = _isLaziable, setData$1 = _setData, setWrapToString$1 = _setWrapToString;
+var WRAP_BIND_FLAG$4 = 1, WRAP_BIND_KEY_FLAG$3 = 2, WRAP_CURRY_BOUND_FLAG$1 = 4, WRAP_CURRY_FLAG$4 = 8, WRAP_PARTIAL_FLAG$1 = 32, WRAP_PARTIAL_RIGHT_FLAG$1 = 64;
+function createRecurry$2(func2, bitmask, wrapFunc, placeholder2, thisArg, partials, holders, argPos, ary2, arity) {
+  var isCurry = bitmask & WRAP_CURRY_FLAG$4, newHolders = isCurry ? holders : void 0, newHoldersRight = isCurry ? void 0 : holders, newPartials = isCurry ? partials : void 0, newPartialsRight = isCurry ? void 0 : partials;
+  bitmask |= isCurry ? WRAP_PARTIAL_FLAG$1 : WRAP_PARTIAL_RIGHT_FLAG$1;
+  bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG$1 : WRAP_PARTIAL_FLAG$1);
+  if (!(bitmask & WRAP_CURRY_BOUND_FLAG$1)) {
+    bitmask &= ~(WRAP_BIND_FLAG$4 | WRAP_BIND_KEY_FLAG$3);
+  }
+  var newData = [
+    func2,
+    bitmask,
+    thisArg,
+    newPartials,
+    newHolders,
+    newPartialsRight,
+    newHoldersRight,
+    argPos,
+    ary2,
+    arity
+  ];
+  var result = wrapFunc.apply(void 0, newData);
+  if (isLaziable(func2)) {
+    setData$1(result, newData);
+  }
+  result.placeholder = placeholder2;
+  return setWrapToString$1(result, func2, bitmask);
+}
+var _createRecurry = createRecurry$2;
+function getHolder$2(func2) {
+  var object = func2;
+  return object.placeholder;
+}
+var _getHolder = getHolder$2;
+var _isIndex;
+var hasRequired_isIndex;
+function require_isIndex() {
+  if (hasRequired_isIndex)
+    return _isIndex;
+  hasRequired_isIndex = 1;
+  var MAX_SAFE_INTEGER2 = 9007199254740991;
+  var reIsUint = /^(?:0|[1-9]\d*)$/;
+  function isIndex2(value, length) {
+    var type = typeof value;
+    length = length == null ? MAX_SAFE_INTEGER2 : length;
+    return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+  }
+  _isIndex = isIndex2;
+  return _isIndex;
+}
+var copyArray$2 = _copyArray, isIndex$2 = require_isIndex();
+var nativeMin$1 = Math.min;
+function reorder$1(array, indexes) {
+  var arrLength = array.length, length = nativeMin$1(indexes.length, arrLength), oldArray = copyArray$2(array);
+  while (length--) {
+    var index = indexes[length];
+    array[length] = isIndex$2(index, arrLength) ? oldArray[index] : void 0;
+  }
+  return array;
+}
+var _reorder = reorder$1;
+var PLACEHOLDER$1 = "__lodash_placeholder__";
+function replaceHolders$3(array, placeholder2) {
+  var index = -1, length = array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (value === placeholder2 || value === PLACEHOLDER$1) {
+      array[index] = PLACEHOLDER$1;
+      result[resIndex++] = index;
+    }
+  }
+  return result;
+}
+var _replaceHolders = replaceHolders$3;
+var composeArgs$1 = _composeArgs, composeArgsRight$1 = _composeArgsRight, countHolders = _countHolders, createCtor$2 = _createCtor, createRecurry$1 = _createRecurry, getHolder$1 = _getHolder, reorder = _reorder, replaceHolders$2 = _replaceHolders, root$6 = _root;
+var WRAP_BIND_FLAG$3 = 1, WRAP_BIND_KEY_FLAG$2 = 2, WRAP_CURRY_FLAG$3 = 8, WRAP_CURRY_RIGHT_FLAG$1 = 16, WRAP_ARY_FLAG$2 = 128, WRAP_FLIP_FLAG = 512;
+function createHybrid$2(func2, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary2, arity) {
+  var isAry = bitmask & WRAP_ARY_FLAG$2, isBind = bitmask & WRAP_BIND_FLAG$3, isBindKey = bitmask & WRAP_BIND_KEY_FLAG$2, isCurried = bitmask & (WRAP_CURRY_FLAG$3 | WRAP_CURRY_RIGHT_FLAG$1), isFlip = bitmask & WRAP_FLIP_FLAG, Ctor = isBindKey ? void 0 : createCtor$2(func2);
+  function wrapper() {
+    var length = arguments.length, args = Array(length), index = length;
+    while (index--) {
+      args[index] = arguments[index];
+    }
+    if (isCurried) {
+      var placeholder2 = getHolder$1(wrapper), holdersCount = countHolders(args, placeholder2);
+    }
+    if (partials) {
+      args = composeArgs$1(args, partials, holders, isCurried);
+    }
+    if (partialsRight) {
+      args = composeArgsRight$1(args, partialsRight, holdersRight, isCurried);
+    }
+    length -= holdersCount;
+    if (isCurried && length < arity) {
+      var newHolders = replaceHolders$2(args, placeholder2);
+      return createRecurry$1(
+        func2,
+        bitmask,
+        createHybrid$2,
+        wrapper.placeholder,
+        thisArg,
+        args,
+        newHolders,
+        argPos,
+        ary2,
+        arity - length
+      );
+    }
+    var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func2] : func2;
+    length = args.length;
+    if (argPos) {
+      args = reorder(args, argPos);
+    } else if (isFlip && length > 1) {
+      args.reverse();
+    }
+    if (isAry && ary2 < length) {
+      args.length = ary2;
+    }
+    if (this && this !== root$6 && this instanceof wrapper) {
+      fn = Ctor || createCtor$2(fn);
+    }
+    return fn.apply(thisBinding, args);
+  }
+  return wrapper;
+}
+var _createHybrid = createHybrid$2;
+var apply$2 = _apply, createCtor$1 = _createCtor, createHybrid$1 = _createHybrid, createRecurry = _createRecurry, getHolder = _getHolder, replaceHolders$1 = _replaceHolders, root$5 = _root;
+function createCurry$1(func2, bitmask, arity) {
+  var Ctor = createCtor$1(func2);
+  function wrapper() {
+    var length = arguments.length, args = Array(length), index = length, placeholder2 = getHolder(wrapper);
+    while (index--) {
+      args[index] = arguments[index];
+    }
+    var holders = length < 3 && args[0] !== placeholder2 && args[length - 1] !== placeholder2 ? [] : replaceHolders$1(args, placeholder2);
+    length -= holders.length;
+    if (length < arity) {
+      return createRecurry(
+        func2,
+        bitmask,
+        createHybrid$1,
+        wrapper.placeholder,
+        void 0,
+        args,
+        holders,
+        void 0,
+        void 0,
+        arity - length
+      );
+    }
+    var fn = this && this !== root$5 && this instanceof wrapper ? Ctor : func2;
+    return apply$2(fn, this, args);
+  }
+  return wrapper;
+}
+var _createCurry = createCurry$1;
+var apply$1 = _apply, createCtor = _createCtor, root$4 = _root;
+var WRAP_BIND_FLAG$2 = 1;
+function createPartial$1(func2, bitmask, thisArg, partials) {
+  var isBind = bitmask & WRAP_BIND_FLAG$2, Ctor = createCtor(func2);
+  function wrapper() {
+    var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array(leftLength + argsLength), fn = this && this !== root$4 && this instanceof wrapper ? Ctor : func2;
+    while (++leftIndex < leftLength) {
+      args[leftIndex] = partials[leftIndex];
+    }
+    while (argsLength--) {
+      args[leftIndex++] = arguments[++argsIndex];
+    }
+    return apply$1(fn, isBind ? thisArg : this, args);
+  }
+  return wrapper;
+}
+var _createPartial = createPartial$1;
+var composeArgs = _composeArgs, composeArgsRight = _composeArgsRight, replaceHolders = _replaceHolders;
+var PLACEHOLDER = "__lodash_placeholder__";
+var WRAP_BIND_FLAG$1 = 1, WRAP_BIND_KEY_FLAG$1 = 2, WRAP_CURRY_BOUND_FLAG = 4, WRAP_CURRY_FLAG$2 = 8, WRAP_ARY_FLAG$1 = 128, WRAP_REARG_FLAG$1 = 256;
+var nativeMin = Math.min;
+function mergeData$1(data, source) {
+  var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG$1 | WRAP_BIND_KEY_FLAG$1 | WRAP_ARY_FLAG$1);
+  var isCombo = srcBitmask == WRAP_ARY_FLAG$1 && bitmask == WRAP_CURRY_FLAG$2 || srcBitmask == WRAP_ARY_FLAG$1 && bitmask == WRAP_REARG_FLAG$1 && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG$1 | WRAP_REARG_FLAG$1) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG$2;
+  if (!(isCommon || isCombo)) {
+    return data;
+  }
+  if (srcBitmask & WRAP_BIND_FLAG$1) {
+    data[2] = source[2];
+    newBitmask |= bitmask & WRAP_BIND_FLAG$1 ? 0 : WRAP_CURRY_BOUND_FLAG;
+  }
+  var value = source[3];
+  if (value) {
+    var partials = data[3];
+    data[3] = partials ? composeArgs(partials, value, source[4]) : value;
+    data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
+  }
+  value = source[5];
+  if (value) {
+    partials = data[5];
+    data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
+    data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
+  }
+  value = source[7];
+  if (value) {
+    data[7] = value;
+  }
+  if (srcBitmask & WRAP_ARY_FLAG$1) {
+    data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
+  }
+  if (data[9] == null) {
+    data[9] = source[9];
+  }
+  data[0] = source[0];
+  data[1] = newBitmask;
+  return data;
+}
+var _mergeData = mergeData$1;
+var reWhitespace = /\s/;
+function trimmedEndIndex$1(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {
+  }
+  return index;
+}
+var _trimmedEndIndex = trimmedEndIndex$1;
+var trimmedEndIndex = _trimmedEndIndex;
+var reTrimStart = /^\s+/;
+function baseTrim$1(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+var _baseTrim = baseTrim$1;
+var baseTrim = _baseTrim, isObject$3 = isObject_1, isSymbol$1 = isSymbol_1;
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber$1(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol$1(value)) {
+    return NAN;
+  }
+  if (isObject$3(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject$3(other) ? other + "" : other;
+  }
+  if (typeof value != "string") {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var toNumber_1 = toNumber$1;
+var toNumber = toNumber_1;
+var INFINITY = 1 / 0, MAX_INTEGER = 17976931348623157e292;
+function toFinite$1(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber(value);
+  if (value === INFINITY || value === -INFINITY) {
+    var sign = value < 0 ? -1 : 1;
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+var toFinite_1 = toFinite$1;
+var toFinite = toFinite_1;
+function toInteger$1(value) {
+  var result = toFinite(value), remainder = result % 1;
+  return result === result ? remainder ? result - remainder : result : 0;
+}
+var toInteger_1 = toInteger$1;
+var baseSetData = _baseSetData, createBind = _createBind, createCurry = _createCurry, createHybrid = _createHybrid, createPartial = _createPartial, getData = _getData, mergeData = _mergeData, setData = _setData, setWrapToString = _setWrapToString, toInteger = toInteger_1;
+var FUNC_ERROR_TEXT = "Expected a function";
+var WRAP_BIND_FLAG = 1, WRAP_BIND_KEY_FLAG = 2, WRAP_CURRY_FLAG$1 = 8, WRAP_CURRY_RIGHT_FLAG = 16, WRAP_PARTIAL_FLAG = 32, WRAP_PARTIAL_RIGHT_FLAG = 64;
+var nativeMax$1 = Math.max;
+function createWrap$3(func2, bitmask, thisArg, partials, holders, argPos, ary2, arity) {
+  var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
+  if (!isBindKey && typeof func2 != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var length = partials ? partials.length : 0;
+  if (!length) {
+    bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
+    partials = holders = void 0;
+  }
+  ary2 = ary2 === void 0 ? ary2 : nativeMax$1(toInteger(ary2), 0);
+  arity = arity === void 0 ? arity : toInteger(arity);
+  length -= holders ? holders.length : 0;
+  if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
+    var partialsRight = partials, holdersRight = holders;
+    partials = holders = void 0;
+  }
+  var data = isBindKey ? void 0 : getData(func2);
+  var newData = [
+    func2,
+    bitmask,
+    thisArg,
+    partials,
+    holders,
+    partialsRight,
+    holdersRight,
+    argPos,
+    ary2,
+    arity
+  ];
+  if (data) {
+    mergeData(newData, data);
+  }
+  func2 = newData[0];
+  bitmask = newData[1];
+  thisArg = newData[2];
+  partials = newData[3];
+  holders = newData[4];
+  arity = newData[9] = newData[9] === void 0 ? isBindKey ? 0 : func2.length : nativeMax$1(newData[9] - length, 0);
+  if (!arity && bitmask & (WRAP_CURRY_FLAG$1 | WRAP_CURRY_RIGHT_FLAG)) {
+    bitmask &= ~(WRAP_CURRY_FLAG$1 | WRAP_CURRY_RIGHT_FLAG);
+  }
+  if (!bitmask || bitmask == WRAP_BIND_FLAG) {
+    var result = createBind(func2, bitmask, thisArg);
+  } else if (bitmask == WRAP_CURRY_FLAG$1 || bitmask == WRAP_CURRY_RIGHT_FLAG) {
+    result = createCurry(func2, bitmask, arity);
+  } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
+    result = createPartial(func2, bitmask, thisArg, partials);
+  } else {
+    result = createHybrid.apply(void 0, newData);
+  }
+  var setter = data ? baseSetData : setData;
+  return setWrapToString(setter(result, newData), func2, bitmask);
+}
+var _createWrap = createWrap$3;
+var createWrap$2 = _createWrap;
+var WRAP_ARY_FLAG = 128;
+function ary(func2, n, guard) {
+  n = guard ? void 0 : n;
+  n = func2 && n == null ? func2.length : n;
+  return createWrap$2(func2, WRAP_ARY_FLAG, void 0, void 0, void 0, void 0, n);
+}
+var ary_1 = ary;
+var defineProperty = _defineProperty;
+function baseAssignValue$1(object, key, value) {
+  if (key == "__proto__" && defineProperty) {
+    defineProperty(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+var _baseAssignValue = baseAssignValue$1;
+var _assignValue;
+var hasRequired_assignValue;
+function require_assignValue() {
+  if (hasRequired_assignValue)
+    return _assignValue;
+  hasRequired_assignValue = 1;
+  var baseAssignValue2 = _baseAssignValue, eq2 = requireEq();
+  var objectProto2 = Object.prototype;
+  var hasOwnProperty2 = objectProto2.hasOwnProperty;
+  function assignValue2(object, key, value) {
+    var objValue = object[key];
+    if (!(hasOwnProperty2.call(object, key) && eq2(objValue, value)) || value === void 0 && !(key in object)) {
+      baseAssignValue2(object, key, value);
+    }
+  }
+  _assignValue = assignValue2;
+  return _assignValue;
+}
+var assignValue$1 = require_assignValue(), baseAssignValue = _baseAssignValue;
+function copyObject$4(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+  var index = -1, length = props.length;
+  while (++index < length) {
+    var key = props[index];
+    var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
+    if (newValue === void 0) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue$1(object, key, newValue);
+    }
+  }
+  return object;
+}
+var _copyObject = copyObject$4;
+function baseTimes$1(n, iteratee2) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee2(index);
+  }
+  return result;
+}
+var _baseTimes = baseTimes$1;
+var baseGetTag$4 = _baseGetTag, isObjectLike$8 = isObjectLike_1;
+var argsTag$3 = "[object Arguments]";
+function baseIsArguments$1(value) {
+  return isObjectLike$8(value) && baseGetTag$4(value) == argsTag$3;
+}
+var _baseIsArguments = baseIsArguments$1;
+var baseIsArguments = _baseIsArguments, isObjectLike$7 = isObjectLike_1;
+var objectProto$9 = Object.prototype;
+var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
+var propertyIsEnumerable$1 = objectProto$9.propertyIsEnumerable;
+var isArguments$3 = baseIsArguments(function() {
+  return arguments;
+}()) ? baseIsArguments : function(value) {
+  return isObjectLike$7(value) && hasOwnProperty$7.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
+};
+var isArguments_1 = isArguments$3;
+var isBufferExports = {};
+var isBuffer$3 = {
+  get exports() {
+    return isBufferExports;
+  },
+  set exports(v) {
+    isBufferExports = v;
+  }
+};
+function stubFalse() {
+  return false;
+}
+var stubFalse_1 = stubFalse;
+(function(module, exports) {
+  var root2 = _root, stubFalse2 = stubFalse_1;
+  var freeExports = exports && !exports.nodeType && exports;
+  var freeModule = freeExports && true && module && !module.nodeType && module;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var Buffer = moduleExports ? root2.Buffer : void 0;
+  var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+  var isBuffer2 = nativeIsBuffer || stubFalse2;
+  module.exports = isBuffer2;
+})(isBuffer$3, isBufferExports);
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength$3(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+var isLength_1 = isLength$3;
+var baseGetTag$3 = _baseGetTag, isLength$2 = isLength_1, isObjectLike$6 = isObjectLike_1;
+var argsTag$2 = "[object Arguments]", arrayTag$2 = "[object Array]", boolTag$3 = "[object Boolean]", dateTag$3 = "[object Date]", errorTag$3 = "[object Error]", funcTag$1 = "[object Function]", mapTag$5 = "[object Map]", numberTag$3 = "[object Number]", objectTag$4 = "[object Object]", regexpTag$3 = "[object RegExp]", setTag$5 = "[object Set]", stringTag$3 = "[object String]", weakMapTag$3 = "[object WeakMap]";
+var arrayBufferTag$3 = "[object ArrayBuffer]", dataViewTag$4 = "[object DataView]", float32Tag$2 = "[object Float32Array]", float64Tag$2 = "[object Float64Array]", int8Tag$2 = "[object Int8Array]", int16Tag$2 = "[object Int16Array]", int32Tag$2 = "[object Int32Array]", uint8Tag$2 = "[object Uint8Array]", uint8ClampedTag$2 = "[object Uint8ClampedArray]", uint16Tag$2 = "[object Uint16Array]", uint32Tag$2 = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] = typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] = typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] = typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] = typedArrayTags[uint32Tag$2] = true;
+typedArrayTags[argsTag$2] = typedArrayTags[arrayTag$2] = typedArrayTags[arrayBufferTag$3] = typedArrayTags[boolTag$3] = typedArrayTags[dataViewTag$4] = typedArrayTags[dateTag$3] = typedArrayTags[errorTag$3] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$5] = typedArrayTags[numberTag$3] = typedArrayTags[objectTag$4] = typedArrayTags[regexpTag$3] = typedArrayTags[setTag$5] = typedArrayTags[stringTag$3] = typedArrayTags[weakMapTag$3] = false;
+function baseIsTypedArray$1(value) {
+  return isObjectLike$6(value) && isLength$2(value.length) && !!typedArrayTags[baseGetTag$3(value)];
+}
+var _baseIsTypedArray = baseIsTypedArray$1;
+function baseUnary$3(func2) {
+  return function(value) {
+    return func2(value);
+  };
+}
+var _baseUnary = baseUnary$3;
+var _nodeUtilExports = {};
+var _nodeUtil = {
+  get exports() {
+    return _nodeUtilExports;
+  },
+  set exports(v) {
+    _nodeUtilExports = v;
+  }
+};
+(function(module, exports) {
+  var freeGlobal2 = _freeGlobal;
+  var freeExports = exports && !exports.nodeType && exports;
+  var freeModule = freeExports && true && module && !module.nodeType && module;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var freeProcess = moduleExports && freeGlobal2.process;
+  var nodeUtil2 = 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 = nodeUtil2;
+})(_nodeUtil, _nodeUtilExports);
+var baseIsTypedArray = _baseIsTypedArray, baseUnary$2 = _baseUnary, nodeUtil$2 = _nodeUtilExports;
+var nodeIsTypedArray = nodeUtil$2 && nodeUtil$2.isTypedArray;
+var isTypedArray$2 = nodeIsTypedArray ? baseUnary$2(nodeIsTypedArray) : baseIsTypedArray;
+var isTypedArray_1 = isTypedArray$2;
+var baseTimes = _baseTimes, isArguments$2 = isArguments_1, isArray$7 = isArray_1, isBuffer$2 = isBufferExports, isIndex$1 = require_isIndex(), isTypedArray$1 = isTypedArray_1;
+var objectProto$8 = Object.prototype;
+var hasOwnProperty$6 = objectProto$8.hasOwnProperty;
+function arrayLikeKeys$2(value, inherited) {
+  var isArr = isArray$7(value), isArg = !isArr && isArguments$2(value), isBuff = !isArr && !isArg && isBuffer$2(value), isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty$6.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$1(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _arrayLikeKeys = arrayLikeKeys$2;
+var objectProto$7 = Object.prototype;
+function isPrototype$3(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$7;
+  return value === proto;
+}
+var _isPrototype = isPrototype$3;
+function overArg$2(func2, transform) {
+  return function(arg) {
+    return func2(transform(arg));
+  };
+}
+var _overArg = overArg$2;
+var overArg$1 = _overArg;
+var nativeKeys$1 = overArg$1(Object.keys, Object);
+var _nativeKeys = nativeKeys$1;
+var isPrototype$2 = _isPrototype, nativeKeys = _nativeKeys;
+var objectProto$6 = Object.prototype;
+var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+function baseKeys$1(object) {
+  if (!isPrototype$2(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$5.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _baseKeys = baseKeys$1;
+var isFunction$1 = isFunction_1, isLength$1 = isLength_1;
+function isArrayLike$2(value) {
+  return value != null && isLength$1(value.length) && !isFunction$1(value);
+}
+var isArrayLike_1 = isArrayLike$2;
+var arrayLikeKeys$1 = _arrayLikeKeys, baseKeys = _baseKeys, isArrayLike$1 = isArrayLike_1;
+function keys$4(object) {
+  return isArrayLike$1(object) ? arrayLikeKeys$1(object) : baseKeys(object);
+}
+var keys_1 = keys$4;
+var copyObject$3 = _copyObject, keys$3 = keys_1;
+function baseAssign$1(object, source) {
+  return object && copyObject$3(source, keys$3(source), object);
+}
+var _baseAssign = baseAssign$1;
+var ListCache$2 = _ListCache;
+function stackClear$1() {
+  this.__data__ = new ListCache$2();
+  this.size = 0;
+}
+var _stackClear = stackClear$1;
+function stackDelete$1(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var _stackDelete = stackDelete$1;
+function stackGet$1(key) {
+  return this.__data__.get(key);
+}
+var _stackGet = stackGet$1;
+function stackHas$1(key) {
+  return this.__data__.has(key);
+}
+var _stackHas = stackHas$1;
+var ListCache$1 = _ListCache, Map$2 = _Map, MapCache$1 = _MapCache;
+var LARGE_ARRAY_SIZE = 200;
+function stackSet$1(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache$1) {
+    var pairs = data.__data__;
+    if (!Map$2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache$1(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var _stackSet = stackSet$1;
+var ListCache = _ListCache, stackClear = _stackClear, stackDelete = _stackDelete, stackGet = _stackGet, stackHas = _stackHas, stackSet = _stackSet;
+function Stack$3(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack$3.prototype.clear = stackClear;
+Stack$3.prototype["delete"] = stackDelete;
+Stack$3.prototype.get = stackGet;
+Stack$3.prototype.has = stackHas;
+Stack$3.prototype.set = stackSet;
+var _Stack = Stack$3;
+function nativeKeysIn$1(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _nativeKeysIn = nativeKeysIn$1;
+var isObject$2 = isObject_1, isPrototype$1 = _isPrototype, nativeKeysIn = _nativeKeysIn;
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+function baseKeysIn$1(object) {
+  if (!isObject$2(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype$1(object), result = [];
+  for (var key in object) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty$4.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _baseKeysIn = baseKeysIn$1;
+var arrayLikeKeys = _arrayLikeKeys, baseKeysIn = _baseKeysIn, isArrayLike = isArrayLike_1;
+function keysIn$3(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+var keysIn_1 = keysIn$3;
+var copyObject$2 = _copyObject, keysIn$2 = keysIn_1;
+function baseAssignIn$1(object, source) {
+  return object && copyObject$2(source, keysIn$2(source), object);
+}
+var _baseAssignIn = baseAssignIn$1;
+var _cloneBufferExports = {};
+var _cloneBuffer = {
+  get exports() {
+    return _cloneBufferExports;
+  },
+  set exports(v) {
+    _cloneBufferExports = v;
+  }
+};
+(function(module, exports) {
+  var root2 = _root;
+  var freeExports = exports && !exports.nodeType && exports;
+  var freeModule = freeExports && true && module && !module.nodeType && module;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var Buffer = moduleExports ? root2.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+  function cloneBuffer2(buffer, isDeep) {
+    if (isDeep) {
+      return buffer.slice();
+    }
+    var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+    buffer.copy(result);
+    return result;
+  }
+  module.exports = cloneBuffer2;
+})(_cloneBuffer, _cloneBufferExports);
+function arrayFilter$1(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;
+}
+var _arrayFilter = arrayFilter$1;
+function stubArray$2() {
+  return [];
+}
+var stubArray_1 = stubArray$2;
+var arrayFilter = _arrayFilter, stubArray$1 = stubArray_1;
+var objectProto$4 = Object.prototype;
+var propertyIsEnumerable = objectProto$4.propertyIsEnumerable;
+var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
+var getSymbols$3 = !nativeGetSymbols$1 ? stubArray$1 : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols$1(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+var _getSymbols = getSymbols$3;
+var copyObject$1 = _copyObject, getSymbols$2 = _getSymbols;
+function copySymbols$1(source, object) {
+  return copyObject$1(source, getSymbols$2(source), object);
+}
+var _copySymbols = copySymbols$1;
+function arrayPush$3(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var _arrayPush = arrayPush$3;
+var overArg = _overArg;
+var getPrototype$3 = overArg(Object.getPrototypeOf, Object);
+var _getPrototype = getPrototype$3;
+var arrayPush$2 = _arrayPush, getPrototype$2 = _getPrototype, getSymbols$1 = _getSymbols, stubArray = stubArray_1;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbolsIn$2 = !nativeGetSymbols ? stubArray : function(object) {
+  var result = [];
+  while (object) {
+    arrayPush$2(result, getSymbols$1(object));
+    object = getPrototype$2(object);
+  }
+  return result;
+};
+var _getSymbolsIn = getSymbolsIn$2;
+var copyObject = _copyObject, getSymbolsIn$1 = _getSymbolsIn;
+function copySymbolsIn$1(source, object) {
+  return copyObject(source, getSymbolsIn$1(source), object);
+}
+var _copySymbolsIn = copySymbolsIn$1;
+var arrayPush$1 = _arrayPush, isArray$6 = isArray_1;
+function baseGetAllKeys$2(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray$6(object) ? result : arrayPush$1(result, symbolsFunc(object));
+}
+var _baseGetAllKeys = baseGetAllKeys$2;
+var baseGetAllKeys$1 = _baseGetAllKeys, getSymbols = _getSymbols, keys$2 = keys_1;
+function getAllKeys$2(object) {
+  return baseGetAllKeys$1(object, keys$2, getSymbols);
+}
+var _getAllKeys = getAllKeys$2;
+var baseGetAllKeys = _baseGetAllKeys, getSymbolsIn = _getSymbolsIn, keysIn$1 = keysIn_1;
+function getAllKeysIn$1(object) {
+  return baseGetAllKeys(object, keysIn$1, getSymbolsIn);
+}
+var _getAllKeysIn = getAllKeysIn$1;
+var getNative$2 = _getNative, root$3 = _root;
+var DataView$1 = getNative$2(root$3, "DataView");
+var _DataView = DataView$1;
+var getNative$1 = _getNative, root$2 = _root;
+var Promise$2 = getNative$1(root$2, "Promise");
+var _Promise = Promise$2;
+var getNative = _getNative, root$1 = _root;
+var Set$1 = getNative(root$1, "Set");
+var _Set = Set$1;
+var DataView = _DataView, Map$1 = _Map, Promise$1 = _Promise, Set = _Set, WeakMap$1 = _WeakMap, baseGetTag$2 = _baseGetTag, toSource = _toSource;
+var mapTag$4 = "[object Map]", objectTag$3 = "[object Object]", promiseTag = "[object Promise]", setTag$4 = "[object Set]", weakMapTag$2 = "[object WeakMap]";
+var dataViewTag$3 = "[object DataView]";
+var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set), weakMapCtorString = toSource(WeakMap$1);
+var getTag$5 = baseGetTag$2;
+if (DataView && getTag$5(new DataView(new ArrayBuffer(1))) != dataViewTag$3 || Map$1 && getTag$5(new Map$1()) != mapTag$4 || Promise$1 && getTag$5(Promise$1.resolve()) != promiseTag || Set && getTag$5(new Set()) != setTag$4 || WeakMap$1 && getTag$5(new WeakMap$1()) != weakMapTag$2) {
+  getTag$5 = function(value) {
+    var result = baseGetTag$2(value), Ctor = result == objectTag$3 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag$3;
+        case mapCtorString:
+          return mapTag$4;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag$4;
+        case weakMapCtorString:
+          return weakMapTag$2;
+      }
+    }
+    return result;
+  };
+}
+var _getTag = getTag$5;
+var objectProto$3 = Object.prototype;
+var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
+function initCloneArray$1(array) {
+  var length = array.length, result = new array.constructor(length);
+  if (length && typeof array[0] == "string" && hasOwnProperty$3.call(array, "index")) {
+    result.index = array.index;
+    result.input = array.input;
+  }
+  return result;
+}
+var _initCloneArray = initCloneArray$1;
+var root = _root;
+var Uint8Array$2 = root.Uint8Array;
+var _Uint8Array = Uint8Array$2;
+var Uint8Array$1 = _Uint8Array;
+function cloneArrayBuffer$3(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array$1(result).set(new Uint8Array$1(arrayBuffer));
+  return result;
+}
+var _cloneArrayBuffer = cloneArrayBuffer$3;
+var cloneArrayBuffer$2 = _cloneArrayBuffer;
+function cloneDataView$1(dataView, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer$2(dataView.buffer) : dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+var _cloneDataView = cloneDataView$1;
+var reFlags = /\w*$/;
+function cloneRegExp$1(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+var _cloneRegExp = cloneRegExp$1;
+var Symbol$3 = _Symbol;
+var symbolProto$1 = Symbol$3 ? Symbol$3.prototype : void 0, symbolValueOf$1 = symbolProto$1 ? symbolProto$1.valueOf : void 0;
+function cloneSymbol$1(symbol) {
+  return symbolValueOf$1 ? Object(symbolValueOf$1.call(symbol)) : {};
+}
+var _cloneSymbol = cloneSymbol$1;
+var cloneArrayBuffer$1 = _cloneArrayBuffer;
+function cloneTypedArray$1(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer$1(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var _cloneTypedArray = cloneTypedArray$1;
+var cloneArrayBuffer = _cloneArrayBuffer, cloneDataView = _cloneDataView, cloneRegExp = _cloneRegExp, cloneSymbol = _cloneSymbol, cloneTypedArray = _cloneTypedArray;
+var boolTag$2 = "[object Boolean]", dateTag$2 = "[object Date]", mapTag$3 = "[object Map]", numberTag$2 = "[object Number]", regexpTag$2 = "[object RegExp]", setTag$3 = "[object Set]", stringTag$2 = "[object String]", symbolTag$2 = "[object Symbol]";
+var arrayBufferTag$2 = "[object ArrayBuffer]", dataViewTag$2 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
+function initCloneByTag$1(object, tag, isDeep) {
+  var Ctor = object.constructor;
+  switch (tag) {
+    case arrayBufferTag$2:
+      return cloneArrayBuffer(object);
+    case boolTag$2:
+    case dateTag$2:
+      return new Ctor(+object);
+    case dataViewTag$2:
+      return cloneDataView(object, isDeep);
+    case float32Tag$1:
+    case float64Tag$1:
+    case int8Tag$1:
+    case int16Tag$1:
+    case int32Tag$1:
+    case uint8Tag$1:
+    case uint8ClampedTag$1:
+    case uint16Tag$1:
+    case uint32Tag$1:
+      return cloneTypedArray(object, isDeep);
+    case mapTag$3:
+      return new Ctor();
+    case numberTag$2:
+    case stringTag$2:
+      return new Ctor(object);
+    case regexpTag$2:
+      return cloneRegExp(object);
+    case setTag$3:
+      return new Ctor();
+    case symbolTag$2:
+      return cloneSymbol(object);
+  }
+}
+var _initCloneByTag = initCloneByTag$1;
+var baseCreate = _baseCreate, getPrototype$1 = _getPrototype, isPrototype = _isPrototype;
+function initCloneObject$1(object) {
+  return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype$1(object)) : {};
+}
+var _initCloneObject = initCloneObject$1;
+var getTag$4 = _getTag, isObjectLike$5 = isObjectLike_1;
+var mapTag$2 = "[object Map]";
+function baseIsMap$1(value) {
+  return isObjectLike$5(value) && getTag$4(value) == mapTag$2;
+}
+var _baseIsMap = baseIsMap$1;
+var baseIsMap = _baseIsMap, baseUnary$1 = _baseUnary, nodeUtil$1 = _nodeUtilExports;
+var nodeIsMap = nodeUtil$1 && nodeUtil$1.isMap;
+var isMap$1 = nodeIsMap ? baseUnary$1(nodeIsMap) : baseIsMap;
+var isMap_1 = isMap$1;
+var getTag$3 = _getTag, isObjectLike$4 = isObjectLike_1;
+var setTag$2 = "[object Set]";
+function baseIsSet$1(value) {
+  return isObjectLike$4(value) && getTag$3(value) == setTag$2;
+}
+var _baseIsSet = baseIsSet$1;
+var baseIsSet = _baseIsSet, baseUnary = _baseUnary, nodeUtil = _nodeUtilExports;
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+var isSet$1 = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+var isSet_1 = isSet$1;
+var Stack$2 = _Stack, arrayEach = _arrayEach, assignValue = require_assignValue(), baseAssign = _baseAssign, baseAssignIn = _baseAssignIn, cloneBuffer = _cloneBufferExports, copyArray$1 = _copyArray, copySymbols = _copySymbols, copySymbolsIn = _copySymbolsIn, getAllKeys$1 = _getAllKeys, getAllKeysIn = _getAllKeysIn, getTag$2 = _getTag, initCloneArray = _initCloneArray, initCloneByTag = _initCloneByTag, initCloneObject = _initCloneObject, isArray$5 = isArray_1, isBuffer$1 = isBufferExports, isMap = isMap_1, isObject$1 = isObject_1, isSet = isSet_1, keys$1 = keys_1, keysIn = keysIn_1;
+var CLONE_DEEP_FLAG$1 = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG$1 = 4;
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$2 = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag$1 = "[object Map]", numberTag$1 = "[object Number]", objectTag$2 = "[object Object]", regexpTag$1 = "[object RegExp]", setTag$1 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]", weakMapTag$1 = "[object WeakMap]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[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 cloneableTags = {};
+cloneableTags[argsTag$1] = cloneableTags[arrayTag$1] = cloneableTags[arrayBufferTag$1] = cloneableTags[dataViewTag$1] = cloneableTags[boolTag$1] = cloneableTags[dateTag$1] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag$1] = cloneableTags[numberTag$1] = cloneableTags[objectTag$2] = cloneableTags[regexpTag$1] = cloneableTags[setTag$1] = cloneableTags[stringTag$1] = cloneableTags[symbolTag$1] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag$2] = cloneableTags[funcTag] = cloneableTags[weakMapTag$1] = false;
+function baseClone$2(value, bitmask, customizer, key, object, stack) {
+  var result, isDeep = bitmask & CLONE_DEEP_FLAG$1, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG$1;
+  if (customizer) {
+    result = object ? customizer(value, key, object, stack) : customizer(value);
+  }
+  if (result !== void 0) {
+    return result;
+  }
+  if (!isObject$1(value)) {
+    return value;
+  }
+  var isArr = isArray$5(value);
+  if (isArr) {
+    result = initCloneArray(value);
+    if (!isDeep) {
+      return copyArray$1(value, result);
+    }
+  } else {
+    var tag = getTag$2(value), isFunc = tag == funcTag || tag == genTag;
+    if (isBuffer$1(value)) {
+      return cloneBuffer(value, isDeep);
+    }
+    if (tag == objectTag$2 || tag == argsTag$1 || isFunc && !object) {
+      result = isFlat || isFunc ? {} : initCloneObject(value);
+      if (!isDeep) {
+        return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
+      }
+    } else {
+      if (!cloneableTags[tag]) {
+        return object ? value : {};
+      }
+      result = initCloneByTag(value, tag, isDeep);
+    }
+  }
+  stack || (stack = new Stack$2());
+  var stacked = stack.get(value);
+  if (stacked) {
+    return stacked;
+  }
+  stack.set(value, result);
+  if (isSet(value)) {
+    value.forEach(function(subValue) {
+      result.add(baseClone$2(subValue, bitmask, customizer, subValue, value, stack));
+    });
+  } else if (isMap(value)) {
+    value.forEach(function(subValue, key2) {
+      result.set(key2, baseClone$2(subValue, bitmask, customizer, key2, value, stack));
+    });
+  }
+  var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys$1 : isFlat ? keysIn : keys$1;
+  var props = isArr ? void 0 : keysFunc(value);
+  arrayEach(props || value, function(subValue, key2) {
+    if (props) {
+      key2 = subValue;
+      subValue = value[key2];
+    }
+    assignValue(result, key2, baseClone$2(subValue, bitmask, customizer, key2, value, stack));
+  });
+  return result;
+}
+var _baseClone = baseClone$2;
+var baseClone$1 = _baseClone;
+var CLONE_SYMBOLS_FLAG = 4;
+function clone(value) {
+  return baseClone$1(value, CLONE_SYMBOLS_FLAG);
+}
+var clone_1 = clone;
+var createWrap$1 = _createWrap;
+var WRAP_CURRY_FLAG = 8;
+function curry(func2, arity, guard) {
+  arity = guard ? void 0 : arity;
+  var result = createWrap$1(func2, WRAP_CURRY_FLAG, void 0, void 0, void 0, void 0, void 0, arity);
+  result.placeholder = curry.placeholder;
+  return result;
+}
+curry.placeholder = {};
+var curry_1 = curry;
+var baseGetTag$1 = _baseGetTag, getPrototype = _getPrototype, isObjectLike$3 = isObjectLike_1;
+var objectTag$1 = "[object Object]";
+var funcProto = Function.prototype, objectProto$2 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+var objectCtorString = funcToString.call(Object);
+function isPlainObject$1(value) {
+  if (!isObjectLike$3(value) || baseGetTag$1(value) != objectTag$1) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty$2.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+}
+var isPlainObject_1 = isPlainObject$1;
+var baseGetTag = _baseGetTag, isObjectLike$2 = isObjectLike_1, isPlainObject = isPlainObject_1;
+var domExcTag = "[object DOMException]", errorTag$1 = "[object Error]";
+function isError(value) {
+  if (!isObjectLike$2(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == errorTag$1 || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject(value);
+}
+var isError_1 = isError;
+var getTag$1 = _getTag, isObjectLike$1 = isObjectLike_1;
+var weakMapTag = "[object WeakMap]";
+function isWeakMap(value) {
+  return isObjectLike$1(value) && getTag$1(value) == weakMapTag;
+}
+var isWeakMap_1 = isWeakMap;
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function setCacheAdd$1(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+var _setCacheAdd = setCacheAdd$1;
+function setCacheHas$1(value) {
+  return this.__data__.has(value);
+}
+var _setCacheHas = setCacheHas$1;
+var MapCache = _MapCache, setCacheAdd = _setCacheAdd, setCacheHas = _setCacheHas;
+function SetCache$1(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache();
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+SetCache$1.prototype.add = SetCache$1.prototype.push = setCacheAdd;
+SetCache$1.prototype.has = setCacheHas;
+var _SetCache = SetCache$1;
+function arraySome$1(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+var _arraySome = arraySome$1;
+function cacheHas$1(cache2, key) {
+  return cache2.has(key);
+}
+var _cacheHas = cacheHas$1;
+var SetCache = _SetCache, arraySome = _arraySome, cacheHas = _cacheHas;
+var COMPARE_PARTIAL_FLAG$5 = 1, COMPARE_UNORDERED_FLAG$3 = 2;
+function equalArrays$2(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, 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$3 ? 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;
+}
+var _equalArrays = equalArrays$2;
+function mapToArray$1(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+var _mapToArray = mapToArray$1;
+function setToArray$1(set2) {
+  var index = -1, result = Array(set2.size);
+  set2.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var _setToArray = setToArray$1;
+var Symbol$2 = _Symbol, Uint8Array = _Uint8Array, eq = requireEq(), equalArrays$1 = _equalArrays, mapToArray = _mapToArray, setToArray = _setToArray;
+var COMPARE_PARTIAL_FLAG$4 = 1, COMPARE_UNORDERED_FLAG$2 = 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 = Symbol$2 ? Symbol$2.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function equalByTag$1(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 convert2 = mapToArray;
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
+      convert2 || (convert2 = setToArray);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG$2;
+      stack.set(object, other);
+      var result = equalArrays$1(convert2(object), convert2(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+var _equalByTag = equalByTag$1;
+var getAllKeys = _getAllKeys;
+var COMPARE_PARTIAL_FLAG$3 = 1;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function equalObjects$1(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, 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$1.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;
+}
+var _equalObjects = equalObjects$1;
+var Stack$1 = _Stack, equalArrays = _equalArrays, equalByTag = _equalByTag, equalObjects = _equalObjects, getTag = _getTag, isArray$4 = isArray_1, isBuffer = isBufferExports, isTypedArray = isTypedArray_1;
+var COMPARE_PARTIAL_FLAG$2 = 1;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseIsEqualDeep$1(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray$4(object), othIsArr = isArray$4(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 && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack$1());
+    return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
+    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$1());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack$1());
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+var _baseIsEqualDeep = baseIsEqualDeep$1;
+var baseIsEqualDeep = _baseIsEqualDeep, isObjectLike = isObjectLike_1;
+function baseIsEqual$2(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$2, stack);
+}
+var _baseIsEqual = baseIsEqual$2;
+var Stack = _Stack, baseIsEqual$1 = _baseIsEqual;
+var COMPARE_PARTIAL_FLAG$1 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
+function baseIsMatch$1(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$1(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var _baseIsMatch = baseIsMatch$1;
+var isObject = isObject_1;
+function isStrictComparable$2(value) {
+  return value === value && !isObject(value);
+}
+var _isStrictComparable = isStrictComparable$2;
+var isStrictComparable$1 = _isStrictComparable, keys = keys_1;
+function getMatchData$1(object) {
+  var result = keys(object), length = result.length;
+  while (length--) {
+    var key = result[length], value = object[key];
+    result[length] = [key, value, isStrictComparable$1(value)];
+  }
+  return result;
+}
+var _getMatchData = getMatchData$1;
+function matchesStrictComparable$2(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+  };
+}
+var _matchesStrictComparable = matchesStrictComparable$2;
+var baseIsMatch = _baseIsMatch, getMatchData = _getMatchData, matchesStrictComparable$1 = _matchesStrictComparable;
+function baseMatches$1(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable$1(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+var _baseMatches = baseMatches$1;
+function baseHasIn$1(object, key) {
+  return object != null && key in Object(object);
+}
+var _baseHasIn = baseHasIn$1;
+var castPath = _castPath, isArguments$1 = isArguments_1, isArray$3 = isArray_1, isIndex = require_isIndex(), isLength = isLength_1, toKey$3 = _toKey;
+function hasPath$1(object, path, hasFunc) {
+  path = castPath(path, object);
+  var index = -1, length = path.length, result = false;
+  while (++index < length) {
+    var key = toKey$3(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$3(object) || isArguments$1(object));
+}
+var _hasPath = hasPath$1;
+var baseHasIn = _baseHasIn, hasPath = _hasPath;
+function hasIn$1(object, path) {
+  return object != null && hasPath(object, path, baseHasIn);
+}
+var hasIn_1 = hasIn$1;
+var baseIsEqual = _baseIsEqual, get = get_1, hasIn = hasIn_1, isKey$1 = _isKey, isStrictComparable = _isStrictComparable, matchesStrictComparable = _matchesStrictComparable, toKey$2 = _toKey;
+var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+function baseMatchesProperty$1(path, srcValue) {
+  if (isKey$1(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey$2(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);
+  };
+}
+var _baseMatchesProperty = baseMatchesProperty$1;
+function baseProperty$1(key) {
+  return function(object) {
+    return object == null ? void 0 : object[key];
+  };
+}
+var _baseProperty = baseProperty$1;
+var baseGet = _baseGet;
+function basePropertyDeep$1(path) {
+  return function(object) {
+    return baseGet(object, path);
+  };
+}
+var _basePropertyDeep = basePropertyDeep$1;
+var baseProperty = _baseProperty, basePropertyDeep = _basePropertyDeep, isKey = _isKey, toKey$1 = _toKey;
+function property$1(path) {
+  return isKey(path) ? baseProperty(toKey$1(path)) : basePropertyDeep(path);
+}
+var property_1 = property$1;
+var baseMatches = _baseMatches, baseMatchesProperty = _baseMatchesProperty, identity = identity_1, isArray$2 = isArray_1, property = property_1;
+function baseIteratee$1(value) {
+  if (typeof value == "function") {
+    return value;
+  }
+  if (value == null) {
+    return identity;
+  }
+  if (typeof value == "object") {
+    return isArray$2(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+  }
+  return property(value);
+}
+var _baseIteratee = baseIteratee$1;
+var baseClone = _baseClone, baseIteratee = _baseIteratee;
+var CLONE_DEEP_FLAG = 1;
+function iteratee(func2) {
+  return baseIteratee(typeof func2 == "function" ? func2 : baseClone(func2, CLONE_DEEP_FLAG));
+}
+var iteratee_1 = iteratee;
+var Symbol$1 = _Symbol, isArguments = isArguments_1, isArray$1 = isArray_1;
+var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : void 0;
+function isFlattenable$1(value) {
+  return isArray$1(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
+}
+var _isFlattenable = isFlattenable$1;
+var arrayPush = _arrayPush, isFlattenable = _isFlattenable;
+function baseFlatten$1(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$1(value, depth - 1, predicate, isStrict, result);
+      } else {
+        arrayPush(result, value);
+      }
+    } else if (!isStrict) {
+      result[result.length] = value;
+    }
+  }
+  return result;
+}
+var _baseFlatten = baseFlatten$1;
+var baseFlatten = _baseFlatten;
+function flatten$1(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? baseFlatten(array, 1) : [];
+}
+var flatten_1 = flatten$1;
+var apply = _apply;
+var nativeMax = Math.max;
+function overRest$1(func2, start, transform) {
+  start = nativeMax(start === void 0 ? func2.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(func2, this, otherArgs);
+  };
+}
+var _overRest = overRest$1;
+var flatten = flatten_1, overRest = _overRest, setToString = _setToString;
+function flatRest$1(func2) {
+  return setToString(overRest(func2, void 0, flatten), func2 + "");
+}
+var _flatRest = flatRest$1;
+var createWrap = _createWrap, flatRest = _flatRest;
+var WRAP_REARG_FLAG = 256;
+var rearg = flatRest(function(func2, indexes) {
+  return createWrap(func2, WRAP_REARG_FLAG, void 0, void 0, void 0, indexes);
+});
+var rearg_1 = rearg;
+var arrayMap = _arrayMap, copyArray = _copyArray, isArray = isArray_1, isSymbol = isSymbol_1, stringToPath = _stringToPath, toKey = _toKey, toString = toString_1;
+function toPath(value) {
+  if (isArray(value)) {
+    return arrayMap(value, toKey);
+  }
+  return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
+}
+var toPath_1 = toPath;
+var _util = {
+  "ary": ary_1,
+  "assign": _baseAssign,
+  "clone": clone_1,
+  "curry": curry_1,
+  "forEach": _arrayEach,
+  "isArray": isArray_1,
+  "isError": isError_1,
+  "isFunction": isFunction_1,
+  "isWeakMap": isWeakMap_1,
+  "iteratee": iteratee_1,
+  "keys": _baseKeys,
+  "rearg": rearg_1,
+  "toInteger": toInteger_1,
+  "toPath": toPath_1
+};
+var baseConvert = _baseConvert, util = _util;
+function convert$1(name, func2, options) {
+  return baseConvert(util, name, func2, options);
+}
+var convert_1 = convert$1;
+var _baseSet;
+var hasRequired_baseSet;
+function require_baseSet() {
+  if (hasRequired_baseSet)
+    return _baseSet;
+  hasRequired_baseSet = 1;
+  var assignValue2 = require_assignValue(), castPath2 = _castPath, isIndex2 = require_isIndex(), isObject2 = isObject_1, toKey2 = _toKey;
+  function baseSet(object, path, value, customizer) {
+    if (!isObject2(object)) {
+      return object;
+    }
+    path = castPath2(path, object);
+    var index = -1, length = path.length, lastIndex = length - 1, nested = object;
+    while (nested != null && ++index < length) {
+      var key = toKey2(path[index]), newValue = value;
+      if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        return object;
+      }
+      if (index != lastIndex) {
+        var objValue = nested[key];
+        newValue = customizer ? customizer(objValue, key, nested) : void 0;
+        if (newValue === void 0) {
+          newValue = isObject2(objValue) ? objValue : isIndex2(path[index + 1]) ? [] : {};
+        }
+      }
+      assignValue2(nested, key, newValue);
+      nested = nested[key];
+    }
+    return object;
+  }
+  _baseSet = baseSet;
+  return _baseSet;
+}
+var set_1;
+var hasRequiredSet;
+function requireSet() {
+  if (hasRequiredSet)
+    return set_1;
+  hasRequiredSet = 1;
+  var baseSet = require_baseSet();
+  function set2(object, path, value) {
+    return object == null ? object : baseSet(object, path, value);
+  }
+  set_1 = set2;
+  return set_1;
+}
+var convert = convert_1, func = convert("set", requireSet());
+func.placeholder = requirePlaceholder();
+var set = func;
+const formatTimestamp = (obj, props) => {
+  if (props == null)
+    return obj;
+  return props.reduce((result, prop) => {
+    const value = get_1(obj, prop);
+    return set(prop, value != null && value.toDate ? value.toDate() : value, result);
+  }, obj);
+};
+const getFirestoreConverter = (parseDates) => ({
+  fromFirestore(snapshot) {
+    const data = snapshot.data();
+    return {
+      ...formatTimestamp(data, parseDates),
+      ref: snapshot.ref,
+      exists: snapshot.exists,
+      id: snapshot.id
+    };
+  },
+  toFirestore(model) {
+    return model;
+  }
+});
+var shimExports = {};
+var shim = {
+  get exports() {
+    return shimExports;
+  },
+  set exports(v) {
+    shimExports = v;
+  }
+};
+var useSyncExternalStoreShim_production_min = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_production_min;
+function requireUseSyncExternalStoreShim_production_min() {
+  if (hasRequiredUseSyncExternalStoreShim_production_min)
+    return useSyncExternalStoreShim_production_min;
+  hasRequiredUseSyncExternalStoreShim_production_min = 1;
+  var e = React;
+  function h(a, b) {
+    return a === b && (0 !== a || 1 / a === 1 / b) || a !== a && b !== b;
+  }
+  var k = "function" === typeof Object.is ? Object.is : h, l = e.useState, m = e.useEffect, n = e.useLayoutEffect, p = e.useDebugValue;
+  function q(a, b) {
+    var d = b(), f = l({ inst: { value: d, getSnapshot: b } }), c = f[0].inst, g = f[1];
+    n(function() {
+      c.value = d;
+      c.getSnapshot = b;
+      r(c) && g({ inst: c });
+    }, [a, d, b]);
+    m(function() {
+      r(c) && g({ inst: c });
+      return a(function() {
+        r(c) && g({ inst: c });
+      });
+    }, [a]);
+    p(d);
+    return d;
+  }
+  function r(a) {
+    var b = a.getSnapshot;
+    a = a.value;
+    try {
+      var d = b();
+      return !k(a, d);
+    } catch (f) {
+      return true;
+    }
+  }
+  function t(a, b) {
+    return b();
+  }
+  var u = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? t : q;
+  useSyncExternalStoreShim_production_min.useSyncExternalStore = void 0 !== e.useSyncExternalStore ? e.useSyncExternalStore : u;
+  return useSyncExternalStoreShim_production_min;
+}
+var useSyncExternalStoreShim_development = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreShim_development;
+function requireUseSyncExternalStoreShim_development() {
+  if (hasRequiredUseSyncExternalStoreShim_development)
+    return useSyncExternalStoreShim_development;
+  hasRequiredUseSyncExternalStoreShim_development = 1;
+  if (process.env.NODE_ENV !== "production") {
+    (function() {
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      }
+      var React$1 = React;
+      var ReactSharedInternals = React$1.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+      function error(format) {
+        {
+          {
+            for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+              args[_key2 - 1] = arguments[_key2];
+            }
+            printWarning("error", format, args);
+          }
+        }
+      }
+      function printWarning(level, format, args) {
+        {
+          var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+          var stack = ReactDebugCurrentFrame.getStackAddendum();
+          if (stack !== "") {
+            format += "%s";
+            args = args.concat([stack]);
+          }
+          var argsWithFormat = args.map(function(item) {
+            return String(item);
+          });
+          argsWithFormat.unshift("Warning: " + format);
+          Function.prototype.apply.call(console[level], console, argsWithFormat);
+        }
+      }
+      function is(x, y) {
+        return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      var objectIs = typeof Object.is === "function" ? Object.is : is;
+      var useState = React$1.useState, useEffect2 = React$1.useEffect, useLayoutEffect2 = React$1.useLayoutEffect, useDebugValue2 = React$1.useDebugValue;
+      var didWarnOld18Alpha = false;
+      var didWarnUncachedGetSnapshot = false;
+      function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+        {
+          if (!didWarnOld18Alpha) {
+            if (React$1.startTransition !== void 0) {
+              didWarnOld18Alpha = true;
+              error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release.");
+            }
+          }
+        }
+        var value = getSnapshot();
+        {
+          if (!didWarnUncachedGetSnapshot) {
+            var cachedValue = getSnapshot();
+            if (!objectIs(value, cachedValue)) {
+              error("The result of getSnapshot should be cached to avoid an infinite loop");
+              didWarnUncachedGetSnapshot = true;
+            }
+          }
+        }
+        var _useState = useState({
+          inst: {
+            value,
+            getSnapshot
+          }
+        }), inst = _useState[0].inst, forceUpdate = _useState[1];
+        useLayoutEffect2(function() {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({
+              inst
+            });
+          }
+        }, [subscribe, value, getSnapshot]);
+        useEffect2(function() {
+          if (checkIfSnapshotChanged(inst)) {
+            forceUpdate({
+              inst
+            });
+          }
+          var handleStoreChange = function() {
+            if (checkIfSnapshotChanged(inst)) {
+              forceUpdate({
+                inst
+              });
+            }
+          };
+          return subscribe(handleStoreChange);
+        }, [subscribe]);
+        useDebugValue2(value);
+        return value;
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        var prevValue = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(prevValue, nextValue);
+        } catch (error2) {
+          return true;
+        }
+      }
+      function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
+        return getSnapshot();
+      }
+      var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+      var isServerEnvironment = !canUseDOM;
+      var shim2 = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+      var useSyncExternalStore$2 = React$1.useSyncExternalStore !== void 0 ? React$1.useSyncExternalStore : shim2;
+      useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
+      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
+        __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+      }
+    })();
+  }
+  return useSyncExternalStoreShim_development;
+}
+(function(module) {
+  if (process.env.NODE_ENV === "production") {
+    module.exports = requireUseSyncExternalStoreShim_production_min();
+  } else {
+    module.exports = requireUseSyncExternalStoreShim_development();
+  }
+})(shim);
+const SWRGlobalState = /* @__PURE__ */ new WeakMap();
+const EMPTY_CACHE = {};
+const INITIAL_CACHE = {};
+const noop = () => {
+};
+const UNDEFINED = (
+  /*#__NOINLINE__*/
+  noop()
+);
+const OBJECT = Object;
+const isUndefined = (v) => v === UNDEFINED;
+const isFunction = (v) => typeof v == "function";
+const mergeObjects = (a, b) => ({
+  ...a,
+  ...b
+});
+const STR_UNDEFINED = "undefined";
+const isWindowDefined = typeof window != STR_UNDEFINED;
+const isDocumentDefined = typeof document != STR_UNDEFINED;
+const hasRequestAnimationFrame = () => isWindowDefined && typeof window["requestAnimationFrame"] != STR_UNDEFINED;
+const createCacheHelper = (cache2, key) => {
+  const state = SWRGlobalState.get(cache2);
+  return [
+    // Getter
+    () => cache2.get(key) || EMPTY_CACHE,
+    // Setter
+    (info) => {
+      if (!isUndefined(key)) {
+        const prev = cache2.get(key);
+        if (!(key in INITIAL_CACHE)) {
+          INITIAL_CACHE[key] = prev;
+        }
+        state[5](key, mergeObjects(prev, info), prev || EMPTY_CACHE);
+      }
+    },
+    // Subscriber
+    state[6],
+    // Get server cache snapshot
+    () => {
+      if (!isUndefined(key)) {
+        if (key in INITIAL_CACHE)
+          return INITIAL_CACHE[key];
+      }
+      return cache2.get(key) || EMPTY_CACHE;
+    }
+  ];
+};
+const table = /* @__PURE__ */ new WeakMap();
+let counter = 0;
+const stableHash = (arg) => {
+  const type = typeof arg;
+  const constructor = arg && arg.constructor;
+  const isDate = constructor == Date;
+  let result;
+  let index;
+  if (OBJECT(arg) === arg && !isDate && constructor != RegExp) {
+    result = table.get(arg);
+    if (result)
+      return result;
+    result = ++counter + "~";
+    table.set(arg, result);
+    if (constructor == Array) {
+      result = "@";
+      for (index = 0; index < arg.length; index++) {
+        result += stableHash(arg[index]) + ",";
+      }
+      table.set(arg, result);
+    }
+    if (constructor == OBJECT) {
+      result = "#";
+      const keys2 = OBJECT.keys(arg).sort();
+      while (!isUndefined(index = keys2.pop())) {
+        if (!isUndefined(arg[index])) {
+          result += index + ":" + stableHash(arg[index]) + ",";
+        }
+      }
+      table.set(arg, result);
+    }
+  } else {
+    result = isDate ? arg.toJSON() : type == "symbol" ? arg.toString() : type == "string" ? JSON.stringify(arg) : "" + arg;
+  }
+  return result;
+};
+let online = true;
+const isOnline = () => online;
+const [onWindowEvent, offWindowEvent] = isWindowDefined && window.addEventListener ? [
+  window.addEventListener.bind(window),
+  window.removeEventListener.bind(window)
+] : [
+  noop,
+  noop
+];
+const isVisible = () => {
+  const visibilityState = isDocumentDefined && document.visibilityState;
+  return isUndefined(visibilityState) || visibilityState !== "hidden";
+};
+const initFocus = (callback) => {
+  if (isDocumentDefined) {
+    document.addEventListener("visibilitychange", callback);
+  }
+  onWindowEvent("focus", callback);
+  return () => {
+    if (isDocumentDefined) {
+      document.removeEventListener("visibilitychange", callback);
+    }
+    offWindowEvent("focus", callback);
+  };
+};
+const initReconnect = (callback) => {
+  const onOnline = () => {
+    online = true;
+    callback();
+  };
+  const onOffline = () => {
+    online = false;
+  };
+  onWindowEvent("online", onOnline);
+  onWindowEvent("offline", onOffline);
+  return () => {
+    offWindowEvent("online", onOnline);
+    offWindowEvent("offline", onOffline);
+  };
+};
+const preset = {
+  isOnline,
+  isVisible
+};
+const defaultConfigOptions = {
+  initFocus,
+  initReconnect
+};
+const IS_REACT_LEGACY = !React.useId;
+const IS_SERVER = !isWindowDefined || "Deno" in window;
+const rAF = (f) => hasRequestAnimationFrame() ? window["requestAnimationFrame"](f) : setTimeout(f, 1);
+const useIsomorphicLayoutEffect = IS_SERVER ? useEffect : useLayoutEffect;
+const navigatorConnection = typeof navigator !== "undefined" && navigator.connection;
+const slowConnection = !IS_SERVER && navigatorConnection && ([
+  "slow-2g",
+  "2g"
+].includes(navigatorConnection.effectiveType) || navigatorConnection.saveData);
+const serialize = (key) => {
+  if (isFunction(key)) {
+    try {
+      key = key();
+    } catch (err) {
+      key = "";
+    }
+  }
+  const args = key;
+  key = typeof key == "string" ? key : (Array.isArray(key) ? key.length : key) ? stableHash(key) : "";
+  return [
+    key,
+    args
+  ];
+};
+let __timestamp = 0;
+const getTimestamp = () => ++__timestamp;
+const FOCUS_EVENT = 0;
+const RECONNECT_EVENT = 1;
+const MUTATE_EVENT = 2;
+const ERROR_REVALIDATE_EVENT = 3;
+var constants = {
+  __proto__: null,
+  FOCUS_EVENT,
+  RECONNECT_EVENT,
+  MUTATE_EVENT,
+  ERROR_REVALIDATE_EVENT
+};
+async function internalMutate(...args) {
+  const [cache2, _key, _data, _opts] = args;
+  const options = mergeObjects({
+    populateCache: true,
+    throwOnError: true
+  }, typeof _opts === "boolean" ? {
+    revalidate: _opts
+  } : _opts || {});
+  let populateCache = options.populateCache;
+  const rollbackOnErrorOption = options.rollbackOnError;
+  let optimisticData = options.optimisticData;
+  const revalidate = options.revalidate !== false;
+  const rollbackOnError = (error) => {
+    return typeof rollbackOnErrorOption === "function" ? rollbackOnErrorOption(error) : rollbackOnErrorOption !== false;
+  };
+  const throwOnError = options.throwOnError;
+  if (isFunction(_key)) {
+    const keyFilter = _key;
+    const matchedKeys = [];
+    const it = cache2.keys();
+    for (let keyIt = it.next(); !keyIt.done; keyIt = it.next()) {
+      const key = keyIt.value;
+      if (
+        // Skip the special useSWRInfinite and useSWRSubscription keys.
+        !/^\$(inf|sub)\$/.test(key) && keyFilter(cache2.get(key)._k)
+      ) {
+        matchedKeys.push(key);
+      }
+    }
+    return Promise.all(matchedKeys.map(mutateByKey));
+  }
+  return mutateByKey(_key);
+  async function mutateByKey(_k) {
+    const [key] = serialize(_k);
+    if (!key)
+      return;
+    const [get2, set2] = createCacheHelper(cache2, key);
+    const [EVENT_REVALIDATORS, MUTATION, FETCH] = SWRGlobalState.get(cache2);
+    const revalidators = EVENT_REVALIDATORS[key];
+    const startRevalidate = () => {
+      if (revalidate) {
+        delete FETCH[key];
+        if (revalidators && revalidators[0]) {
+          return revalidators[0](MUTATE_EVENT).then(() => get2().data);
+        }
+      }
+      return get2().data;
+    };
+    if (args.length < 3) {
+      return startRevalidate();
+    }
+    let data = _data;
+    let error;
+    const beforeMutationTs = getTimestamp();
+    MUTATION[key] = [
+      beforeMutationTs,
+      0
+    ];
+    const hasOptimisticData = !isUndefined(optimisticData);
+    const state = get2();
+    const displayedData = state.data;
+    const currentData = state._c;
+    const committedData = isUndefined(currentData) ? displayedData : currentData;
+    if (hasOptimisticData) {
+      optimisticData = isFunction(optimisticData) ? optimisticData(committedData) : optimisticData;
+      set2({
+        data: optimisticData,
+        _c: committedData
+      });
+    }
+    if (isFunction(data)) {
+      try {
+        data = data(committedData);
+      } catch (err) {
+        error = err;
+      }
+    }
+    if (data && isFunction(data.then)) {
+      data = await data.catch((err) => {
+        error = err;
+      });
+      if (beforeMutationTs !== MUTATION[key][0]) {
+        if (error)
+          throw error;
+        return data;
+      } else if (error && hasOptimisticData && rollbackOnError(error)) {
+        populateCache = true;
+        data = committedData;
+        set2({
+          data,
+          _c: UNDEFINED
+        });
+      }
+    }
+    if (populateCache) {
+      if (!error) {
+        if (isFunction(populateCache)) {
+          data = populateCache(data, committedData);
+        }
+        set2({
+          data,
+          _c: UNDEFINED
+        });
+      }
+    }
+    MUTATION[key][1] = getTimestamp();
+    const res = await startRevalidate();
+    set2({
+      _c: UNDEFINED
+    });
+    if (error) {
+      if (throwOnError)
+        throw error;
+      return;
+    }
+    return populateCache ? res : data;
+  }
+}
+const revalidateAllKeys = (revalidators, type) => {
+  for (const key in revalidators) {
+    if (revalidators[key][0])
+      revalidators[key][0](type);
+  }
+};
+const initCache = (provider, options) => {
+  if (!SWRGlobalState.has(provider)) {
+    const opts = mergeObjects(defaultConfigOptions, options);
+    const EVENT_REVALIDATORS = {};
+    const mutate2 = internalMutate.bind(UNDEFINED, provider);
+    let unmount = noop;
+    const subscriptions = {};
+    const subscribe = (key, callback) => {
+      const subs = subscriptions[key] || [];
+      subscriptions[key] = subs;
+      subs.push(callback);
+      return () => subs.splice(subs.indexOf(callback), 1);
+    };
+    const setter = (key, value, prev) => {
+      provider.set(key, value);
+      const subs = subscriptions[key];
+      if (subs) {
+        for (const fn of subs) {
+          fn(value, prev);
+        }
+      }
+    };
+    const initProvider = () => {
+      if (!SWRGlobalState.has(provider)) {
+        SWRGlobalState.set(provider, [
+          EVENT_REVALIDATORS,
+          {},
+          {},
+          {},
+          mutate2,
+          setter,
+          subscribe
+        ]);
+        if (!IS_SERVER) {
+          const releaseFocus = opts.initFocus(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, FOCUS_EVENT)));
+          const releaseReconnect = opts.initReconnect(setTimeout.bind(UNDEFINED, revalidateAllKeys.bind(UNDEFINED, EVENT_REVALIDATORS, RECONNECT_EVENT)));
+          unmount = () => {
+            releaseFocus && releaseFocus();
+            releaseReconnect && releaseReconnect();
+            SWRGlobalState.delete(provider);
+          };
+        }
+      }
+    };
+    initProvider();
+    return [
+      provider,
+      mutate2,
+      initProvider,
+      unmount
+    ];
+  }
+  return [
+    provider,
+    SWRGlobalState.get(provider)[4]
+  ];
+};
+const onErrorRetry = (_, __, config, revalidate, opts) => {
+  const maxRetryCount = config.errorRetryCount;
+  const currentRetryCount = opts.retryCount;
+  const timeout = ~~((Math.random() + 0.5) * (1 << (currentRetryCount < 8 ? currentRetryCount : 8))) * config.errorRetryInterval;
+  if (!isUndefined(maxRetryCount) && currentRetryCount > maxRetryCount) {
+    return;
+  }
+  setTimeout(revalidate, timeout, opts);
+};
+const compare = (currentData, newData) => stableHash(currentData) == stableHash(newData);
+const [cache, mutate] = initCache(/* @__PURE__ */ new Map());
+const defaultConfig = mergeObjects(
+  {
+    // events
+    onLoadingSlow: noop,
+    onSuccess: noop,
+    onError: noop,
+    onErrorRetry,
+    onDiscarded: noop,
+    // switches
+    revalidateOnFocus: true,
+    revalidateOnReconnect: true,
+    revalidateIfStale: true,
+    shouldRetryOnError: true,
+    // timeouts
+    errorRetryInterval: slowConnection ? 1e4 : 5e3,
+    focusThrottleInterval: 5 * 1e3,
+    dedupingInterval: 2 * 1e3,
+    loadingTimeout: slowConnection ? 5e3 : 3e3,
+    // providers
+    compare,
+    isPaused: () => false,
+    cache,
+    mutate,
+    fallback: {}
+  },
+  // use web preset by default
+  preset
+);
+const mergeConfigs = (a, b) => {
+  const v = mergeObjects(a, b);
+  if (b) {
+    const { use: u1, fallback: f1 } = a;
+    const { use: u2, fallback: f2 } = b;
+    if (u1 && u2) {
+      v.use = u1.concat(u2);
+    }
+    if (f1 && f2) {
+      v.fallback = mergeObjects(f1, f2);
+    }
+  }
+  return v;
+};
+const SWRConfigContext = createContext({});
+const enableDevtools = isWindowDefined && window.__SWR_DEVTOOLS_USE__;
+const use = enableDevtools ? window.__SWR_DEVTOOLS_USE__ : [];
+const setupDevTools = () => {
+  if (enableDevtools) {
+    window.__SWR_DEVTOOLS_REACT__ = React;
+  }
+};
+const normalize = (args) => {
+  return isFunction(args[1]) ? [
+    args[0],
+    args[1],
+    args[2] || {}
+  ] : [
+    args[0],
+    null,
+    (args[1] === null ? args[2] : args[1]) || {}
+  ];
+};
+const useSWRConfig = () => {
+  return mergeObjects(defaultConfig, useContext(SWRConfigContext));
+};
+const middleware = (useSWRNext) => (key_, fetcher_, config) => {
+  const fetcher = fetcher_ && ((...args) => {
+    const key = serialize(key_)[0];
+    const [, , , PRELOAD] = SWRGlobalState.get(cache);
+    const req = PRELOAD[key];
+    if (req) {
+      delete PRELOAD[key];
+      return req;
+    }
+    return fetcher_(...args);
+  });
+  return useSWRNext(key_, fetcher, config);
+};
+const BUILT_IN_MIDDLEWARE = use.concat(middleware);
+const withArgs = (hook) => {
+  return function useSWRArgs(...args) {
+    const fallbackConfig = useSWRConfig();
+    const [key, fn, _config] = normalize(args);
+    const config = mergeConfigs(fallbackConfig, _config);
+    let next = hook;
+    const { use: use2 } = config;
+    const middleware2 = (use2 || []).concat(BUILT_IN_MIDDLEWARE);
+    for (let i = middleware2.length; i--; ) {
+      next = middleware2[i](next);
+    }
+    return next(key, fn || config.fetcher || null, config);
+  };
+};
+const subscribeCallback = (key, callbacks, callback) => {
+  const keyedRevalidators = callbacks[key] || (callbacks[key] = []);
+  keyedRevalidators.push(callback);
+  return () => {
+    const index = keyedRevalidators.indexOf(callback);
+    if (index >= 0) {
+      keyedRevalidators[index] = keyedRevalidators[keyedRevalidators.length - 1];
+      keyedRevalidators.pop();
+    }
+  };
+};
+const withMiddleware = (useSWR2, middleware2) => {
+  return (...args) => {
+    const [key, fn, config] = normalize(args);
+    const uses = (config.use || []).concat(middleware2);
+    return useSWR2(key, fn, {
+      ...config,
+      use: uses
+    });
+  };
+};
+setupDevTools();
+const WITH_DEDUPE = {
+  dedupe: true
+};
+const useSWRHandler = (_key, fetcher, config) => {
+  const { cache: cache2, compare: compare2, suspense, fallbackData, revalidateOnMount, revalidateIfStale, refreshInterval, refreshWhenHidden, refreshWhenOffline, keepPreviousData } = config;
+  const [EVENT_REVALIDATORS, MUTATION, FETCH] = SWRGlobalState.get(cache2);
+  const [key, fnArg] = serialize(_key);
+  const initialMountedRef = useRef(false);
+  const unmountedRef = useRef(false);
+  const keyRef = useRef(key);
+  const fetcherRef = useRef(fetcher);
+  const configRef = useRef(config);
+  const getConfig = () => configRef.current;
+  const isActive = () => getConfig().isVisible() && getConfig().isOnline();
+  const [getCache, setCache, subscribeCache, getInitialCache] = createCacheHelper(cache2, key);
+  const stateDependencies = useRef({}).current;
+  const fallback = isUndefined(fallbackData) ? config.fallback[key] : fallbackData;
+  const isEqual = (prev, current) => {
+    let equal = true;
+    for (const _ in stateDependencies) {
+      const t = _;
+      if (t === "data") {
+        if (!compare2(current[t], prev[t])) {
+          if (isUndefined(prev[t])) {
+            if (!compare2(current[t], returnedData)) {
+              equal = false;
+            }
+          } else {
+            equal = false;
+          }
+        }
+      } else {
+        if (current[t] !== prev[t]) {
+          equal = false;
+        }
+      }
+    }
+    return equal;
+  };
+  const getSnapshot = useMemo(() => {
+    const shouldStartRequest = (() => {
+      if (!key)
+        return false;
+      if (!fetcher)
+        return false;
+      if (!isUndefined(revalidateOnMount))
+        return revalidateOnMount;
+      if (getConfig().isPaused())
+        return false;
+      if (suspense)
+        return false;
+      if (!isUndefined(revalidateIfStale))
+        return revalidateIfStale;
+      return true;
+    })();
+    const getSelectedCache = (state) => {
+      const snapshot = mergeObjects(state);
+      delete snapshot._k;
+      if (!shouldStartRequest) {
+        return snapshot;
+      }
+      return {
+        isValidating: true,
+        isLoading: true,
+        ...snapshot
+      };
+    };
+    const cachedData2 = getCache();
+    const initialData = getInitialCache();
+    const clientSnapshot = getSelectedCache(cachedData2);
+    const serverSnapshot = cachedData2 === initialData ? clientSnapshot : getSelectedCache(initialData);
+    let memorizedSnapshot = clientSnapshot;
+    return [
+      () => {
+        const newSnapshot = getSelectedCache(getCache());
+        return isEqual(newSnapshot, memorizedSnapshot) ? memorizedSnapshot : memorizedSnapshot = newSnapshot;
+      },
+      () => serverSnapshot
+    ];
+  }, [
+    cache2,
+    key
+  ]);
+  const cached = shimExports.useSyncExternalStore(useCallback(
+    (callback) => subscribeCache(key, (current, prev) => {
+      if (!isEqual(prev, current))
+        callback();
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      cache2,
+      key
+    ]
+  ), getSnapshot[0], getSnapshot[1]);
+  const isInitialMount = !initialMountedRef.current;
+  const hasRevalidator = EVENT_REVALIDATORS[key] && EVENT_REVALIDATORS[key].length > 0;
+  const cachedData = cached.data;
+  const data = isUndefined(cachedData) ? fallback : cachedData;
+  const error = cached.error;
+  const laggyDataRef = useRef(data);
+  const returnedData = keepPreviousData ? isUndefined(cachedData) ? laggyDataRef.current : cachedData : data;
+  const shouldDoInitialRevalidation = (() => {
+    if (hasRevalidator && !isUndefined(error))
+      return false;
+    if (isInitialMount && !isUndefined(revalidateOnMount))
+      return revalidateOnMount;
+    if (getConfig().isPaused())
+      return false;
+    if (suspense)
+      return isUndefined(data) ? false : revalidateIfStale;
+    return isUndefined(data) || revalidateIfStale;
+  })();
+  const defaultValidatingState = !!(key && fetcher && isInitialMount && shouldDoInitialRevalidation);
+  const isValidating = isUndefined(cached.isValidating) ? defaultValidatingState : cached.isValidating;
+  const isLoading = isUndefined(cached.isLoading) ? defaultValidatingState : cached.isLoading;
+  const revalidate = useCallback(
+    async (revalidateOpts) => {
+      const currentFetcher = fetcherRef.current;
+      if (!key || !currentFetcher || unmountedRef.current || getConfig().isPaused()) {
+        return false;
+      }
+      let newData;
+      let startAt;
+      let loading = true;
+      const opts = revalidateOpts || {};
+      const shouldStartNewRequest = !FETCH[key] || !opts.dedupe;
+      const callbackSafeguard = () => {
+        if (IS_REACT_LEGACY) {
+          return !unmountedRef.current && key === keyRef.current && initialMountedRef.current;
+        }
+        return key === keyRef.current;
+      };
+      const finalState = {
+        isValidating: false,
+        isLoading: false
+      };
+      const finishRequestAndUpdateState = () => {
+        setCache(finalState);
+      };
+      const cleanupState = () => {
+        const requestInfo = FETCH[key];
+        if (requestInfo && requestInfo[1] === startAt) {
+          delete FETCH[key];
+        }
+      };
+      const initialState = {
+        isValidating: true
+      };
+      if (isUndefined(getCache().data)) {
+        initialState.isLoading = true;
+      }
+      try {
+        if (shouldStartNewRequest) {
+          setCache(initialState);
+          if (config.loadingTimeout && isUndefined(getCache().data)) {
+            setTimeout(() => {
+              if (loading && callbackSafeguard()) {
+                getConfig().onLoadingSlow(key, config);
+              }
+            }, config.loadingTimeout);
+          }
+          FETCH[key] = [
+            currentFetcher(fnArg),
+            getTimestamp()
+          ];
+        }
+        [newData, startAt] = FETCH[key];
+        newData = await newData;
+        if (shouldStartNewRequest) {
+          setTimeout(cleanupState, config.dedupingInterval);
+        }
+        if (!FETCH[key] || FETCH[key][1] !== startAt) {
+          if (shouldStartNewRequest) {
+            if (callbackSafeguard()) {
+              getConfig().onDiscarded(key);
+            }
+          }
+          return false;
+        }
+        finalState.error = UNDEFINED;
+        const mutationInfo = MUTATION[key];
+        if (!isUndefined(mutationInfo) && // case 1
+        (startAt <= mutationInfo[0] || // case 2
+        startAt <= mutationInfo[1] || // case 3
+        mutationInfo[1] === 0)) {
+          finishRequestAndUpdateState();
+          if (shouldStartNewRequest) {
+            if (callbackSafeguard()) {
+              getConfig().onDiscarded(key);
+            }
+          }
+          return false;
+        }
+        const cacheData = getCache().data;
+        finalState.data = compare2(cacheData, newData) ? cacheData : newData;
+        if (shouldStartNewRequest) {
+          if (callbackSafeguard()) {
+            getConfig().onSuccess(newData, key, config);
+          }
+        }
+      } catch (err) {
+        cleanupState();
+        const currentConfig = getConfig();
+        const { shouldRetryOnError } = currentConfig;
+        if (!currentConfig.isPaused()) {
+          finalState.error = err;
+          if (shouldStartNewRequest && callbackSafeguard()) {
+            currentConfig.onError(err, key, currentConfig);
+            if (shouldRetryOnError === true || isFunction(shouldRetryOnError) && shouldRetryOnError(err)) {
+              if (isActive()) {
+                currentConfig.onErrorRetry(err, key, currentConfig, (_opts) => {
+                  const revalidators = EVENT_REVALIDATORS[key];
+                  if (revalidators && revalidators[0]) {
+                    revalidators[0](constants.ERROR_REVALIDATE_EVENT, _opts);
+                  }
+                }, {
+                  retryCount: (opts.retryCount || 0) + 1,
+                  dedupe: true
+                });
+              }
+            }
+          }
+        }
+      }
+      loading = false;
+      finishRequestAndUpdateState();
+      return true;
+    },
+    // `setState` is immutable, and `eventsCallback`, `fnArg`, and
+    // `keyValidating` are depending on `key`, so we can exclude them from
+    // the deps array.
+    //
+    // FIXME:
+    // `fn` and `config` might be changed during the lifecycle,
+    // but they might be changed every render like this.
+    // `useSWR('key', () => fetch('/api/'), { suspense: true })`
+    // So we omit the values from the deps array
+    // even though it might cause unexpected behaviors.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      key,
+      cache2
+    ]
+  );
+  const boundMutate = useCallback(
+    // Use callback to make sure `keyRef.current` returns latest result every time
+    (...args) => {
+      return internalMutate(cache2, keyRef.current, ...args);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  useIsomorphicLayoutEffect(() => {
+    fetcherRef.current = fetcher;
+    configRef.current = config;
+    if (!isUndefined(cachedData)) {
+      laggyDataRef.current = cachedData;
+    }
+  });
+  useIsomorphicLayoutEffect(() => {
+    if (!key)
+      return;
+    const softRevalidate = revalidate.bind(UNDEFINED, WITH_DEDUPE);
+    let nextFocusRevalidatedAt = 0;
+    const onRevalidate = (type, opts = {}) => {
+      if (type == constants.FOCUS_EVENT) {
+        const now = Date.now();
+        if (getConfig().revalidateOnFocus && now > nextFocusRevalidatedAt && isActive()) {
+          nextFocusRevalidatedAt = now + getConfig().focusThrottleInterval;
+          softRevalidate();
+        }
+      } else if (type == constants.RECONNECT_EVENT) {
+        if (getConfig().revalidateOnReconnect && isActive()) {
+          softRevalidate();
+        }
+      } else if (type == constants.MUTATE_EVENT) {
+        return revalidate();
+      } else if (type == constants.ERROR_REVALIDATE_EVENT) {
+        return revalidate(opts);
+      }
+      return;
+    };
+    const unsubEvents = subscribeCallback(key, EVENT_REVALIDATORS, onRevalidate);
+    unmountedRef.current = false;
+    keyRef.current = key;
+    initialMountedRef.current = true;
+    setCache({
+      _k: fnArg
+    });
+    if (shouldDoInitialRevalidation) {
+      if (isUndefined(data) || IS_SERVER) {
+        softRevalidate();
+      } else {
+        rAF(softRevalidate);
+      }
+    }
+    return () => {
+      unmountedRef.current = true;
+      unsubEvents();
+    };
+  }, [
+    key
+  ]);
+  useIsomorphicLayoutEffect(() => {
+    let timer;
+    function next() {
+      const interval = isFunction(refreshInterval) ? refreshInterval(data) : refreshInterval;
+      if (interval && timer !== -1) {
+        timer = setTimeout(execute, interval);
+      }
+    }
+    function execute() {
+      if (!getCache().error && (refreshWhenHidden || getConfig().isVisible()) && (refreshWhenOffline || getConfig().isOnline())) {
+        revalidate(WITH_DEDUPE).then(next);
+      } else {
+        next();
+      }
+    }
+    next();
+    return () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = -1;
+      }
+    };
+  }, [
+    refreshInterval,
+    refreshWhenHidden,
+    refreshWhenOffline,
+    key
+  ]);
+  useDebugValue(returnedData);
+  if (suspense && isUndefined(data) && key) {
+    if (!IS_REACT_LEGACY && IS_SERVER) {
+      throw new Error("Fallback data is required when using suspense in SSR.");
+    }
+    fetcherRef.current = fetcher;
+    configRef.current = config;
+    unmountedRef.current = false;
+    throw isUndefined(error) ? revalidate(WITH_DEDUPE) : error;
+  }
+  return {
+    mutate: boundMutate,
+    get data() {
+      stateDependencies.data = true;
+      return returnedData;
+    },
+    get error() {
+      stateDependencies.error = true;
+      return error;
+    },
+    get isValidating() {
+      stateDependencies.isValidating = true;
+      return isValidating;
+    },
+    get isLoading() {
+      stateDependencies.isLoading = true;
+      return isLoading;
+    }
+  };
+};
+var useSWR = withArgs(useSWRHandler);
+const subscriptionStorage = /* @__PURE__ */ new WeakMap();
+const SUBSCRIPTION_PREFIX = "$sub$";
+const subscription = (useSWRNext) => {
+  return (_key, subscribe, config) => {
+    const [key] = serialize(_key);
+    const subscriptionKey = key ? SUBSCRIPTION_PREFIX + key : void 0;
+    const swr = useSWRNext(subscriptionKey, null, config);
+    const { cache: cache2 } = config;
+    if (!subscriptionStorage.has(cache2)) {
+      subscriptionStorage.set(cache2, [
+        /* @__PURE__ */ new Map(),
+        /* @__PURE__ */ new Map()
+      ]);
+    }
+    const [subscriptions, disposers] = subscriptionStorage.get(cache2);
+    useIsomorphicLayoutEffect(() => {
+      if (!subscriptionKey)
+        return;
+      const [, set2] = createCacheHelper(cache2, subscriptionKey);
+      const refCount = subscriptions.get(subscriptionKey) || 0;
+      const next = (error, data) => {
+        if (error !== null && typeof error !== "undefined") {
+          set2({
+            error
+          });
+        } else {
+          set2({
+            error: void 0
+          });
+          swr.mutate(data, false);
+        }
+      };
+      subscriptions.set(subscriptionKey, refCount + 1);
+      if (!refCount) {
+        const dispose = subscribe(key, {
+          next
+        });
+        if (typeof dispose !== "function") {
+          throw new Error("The `subscribe` function must return a function to unsubscribe.");
+        }
+        disposers.set(subscriptionKey, dispose);
+      }
+      return () => {
+        setTimeout(() => {
+          const count = subscriptions.get(subscriptionKey) - 1;
+          subscriptions.set(subscriptionKey, count);
+          if (!count) {
+            const dispose = disposers.get(subscriptionKey);
+            dispose == null ? void 0 : dispose();
+          }
+        });
+      };
+    }, [
+      subscriptionKey
+    ]);
+    return {
+      get data() {
+        return swr.data;
+      },
+      get error() {
+        return swr.error;
+      }
+    };
+  };
+};
+const useSWRSubscription = withMiddleware(useSWR, subscription);
+const useCollection = (params) => {
+  return useSWRSubscription(params, (_, { next }) => {
+    if (params == null) {
+      return () => {
+      };
+    }
+    const { path, ...options } = params;
+    const converter = getFirestoreConverter(options == null ? void 0 : options.parseDates);
+    const ref = collection(getFirestore(), path);
+    let q;
+    if (options != null) {
+      const { where: w, orderBy: o, limit: l } = options;
+      q = query(ref, ...(w ? w : []).map((q2) => where(...q2)), ...(o ? o : []).map((q2) => orderBy(...q2)), ...l ? [limit(l)] : []);
+    }
+    const unsub = onSnapshot((q ?? ref).withConverter(converter), (qs) => {
+      next(null, qs.docs.map((x) => x.data()));
+    }, (error) => {
+      next(error);
+    });
+    return () => unsub && unsub();
+  });
+};
+const useCollectionCount = (params, swrOptions) => {
+  const fetcher = (key) => {
+    const { path, ...option } = key;
+    const ref = collection(getFirestore(), path);
+    let q;
+    if (option) {
+      const { where: w, orderBy: o, limit: l } = option;
+      q = query(ref, ...(w ? w : []).map((q2) => where(...q2)), ...(o ? o : []).map((q2) => orderBy(...q2)), ...l ? [limit(l)] : []);
+    }
+    return getCountFromServer(q ?? ref).then((sn) => {
+      return sn.data().count;
+    });
+  };
+  return useSWR(params, fetcher, swrOptions);
+};
+const useCollectionGroup = (params) => {
+  return useSWRSubscription(params, (_, { next }) => {
+    if (params == null) {
+      return () => {
+      };
+    }
+    const { path, ...options } = params;
+    const converter = getFirestoreConverter(options == null ? void 0 : options.parseDates);
+    const ref = collectionGroup(getFirestore(), path);
+    let q;
+    if (options != null) {
+      const { where: w, orderBy: o, limit: l } = options;
+      q = query(ref, ...(w ? w : []).map((q2) => where(...q2)), ...(o ? o : []).map((q2) => orderBy(...q2)), ...l ? [limit(l)] : []);
+    }
+    const unsub = onSnapshot((q ?? ref).withConverter(converter), (qs) => {
+      next(null, qs.docs.map((x) => x.data()));
+    }, (error) => {
+      next(error);
+    });
+    return () => unsub && unsub();
+  });
+};
+const useCollectionGroupCount = (params, swrOptions) => {
+  const fetcher = (key) => {
+    const { path, ...option } = key;
+    const ref = collectionGroup(getFirestore(), path);
+    let q;
+    if (option) {
+      const { where: w, orderBy: o, limit: l } = option;
+      q = query(ref, ...(w ? w : []).map((q2) => where(...q2)), ...(o ? o : []).map((q2) => orderBy(...q2)), ...l ? [limit(l)] : []);
+    }
+    return getCountFromServer(q ?? ref).then((sn) => {
+      return sn.data().count;
+    });
+  };
+  return useSWR(params, fetcher, swrOptions);
+};
+const useDoc = (params) => {
+  return useSWRSubscription(params, (_, { next }) => {
+    if (params == null) {
+      return () => {
+      };
+    }
+    const { path } = params;
+    const ref = doc(getFirestore(), path);
+    const converter = getFirestoreConverter(params == null ? void 0 : params.parseDates);
+    const unsub = onSnapshot(ref.withConverter(converter), (doc2) => {
+      next(null, doc2.data());
+    }, (error) => {
+      next(error);
+    });
+    return () => unsub && unsub();
+  });
+};
+export {
+  useCollection,
+  useCollectionCount,
+  useCollectionGroup,
+  useCollectionGroupCount,
+  useDoc
+};