@storybook/react-native-ui 8.0.0-alpha.3 → 8.2.0-alpha.0

package/dist/index.js

@@ -314,368 +314,2601 @@ var require_debounce = __commonJS({
   }
 });
 
-// ../../node_modules/store2/dist/store2.js
-var require_store2 = __commonJS({
-  "../../node_modules/store2/dist/store2.js"(exports, module2) {
-    (function(window, define) {
-      var _ = {
-        version: "2.14.3",
-        areas: {},
-        apis: {},
-        nsdelim: ".",
-        // utilities
-        inherit: function(api, o) {
-          for (var p in api) {
-            if (!o.hasOwnProperty(p)) {
-              Object.defineProperty(o, p, Object.getOwnPropertyDescriptor(api, p));
+// ../../node_modules/lodash/isFunction.js
+var require_isFunction = __commonJS({
+  "../../node_modules/lodash/isFunction.js"(exports, module2) {
+    var baseGetTag = require_baseGetTag();
+    var isObject = require_isObject();
+    var asyncTag = "[object AsyncFunction]";
+    var funcTag = "[object Function]";
+    var genTag = "[object GeneratorFunction]";
+    var proxyTag = "[object Proxy]";
+    function isFunction(value) {
+      if (!isObject(value)) {
+        return false;
+      }
+      var tag = baseGetTag(value);
+      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+    }
+    module2.exports = isFunction;
+  }
+});
+
+// ../../node_modules/lodash/_coreJsData.js
+var require_coreJsData = __commonJS({
+  "../../node_modules/lodash/_coreJsData.js"(exports, module2) {
+    var root = require_root();
+    var coreJsData = root["__core-js_shared__"];
+    module2.exports = coreJsData;
+  }
+});
+
+// ../../node_modules/lodash/_isMasked.js
+var require_isMasked = __commonJS({
+  "../../node_modules/lodash/_isMasked.js"(exports, module2) {
+    var coreJsData = require_coreJsData();
+    var maskSrcKey = function() {
+      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+      return uid ? "Symbol(src)_1." + uid : "";
+    }();
+    function isMasked(func) {
+      return !!maskSrcKey && maskSrcKey in func;
+    }
+    module2.exports = isMasked;
+  }
+});
+
+// ../../node_modules/lodash/_toSource.js
+var require_toSource = __commonJS({
+  "../../node_modules/lodash/_toSource.js"(exports, module2) {
+    var funcProto = Function.prototype;
+    var funcToString = funcProto.toString;
+    function toSource(func) {
+      if (func != null) {
+        try {
+          return funcToString.call(func);
+        } catch (e) {
+        }
+        try {
+          return func + "";
+        } catch (e) {
+        }
+      }
+      return "";
+    }
+    module2.exports = toSource;
+  }
+});
+
+// ../../node_modules/lodash/_baseIsNative.js
+var require_baseIsNative = __commonJS({
+  "../../node_modules/lodash/_baseIsNative.js"(exports, module2) {
+    var isFunction = require_isFunction();
+    var isMasked = require_isMasked();
+    var isObject = require_isObject();
+    var toSource = require_toSource();
+    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+    var reIsHostCtor = /^\[object .+?Constructor\]$/;
+    var funcProto = Function.prototype;
+    var objectProto = Object.prototype;
+    var funcToString = funcProto.toString;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var reIsNative = RegExp(
+      "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+    );
+    function baseIsNative(value) {
+      if (!isObject(value) || isMasked(value)) {
+        return false;
+      }
+      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+      return pattern.test(toSource(value));
+    }
+    module2.exports = baseIsNative;
+  }
+});
+
+// ../../node_modules/lodash/_getValue.js
+var require_getValue = __commonJS({
+  "../../node_modules/lodash/_getValue.js"(exports, module2) {
+    function getValue(object, key) {
+      return object == null ? void 0 : object[key];
+    }
+    module2.exports = getValue;
+  }
+});
+
+// ../../node_modules/lodash/_getNative.js
+var require_getNative = __commonJS({
+  "../../node_modules/lodash/_getNative.js"(exports, module2) {
+    var baseIsNative = require_baseIsNative();
+    var getValue = require_getValue();
+    function getNative(object, key) {
+      var value = getValue(object, key);
+      return baseIsNative(value) ? value : void 0;
+    }
+    module2.exports = getNative;
+  }
+});
+
+// ../../node_modules/lodash/_defineProperty.js
+var require_defineProperty = __commonJS({
+  "../../node_modules/lodash/_defineProperty.js"(exports, module2) {
+    var getNative = require_getNative();
+    var defineProperty = function() {
+      try {
+        var func = getNative(Object, "defineProperty");
+        func({}, "", {});
+        return func;
+      } catch (e) {
+      }
+    }();
+    module2.exports = defineProperty;
+  }
+});
+
+// ../../node_modules/lodash/_baseAssignValue.js
+var require_baseAssignValue = __commonJS({
+  "../../node_modules/lodash/_baseAssignValue.js"(exports, module2) {
+    var defineProperty = require_defineProperty();
+    function baseAssignValue(object, key, value) {
+      if (key == "__proto__" && defineProperty) {
+        defineProperty(object, key, {
+          "configurable": true,
+          "enumerable": true,
+          "value": value,
+          "writable": true
+        });
+      } else {
+        object[key] = value;
+      }
+    }
+    module2.exports = baseAssignValue;
+  }
+});
+
+// ../../node_modules/lodash/_arrayAggregator.js
+var require_arrayAggregator = __commonJS({
+  "../../node_modules/lodash/_arrayAggregator.js"(exports, module2) {
+    function arrayAggregator(array, setter, iteratee, accumulator) {
+      var index = -1, length = array == null ? 0 : array.length;
+      while (++index < length) {
+        var value = array[index];
+        setter(accumulator, value, iteratee(value), array);
+      }
+      return accumulator;
+    }
+    module2.exports = arrayAggregator;
+  }
+});
+
+// ../../node_modules/lodash/_createBaseFor.js
+var require_createBaseFor = __commonJS({
+  "../../node_modules/lodash/_createBaseFor.js"(exports, module2) {
+    function createBaseFor(fromRight) {
+      return function(object, iteratee, keysFunc) {
+        var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+        while (length--) {
+          var key = props[fromRight ? length : ++index];
+          if (iteratee(iterable[key], key, iterable) === false) {
+            break;
+          }
+        }
+        return object;
+      };
+    }
+    module2.exports = createBaseFor;
+  }
+});
+
+// ../../node_modules/lodash/_baseFor.js
+var require_baseFor = __commonJS({
+  "../../node_modules/lodash/_baseFor.js"(exports, module2) {
+    var createBaseFor = require_createBaseFor();
+    var baseFor = createBaseFor();
+    module2.exports = baseFor;
+  }
+});
+
+// ../../node_modules/lodash/_baseTimes.js
+var require_baseTimes = __commonJS({
+  "../../node_modules/lodash/_baseTimes.js"(exports, module2) {
+    function baseTimes(n, iteratee) {
+      var index = -1, result = Array(n);
+      while (++index < n) {
+        result[index] = iteratee(index);
+      }
+      return result;
+    }
+    module2.exports = baseTimes;
+  }
+});
+
+// ../../node_modules/lodash/_baseIsArguments.js
+var require_baseIsArguments = __commonJS({
+  "../../node_modules/lodash/_baseIsArguments.js"(exports, module2) {
+    var baseGetTag = require_baseGetTag();
+    var isObjectLike = require_isObjectLike();
+    var argsTag = "[object Arguments]";
+    function baseIsArguments(value) {
+      return isObjectLike(value) && baseGetTag(value) == argsTag;
+    }
+    module2.exports = baseIsArguments;
+  }
+});
+
+// ../../node_modules/lodash/isArguments.js
+var require_isArguments = __commonJS({
+  "../../node_modules/lodash/isArguments.js"(exports, module2) {
+    var baseIsArguments = require_baseIsArguments();
+    var isObjectLike = require_isObjectLike();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+    var isArguments = baseIsArguments(function() {
+      return arguments;
+    }()) ? baseIsArguments : function(value) {
+      return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+    };
+    module2.exports = isArguments;
+  }
+});
+
+// ../../node_modules/lodash/isArray.js
+var require_isArray = __commonJS({
+  "../../node_modules/lodash/isArray.js"(exports, module2) {
+    var isArray = Array.isArray;
+    module2.exports = isArray;
+  }
+});
+
+// ../../node_modules/lodash/stubFalse.js
+var require_stubFalse = __commonJS({
+  "../../node_modules/lodash/stubFalse.js"(exports, module2) {
+    function stubFalse() {
+      return false;
+    }
+    module2.exports = stubFalse;
+  }
+});
+
+// ../../node_modules/lodash/isBuffer.js
+var require_isBuffer = __commonJS({
+  "../../node_modules/lodash/isBuffer.js"(exports, module2) {
+    var root = require_root();
+    var stubFalse = require_stubFalse();
+    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+    var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var Buffer2 = moduleExports ? root.Buffer : void 0;
+    var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
+    var isBuffer = nativeIsBuffer || stubFalse;
+    module2.exports = isBuffer;
+  }
+});
+
+// ../../node_modules/lodash/_isIndex.js
+var require_isIndex = __commonJS({
+  "../../node_modules/lodash/_isIndex.js"(exports, module2) {
+    var MAX_SAFE_INTEGER = 9007199254740991;
+    var reIsUint = /^(?:0|[1-9]\d*)$/;
+    function isIndex(value, length) {
+      var type = typeof value;
+      length = length == null ? MAX_SAFE_INTEGER : length;
+      return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+    }
+    module2.exports = isIndex;
+  }
+});
+
+// ../../node_modules/lodash/isLength.js
+var require_isLength = __commonJS({
+  "../../node_modules/lodash/isLength.js"(exports, module2) {
+    var MAX_SAFE_INTEGER = 9007199254740991;
+    function isLength(value) {
+      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+    }
+    module2.exports = isLength;
+  }
+});
+
+// ../../node_modules/lodash/_baseIsTypedArray.js
+var require_baseIsTypedArray = __commonJS({
+  "../../node_modules/lodash/_baseIsTypedArray.js"(exports, module2) {
+    var baseGetTag = require_baseGetTag();
+    var isLength = require_isLength();
+    var isObjectLike = require_isObjectLike();
+    var argsTag = "[object Arguments]";
+    var arrayTag = "[object Array]";
+    var boolTag = "[object Boolean]";
+    var dateTag = "[object Date]";
+    var errorTag = "[object Error]";
+    var funcTag = "[object Function]";
+    var mapTag = "[object Map]";
+    var numberTag = "[object Number]";
+    var objectTag = "[object Object]";
+    var regexpTag = "[object RegExp]";
+    var setTag = "[object Set]";
+    var stringTag = "[object String]";
+    var weakMapTag = "[object WeakMap]";
+    var arrayBufferTag = "[object ArrayBuffer]";
+    var dataViewTag = "[object DataView]";
+    var float32Tag = "[object Float32Array]";
+    var float64Tag = "[object Float64Array]";
+    var int8Tag = "[object Int8Array]";
+    var int16Tag = "[object Int16Array]";
+    var int32Tag = "[object Int32Array]";
+    var uint8Tag = "[object Uint8Array]";
+    var uint8ClampedTag = "[object Uint8ClampedArray]";
+    var uint16Tag = "[object Uint16Array]";
+    var uint32Tag = "[object Uint32Array]";
+    var typedArrayTags = {};
+    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+    function baseIsTypedArray(value) {
+      return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+    }
+    module2.exports = baseIsTypedArray;
+  }
+});
+
+// ../../node_modules/lodash/_baseUnary.js
+var require_baseUnary = __commonJS({
+  "../../node_modules/lodash/_baseUnary.js"(exports, module2) {
+    function baseUnary(func) {
+      return function(value) {
+        return func(value);
+      };
+    }
+    module2.exports = baseUnary;
+  }
+});
+
+// ../../node_modules/lodash/_nodeUtil.js
+var require_nodeUtil = __commonJS({
+  "../../node_modules/lodash/_nodeUtil.js"(exports, module2) {
+    var freeGlobal = require_freeGlobal();
+    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+    var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var freeProcess = moduleExports && freeGlobal.process;
+    var nodeUtil = function() {
+      try {
+        var types = freeModule && freeModule.require && freeModule.require("util").types;
+        if (types) {
+          return types;
+        }
+        return freeProcess && freeProcess.binding && freeProcess.binding("util");
+      } catch (e) {
+      }
+    }();
+    module2.exports = nodeUtil;
+  }
+});
+
+// ../../node_modules/lodash/isTypedArray.js
+var require_isTypedArray = __commonJS({
+  "../../node_modules/lodash/isTypedArray.js"(exports, module2) {
+    var baseIsTypedArray = require_baseIsTypedArray();
+    var baseUnary = require_baseUnary();
+    var nodeUtil = require_nodeUtil();
+    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+    module2.exports = isTypedArray;
+  }
+});
+
+// ../../node_modules/lodash/_arrayLikeKeys.js
+var require_arrayLikeKeys = __commonJS({
+  "../../node_modules/lodash/_arrayLikeKeys.js"(exports, module2) {
+    var baseTimes = require_baseTimes();
+    var isArguments = require_isArguments();
+    var isArray = require_isArray();
+    var isBuffer = require_isBuffer();
+    var isIndex = require_isIndex();
+    var isTypedArray = require_isTypedArray();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    function arrayLikeKeys(value, inherited) {
+      var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+      for (var key in value) {
+        if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+        (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+        isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+        isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+        isIndex(key, length)))) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    module2.exports = arrayLikeKeys;
+  }
+});
+
+// ../../node_modules/lodash/_isPrototype.js
+var require_isPrototype = __commonJS({
+  "../../node_modules/lodash/_isPrototype.js"(exports, module2) {
+    var objectProto = Object.prototype;
+    function isPrototype(value) {
+      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+      return value === proto;
+    }
+    module2.exports = isPrototype;
+  }
+});
+
+// ../../node_modules/lodash/_overArg.js
+var require_overArg = __commonJS({
+  "../../node_modules/lodash/_overArg.js"(exports, module2) {
+    function overArg(func, transform) {
+      return function(arg) {
+        return func(transform(arg));
+      };
+    }
+    module2.exports = overArg;
+  }
+});
+
+// ../../node_modules/lodash/_nativeKeys.js
+var require_nativeKeys = __commonJS({
+  "../../node_modules/lodash/_nativeKeys.js"(exports, module2) {
+    var overArg = require_overArg();
+    var nativeKeys = overArg(Object.keys, Object);
+    module2.exports = nativeKeys;
+  }
+});
+
+// ../../node_modules/lodash/_baseKeys.js
+var require_baseKeys = __commonJS({
+  "../../node_modules/lodash/_baseKeys.js"(exports, module2) {
+    var isPrototype = require_isPrototype();
+    var nativeKeys = require_nativeKeys();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    function baseKeys(object) {
+      if (!isPrototype(object)) {
+        return nativeKeys(object);
+      }
+      var result = [];
+      for (var key in Object(object)) {
+        if (hasOwnProperty.call(object, key) && key != "constructor") {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    module2.exports = baseKeys;
+  }
+});
+
+// ../../node_modules/lodash/isArrayLike.js
+var require_isArrayLike = __commonJS({
+  "../../node_modules/lodash/isArrayLike.js"(exports, module2) {
+    var isFunction = require_isFunction();
+    var isLength = require_isLength();
+    function isArrayLike(value) {
+      return value != null && isLength(value.length) && !isFunction(value);
+    }
+    module2.exports = isArrayLike;
+  }
+});
+
+// ../../node_modules/lodash/keys.js
+var require_keys = __commonJS({
+  "../../node_modules/lodash/keys.js"(exports, module2) {
+    var arrayLikeKeys = require_arrayLikeKeys();
+    var baseKeys = require_baseKeys();
+    var isArrayLike = require_isArrayLike();
+    function keys(object) {
+      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+    }
+    module2.exports = keys;
+  }
+});
+
+// ../../node_modules/lodash/_baseForOwn.js
+var require_baseForOwn = __commonJS({
+  "../../node_modules/lodash/_baseForOwn.js"(exports, module2) {
+    var baseFor = require_baseFor();
+    var keys = require_keys();
+    function baseForOwn(object, iteratee) {
+      return object && baseFor(object, iteratee, keys);
+    }
+    module2.exports = baseForOwn;
+  }
+});
+
+// ../../node_modules/lodash/_createBaseEach.js
+var require_createBaseEach = __commonJS({
+  "../../node_modules/lodash/_createBaseEach.js"(exports, module2) {
+    var isArrayLike = require_isArrayLike();
+    function createBaseEach(eachFunc, fromRight) {
+      return function(collection, iteratee) {
+        if (collection == null) {
+          return collection;
+        }
+        if (!isArrayLike(collection)) {
+          return eachFunc(collection, iteratee);
+        }
+        var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
+        while (fromRight ? index-- : ++index < length) {
+          if (iteratee(iterable[index], index, iterable) === false) {
+            break;
+          }
+        }
+        return collection;
+      };
+    }
+    module2.exports = createBaseEach;
+  }
+});
+
+// ../../node_modules/lodash/_baseEach.js
+var require_baseEach = __commonJS({
+  "../../node_modules/lodash/_baseEach.js"(exports, module2) {
+    var baseForOwn = require_baseForOwn();
+    var createBaseEach = require_createBaseEach();
+    var baseEach = createBaseEach(baseForOwn);
+    module2.exports = baseEach;
+  }
+});
+
+// ../../node_modules/lodash/_baseAggregator.js
+var require_baseAggregator = __commonJS({
+  "../../node_modules/lodash/_baseAggregator.js"(exports, module2) {
+    var baseEach = require_baseEach();
+    function baseAggregator(collection, setter, iteratee, accumulator) {
+      baseEach(collection, function(value, key, collection2) {
+        setter(accumulator, value, iteratee(value), collection2);
+      });
+      return accumulator;
+    }
+    module2.exports = baseAggregator;
+  }
+});
+
+// ../../node_modules/lodash/_listCacheClear.js
+var require_listCacheClear = __commonJS({
+  "../../node_modules/lodash/_listCacheClear.js"(exports, module2) {
+    function listCacheClear() {
+      this.__data__ = [];
+      this.size = 0;
+    }
+    module2.exports = listCacheClear;
+  }
+});
+
+// ../../node_modules/lodash/eq.js
+var require_eq = __commonJS({
+  "../../node_modules/lodash/eq.js"(exports, module2) {
+    function eq(value, other) {
+      return value === other || value !== value && other !== other;
+    }
+    module2.exports = eq;
+  }
+});
+
+// ../../node_modules/lodash/_assocIndexOf.js
+var require_assocIndexOf = __commonJS({
+  "../../node_modules/lodash/_assocIndexOf.js"(exports, module2) {
+    var eq = require_eq();
+    function assocIndexOf(array, key) {
+      var length = array.length;
+      while (length--) {
+        if (eq(array[length][0], key)) {
+          return length;
+        }
+      }
+      return -1;
+    }
+    module2.exports = assocIndexOf;
+  }
+});
+
+// ../../node_modules/lodash/_listCacheDelete.js
+var require_listCacheDelete = __commonJS({
+  "../../node_modules/lodash/_listCacheDelete.js"(exports, module2) {
+    var assocIndexOf = require_assocIndexOf();
+    var arrayProto = Array.prototype;
+    var splice = arrayProto.splice;
+    function listCacheDelete(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        return false;
+      }
+      var lastIndex = data.length - 1;
+      if (index == lastIndex) {
+        data.pop();
+      } else {
+        splice.call(data, index, 1);
+      }
+      --this.size;
+      return true;
+    }
+    module2.exports = listCacheDelete;
+  }
+});
+
+// ../../node_modules/lodash/_listCacheGet.js
+var require_listCacheGet = __commonJS({
+  "../../node_modules/lodash/_listCacheGet.js"(exports, module2) {
+    var assocIndexOf = require_assocIndexOf();
+    function listCacheGet(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      return index < 0 ? void 0 : data[index][1];
+    }
+    module2.exports = listCacheGet;
+  }
+});
+
+// ../../node_modules/lodash/_listCacheHas.js
+var require_listCacheHas = __commonJS({
+  "../../node_modules/lodash/_listCacheHas.js"(exports, module2) {
+    var assocIndexOf = require_assocIndexOf();
+    function listCacheHas(key) {
+      return assocIndexOf(this.__data__, key) > -1;
+    }
+    module2.exports = listCacheHas;
+  }
+});
+
+// ../../node_modules/lodash/_listCacheSet.js
+var require_listCacheSet = __commonJS({
+  "../../node_modules/lodash/_listCacheSet.js"(exports, module2) {
+    var assocIndexOf = require_assocIndexOf();
+    function listCacheSet(key, value) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        ++this.size;
+        data.push([key, value]);
+      } else {
+        data[index][1] = value;
+      }
+      return this;
+    }
+    module2.exports = listCacheSet;
+  }
+});
+
+// ../../node_modules/lodash/_ListCache.js
+var require_ListCache = __commonJS({
+  "../../node_modules/lodash/_ListCache.js"(exports, module2) {
+    var listCacheClear = require_listCacheClear();
+    var listCacheDelete = require_listCacheDelete();
+    var listCacheGet = require_listCacheGet();
+    var listCacheHas = require_listCacheHas();
+    var listCacheSet = require_listCacheSet();
+    function ListCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    ListCache.prototype.clear = listCacheClear;
+    ListCache.prototype["delete"] = listCacheDelete;
+    ListCache.prototype.get = listCacheGet;
+    ListCache.prototype.has = listCacheHas;
+    ListCache.prototype.set = listCacheSet;
+    module2.exports = ListCache;
+  }
+});
+
+// ../../node_modules/lodash/_stackClear.js
+var require_stackClear = __commonJS({
+  "../../node_modules/lodash/_stackClear.js"(exports, module2) {
+    var ListCache = require_ListCache();
+    function stackClear() {
+      this.__data__ = new ListCache();
+      this.size = 0;
+    }
+    module2.exports = stackClear;
+  }
+});
+
+// ../../node_modules/lodash/_stackDelete.js
+var require_stackDelete = __commonJS({
+  "../../node_modules/lodash/_stackDelete.js"(exports, module2) {
+    function stackDelete(key) {
+      var data = this.__data__, result = data["delete"](key);
+      this.size = data.size;
+      return result;
+    }
+    module2.exports = stackDelete;
+  }
+});
+
+// ../../node_modules/lodash/_stackGet.js
+var require_stackGet = __commonJS({
+  "../../node_modules/lodash/_stackGet.js"(exports, module2) {
+    function stackGet(key) {
+      return this.__data__.get(key);
+    }
+    module2.exports = stackGet;
+  }
+});
+
+// ../../node_modules/lodash/_stackHas.js
+var require_stackHas = __commonJS({
+  "../../node_modules/lodash/_stackHas.js"(exports, module2) {
+    function stackHas(key) {
+      return this.__data__.has(key);
+    }
+    module2.exports = stackHas;
+  }
+});
+
+// ../../node_modules/lodash/_Map.js
+var require_Map = __commonJS({
+  "../../node_modules/lodash/_Map.js"(exports, module2) {
+    var getNative = require_getNative();
+    var root = require_root();
+    var Map = getNative(root, "Map");
+    module2.exports = Map;
+  }
+});
+
+// ../../node_modules/lodash/_nativeCreate.js
+var require_nativeCreate = __commonJS({
+  "../../node_modules/lodash/_nativeCreate.js"(exports, module2) {
+    var getNative = require_getNative();
+    var nativeCreate = getNative(Object, "create");
+    module2.exports = nativeCreate;
+  }
+});
+
+// ../../node_modules/lodash/_hashClear.js
+var require_hashClear = __commonJS({
+  "../../node_modules/lodash/_hashClear.js"(exports, module2) {
+    var nativeCreate = require_nativeCreate();
+    function hashClear() {
+      this.__data__ = nativeCreate ? nativeCreate(null) : {};
+      this.size = 0;
+    }
+    module2.exports = hashClear;
+  }
+});
+
+// ../../node_modules/lodash/_hashDelete.js
+var require_hashDelete = __commonJS({
+  "../../node_modules/lodash/_hashDelete.js"(exports, module2) {
+    function hashDelete(key) {
+      var result = this.has(key) && delete this.__data__[key];
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    module2.exports = hashDelete;
+  }
+});
+
+// ../../node_modules/lodash/_hashGet.js
+var require_hashGet = __commonJS({
+  "../../node_modules/lodash/_hashGet.js"(exports, module2) {
+    var nativeCreate = require_nativeCreate();
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    function hashGet(key) {
+      var data = this.__data__;
+      if (nativeCreate) {
+        var result = data[key];
+        return result === HASH_UNDEFINED ? void 0 : result;
+      }
+      return hasOwnProperty.call(data, key) ? data[key] : void 0;
+    }
+    module2.exports = hashGet;
+  }
+});
+
+// ../../node_modules/lodash/_hashHas.js
+var require_hashHas = __commonJS({
+  "../../node_modules/lodash/_hashHas.js"(exports, module2) {
+    var nativeCreate = require_nativeCreate();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    function hashHas(key) {
+      var data = this.__data__;
+      return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+    }
+    module2.exports = hashHas;
+  }
+});
+
+// ../../node_modules/lodash/_hashSet.js
+var require_hashSet = __commonJS({
+  "../../node_modules/lodash/_hashSet.js"(exports, module2) {
+    var nativeCreate = require_nativeCreate();
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    function hashSet(key, value) {
+      var data = this.__data__;
+      this.size += this.has(key) ? 0 : 1;
+      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+      return this;
+    }
+    module2.exports = hashSet;
+  }
+});
+
+// ../../node_modules/lodash/_Hash.js
+var require_Hash = __commonJS({
+  "../../node_modules/lodash/_Hash.js"(exports, module2) {
+    var hashClear = require_hashClear();
+    var hashDelete = require_hashDelete();
+    var hashGet = require_hashGet();
+    var hashHas = require_hashHas();
+    var hashSet = require_hashSet();
+    function Hash(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    Hash.prototype.clear = hashClear;
+    Hash.prototype["delete"] = hashDelete;
+    Hash.prototype.get = hashGet;
+    Hash.prototype.has = hashHas;
+    Hash.prototype.set = hashSet;
+    module2.exports = Hash;
+  }
+});
+
+// ../../node_modules/lodash/_mapCacheClear.js
+var require_mapCacheClear = __commonJS({
+  "../../node_modules/lodash/_mapCacheClear.js"(exports, module2) {
+    var Hash = require_Hash();
+    var ListCache = require_ListCache();
+    var Map = require_Map();
+    function mapCacheClear() {
+      this.size = 0;
+      this.__data__ = {
+        "hash": new Hash(),
+        "map": new (Map || ListCache)(),
+        "string": new Hash()
+      };
+    }
+    module2.exports = mapCacheClear;
+  }
+});
+
+// ../../node_modules/lodash/_isKeyable.js
+var require_isKeyable = __commonJS({
+  "../../node_modules/lodash/_isKeyable.js"(exports, module2) {
+    function isKeyable(value) {
+      var type = typeof value;
+      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+    }
+    module2.exports = isKeyable;
+  }
+});
+
+// ../../node_modules/lodash/_getMapData.js
+var require_getMapData = __commonJS({
+  "../../node_modules/lodash/_getMapData.js"(exports, module2) {
+    var isKeyable = require_isKeyable();
+    function getMapData(map, key) {
+      var data = map.__data__;
+      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+    }
+    module2.exports = getMapData;
+  }
+});
+
+// ../../node_modules/lodash/_mapCacheDelete.js
+var require_mapCacheDelete = __commonJS({
+  "../../node_modules/lodash/_mapCacheDelete.js"(exports, module2) {
+    var getMapData = require_getMapData();
+    function mapCacheDelete(key) {
+      var result = getMapData(this, key)["delete"](key);
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    module2.exports = mapCacheDelete;
+  }
+});
+
+// ../../node_modules/lodash/_mapCacheGet.js
+var require_mapCacheGet = __commonJS({
+  "../../node_modules/lodash/_mapCacheGet.js"(exports, module2) {
+    var getMapData = require_getMapData();
+    function mapCacheGet(key) {
+      return getMapData(this, key).get(key);
+    }
+    module2.exports = mapCacheGet;
+  }
+});
+
+// ../../node_modules/lodash/_mapCacheHas.js
+var require_mapCacheHas = __commonJS({
+  "../../node_modules/lodash/_mapCacheHas.js"(exports, module2) {
+    var getMapData = require_getMapData();
+    function mapCacheHas(key) {
+      return getMapData(this, key).has(key);
+    }
+    module2.exports = mapCacheHas;
+  }
+});
+
+// ../../node_modules/lodash/_mapCacheSet.js
+var require_mapCacheSet = __commonJS({
+  "../../node_modules/lodash/_mapCacheSet.js"(exports, module2) {
+    var getMapData = require_getMapData();
+    function mapCacheSet(key, value) {
+      var data = getMapData(this, key), size = data.size;
+      data.set(key, value);
+      this.size += data.size == size ? 0 : 1;
+      return this;
+    }
+    module2.exports = mapCacheSet;
+  }
+});
+
+// ../../node_modules/lodash/_MapCache.js
+var require_MapCache = __commonJS({
+  "../../node_modules/lodash/_MapCache.js"(exports, module2) {
+    var mapCacheClear = require_mapCacheClear();
+    var mapCacheDelete = require_mapCacheDelete();
+    var mapCacheGet = require_mapCacheGet();
+    var mapCacheHas = require_mapCacheHas();
+    var mapCacheSet = require_mapCacheSet();
+    function MapCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    MapCache.prototype.clear = mapCacheClear;
+    MapCache.prototype["delete"] = mapCacheDelete;
+    MapCache.prototype.get = mapCacheGet;
+    MapCache.prototype.has = mapCacheHas;
+    MapCache.prototype.set = mapCacheSet;
+    module2.exports = MapCache;
+  }
+});
+
+// ../../node_modules/lodash/_stackSet.js
+var require_stackSet = __commonJS({
+  "../../node_modules/lodash/_stackSet.js"(exports, module2) {
+    var ListCache = require_ListCache();
+    var Map = require_Map();
+    var MapCache = require_MapCache();
+    var LARGE_ARRAY_SIZE = 200;
+    function stackSet(key, value) {
+      var data = this.__data__;
+      if (data instanceof ListCache) {
+        var pairs = data.__data__;
+        if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+          pairs.push([key, value]);
+          this.size = ++data.size;
+          return this;
+        }
+        data = this.__data__ = new MapCache(pairs);
+      }
+      data.set(key, value);
+      this.size = data.size;
+      return this;
+    }
+    module2.exports = stackSet;
+  }
+});
+
+// ../../node_modules/lodash/_Stack.js
+var require_Stack = __commonJS({
+  "../../node_modules/lodash/_Stack.js"(exports, module2) {
+    var ListCache = require_ListCache();
+    var stackClear = require_stackClear();
+    var stackDelete = require_stackDelete();
+    var stackGet = require_stackGet();
+    var stackHas = require_stackHas();
+    var stackSet = require_stackSet();
+    function Stack(entries) {
+      var data = this.__data__ = new ListCache(entries);
+      this.size = data.size;
+    }
+    Stack.prototype.clear = stackClear;
+    Stack.prototype["delete"] = stackDelete;
+    Stack.prototype.get = stackGet;
+    Stack.prototype.has = stackHas;
+    Stack.prototype.set = stackSet;
+    module2.exports = Stack;
+  }
+});
+
+// ../../node_modules/lodash/_setCacheAdd.js
+var require_setCacheAdd = __commonJS({
+  "../../node_modules/lodash/_setCacheAdd.js"(exports, module2) {
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    function setCacheAdd(value) {
+      this.__data__.set(value, HASH_UNDEFINED);
+      return this;
+    }
+    module2.exports = setCacheAdd;
+  }
+});
+
+// ../../node_modules/lodash/_setCacheHas.js
+var require_setCacheHas = __commonJS({
+  "../../node_modules/lodash/_setCacheHas.js"(exports, module2) {
+    function setCacheHas(value) {
+      return this.__data__.has(value);
+    }
+    module2.exports = setCacheHas;
+  }
+});
+
+// ../../node_modules/lodash/_SetCache.js
+var require_SetCache = __commonJS({
+  "../../node_modules/lodash/_SetCache.js"(exports, module2) {
+    var MapCache = require_MapCache();
+    var setCacheAdd = require_setCacheAdd();
+    var setCacheHas = require_setCacheHas();
+    function SetCache(values) {
+      var index = -1, length = values == null ? 0 : values.length;
+      this.__data__ = new MapCache();
+      while (++index < length) {
+        this.add(values[index]);
+      }
+    }
+    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+    SetCache.prototype.has = setCacheHas;
+    module2.exports = SetCache;
+  }
+});
+
+// ../../node_modules/lodash/_arraySome.js
+var require_arraySome = __commonJS({
+  "../../node_modules/lodash/_arraySome.js"(exports, module2) {
+    function arraySome(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length;
+      while (++index < length) {
+        if (predicate(array[index], index, array)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    module2.exports = arraySome;
+  }
+});
+
+// ../../node_modules/lodash/_cacheHas.js
+var require_cacheHas = __commonJS({
+  "../../node_modules/lodash/_cacheHas.js"(exports, module2) {
+    function cacheHas(cache, key) {
+      return cache.has(key);
+    }
+    module2.exports = cacheHas;
+  }
+});
+
+// ../../node_modules/lodash/_equalArrays.js
+var require_equalArrays = __commonJS({
+  "../../node_modules/lodash/_equalArrays.js"(exports, module2) {
+    var SetCache = require_SetCache();
+    var arraySome = require_arraySome();
+    var cacheHas = require_cacheHas();
+    var COMPARE_PARTIAL_FLAG = 1;
+    var COMPARE_UNORDERED_FLAG = 2;
+    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+        return false;
+      }
+      var arrStacked = stack.get(array);
+      var othStacked = stack.get(other);
+      if (arrStacked && othStacked) {
+        return arrStacked == other && othStacked == array;
+      }
+      var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
+      stack.set(array, other);
+      stack.set(other, array);
+      while (++index < arrLength) {
+        var arrValue = array[index], othValue = other[index];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+        }
+        if (compared !== void 0) {
+          if (compared) {
+            continue;
+          }
+          result = false;
+          break;
+        }
+        if (seen) {
+          if (!arraySome(other, function(othValue2, othIndex) {
+            if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+              return seen.push(othIndex);
             }
+          })) {
+            result = false;
+            break;
+          }
+        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+          result = false;
+          break;
+        }
+      }
+      stack["delete"](array);
+      stack["delete"](other);
+      return result;
+    }
+    module2.exports = equalArrays;
+  }
+});
+
+// ../../node_modules/lodash/_Uint8Array.js
+var require_Uint8Array = __commonJS({
+  "../../node_modules/lodash/_Uint8Array.js"(exports, module2) {
+    var root = require_root();
+    var Uint8Array2 = root.Uint8Array;
+    module2.exports = Uint8Array2;
+  }
+});
+
+// ../../node_modules/lodash/_mapToArray.js
+var require_mapToArray = __commonJS({
+  "../../node_modules/lodash/_mapToArray.js"(exports, module2) {
+    function mapToArray(map) {
+      var index = -1, result = Array(map.size);
+      map.forEach(function(value, key) {
+        result[++index] = [key, value];
+      });
+      return result;
+    }
+    module2.exports = mapToArray;
+  }
+});
+
+// ../../node_modules/lodash/_setToArray.js
+var require_setToArray = __commonJS({
+  "../../node_modules/lodash/_setToArray.js"(exports, module2) {
+    function setToArray(set) {
+      var index = -1, result = Array(set.size);
+      set.forEach(function(value) {
+        result[++index] = value;
+      });
+      return result;
+    }
+    module2.exports = setToArray;
+  }
+});
+
+// ../../node_modules/lodash/_equalByTag.js
+var require_equalByTag = __commonJS({
+  "../../node_modules/lodash/_equalByTag.js"(exports, module2) {
+    var Symbol2 = require_Symbol();
+    var Uint8Array2 = require_Uint8Array();
+    var eq = require_eq();
+    var equalArrays = require_equalArrays();
+    var mapToArray = require_mapToArray();
+    var setToArray = require_setToArray();
+    var COMPARE_PARTIAL_FLAG = 1;
+    var COMPARE_UNORDERED_FLAG = 2;
+    var boolTag = "[object Boolean]";
+    var dateTag = "[object Date]";
+    var errorTag = "[object Error]";
+    var mapTag = "[object Map]";
+    var numberTag = "[object Number]";
+    var regexpTag = "[object RegExp]";
+    var setTag = "[object Set]";
+    var stringTag = "[object String]";
+    var symbolTag = "[object Symbol]";
+    var arrayBufferTag = "[object ArrayBuffer]";
+    var dataViewTag = "[object DataView]";
+    var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
+    var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+      switch (tag) {
+        case dataViewTag:
+          if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+            return false;
           }
-          return o;
-        },
-        stringify: function(d, fn) {
-          return d === void 0 || typeof d === "function" ? d + "" : JSON.stringify(d, fn || _.replace);
-        },
-        parse: function(s, fn) {
-          try {
-            return JSON.parse(s, fn || _.revive);
-          } catch (e) {
-            return s;
+          object = object.buffer;
+          other = other.buffer;
+        case arrayBufferTag:
+          if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
+            return false;
           }
-        },
-        // extension hooks
-        fn: function(name, fn) {
-          _.storeAPI[name] = fn;
-          for (var api in _.apis) {
-            _.apis[api][name] = fn;
+          return true;
+        case boolTag:
+        case dateTag:
+        case numberTag:
+          return eq(+object, +other);
+        case errorTag:
+          return object.name == other.name && object.message == other.message;
+        case regexpTag:
+        case stringTag:
+          return object == other + "";
+        case mapTag:
+          var convert = mapToArray;
+        case setTag:
+          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+          convert || (convert = setToArray);
+          if (object.size != other.size && !isPartial) {
+            return false;
           }
-        },
-        get: function(area, key) {
-          return area.getItem(key);
-        },
-        set: function(area, key, string) {
-          area.setItem(key, string);
-        },
-        remove: function(area, key) {
-          area.removeItem(key);
-        },
-        key: function(area, i) {
-          return area.key(i);
-        },
-        length: function(area) {
-          return area.length;
-        },
-        clear: function(area) {
-          area.clear();
-        },
-        // core functions
-        Store: function(id, area, namespace) {
-          var store3 = _.inherit(_.storeAPI, function(key, data, overwrite) {
-            if (arguments.length === 0) {
-              return store3.getAll();
-            }
-            if (typeof data === "function") {
-              return store3.transact(key, data, overwrite);
-            }
-            if (data !== void 0) {
-              return store3.set(key, data, overwrite);
-            }
-            if (typeof key === "string" || typeof key === "number") {
-              return store3.get(key);
-            }
-            if (typeof key === "function") {
-              return store3.each(key);
-            }
-            if (!key) {
-              return store3.clear();
-            }
-            return store3.setAll(key, data);
-          });
-          store3._id = id;
-          try {
-            var testKey = "__store2_test";
-            area.setItem(testKey, "ok");
-            store3._area = area;
-            area.removeItem(testKey);
-          } catch (e) {
-            store3._area = _.storage("fake");
+          var stacked = stack.get(object);
+          if (stacked) {
+            return stacked == other;
+          }
+          bitmask |= COMPARE_UNORDERED_FLAG;
+          stack.set(object, other);
+          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+          stack["delete"](object);
+          return result;
+        case symbolTag:
+          if (symbolValueOf) {
+            return symbolValueOf.call(object) == symbolValueOf.call(other);
+          }
+      }
+      return false;
+    }
+    module2.exports = equalByTag;
+  }
+});
+
+// ../../node_modules/lodash/_arrayPush.js
+var require_arrayPush = __commonJS({
+  "../../node_modules/lodash/_arrayPush.js"(exports, module2) {
+    function arrayPush(array, values) {
+      var index = -1, length = values.length, offset = array.length;
+      while (++index < length) {
+        array[offset + index] = values[index];
+      }
+      return array;
+    }
+    module2.exports = arrayPush;
+  }
+});
+
+// ../../node_modules/lodash/_baseGetAllKeys.js
+var require_baseGetAllKeys = __commonJS({
+  "../../node_modules/lodash/_baseGetAllKeys.js"(exports, module2) {
+    var arrayPush = require_arrayPush();
+    var isArray = require_isArray();
+    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+      var result = keysFunc(object);
+      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+    }
+    module2.exports = baseGetAllKeys;
+  }
+});
+
+// ../../node_modules/lodash/_arrayFilter.js
+var require_arrayFilter = __commonJS({
+  "../../node_modules/lodash/_arrayFilter.js"(exports, module2) {
+    function arrayFilter(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+      while (++index < length) {
+        var value = array[index];
+        if (predicate(value, index, array)) {
+          result[resIndex++] = value;
+        }
+      }
+      return result;
+    }
+    module2.exports = arrayFilter;
+  }
+});
+
+// ../../node_modules/lodash/stubArray.js
+var require_stubArray = __commonJS({
+  "../../node_modules/lodash/stubArray.js"(exports, module2) {
+    function stubArray() {
+      return [];
+    }
+    module2.exports = stubArray;
+  }
+});
+
+// ../../node_modules/lodash/_getSymbols.js
+var require_getSymbols = __commonJS({
+  "../../node_modules/lodash/_getSymbols.js"(exports, module2) {
+    var arrayFilter = require_arrayFilter();
+    var stubArray = require_stubArray();
+    var objectProto = Object.prototype;
+    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+    var nativeGetSymbols = Object.getOwnPropertySymbols;
+    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+      if (object == null) {
+        return [];
+      }
+      object = Object(object);
+      return arrayFilter(nativeGetSymbols(object), function(symbol) {
+        return propertyIsEnumerable.call(object, symbol);
+      });
+    };
+    module2.exports = getSymbols;
+  }
+});
+
+// ../../node_modules/lodash/_getAllKeys.js
+var require_getAllKeys = __commonJS({
+  "../../node_modules/lodash/_getAllKeys.js"(exports, module2) {
+    var baseGetAllKeys = require_baseGetAllKeys();
+    var getSymbols = require_getSymbols();
+    var keys = require_keys();
+    function getAllKeys(object) {
+      return baseGetAllKeys(object, keys, getSymbols);
+    }
+    module2.exports = getAllKeys;
+  }
+});
+
+// ../../node_modules/lodash/_equalObjects.js
+var require_equalObjects = __commonJS({
+  "../../node_modules/lodash/_equalObjects.js"(exports, module2) {
+    var getAllKeys = require_getAllKeys();
+    var COMPARE_PARTIAL_FLAG = 1;
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+      if (objLength != othLength && !isPartial) {
+        return false;
+      }
+      var index = objLength;
+      while (index--) {
+        var key = objProps[index];
+        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+          return false;
+        }
+      }
+      var objStacked = stack.get(object);
+      var othStacked = stack.get(other);
+      if (objStacked && othStacked) {
+        return objStacked == other && othStacked == object;
+      }
+      var result = true;
+      stack.set(object, other);
+      stack.set(other, object);
+      var skipCtor = isPartial;
+      while (++index < objLength) {
+        key = objProps[index];
+        var objValue = object[key], othValue = other[key];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+        }
+        if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+          result = false;
+          break;
+        }
+        skipCtor || (skipCtor = key == "constructor");
+      }
+      if (result && !skipCtor) {
+        var objCtor = object.constructor, othCtor = other.constructor;
+        if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+          result = false;
+        }
+      }
+      stack["delete"](object);
+      stack["delete"](other);
+      return result;
+    }
+    module2.exports = equalObjects;
+  }
+});
+
+// ../../node_modules/lodash/_DataView.js
+var require_DataView = __commonJS({
+  "../../node_modules/lodash/_DataView.js"(exports, module2) {
+    var getNative = require_getNative();
+    var root = require_root();
+    var DataView = getNative(root, "DataView");
+    module2.exports = DataView;
+  }
+});
+
+// ../../node_modules/lodash/_Promise.js
+var require_Promise = __commonJS({
+  "../../node_modules/lodash/_Promise.js"(exports, module2) {
+    var getNative = require_getNative();
+    var root = require_root();
+    var Promise2 = getNative(root, "Promise");
+    module2.exports = Promise2;
+  }
+});
+
+// ../../node_modules/lodash/_Set.js
+var require_Set = __commonJS({
+  "../../node_modules/lodash/_Set.js"(exports, module2) {
+    var getNative = require_getNative();
+    var root = require_root();
+    var Set2 = getNative(root, "Set");
+    module2.exports = Set2;
+  }
+});
+
+// ../../node_modules/lodash/_WeakMap.js
+var require_WeakMap = __commonJS({
+  "../../node_modules/lodash/_WeakMap.js"(exports, module2) {
+    var getNative = require_getNative();
+    var root = require_root();
+    var WeakMap = getNative(root, "WeakMap");
+    module2.exports = WeakMap;
+  }
+});
+
+// ../../node_modules/lodash/_getTag.js
+var require_getTag = __commonJS({
+  "../../node_modules/lodash/_getTag.js"(exports, module2) {
+    var DataView = require_DataView();
+    var Map = require_Map();
+    var Promise2 = require_Promise();
+    var Set2 = require_Set();
+    var WeakMap = require_WeakMap();
+    var baseGetTag = require_baseGetTag();
+    var toSource = require_toSource();
+    var mapTag = "[object Map]";
+    var objectTag = "[object Object]";
+    var promiseTag = "[object Promise]";
+    var setTag = "[object Set]";
+    var weakMapTag = "[object WeakMap]";
+    var dataViewTag = "[object DataView]";
+    var dataViewCtorString = toSource(DataView);
+    var mapCtorString = toSource(Map);
+    var promiseCtorString = toSource(Promise2);
+    var setCtorString = toSource(Set2);
+    var weakMapCtorString = toSource(WeakMap);
+    var getTag = baseGetTag;
+    if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+      getTag = function(value) {
+        var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+        if (ctorString) {
+          switch (ctorString) {
+            case dataViewCtorString:
+              return dataViewTag;
+            case mapCtorString:
+              return mapTag;
+            case promiseCtorString:
+              return promiseTag;
+            case setCtorString:
+              return setTag;
+            case weakMapCtorString:
+              return weakMapTag;
+          }
+        }
+        return result;
+      };
+    }
+    module2.exports = getTag;
+  }
+});
+
+// ../../node_modules/lodash/_baseIsEqualDeep.js
+var require_baseIsEqualDeep = __commonJS({
+  "../../node_modules/lodash/_baseIsEqualDeep.js"(exports, module2) {
+    var Stack = require_Stack();
+    var equalArrays = require_equalArrays();
+    var equalByTag = require_equalByTag();
+    var equalObjects = require_equalObjects();
+    var getTag = require_getTag();
+    var isArray = require_isArray();
+    var isBuffer = require_isBuffer();
+    var isTypedArray = require_isTypedArray();
+    var COMPARE_PARTIAL_FLAG = 1;
+    var argsTag = "[object Arguments]";
+    var arrayTag = "[object Array]";
+    var objectTag = "[object Object]";
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+      var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+      objTag = objTag == argsTag ? objectTag : objTag;
+      othTag = othTag == argsTag ? objectTag : othTag;
+      var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+      if (isSameTag && isBuffer(object)) {
+        if (!isBuffer(other)) {
+          return false;
+        }
+        objIsArr = true;
+        objIsObj = false;
+      }
+      if (isSameTag && !objIsObj) {
+        stack || (stack = new Stack());
+        return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+      }
+      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+        var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+        if (objIsWrapped || othIsWrapped) {
+          var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+          stack || (stack = new Stack());
+          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+        }
+      }
+      if (!isSameTag) {
+        return false;
+      }
+      stack || (stack = new Stack());
+      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+    }
+    module2.exports = baseIsEqualDeep;
+  }
+});
+
+// ../../node_modules/lodash/_baseIsEqual.js
+var require_baseIsEqual = __commonJS({
+  "../../node_modules/lodash/_baseIsEqual.js"(exports, module2) {
+    var baseIsEqualDeep = require_baseIsEqualDeep();
+    var isObjectLike = require_isObjectLike();
+    function baseIsEqual(value, other, bitmask, customizer, stack) {
+      if (value === other) {
+        return true;
+      }
+      if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+        return value !== value && other !== other;
+      }
+      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+    }
+    module2.exports = baseIsEqual;
+  }
+});
+
+// ../../node_modules/lodash/_baseIsMatch.js
+var require_baseIsMatch = __commonJS({
+  "../../node_modules/lodash/_baseIsMatch.js"(exports, module2) {
+    var Stack = require_Stack();
+    var baseIsEqual = require_baseIsEqual();
+    var COMPARE_PARTIAL_FLAG = 1;
+    var COMPARE_UNORDERED_FLAG = 2;
+    function baseIsMatch(object, source, matchData, customizer) {
+      var index = matchData.length, length = index, noCustomizer = !customizer;
+      if (object == null) {
+        return !length;
+      }
+      object = Object(object);
+      while (index--) {
+        var data = matchData[index];
+        if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+          return false;
+        }
+      }
+      while (++index < length) {
+        data = matchData[index];
+        var key = data[0], objValue = object[key], srcValue = data[1];
+        if (noCustomizer && data[2]) {
+          if (objValue === void 0 && !(key in object)) {
+            return false;
+          }
+        } else {
+          var stack = new Stack();
+          if (customizer) {
+            var result = customizer(objValue, srcValue, key, object, source, stack);
+          }
+          if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result)) {
+            return false;
           }
-          store3._ns = namespace || "";
-          if (!_.areas[id]) {
-            _.areas[id] = store3._area;
+        }
+      }
+      return true;
+    }
+    module2.exports = baseIsMatch;
+  }
+});
+
+// ../../node_modules/lodash/_isStrictComparable.js
+var require_isStrictComparable = __commonJS({
+  "../../node_modules/lodash/_isStrictComparable.js"(exports, module2) {
+    var isObject = require_isObject();
+    function isStrictComparable(value) {
+      return value === value && !isObject(value);
+    }
+    module2.exports = isStrictComparable;
+  }
+});
+
+// ../../node_modules/lodash/_getMatchData.js
+var require_getMatchData = __commonJS({
+  "../../node_modules/lodash/_getMatchData.js"(exports, module2) {
+    var isStrictComparable = require_isStrictComparable();
+    var keys = require_keys();
+    function getMatchData(object) {
+      var result = keys(object), length = result.length;
+      while (length--) {
+        var key = result[length], value = object[key];
+        result[length] = [key, value, isStrictComparable(value)];
+      }
+      return result;
+    }
+    module2.exports = getMatchData;
+  }
+});
+
+// ../../node_modules/lodash/_matchesStrictComparable.js
+var require_matchesStrictComparable = __commonJS({
+  "../../node_modules/lodash/_matchesStrictComparable.js"(exports, module2) {
+    function matchesStrictComparable(key, srcValue) {
+      return function(object) {
+        if (object == null) {
+          return false;
+        }
+        return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+      };
+    }
+    module2.exports = matchesStrictComparable;
+  }
+});
+
+// ../../node_modules/lodash/_baseMatches.js
+var require_baseMatches = __commonJS({
+  "../../node_modules/lodash/_baseMatches.js"(exports, module2) {
+    var baseIsMatch = require_baseIsMatch();
+    var getMatchData = require_getMatchData();
+    var matchesStrictComparable = require_matchesStrictComparable();
+    function baseMatches(source) {
+      var matchData = getMatchData(source);
+      if (matchData.length == 1 && matchData[0][2]) {
+        return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+      }
+      return function(object) {
+        return object === source || baseIsMatch(object, source, matchData);
+      };
+    }
+    module2.exports = baseMatches;
+  }
+});
+
+// ../../node_modules/lodash/_isKey.js
+var require_isKey = __commonJS({
+  "../../node_modules/lodash/_isKey.js"(exports, module2) {
+    var isArray = require_isArray();
+    var isSymbol = require_isSymbol();
+    var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+    var reIsPlainProp = /^\w*$/;
+    function isKey(value, object) {
+      if (isArray(value)) {
+        return false;
+      }
+      var type = typeof value;
+      if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
+        return true;
+      }
+      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+    }
+    module2.exports = isKey;
+  }
+});
+
+// ../../node_modules/lodash/memoize.js
+var require_memoize = __commonJS({
+  "../../node_modules/lodash/memoize.js"(exports, module2) {
+    var MapCache = require_MapCache();
+    var FUNC_ERROR_TEXT = "Expected a function";
+    function memoize2(func, resolver) {
+      if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+        throw new TypeError(FUNC_ERROR_TEXT);
+      }
+      var memoized = function() {
+        var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+        if (cache.has(key)) {
+          return cache.get(key);
+        }
+        var result = func.apply(this, args);
+        memoized.cache = cache.set(key, result) || cache;
+        return result;
+      };
+      memoized.cache = new (memoize2.Cache || MapCache)();
+      return memoized;
+    }
+    memoize2.Cache = MapCache;
+    module2.exports = memoize2;
+  }
+});
+
+// ../../node_modules/lodash/_memoizeCapped.js
+var require_memoizeCapped = __commonJS({
+  "../../node_modules/lodash/_memoizeCapped.js"(exports, module2) {
+    var memoize2 = require_memoize();
+    var MAX_MEMOIZE_SIZE = 500;
+    function memoizeCapped(func) {
+      var result = memoize2(func, function(key) {
+        if (cache.size === MAX_MEMOIZE_SIZE) {
+          cache.clear();
+        }
+        return key;
+      });
+      var cache = result.cache;
+      return result;
+    }
+    module2.exports = memoizeCapped;
+  }
+});
+
+// ../../node_modules/lodash/_stringToPath.js
+var require_stringToPath = __commonJS({
+  "../../node_modules/lodash/_stringToPath.js"(exports, module2) {
+    var memoizeCapped = require_memoizeCapped();
+    var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+    var reEscapeChar = /\\(\\)?/g;
+    var stringToPath = memoizeCapped(function(string) {
+      var result = [];
+      if (string.charCodeAt(0) === 46) {
+        result.push("");
+      }
+      string.replace(rePropName, function(match, number, quote, subString) {
+        result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+      });
+      return result;
+    });
+    module2.exports = stringToPath;
+  }
+});
+
+// ../../node_modules/lodash/_arrayMap.js
+var require_arrayMap = __commonJS({
+  "../../node_modules/lodash/_arrayMap.js"(exports, module2) {
+    function arrayMap(array, iteratee) {
+      var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+      while (++index < length) {
+        result[index] = iteratee(array[index], index, array);
+      }
+      return result;
+    }
+    module2.exports = arrayMap;
+  }
+});
+
+// ../../node_modules/lodash/_baseToString.js
+var require_baseToString = __commonJS({
+  "../../node_modules/lodash/_baseToString.js"(exports, module2) {
+    var Symbol2 = require_Symbol();
+    var arrayMap = require_arrayMap();
+    var isArray = require_isArray();
+    var isSymbol = require_isSymbol();
+    var INFINITY = 1 / 0;
+    var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
+    var symbolToString = symbolProto ? symbolProto.toString : void 0;
+    function baseToString(value) {
+      if (typeof value == "string") {
+        return value;
+      }
+      if (isArray(value)) {
+        return arrayMap(value, baseToString) + "";
+      }
+      if (isSymbol(value)) {
+        return symbolToString ? symbolToString.call(value) : "";
+      }
+      var result = value + "";
+      return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+    }
+    module2.exports = baseToString;
+  }
+});
+
+// ../../node_modules/lodash/toString.js
+var require_toString = __commonJS({
+  "../../node_modules/lodash/toString.js"(exports, module2) {
+    var baseToString = require_baseToString();
+    function toString(value) {
+      return value == null ? "" : baseToString(value);
+    }
+    module2.exports = toString;
+  }
+});
+
+// ../../node_modules/lodash/_castPath.js
+var require_castPath = __commonJS({
+  "../../node_modules/lodash/_castPath.js"(exports, module2) {
+    var isArray = require_isArray();
+    var isKey = require_isKey();
+    var stringToPath = require_stringToPath();
+    var toString = require_toString();
+    function castPath(value, object) {
+      if (isArray(value)) {
+        return value;
+      }
+      return isKey(value, object) ? [value] : stringToPath(toString(value));
+    }
+    module2.exports = castPath;
+  }
+});
+
+// ../../node_modules/lodash/_toKey.js
+var require_toKey = __commonJS({
+  "../../node_modules/lodash/_toKey.js"(exports, module2) {
+    var isSymbol = require_isSymbol();
+    var INFINITY = 1 / 0;
+    function toKey(value) {
+      if (typeof value == "string" || isSymbol(value)) {
+        return value;
+      }
+      var result = value + "";
+      return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+    }
+    module2.exports = toKey;
+  }
+});
+
+// ../../node_modules/lodash/_baseGet.js
+var require_baseGet = __commonJS({
+  "../../node_modules/lodash/_baseGet.js"(exports, module2) {
+    var castPath = require_castPath();
+    var toKey = require_toKey();
+    function baseGet(object, path) {
+      path = castPath(path, object);
+      var index = 0, length = path.length;
+      while (object != null && index < length) {
+        object = object[toKey(path[index++])];
+      }
+      return index && index == length ? object : void 0;
+    }
+    module2.exports = baseGet;
+  }
+});
+
+// ../../node_modules/lodash/get.js
+var require_get = __commonJS({
+  "../../node_modules/lodash/get.js"(exports, module2) {
+    var baseGet = require_baseGet();
+    function get2(object, path, defaultValue) {
+      var result = object == null ? void 0 : baseGet(object, path);
+      return result === void 0 ? defaultValue : result;
+    }
+    module2.exports = get2;
+  }
+});
+
+// ../../node_modules/lodash/_baseHasIn.js
+var require_baseHasIn = __commonJS({
+  "../../node_modules/lodash/_baseHasIn.js"(exports, module2) {
+    function baseHasIn(object, key) {
+      return object != null && key in Object(object);
+    }
+    module2.exports = baseHasIn;
+  }
+});
+
+// ../../node_modules/lodash/_hasPath.js
+var require_hasPath = __commonJS({
+  "../../node_modules/lodash/_hasPath.js"(exports, module2) {
+    var castPath = require_castPath();
+    var isArguments = require_isArguments();
+    var isArray = require_isArray();
+    var isIndex = require_isIndex();
+    var isLength = require_isLength();
+    var toKey = require_toKey();
+    function hasPath(object, path, hasFunc) {
+      path = castPath(path, object);
+      var index = -1, length = path.length, result = false;
+      while (++index < length) {
+        var key = toKey(path[index]);
+        if (!(result = object != null && hasFunc(object, key))) {
+          break;
+        }
+        object = object[key];
+      }
+      if (result || ++index != length) {
+        return result;
+      }
+      length = object == null ? 0 : object.length;
+      return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
+    }
+    module2.exports = hasPath;
+  }
+});
+
+// ../../node_modules/lodash/hasIn.js
+var require_hasIn = __commonJS({
+  "../../node_modules/lodash/hasIn.js"(exports, module2) {
+    var baseHasIn = require_baseHasIn();
+    var hasPath = require_hasPath();
+    function hasIn(object, path) {
+      return object != null && hasPath(object, path, baseHasIn);
+    }
+    module2.exports = hasIn;
+  }
+});
+
+// ../../node_modules/lodash/_baseMatchesProperty.js
+var require_baseMatchesProperty = __commonJS({
+  "../../node_modules/lodash/_baseMatchesProperty.js"(exports, module2) {
+    var baseIsEqual = require_baseIsEqual();
+    var get2 = require_get();
+    var hasIn = require_hasIn();
+    var isKey = require_isKey();
+    var isStrictComparable = require_isStrictComparable();
+    var matchesStrictComparable = require_matchesStrictComparable();
+    var toKey = require_toKey();
+    var COMPARE_PARTIAL_FLAG = 1;
+    var COMPARE_UNORDERED_FLAG = 2;
+    function baseMatchesProperty(path, srcValue) {
+      if (isKey(path) && isStrictComparable(srcValue)) {
+        return matchesStrictComparable(toKey(path), srcValue);
+      }
+      return function(object) {
+        var objValue = get2(object, path);
+        return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+      };
+    }
+    module2.exports = baseMatchesProperty;
+  }
+});
+
+// ../../node_modules/lodash/identity.js
+var require_identity = __commonJS({
+  "../../node_modules/lodash/identity.js"(exports, module2) {
+    function identity(value) {
+      return value;
+    }
+    module2.exports = identity;
+  }
+});
+
+// ../../node_modules/lodash/_baseProperty.js
+var require_baseProperty = __commonJS({
+  "../../node_modules/lodash/_baseProperty.js"(exports, module2) {
+    function baseProperty(key) {
+      return function(object) {
+        return object == null ? void 0 : object[key];
+      };
+    }
+    module2.exports = baseProperty;
+  }
+});
+
+// ../../node_modules/lodash/_basePropertyDeep.js
+var require_basePropertyDeep = __commonJS({
+  "../../node_modules/lodash/_basePropertyDeep.js"(exports, module2) {
+    var baseGet = require_baseGet();
+    function basePropertyDeep(path) {
+      return function(object) {
+        return baseGet(object, path);
+      };
+    }
+    module2.exports = basePropertyDeep;
+  }
+});
+
+// ../../node_modules/lodash/property.js
+var require_property = __commonJS({
+  "../../node_modules/lodash/property.js"(exports, module2) {
+    var baseProperty = require_baseProperty();
+    var basePropertyDeep = require_basePropertyDeep();
+    var isKey = require_isKey();
+    var toKey = require_toKey();
+    function property(path) {
+      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+    }
+    module2.exports = property;
+  }
+});
+
+// ../../node_modules/lodash/_baseIteratee.js
+var require_baseIteratee = __commonJS({
+  "../../node_modules/lodash/_baseIteratee.js"(exports, module2) {
+    var baseMatches = require_baseMatches();
+    var baseMatchesProperty = require_baseMatchesProperty();
+    var identity = require_identity();
+    var isArray = require_isArray();
+    var property = require_property();
+    function baseIteratee(value) {
+      if (typeof value == "function") {
+        return value;
+      }
+      if (value == null) {
+        return identity;
+      }
+      if (typeof value == "object") {
+        return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+      }
+      return property(value);
+    }
+    module2.exports = baseIteratee;
+  }
+});
+
+// ../../node_modules/lodash/_createAggregator.js
+var require_createAggregator = __commonJS({
+  "../../node_modules/lodash/_createAggregator.js"(exports, module2) {
+    var arrayAggregator = require_arrayAggregator();
+    var baseAggregator = require_baseAggregator();
+    var baseIteratee = require_baseIteratee();
+    var isArray = require_isArray();
+    function createAggregator(setter, initializer) {
+      return function(collection, iteratee) {
+        var func = isArray(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {};
+        return func(collection, setter, baseIteratee(iteratee, 2), accumulator);
+      };
+    }
+    module2.exports = createAggregator;
+  }
+});
+
+// ../../node_modules/lodash/countBy.js
+var require_countBy = __commonJS({
+  "../../node_modules/lodash/countBy.js"(exports, module2) {
+    var baseAssignValue = require_baseAssignValue();
+    var createAggregator = require_createAggregator();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var countBy2 = createAggregator(function(result, value, key) {
+      if (hasOwnProperty.call(result, key)) {
+        ++result[key];
+      } else {
+        baseAssignValue(result, key, 1);
+      }
+    });
+    module2.exports = countBy2;
+  }
+});
+
+// ../../node_modules/lodash/isEqual.js
+var require_isEqual = __commonJS({
+  "../../node_modules/lodash/isEqual.js"(exports, module2) {
+    var baseIsEqual = require_baseIsEqual();
+    function isEqual2(value, other) {
+      return baseIsEqual(value, other);
+    }
+    module2.exports = isEqual2;
+  }
+});
+
+// ../../node_modules/lodash/_assignMergeValue.js
+var require_assignMergeValue = __commonJS({
+  "../../node_modules/lodash/_assignMergeValue.js"(exports, module2) {
+    var baseAssignValue = require_baseAssignValue();
+    var eq = require_eq();
+    function assignMergeValue(object, key, value) {
+      if (value !== void 0 && !eq(object[key], value) || value === void 0 && !(key in object)) {
+        baseAssignValue(object, key, value);
+      }
+    }
+    module2.exports = assignMergeValue;
+  }
+});
+
+// ../../node_modules/lodash/_cloneBuffer.js
+var require_cloneBuffer = __commonJS({
+  "../../node_modules/lodash/_cloneBuffer.js"(exports, module2) {
+    var root = require_root();
+    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+    var freeModule = freeExports && typeof module2 == "object" && module2 && !module2.nodeType && module2;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var Buffer2 = moduleExports ? root.Buffer : void 0;
+    var allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : void 0;
+    function cloneBuffer(buffer, isDeep) {
+      if (isDeep) {
+        return buffer.slice();
+      }
+      var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+      buffer.copy(result);
+      return result;
+    }
+    module2.exports = cloneBuffer;
+  }
+});
+
+// ../../node_modules/lodash/_cloneArrayBuffer.js
+var require_cloneArrayBuffer = __commonJS({
+  "../../node_modules/lodash/_cloneArrayBuffer.js"(exports, module2) {
+    var Uint8Array2 = require_Uint8Array();
+    function cloneArrayBuffer(arrayBuffer) {
+      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+      new Uint8Array2(result).set(new Uint8Array2(arrayBuffer));
+      return result;
+    }
+    module2.exports = cloneArrayBuffer;
+  }
+});
+
+// ../../node_modules/lodash/_cloneTypedArray.js
+var require_cloneTypedArray = __commonJS({
+  "../../node_modules/lodash/_cloneTypedArray.js"(exports, module2) {
+    var cloneArrayBuffer = require_cloneArrayBuffer();
+    function cloneTypedArray(typedArray, isDeep) {
+      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+    }
+    module2.exports = cloneTypedArray;
+  }
+});
+
+// ../../node_modules/lodash/_copyArray.js
+var require_copyArray = __commonJS({
+  "../../node_modules/lodash/_copyArray.js"(exports, module2) {
+    function copyArray(source, array) {
+      var index = -1, length = source.length;
+      array || (array = Array(length));
+      while (++index < length) {
+        array[index] = source[index];
+      }
+      return array;
+    }
+    module2.exports = copyArray;
+  }
+});
+
+// ../../node_modules/lodash/_baseCreate.js
+var require_baseCreate = __commonJS({
+  "../../node_modules/lodash/_baseCreate.js"(exports, module2) {
+    var isObject = require_isObject();
+    var objectCreate = Object.create;
+    var baseCreate = function() {
+      function object() {
+      }
+      return function(proto) {
+        if (!isObject(proto)) {
+          return {};
+        }
+        if (objectCreate) {
+          return objectCreate(proto);
+        }
+        object.prototype = proto;
+        var result = new object();
+        object.prototype = void 0;
+        return result;
+      };
+    }();
+    module2.exports = baseCreate;
+  }
+});
+
+// ../../node_modules/lodash/_getPrototype.js
+var require_getPrototype = __commonJS({
+  "../../node_modules/lodash/_getPrototype.js"(exports, module2) {
+    var overArg = require_overArg();
+    var getPrototype = overArg(Object.getPrototypeOf, Object);
+    module2.exports = getPrototype;
+  }
+});
+
+// ../../node_modules/lodash/_initCloneObject.js
+var require_initCloneObject = __commonJS({
+  "../../node_modules/lodash/_initCloneObject.js"(exports, module2) {
+    var baseCreate = require_baseCreate();
+    var getPrototype = require_getPrototype();
+    var isPrototype = require_isPrototype();
+    function initCloneObject(object) {
+      return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
+    }
+    module2.exports = initCloneObject;
+  }
+});
+
+// ../../node_modules/lodash/isArrayLikeObject.js
+var require_isArrayLikeObject = __commonJS({
+  "../../node_modules/lodash/isArrayLikeObject.js"(exports, module2) {
+    var isArrayLike = require_isArrayLike();
+    var isObjectLike = require_isObjectLike();
+    function isArrayLikeObject(value) {
+      return isObjectLike(value) && isArrayLike(value);
+    }
+    module2.exports = isArrayLikeObject;
+  }
+});
+
+// ../../node_modules/lodash/isPlainObject.js
+var require_isPlainObject = __commonJS({
+  "../../node_modules/lodash/isPlainObject.js"(exports, module2) {
+    var baseGetTag = require_baseGetTag();
+    var getPrototype = require_getPrototype();
+    var isObjectLike = require_isObjectLike();
+    var objectTag = "[object Object]";
+    var funcProto = Function.prototype;
+    var objectProto = Object.prototype;
+    var funcToString = funcProto.toString;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var objectCtorString = funcToString.call(Object);
+    function isPlainObject(value) {
+      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
+        return false;
+      }
+      var proto = getPrototype(value);
+      if (proto === null) {
+        return true;
+      }
+      var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
+      return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+    }
+    module2.exports = isPlainObject;
+  }
+});
+
+// ../../node_modules/lodash/_safeGet.js
+var require_safeGet = __commonJS({
+  "../../node_modules/lodash/_safeGet.js"(exports, module2) {
+    function safeGet(object, key) {
+      if (key === "constructor" && typeof object[key] === "function") {
+        return;
+      }
+      if (key == "__proto__") {
+        return;
+      }
+      return object[key];
+    }
+    module2.exports = safeGet;
+  }
+});
+
+// ../../node_modules/lodash/_assignValue.js
+var require_assignValue = __commonJS({
+  "../../node_modules/lodash/_assignValue.js"(exports, module2) {
+    var baseAssignValue = require_baseAssignValue();
+    var eq = require_eq();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    function assignValue(object, key, value) {
+      var objValue = object[key];
+      if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
+        baseAssignValue(object, key, value);
+      }
+    }
+    module2.exports = assignValue;
+  }
+});
+
+// ../../node_modules/lodash/_copyObject.js
+var require_copyObject = __commonJS({
+  "../../node_modules/lodash/_copyObject.js"(exports, module2) {
+    var assignValue = require_assignValue();
+    var baseAssignValue = require_baseAssignValue();
+    function copyObject(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(object, key, newValue);
+        }
+      }
+      return object;
+    }
+    module2.exports = copyObject;
+  }
+});
+
+// ../../node_modules/lodash/_nativeKeysIn.js
+var require_nativeKeysIn = __commonJS({
+  "../../node_modules/lodash/_nativeKeysIn.js"(exports, module2) {
+    function nativeKeysIn(object) {
+      var result = [];
+      if (object != null) {
+        for (var key in Object(object)) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    module2.exports = nativeKeysIn;
+  }
+});
+
+// ../../node_modules/lodash/_baseKeysIn.js
+var require_baseKeysIn = __commonJS({
+  "../../node_modules/lodash/_baseKeysIn.js"(exports, module2) {
+    var isObject = require_isObject();
+    var isPrototype = require_isPrototype();
+    var nativeKeysIn = require_nativeKeysIn();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    function baseKeysIn(object) {
+      if (!isObject(object)) {
+        return nativeKeysIn(object);
+      }
+      var isProto = isPrototype(object), result = [];
+      for (var key in object) {
+        if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    module2.exports = baseKeysIn;
+  }
+});
+
+// ../../node_modules/lodash/keysIn.js
+var require_keysIn = __commonJS({
+  "../../node_modules/lodash/keysIn.js"(exports, module2) {
+    var arrayLikeKeys = require_arrayLikeKeys();
+    var baseKeysIn = require_baseKeysIn();
+    var isArrayLike = require_isArrayLike();
+    function keysIn(object) {
+      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+    }
+    module2.exports = keysIn;
+  }
+});
+
+// ../../node_modules/lodash/toPlainObject.js
+var require_toPlainObject = __commonJS({
+  "../../node_modules/lodash/toPlainObject.js"(exports, module2) {
+    var copyObject = require_copyObject();
+    var keysIn = require_keysIn();
+    function toPlainObject(value) {
+      return copyObject(value, keysIn(value));
+    }
+    module2.exports = toPlainObject;
+  }
+});
+
+// ../../node_modules/lodash/_baseMergeDeep.js
+var require_baseMergeDeep = __commonJS({
+  "../../node_modules/lodash/_baseMergeDeep.js"(exports, module2) {
+    var assignMergeValue = require_assignMergeValue();
+    var cloneBuffer = require_cloneBuffer();
+    var cloneTypedArray = require_cloneTypedArray();
+    var copyArray = require_copyArray();
+    var initCloneObject = require_initCloneObject();
+    var isArguments = require_isArguments();
+    var isArray = require_isArray();
+    var isArrayLikeObject = require_isArrayLikeObject();
+    var isBuffer = require_isBuffer();
+    var isFunction = require_isFunction();
+    var isObject = require_isObject();
+    var isPlainObject = require_isPlainObject();
+    var isTypedArray = require_isTypedArray();
+    var safeGet = require_safeGet();
+    var toPlainObject = require_toPlainObject();
+    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+      var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
+      if (stacked) {
+        assignMergeValue(object, key, stacked);
+        return;
+      }
+      var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
+      var isCommon = newValue === void 0;
+      if (isCommon) {
+        var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+        newValue = srcValue;
+        if (isArr || isBuff || isTyped) {
+          if (isArray(objValue)) {
+            newValue = objValue;
+          } else if (isArrayLikeObject(objValue)) {
+            newValue = copyArray(objValue);
+          } else if (isBuff) {
+            isCommon = false;
+            newValue = cloneBuffer(srcValue, true);
+          } else if (isTyped) {
+            isCommon = false;
+            newValue = cloneTypedArray(srcValue, true);
+          } else {
+            newValue = [];
           }
-          if (!_.apis[store3._ns + store3._id]) {
-            _.apis[store3._ns + store3._id] = store3;
+        } else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+          newValue = objValue;
+          if (isArguments(objValue)) {
+            newValue = toPlainObject(objValue);
+          } else if (!isObject(objValue) || isFunction(objValue)) {
+            newValue = initCloneObject(srcValue);
           }
-          return store3;
-        },
-        storeAPI: {
-          // admin functions
-          area: function(id, area) {
-            var store3 = this[id];
-            if (!store3 || !store3.area) {
-              store3 = _.Store(id, area, this._ns);
-              if (!this[id]) {
-                this[id] = store3;
-              }
-            }
-            return store3;
-          },
-          namespace: function(namespace, singleArea, delim) {
-            delim = delim || this._delim || _.nsdelim;
-            if (!namespace) {
-              return this._ns ? this._ns.substring(0, this._ns.length - delim.length) : "";
-            }
-            var ns = namespace, store3 = this[ns];
-            if (!store3 || !store3.namespace) {
-              store3 = _.Store(this._id, this._area, this._ns + ns + delim);
-              store3._delim = delim;
-              if (!this[ns]) {
-                this[ns] = store3;
-              }
-              if (!singleArea) {
-                for (var name in _.areas) {
-                  store3.area(name, _.areas[name]);
-                }
-              }
-            }
-            return store3;
-          },
-          isFake: function(force) {
-            if (force) {
-              this._real = this._area;
-              this._area = _.storage("fake");
-            } else if (force === false) {
-              this._area = this._real || this._area;
-            }
-            return this._area.name === "fake";
-          },
-          toString: function() {
-            return "store" + (this._ns ? "." + this.namespace() : "") + "[" + this._id + "]";
-          },
-          // storage functions
-          has: function(key) {
-            if (this._area.has) {
-              return this._area.has(this._in(key));
-            }
-            return !!(this._in(key) in this._area);
-          },
-          size: function() {
-            return this.keys().length;
-          },
-          each: function(fn, fill) {
-            for (var i = 0, m = _.length(this._area); i < m; i++) {
-              var key = this._out(_.key(this._area, i));
-              if (key !== void 0) {
-                if (fn.call(this, key, this.get(key), fill) === false) {
-                  break;
-                }
-              }
-              if (m > _.length(this._area)) {
-                m--;
-                i--;
-              }
-            }
-            return fill || this;
-          },
-          keys: function(fillList) {
-            return this.each(function(k, v, list) {
-              list.push(k);
-            }, fillList || []);
-          },
-          get: function(key, alt) {
-            var s = _.get(this._area, this._in(key)), fn;
-            if (typeof alt === "function") {
-              fn = alt;
-              alt = null;
-            }
-            return s !== null ? _.parse(s, fn) : alt != null ? alt : s;
-          },
-          getAll: function(fillObj) {
-            return this.each(function(k, v, all) {
-              all[k] = v;
-            }, fillObj || {});
-          },
-          transact: function(key, fn, alt) {
-            var val = this.get(key, alt), ret = fn(val);
-            this.set(key, ret === void 0 ? val : ret);
-            return this;
-          },
-          set: function(key, data, overwrite) {
-            var d = this.get(key), replacer;
-            if (d != null && overwrite === false) {
-              return data;
-            }
-            if (typeof overwrite === "function") {
-              replacer = overwrite;
-              overwrite = void 0;
-            }
-            return _.set(this._area, this._in(key), _.stringify(data, replacer), overwrite) || d;
-          },
-          setAll: function(data, overwrite) {
-            var changed, val;
-            for (var key in data) {
-              val = data[key];
-              if (this.set(key, val, overwrite) !== val) {
-                changed = true;
-              }
-            }
-            return changed;
-          },
-          add: function(key, data, replacer) {
-            var d = this.get(key);
-            if (d instanceof Array) {
-              data = d.concat(data);
-            } else if (d !== null) {
-              var type = typeof d;
-              if (type === typeof data && type === "object") {
-                for (var k in data) {
-                  d[k] = data[k];
-                }
-                data = d;
-              } else {
-                data = d + data;
-              }
-            }
-            _.set(this._area, this._in(key), _.stringify(data, replacer));
-            return data;
-          },
-          remove: function(key, alt) {
-            var d = this.get(key, alt);
-            _.remove(this._area, this._in(key));
-            return d;
-          },
-          clear: function() {
-            if (!this._ns) {
-              _.clear(this._area);
-            } else {
-              this.each(function(k) {
-                _.remove(this._area, this._in(k));
-              }, 1);
-            }
-            return this;
-          },
-          clearAll: function() {
-            var area = this._area;
-            for (var id in _.areas) {
-              if (_.areas.hasOwnProperty(id)) {
-                this._area = _.areas[id];
-                this.clear();
-              }
-            }
-            this._area = area;
-            return this;
-          },
-          // internal use functions
-          _in: function(k) {
-            if (typeof k !== "string") {
-              k = _.stringify(k);
-            }
-            return this._ns ? this._ns + k : k;
-          },
-          _out: function(k) {
-            return this._ns ? k && k.indexOf(this._ns) === 0 ? k.substring(this._ns.length) : void 0 : (
-              // so each() knows to skip it
-              k
-            );
+        } else {
+          isCommon = false;
+        }
+      }
+      if (isCommon) {
+        stack.set(srcValue, newValue);
+        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+        stack["delete"](srcValue);
+      }
+      assignMergeValue(object, key, newValue);
+    }
+    module2.exports = baseMergeDeep;
+  }
+});
+
+// ../../node_modules/lodash/_baseMerge.js
+var require_baseMerge = __commonJS({
+  "../../node_modules/lodash/_baseMerge.js"(exports, module2) {
+    var Stack = require_Stack();
+    var assignMergeValue = require_assignMergeValue();
+    var baseFor = require_baseFor();
+    var baseMergeDeep = require_baseMergeDeep();
+    var isObject = require_isObject();
+    var keysIn = require_keysIn();
+    var safeGet = require_safeGet();
+    function baseMerge(object, source, srcIndex, customizer, stack) {
+      if (object === source) {
+        return;
+      }
+      baseFor(source, function(srcValue, key) {
+        stack || (stack = new Stack());
+        if (isObject(srcValue)) {
+          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+        } else {
+          var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
+          if (newValue === void 0) {
+            newValue = srcValue;
           }
-        },
-        // end _.storeAPI
-        storage: function(name) {
-          return _.inherit(_.storageAPI, { items: {}, name });
-        },
-        storageAPI: {
-          length: 0,
-          has: function(k) {
-            return this.items.hasOwnProperty(k);
-          },
-          key: function(i) {
-            var c = 0;
-            for (var k in this.items) {
-              if (this.has(k) && i === c++) {
-                return k;
-              }
-            }
-          },
-          setItem: function(k, v) {
-            if (!this.has(k)) {
-              this.length++;
-            }
-            this.items[k] = v;
-          },
-          removeItem: function(k) {
-            if (this.has(k)) {
-              delete this.items[k];
-              this.length--;
-            }
-          },
-          getItem: function(k) {
-            return this.has(k) ? this.items[k] : null;
-          },
-          clear: function() {
-            for (var k in this.items) {
-              this.removeItem(k);
-            }
+          assignMergeValue(object, key, newValue);
+        }
+      }, keysIn);
+    }
+    module2.exports = baseMerge;
+  }
+});
+
+// ../../node_modules/lodash/_apply.js
+var require_apply = __commonJS({
+  "../../node_modules/lodash/_apply.js"(exports, module2) {
+    function apply(func, thisArg, args) {
+      switch (args.length) {
+        case 0:
+          return func.call(thisArg);
+        case 1:
+          return func.call(thisArg, args[0]);
+        case 2:
+          return func.call(thisArg, args[0], args[1]);
+        case 3:
+          return func.call(thisArg, args[0], args[1], args[2]);
+      }
+      return func.apply(thisArg, args);
+    }
+    module2.exports = apply;
+  }
+});
+
+// ../../node_modules/lodash/_overRest.js
+var require_overRest = __commonJS({
+  "../../node_modules/lodash/_overRest.js"(exports, module2) {
+    var apply = require_apply();
+    var nativeMax = Math.max;
+    function overRest(func, start, transform) {
+      start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+      return function() {
+        var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+        while (++index < length) {
+          array[index] = args[start + index];
+        }
+        index = -1;
+        var otherArgs = Array(start + 1);
+        while (++index < start) {
+          otherArgs[index] = args[index];
+        }
+        otherArgs[start] = transform(array);
+        return apply(func, this, otherArgs);
+      };
+    }
+    module2.exports = overRest;
+  }
+});
+
+// ../../node_modules/lodash/constant.js
+var require_constant = __commonJS({
+  "../../node_modules/lodash/constant.js"(exports, module2) {
+    function constant(value) {
+      return function() {
+        return value;
+      };
+    }
+    module2.exports = constant;
+  }
+});
+
+// ../../node_modules/lodash/_baseSetToString.js
+var require_baseSetToString = __commonJS({
+  "../../node_modules/lodash/_baseSetToString.js"(exports, module2) {
+    var constant = require_constant();
+    var defineProperty = require_defineProperty();
+    var identity = require_identity();
+    var baseSetToString = !defineProperty ? identity : function(func, string) {
+      return defineProperty(func, "toString", {
+        "configurable": true,
+        "enumerable": false,
+        "value": constant(string),
+        "writable": true
+      });
+    };
+    module2.exports = baseSetToString;
+  }
+});
+
+// ../../node_modules/lodash/_shortOut.js
+var require_shortOut = __commonJS({
+  "../../node_modules/lodash/_shortOut.js"(exports, module2) {
+    var HOT_COUNT = 800;
+    var HOT_SPAN = 16;
+    var nativeNow = Date.now;
+    function shortOut(func) {
+      var count = 0, lastCalled = 0;
+      return function() {
+        var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
+        lastCalled = stamp;
+        if (remaining > 0) {
+          if (++count >= HOT_COUNT) {
+            return arguments[0];
           }
+        } else {
+          count = 0;
+        }
+        return func.apply(void 0, arguments);
+      };
+    }
+    module2.exports = shortOut;
+  }
+});
+
+// ../../node_modules/lodash/_setToString.js
+var require_setToString = __commonJS({
+  "../../node_modules/lodash/_setToString.js"(exports, module2) {
+    var baseSetToString = require_baseSetToString();
+    var shortOut = require_shortOut();
+    var setToString = shortOut(baseSetToString);
+    module2.exports = setToString;
+  }
+});
+
+// ../../node_modules/lodash/_baseRest.js
+var require_baseRest = __commonJS({
+  "../../node_modules/lodash/_baseRest.js"(exports, module2) {
+    var identity = require_identity();
+    var overRest = require_overRest();
+    var setToString = require_setToString();
+    function baseRest(func, start) {
+      return setToString(overRest(func, start, identity), func + "");
+    }
+    module2.exports = baseRest;
+  }
+});
+
+// ../../node_modules/lodash/_isIterateeCall.js
+var require_isIterateeCall = __commonJS({
+  "../../node_modules/lodash/_isIterateeCall.js"(exports, module2) {
+    var eq = require_eq();
+    var isArrayLike = require_isArrayLike();
+    var isIndex = require_isIndex();
+    var isObject = require_isObject();
+    function isIterateeCall(value, index, object) {
+      if (!isObject(object)) {
+        return false;
+      }
+      var type = typeof index;
+      if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
+        return eq(object[index], value);
+      }
+      return false;
+    }
+    module2.exports = isIterateeCall;
+  }
+});
+
+// ../../node_modules/lodash/_createAssigner.js
+var require_createAssigner = __commonJS({
+  "../../node_modules/lodash/_createAssigner.js"(exports, module2) {
+    var baseRest = require_baseRest();
+    var isIterateeCall = require_isIterateeCall();
+    function createAssigner(assigner) {
+      return baseRest(function(object, sources) {
+        var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
+        customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
+        if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+          customizer = length < 3 ? void 0 : customizer;
+          length = 1;
         }
-        // end _.storageAPI
-      };
-      var store2 = (
-        // safely set this up (throws error in IE10/32bit mode for local files)
-        _.Store("local", function() {
-          try {
-            return localStorage;
-          } catch (e) {
+        object = Object(object);
+        while (++index < length) {
+          var source = sources[index];
+          if (source) {
+            assigner(object, source, index, customizer);
           }
-        }())
-      );
-      store2.local = store2;
-      store2._ = _;
-      store2.area("session", function() {
-        try {
-          return sessionStorage;
-        } catch (e) {
-        }
-      }());
-      store2.area("page", _.storage("page"));
-      if (typeof define === "function" && define.amd !== void 0) {
-        define("store2", [], function() {
-          return store2;
-        });
-      } else if (typeof module2 !== "undefined" && module2.exports) {
-        module2.exports = store2;
-      } else {
-        if (window.store) {
-          _.conflict = window.store;
         }
-        window.store = store2;
-      }
-    })(exports, exports && exports.define);
+        return object;
+      });
+    }
+    module2.exports = createAssigner;
   }
 });
 
-// ../../node_modules/@storybook/types/dist/index.js
-var require_dist = __commonJS({
-  "../../node_modules/@storybook/types/dist/index.js"(exports, module2) {
-    "use strict";
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-    var __export2 = (target, all) => {
-      for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
-    };
-    var __copyProps2 = (to, from, except, desc) => {
-      if (from && typeof from == "object" || typeof from == "function")
-        for (let key of __getOwnPropNames2(from))
-          !__hasOwnProp2.call(to, key) && key !== except && __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
-      return to;
-    };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var src_exports2 = {};
-    __export2(src_exports2, { Addon_TypesEnum: () => Addon_TypesEnum2 });
-    module2.exports = __toCommonJS2(src_exports2);
-    var Addon_TypesEnum2 = ((Addon_TypesEnum22) => (Addon_TypesEnum22.TAB = "tab", Addon_TypesEnum22.PANEL = "panel", Addon_TypesEnum22.TOOL = "tool", Addon_TypesEnum22.TOOLEXTRA = "toolextra", Addon_TypesEnum22.PREVIEW = "preview", Addon_TypesEnum22.experimental_PAGE = "page", Addon_TypesEnum22.experimental_SIDEBAR_BOTTOM = "sidebar-bottom", Addon_TypesEnum22.experimental_SIDEBAR_TOP = "sidebar-top", Addon_TypesEnum22))(Addon_TypesEnum2 || {});
+// ../../node_modules/lodash/mergeWith.js
+var require_mergeWith = __commonJS({
+  "../../node_modules/lodash/mergeWith.js"(exports, module2) {
+    var baseMerge = require_baseMerge();
+    var createAssigner = require_createAssigner();
+    var mergeWith2 = createAssigner(function(object, source, srcIndex, customizer) {
+      baseMerge(object, source, srcIndex, customizer);
+    });
+    module2.exports = mergeWith2;
   }
 });
 
@@ -699,6 +2932,9 @@ __export(src_exports, {
   StoryNode: () => StoryNode,
   Tree: () => Tree,
   isExpandType: () => isExpandType,
+  transformStoryIndexToStoriesHash: () => transformStoryIndexToStoriesHash,
+  transformStoryIndexV2toV3: () => transformStoryIndexV2toV3,
+  transformStoryIndexV3toV4: () => transformStoryIndexV3toV4,
   useCombination: () => useCombination,
   useLayout: () => useLayout
 });
@@ -823,7 +3059,6 @@ var LeafNode = import_react_native_theming2.styled.TouchableOpacity(
     paddingTop: 5,
     paddingBottom: 4,
     backgroundColor: selected ? theme.color.secondary : void 0,
-    // flex: 1,
     // not sure 👇
     width: "100%",
     borderRadius: 4,
@@ -896,7 +3131,6 @@ var StoryNode = import_react.default.memo(function StoryNode2({
 });
 
 // src/Tree.tsx
-var import_manager_api2 = require("@storybook/manager-api");
 var import_react_native_theming5 = require("@storybook/react-native-theming");
 var import_react6 = __toESM(require("react"));
 
@@ -906,7 +3140,6 @@ var import_react2 = require("react");
 var import_jsx_runtime6 = require("react/jsx-runtime");
 var Button = (0, import_react2.forwardRef)(
   ({
-    // asChild = false,
     Icon,
     animation = "none",
     size = "small",
@@ -957,17 +3190,9 @@ var Button = (0, import_react2.forwardRef)(
   }
 );
 Button.displayName = "Button";
-var StyledButton = import_react_native_theming3.styled.TouchableOpacity(({
-  theme,
-  variant,
-  size,
-  disabled,
-  active,
-  /* animating, animation, */
-  padding
-}) => ({
+var StyledButton = import_react_native_theming3.styled.TouchableOpacity(({ theme, variant, size, disabled, active, padding }) => ({
   border: 0,
-  cursor: disabled ? "not-allowed" : "pointer",
+  // cursor: disabled ? 'not-allowed' : 'pointer',
   display: "flex",
   flexDirection: "row",
   gap: 6,
@@ -988,11 +3213,9 @@ var StyledButton = import_react_native_theming3.styled.TouchableOpacity(({
   paddingVertical: 0,
   height: size === "small" ? 28 : 32,
   position: "relative",
-  //   textDecoration: 'none',
   transitionProperty: "background, box-shadow",
   transitionDuration: "150ms",
   transitionTimingFunction: "ease-out",
-  // verticalAlign: 'top',
   whiteSpace: "nowrap",
   userSelect: "none",
   opacity: disabled ? 0.5 : 1,
@@ -1010,34 +3233,6 @@ var StyledButton = import_react_native_theming3.styled.TouchableOpacity(({
   borderRadius: theme.input.borderRadius,
   // Making sure that the button never shrinks below its minimum size
   flexShrink: 0
-  //   '&:hover': {
-  //     color: variant === 'ghost' ? theme.color.secondary : null,
-  //     background: (() => {
-  //       let bgColor = theme.color.secondary;
-  //       if (variant === 'solid') bgColor = theme.color.secondary;
-  //       if (variant === 'outline') bgColor = theme.button.background;
-  //       if (variant === 'ghost') return transparentize(0.86, theme.color.secondary);
-  //       return theme.base === 'light' ? darken(0.02, bgColor) : lighten(0.03, bgColor);
-  //     })(),
-  //   },
-  //   '&:active': {
-  //     color: variant === 'ghost' ? theme.color.secondary : null,
-  //     background: (() => {
-  //       let bgColor = theme.color.secondary;
-  //       if (variant === 'solid') bgColor = theme.color.secondary;
-  //       if (variant === 'outline') bgColor = theme.button.background;
-  //       if (variant === 'ghost') return theme.background.hoverable;
-  //       return theme.base === 'light' ? darken(0.02, bgColor) : lighten(0.03, bgColor);
-  //     })(),
-  //   },
-  //   '&:focus': {
-  //     boxShadow: `${rgba(theme.color.secondary, 1)} 0 0 0 1px inset`,
-  //     outline: 'none',
-  //   },
-  //   '> svg': {
-  //     animation:
-  //       animating && animation !== 'none' ? `${theme.animation[animation]} 1000ms ease-out` : '',
-  //   },
 }));
 var ButtonText = import_react_native_theming3.styled.Text(({ theme, variant, active }) => ({
   color: (() => {
@@ -1054,7 +3249,6 @@ var ButtonText = import_react_native_theming3.styled.Text(({ theme, variant, act
   flexDirection: "row",
   gap: 6,
   textAlign: "center",
-  // lineHeight: theme.typography.size.s1,
   fontSize: theme.typography.size.s1,
   fontWeight: theme.typography.weight.bold
 }));
@@ -1096,8 +3290,6 @@ var IconButton = (0, import_react3.forwardRef)(
 IconButton.displayName = "IconButton";
 
 // src/useExpanded.ts
-var import_manager_api = require("@storybook/manager-api");
-var import_core_events = require("@storybook/core-events");
 var import_react4 = require("react");
 
 // src/util/tree.ts
@@ -1163,10 +3355,7 @@ var isStoryHoistable = (storyName, componentName) => removeNoiseFromName(storyNa
 
 // src/useExpanded.ts
 var initializeExpanded = ({
-  //   refId,
-  //   data,
   initialExpanded,
-  //   highlightedRef,
   rootIds
 }) => {
   const highlightedAncestors = [];
@@ -1175,30 +3364,16 @@ var initializeExpanded = ({
     {}
   );
 };
-var noop = () => {
-};
 var useExpanded = ({
-  //   containerRef,
-  //   isBrowsing,
   refId,
   data,
   initialExpanded,
   rootIds,
-  //   highlightedRef,
-  //   setHighlightedItemId,
-  // onSelectStoryId,
   selectedStoryId
 }) => {
-  const api = (0, import_manager_api.useStorybookApi)();
   const [expanded, setExpanded] = (0, import_react4.useReducer)(
     (state, { ids, value }) => ids.reduce((acc, id) => Object.assign(acc, { [id]: value }), { ...state }),
-    {
-      refId,
-      data,
-      /* highlightedRef */
-      rootIds,
-      initialExpanded
-    },
+    { refId, data, rootIds, initialExpanded },
     initializeExpanded
   );
   const updateExpanded = (0, import_react4.useCallback)(({ ids, value }) => {
@@ -1207,23 +3382,6 @@ var useExpanded = ({
   (0, import_react4.useEffect)(() => {
     setExpanded({ ids: getAncestorIds(data, selectedStoryId), value: true });
   }, [data, selectedStoryId]);
-  const collapseAll = (0, import_react4.useCallback)(() => {
-    const ids = Object.keys(data).filter((id) => !rootIds.includes(id));
-    setExpanded({ ids, value: false });
-  }, [data, rootIds]);
-  const expandAll = (0, import_react4.useCallback)(() => {
-    setExpanded({ ids: Object.keys(data), value: true });
-  }, [data]);
-  (0, import_react4.useEffect)(() => {
-    if (!api)
-      return noop;
-    api.on(import_core_events.STORIES_COLLAPSE_ALL, collapseAll);
-    api.on(import_core_events.STORIES_EXPAND_ALL, expandAll);
-    return () => {
-      api.off(import_core_events.STORIES_COLLAPSE_ALL, collapseAll);
-      api.off(import_core_events.STORIES_EXPAND_ALL, expandAll);
-    };
-  }, [api, collapseAll, expandAll]);
   return [expanded, updateExpanded];
 };
 
@@ -1375,7 +3533,6 @@ var useLayout = () => (0, import_react5.useContext)(LayoutContext);
 var import_jsx_runtime12 = require("react/jsx-runtime");
 var Node = import_react6.default.memo(function Node2({
   item,
-  //   status,
   refId,
   isOrphan,
   isDisplayed,
@@ -1385,8 +3542,7 @@ var Node = import_react6.default.memo(function Node2({
   setFullyExpanded,
   isExpanded,
   setExpanded,
-  onSelectStoryId,
-  api: _1
+  onSelectStoryId
 }) {
   const { isDesktop, isMobile, closeMobileMenu } = useLayout();
   if (!isDisplayed) {
@@ -1412,43 +3568,36 @@ var Node = import_react6.default.memo(function Node2({
     ) });
   }
   if (item.type === "root") {
-    return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
-      RootNode,
-      {
-        id,
-        children: [
-          /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
-            CollapseButton,
-            {
-              "data-action": "collapse-root",
-              onPress: (event) => {
-                event.preventDefault();
-                setExpanded({ ids: [item.id], value: !isExpanded });
-              },
-              "aria-expanded": isExpanded,
-              children: [
-                /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CollapseIcon, { isExpanded }),
-                /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_react_native2.Text, { children: item.renderLabel?.(item) || item.name })
-              ]
-            }
-          ),
-          isExpanded && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
-            IconButton,
-            {
-              "aria-label": isFullyExpanded ? "Expand" : "Collapse",
-              "data-action": "expand-all",
-              "data-expanded": isFullyExpanded,
-              onPress: (event) => {
-                event.preventDefault();
-                setFullyExpanded();
-              },
-              children: isFullyExpanded ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CollapseAllIcon, {}) : /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(ExpandAllIcon, {})
-            }
-          )
-        ]
-      },
-      id
-    );
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(RootNode, { id, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(
+        CollapseButton,
+        {
+          "data-action": "collapse-root",
+          onPress: (event) => {
+            event.preventDefault();
+            setExpanded({ ids: [item.id], value: !isExpanded });
+          },
+          "aria-expanded": isExpanded,
+          children: [
+            /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CollapseIcon, { isExpanded }),
+            /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_react_native2.Text, { children: item.renderLabel?.(item, {}) || item.name })
+          ]
+        }
+      ),
+      isExpanded && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+        IconButton,
+        {
+          "aria-label": isFullyExpanded ? "Expand" : "Collapse",
+          "data-action": "expand-all",
+          "data-expanded": isFullyExpanded,
+          onPress: (event) => {
+            event.preventDefault();
+            setFullyExpanded();
+          },
+          children: isFullyExpanded ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(CollapseAllIcon, {}) : /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(ExpandAllIcon, {})
+        }
+      )
+    ] }, id);
   }
   if (item.type === "component" || item.type === "group") {
     const BranchNode2 = item.type === "component" ? ComponentNode : GroupNode;
@@ -1502,7 +3651,6 @@ var RootNodeText = import_react_native_theming5.styled.Text(({ theme }) => ({
   color: theme.textMutedColor,
   lineHeight: 16,
   letterSpacing: 2.5,
-  //   letterSpacing: '0.16em',
   textTransform: "uppercase"
 }));
 var CollapseButton = import_react_native_theming5.styled.TouchableOpacity(({}) => ({
@@ -1511,24 +3659,13 @@ var CollapseButton = import_react_native_theming5.styled.TouchableOpacity(({}) =
   paddingVertical: 0,
   paddingHorizontal: 8,
   borderRadius: 4,
-  //   transition: 'color 150ms, box-shadow 150ms',
   gap: 6,
   alignItems: "center",
   cursor: "pointer",
   height: 28
 }));
-var Tree = import_react6.default.memo(function Tree2({
-  // isBrowsing,
-  isMain,
-  refId,
-  data,
-  status,
-  docsMode,
-  selectedStoryId,
-  onSelectStoryId
-}) {
+var Tree = import_react6.default.memo(function Tree2({ isMain, refId, data, status, docsMode, selectedStoryId, onSelectStoryId }) {
   const containerRef = (0, import_react6.useRef)(null);
-  const api = (0, import_manager_api2.useStorybookApi)();
   const [rootIds, orphanIds, initialExpanded] = (0, import_react6.useMemo)(
     () => Object.keys(data).reduce(
       (acc, id) => {
@@ -1605,14 +3742,10 @@ var Tree = import_react6.default.memo(function Tree2({
     );
   }, [collapsedItems, collapsedData]);
   const [expanded, setExpanded] = useExpanded({
-    // containerRef,
-    // isBrowsing,
     refId,
     data: collapsedData,
     initialExpanded,
     rootIds,
-    // highlightedRef,
-    // setHighlightedItemId,
     selectedStoryId,
     onSelectStoryId
   });
@@ -1624,24 +3757,24 @@ var Tree = import_react6.default.memo(function Tree2({
       if (item.type === "root") {
         const descendants = expandableDescendants[item.id];
         const isFullyExpanded = descendants.every((d) => expanded[d]);
-        return (
-          // @ts-expect-error (TODO)
-          /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
-            Root,
-            {
-              item,
-              refId,
-              isOrphan: false,
-              isDisplayed: true,
-              isSelected: selectedStoryId === itemId,
-              isExpanded: !!expanded[itemId],
-              setExpanded,
-              isFullyExpanded,
-              expandableDescendants: descendants,
-              onSelectStoryId
-            },
-            id
-          )
+        return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+          Root,
+          {
+            item,
+            refId,
+            isOrphan: false,
+            isDisplayed: true,
+            isSelected: selectedStoryId === itemId,
+            isExpanded: !!expanded[itemId],
+            setExpanded,
+            isFullyExpanded,
+            expandableDescendants: descendants,
+            onSelectStoryId,
+            docsMode: false,
+            color: "",
+            status: {}
+          },
+          id
         );
       }
       const isDisplayed = !item.parent || ancestry[itemId].every((a) => expanded[a]);
@@ -1649,7 +3782,6 @@ var Tree = import_react6.default.memo(function Tree2({
       return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
         Node,
         {
-          api,
           item,
           status: status?.[itemId],
           refId,
@@ -1667,7 +3799,6 @@ var Tree = import_react6.default.memo(function Tree2({
     });
   }, [
     ancestry,
-    api,
     collapsedData,
     collapsedItems,
     docsMode,
@@ -1713,15 +3844,12 @@ var import_react8 = __toESM(require("react"));
 
 // src/Refs.tsx
 var import_react7 = __toESM(require("react"));
-var import_manager_api3 = require("@storybook/manager-api");
 var import_react_native_theming6 = require("@storybook/react-native-theming");
 var import_jsx_runtime13 = require("react/jsx-runtime");
 var Wrapper2 = import_react_native_theming6.styled.View(({}) => ({
   position: "relative"
 }));
 var Ref = import_react7.default.memo(function Ref2(props) {
-  const { docsOptions } = (0, import_manager_api3.useStorybookState)();
-  const api = (0, import_manager_api3.useStorybookApi)();
   const {
     index,
     id: refId,
@@ -1729,8 +3857,6 @@ var Ref = import_react7.default.memo(function Ref2(props) {
     isLoading: isLoadingMain,
     isBrowsing,
     selectedStoryId,
-    // highlightedRef,
-    // setHighlighted,
     loginUrl,
     type,
     expanded = true,
@@ -1754,9 +3880,8 @@ var Ref = import_react7.default.memo(function Ref2(props) {
   const onSelectStoryId = (0, import_react7.useCallback)(
     (storyId) => {
       setSelection({ refId, storyId });
-      return api && api.selectStory(storyId, DEFAULT_REF_ID);
     },
-    [api, refId, setSelection]
+    [refId, setSelection]
   );
   return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_jsx_runtime13.Fragment, { children: isExpanded && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Wrapper2, { "data-title": title, isMain: true, children: state === "ready" && /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
     Tree,
@@ -1766,7 +3891,7 @@ var Ref = import_react7.default.memo(function Ref2(props) {
       isMain: true,
       refId,
       data: index,
-      docsMode: docsOptions?.docsMode,
+      docsMode: false,
       selectedStoryId,
       onSelectStoryId
     }
@@ -1803,20 +3928,24 @@ var import_react14 = __toESM(require("react"));
 var import_react_native_theming9 = require("@storybook/react-native-theming");
 
 // src/Search.tsx
-var import_manager_api4 = require("@storybook/manager-api");
 var import_react_native_theming7 = require("@storybook/react-native-theming");
 var import_fuse = __toESM(require("fuse.js"));
 var import_react10 = __toESM(require("react"));
 
 // src/types.ts
-function isExpandType(x) {
-  return !!(x && x.showAll);
+function isExpandType(x2) {
+  return !!(x2 && x2.showAll);
 }
 
 // src/icon/SearchIcon.tsx
 var import_react_native_svg8 = require("react-native-svg");
 var import_jsx_runtime15 = require("react/jsx-runtime");
-var SearchIcon = ({ color = "currentColor", width = 14, height = 14, ...props }) => {
+var SearchIcon = ({
+  color = "currentColor",
+  width = 14,
+  height = 14,
+  ...props
+}) => {
   return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_react_native_svg8.Svg, { width, height, viewBox: "0 0 14 14", fill: "none", ...props, children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
     import_react_native_svg8.Path,
     {
@@ -1831,7 +3960,12 @@ var SearchIcon = ({ color = "currentColor", width = 14, height = 14, ...props })
 // src/icon/CloseIcon.tsx
 var import_react_native_svg9 = require("react-native-svg");
 var import_jsx_runtime16 = require("react/jsx-runtime");
-var CloseIcon = ({ color = "currentColor", width = 14, height = 14, ...props }) => {
+var CloseIcon = ({
+  color = "currentColor",
+  width = 14,
+  height = 14,
+  ...props
+}) => {
   return /* @__PURE__ */ (0, import_jsx_runtime16.jsxs)(import_react_native_svg9.Svg, { width, height, viewBox: "0 0 14 14", fill: "none", ...props, children: [
     /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
       import_react_native_svg9.Path,
@@ -1889,10 +4023,8 @@ var SearchField = import_react_native_theming7.styled.View({
   display: "flex",
   flexDirection: "column",
   position: "relative"
-  // marginBottom: 16,
 });
 var Input = (0, import_react_native_theming7.styled)(import_bottom_sheet.BottomSheetTextInput)(({ theme }) => ({
-  // appearance: 'none',
   height: 32,
   paddingLeft: 28,
   paddingRight: 28,
@@ -1901,34 +4033,8 @@ var Input = (0, import_react_native_theming7.styled)(import_bottom_sheet.BottomS
   backgroundColor: "transparent",
   borderRadius: 4,
   fontSize: theme.typography.size.s1 + 1,
-  // transition: 'all 150ms',
   color: theme.color.defaultText,
   width: "100%"
-  // '&:focus, &:active': {
-  //   outline: 0,
-  //   borderColor: theme.color.secondary,
-  //   background: theme.background.app,
-  // },
-  // '&::placeholder': {
-  //   color: theme.textMutedColor,
-  //   opacity: 1,
-  // },
-  // '&:valid ~ code, &:focus ~ code': {
-  //   display: 'none',
-  // },
-  // '&:invalid ~ svg': {
-  //   display: 'none',
-  // },
-  // '&:valid ~ svg': {
-  //   display: 'block',
-  // },
-  // '&::-ms-clear': {
-  //   display: 'none',
-  // },
-  // '&::-webkit-search-decoration, &::-webkit-search-cancel-button, &::-webkit-search-results-button, &::-webkit-search-results-decoration':
-  //   {
-  //     display: 'none',
-  //   },
 }));
 var ClearIcon = import_react_native_theming7.styled.TouchableOpacity(({ theme }) => ({
   position: "absolute",
@@ -1943,35 +4049,23 @@ var ClearIcon = import_react_native_theming7.styled.TouchableOpacity(({ theme })
   justifyContent: "center",
   height: "100%"
 }));
-var Search = import_react10.default.memo(function Search2({
-  children,
-  dataset,
-  setSelection,
-  // enableShortcuts = true,
-  getLastViewed,
-  initialQuery = ""
-}) {
-  const api = (0, import_manager_api4.useStorybookApi)();
+var Search = import_react10.default.memo(function Search2({ children, dataset, setSelection, getLastViewed, initialQuery = "" }) {
   const inputRef = (0, import_react10.useRef)(null);
   const [inputValue, setInputValue] = (0, import_react10.useState)(initialQuery);
   const [isOpen, setIsOpen] = (0, import_react10.useState)(false);
   const [allComponents, showAllComponents] = (0, import_react10.useState)(false);
   const selectStory = (0, import_react10.useCallback)(
     (id, refId) => {
-      if (api) {
-        api.selectStory(id, void 0, { ref: refId !== DEFAULT_REF_ID && refId });
-      }
       setSelection({ storyId: id, refId });
       inputRef.current?.blur();
       showAllComponents(false);
     },
-    [api, setSelection]
+    [setSelection]
   );
   const getItemProps = (0, import_react10.useCallback)(
     ({ item: result }) => {
       return {
         icon: result?.item?.type === "component" ? "component" : "story",
-        // isHighlighted:
         result,
         onPress: () => {
           if (result?.item?.type === "story") {
@@ -1987,8 +4081,6 @@ var Search = import_react10.default.memo(function Search2({
         item: result.item,
         matches: result.matches,
         isHighlighted: false
-        // isHighlighted: searchItem.
-        // isHighlighted: searchItem.item.
       };
     },
     [selectStory]
@@ -2056,40 +4148,34 @@ var Search = import_react10.default.memo(function Search2({
   const input = inputValue ? inputValue.trim() : "";
   const results = input ? getResults(input) : [];
   return /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_react_native4.View, { style: { flex: 1 }, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(
-      SearchField,
-      {
-        children: [
-          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(SearchIconWrapper, { children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(SearchIcon, {}) }),
-          /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
-            Input,
-            {
-              ref: inputRef,
-              onChangeText: setInputValue,
-              onFocus: () => setIsOpen(true),
-              onBlur: () => setIsOpen(false)
-            }
-          ),
-          isOpen && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
-            ClearIcon,
-            {
-              onPress: () => {
-                setInputValue("");
-                inputRef.current.clear();
-              },
-              children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(CloseIcon, {})
-            }
-          )
-        ]
-      }
-    ),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(SearchField, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(SearchIconWrapper, { children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(SearchIcon, {}) }),
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        Input,
+        {
+          ref: inputRef,
+          onChangeText: setInputValue,
+          onFocus: () => setIsOpen(true),
+          onBlur: () => setIsOpen(false)
+        }
+      ),
+      isOpen && /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+        ClearIcon,
+        {
+          onPress: () => {
+            setInputValue("");
+            inputRef.current.clear();
+          },
+          children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(CloseIcon, {})
+        }
+      )
+    ] }),
     children({
       query: input,
       results,
       isBrowsing: !isOpen || !inputValue.length,
       closeMenu: () => {
       },
-      // getMenuProps,
       getItemProps,
       highlightedIndex: null
     })
@@ -2146,14 +4232,9 @@ var NoResults = import_react_native_theming8.styled.View(({ theme }) => ({
   fontSize: theme.typography.size.s2,
   lineHeight: 18,
   color: theme.color.defaultText
-  // small: {
-  //   color: theme.barTextColor,
-  //   fontSize: theme.typography.size.s1,
-  // },
 }));
 var Mark = import_react_native_theming8.styled.Text(({ theme }) => ({
   backgroundColor: "transparent",
-  // fontSize: theme.typography.size.s1 - 1,
   color: theme.color.secondary
 }));
 var MoreWrapper = import_react_native_theming8.styled.View({
@@ -2172,14 +4253,6 @@ var RecentlyOpenedTitle = import_react_native_theming8.styled.View(({ theme }) =
   marginTop: 16,
   marginBottom: 4,
   alignItems: "center"
-  // '.search-result-recentlyOpened-clear': {
-  //   visibility: 'hidden',
-  // },
-  // '&:hover': {
-  //   '.search-result-recentlyOpened-clear': {
-  //     visibility: 'visible',
-  //   },
-  // },
 }));
 var Highlight = import_react11.default.memo(
   function Highlight2({ children, match }) {
@@ -2201,39 +4274,16 @@ var Highlight = import_react11.default.memo(
   }
 );
 var Title = import_react_native_theming8.styled.Text(({ theme }) => ({
-  // display: 'grid',
   justifyContent: "flex-start",
-  // gridAutoColumns: 'auto',
-  // gridAutoFlow: 'column',
   color: theme.textMutedColor,
   fontSize: theme.typography.size.s2
-  // '& > span': {
-  //   display: 'block',
-  //   whiteSpace: 'nowrap',
-  //   overflow: 'hidden',
-  //   textOverflow: 'ellipsis',
-  // },
 }));
 var Path10 = import_react_native_theming8.styled.View(({ theme }) => ({
-  // display: 'grid',
   justifyContent: "flex-start",
   marginVertical: 2,
-  // gridAutoColumns: 'auto',
-  // gridAutoFlow: 'column',
   color: theme.textMutedColor,
   fontSize: theme.typography.size.s1 - 1,
   flexDirection: "row"
-  // '& > span': {
-  //   display: 'block',
-  //   whiteSpace: 'nowrap',
-  //   overflow: 'hidden',
-  //   textOverflow: 'ellipsis',
-  // },
-  // '& > span + span': {
-  //   '&:before': {
-  //     content: "' / '",
-  //   },
-  // },
 }));
 var PathText = import_react_native_theming8.styled.Text(({ theme }) => ({
   fontSize: theme.typography.size.s1 - 1,
@@ -2278,11 +4328,8 @@ var SearchResults = import_react11.default.memo(function SearchResults2({
   query,
   results,
   closeMenu,
-  // getMenuProps,
   getItemProps,
   highlightedIndex,
-  // isLoading = false,
-  // enableShortcuts = true,
   clearLastViewed
 }) {
   const handleClearLastViewed = () => {
@@ -2292,12 +4339,7 @@ var SearchResults = import_react11.default.memo(function SearchResults2({
   return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(ResultsList, { children: [
     results.length > 0 && !query && /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(RecentlyOpenedTitle, { children: [
       "Recently opened",
-      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(
-        IconButton,
-        {
-          onPress: handleClearLastViewed
-        }
-      )
+      /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(IconButton, { onPress: handleClearLastViewed })
     ] }),
     results.length === 0 && query && /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_react_native5.View, { children: /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(NoResults, { children: [
       /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(import_react_native5.Text, { style: { marginBottom: 8 }, children: "No components found" }),
@@ -2333,7 +4375,7 @@ var SearchResults = import_react11.default.memo(function SearchResults2({
 // src/useLastViewed.ts
 var import_debounce = __toESM(require_debounce());
 var import_react13 = require("react");
-var import_store2 = __toESM(require_store2());
+var import_store2 = __toESM(require("store2"));
 var save = (0, import_debounce.default)((value) => import_store2.default.set("lastViewedStoryIds", value), 1e3);
 var useLastViewed = (selection) => {
   const initialLastViewedStoryIds = (0, import_react13.useMemo)(() => {
@@ -2379,25 +4421,15 @@ var useLastViewed = (selection) => {
 var import_react_native6 = require("react-native");
 var import_jsx_runtime19 = require("react/jsx-runtime");
 var Container2 = import_react_native_theming9.styled.View(({ theme }) => ({
-  // position: 'absolute',
-  // zIndex: 1,
-  // left: 0,
-  // top: 0,
-  // bottom: 0,
-  // right: 0,
   width: "100%",
   height: "100%",
   display: "flex",
   flexDirection: "column",
   background: theme.background.content
-  // [MEDIA_DESKTOP_BREAKPOINT]: {
-  //   background: theme.background.app,
-  // },
 }));
 var Top = import_react_native_theming9.styled.View({
   paddingLeft: 4,
   paddingRight: 4,
-  // paddingBottom: 20,
   paddingTop: 16,
   flex: 1,
   flexDirection: "row"
@@ -2437,66 +4469,45 @@ var Sidebar = import_react14.default.memo(function Sidebar2({
   indexError,
   status,
   previewInitialized,
-  // menu,
-  // extra,
-  // bottom = [],
-  // menuHighlighted = false,
-  // enableShortcuts = true,
   refs = {},
   setSelection
 }) {
   const selected = (0, import_react14.useMemo)(() => storyId && { storyId, refId }, [storyId, refId]);
   const dataset = useCombination(index, indexError, previewInitialized, status, refs);
   const lastViewedProps = useLastViewed(selected);
-  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(Container2, { style: { paddingHorizontal: 10 }, children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(Top, { children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
-    Search,
-    {
-      dataset,
-      setSelection,
-      ...lastViewedProps,
-      children: ({
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(Container2, { style: { paddingHorizontal: 10 }, children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(Top, { children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(Search, { dataset, setSelection, ...lastViewedProps, children: ({ query, results, isBrowsing, closeMenu, getItemProps, highlightedIndex }) => /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(Swap, { condition: isBrowsing, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+      Explorer,
+      {
+        dataset,
+        selected,
+        isLoading: false,
+        isBrowsing,
+        setSelection
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+      SearchResults,
+      {
         query,
         results,
-        isBrowsing,
         closeMenu,
-        // getMenuProps,
         getItemProps,
-        highlightedIndex
-      }) => /* @__PURE__ */ (0, import_jsx_runtime19.jsxs)(Swap, { condition: isBrowsing, children: [
-        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
-          Explorer,
-          {
-            dataset,
-            selected,
-            isLoading: false,
-            isBrowsing,
-            setSelection
-          }
-        ),
-        /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
-          SearchResults,
-          {
-            query,
-            results,
-            closeMenu,
-            getItemProps,
-            highlightedIndex,
-            isLoading: false,
-            clearLastViewed: lastViewedProps.clearLastViewed
-          }
-        )
-      ] })
-    }
-  ) }) });
+        highlightedIndex,
+        isLoading: false,
+        clearLastViewed: lastViewedProps.clearLastViewed
+      }
+    )
+  ] }) }) }) });
 });
 
 // src/Layout.tsx
-var import_core_events2 = require("@storybook/core-events");
-var import_manager_api6 = require("@storybook/manager-api");
+var import_core_events = require("@storybook/core/core-events");
+var import_manager_api2 = require("@storybook/core/manager-api");
 var import_react_native_theming11 = require("@storybook/react-native-theming");
 var import_react17 = require("react");
 var import_react_native9 = require("react-native");
-var import_react_native_safe_area_context2 = require("react-native-safe-area-context");
+var import_react_native_safe_area_context3 = require("react-native-safe-area-context");
 
 // src/icon/BottomBarToggleIcon.tsx
 var import_react_native_svg10 = require("react-native-svg");
@@ -2550,6 +4561,7 @@ var import_bottom_sheet2 = require("@gorhom/bottom-sheet");
 var import_react15 = require("react");
 var import_react_native7 = require("react-native");
 var import_react_native_reanimated = require("react-native-reanimated");
+var import_react_native_safe_area_context = require("react-native-safe-area-context");
 var import_jsx_runtime22 = require("react/jsx-runtime");
 var BottomSheetBackdropComponent = (backdropComponentProps) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
   import_bottom_sheet2.BottomSheetBackdrop,
@@ -2562,19 +4574,18 @@ var BottomSheetBackdropComponent = (backdropComponentProps) => /* @__PURE__ */ (
   }
 );
 var MobileMenuDrawer = (0, import_react15.forwardRef)(
-  ({ children }, ref) => {
-    const [isMobileMenuOpen, setMobileMenuOpen] = (0, import_react15.useState)(false);
+  ({ children, onStateChange }, ref) => {
     const reducedMotion = (0, import_react_native_reanimated.useReducedMotion)();
+    const insets = (0, import_react_native_safe_area_context.useSafeAreaInsets)();
     const menuBottomSheetRef = (0, import_react15.useRef)(null);
     (0, import_react15.useImperativeHandle)(ref, () => ({
-      isMobileMenuOpen,
       setMobileMenuOpen: (open) => {
         if (open) {
-          setMobileMenuOpen(true);
+          onStateChange(true);
           menuBottomSheetRef.current?.present();
         } else {
           import_react_native7.Keyboard.dismiss();
-          setMobileMenuOpen(false);
+          onStateChange(false);
           menuBottomSheetRef.current?.dismiss();
         }
       }
@@ -2586,7 +4597,7 @@ var MobileMenuDrawer = (0, import_react15.forwardRef)(
         index: 1,
         animateOnMount: !reducedMotion,
         onDismiss: () => {
-          setMobileMenuOpen(false);
+          onStateChange(false);
         },
         snapPoints: ["50%", "75%"],
         enableDismissOnClose: true,
@@ -2596,7 +4607,16 @@ var MobileMenuDrawer = (0, import_react15.forwardRef)(
         keyboardBlurBehavior: "restore",
         stackBehavior: "replace",
         backdropComponent: BottomSheetBackdropComponent,
-        children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_bottom_sheet2.BottomSheetScrollView, { keyboardShouldPersistTaps: "handled", children })
+        children: /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(
+          import_bottom_sheet2.BottomSheetScrollView,
+          {
+            keyboardShouldPersistTaps: "handled",
+            contentContainerStyle: {
+              paddingBottom: insets.bottom
+            },
+            children
+          }
+        )
       }
     );
   }
@@ -2604,129 +4624,132 @@ var MobileMenuDrawer = (0, import_react15.forwardRef)(
 
 // src/MobileAddonsPanel.tsx
 var import_bottom_sheet3 = require("@gorhom/bottom-sheet");
-var import_manager_api5 = require("@storybook/manager-api");
+var import_manager_api = require("@storybook/core/manager-api");
 var import_react_native_theming10 = require("@storybook/react-native-theming");
-var import_types3 = __toESM(require_dist());
+var import_types3 = require("@storybook/core/types");
 var import_react16 = require("react");
 var import_react_native8 = require("react-native");
 var import_react_native_gesture_handler = require("react-native-gesture-handler");
-var import_react_native_reanimated2 = require("react-native-reanimated");
-var import_react_native_safe_area_context = require("react-native-safe-area-context");
+var import_react_native_reanimated2 = __toESM(require("react-native-reanimated"));
+var import_react_native_safe_area_context2 = require("react-native-safe-area-context");
 var import_jsx_runtime23 = require("react/jsx-runtime");
-var MobileAddonsPanel = (0, import_react16.forwardRef)(
-  ({ storyId }, ref) => {
-    const [isAddonsPanelOpen, setAddonsPanelOpen] = (0, import_react16.useState)(false);
-    const reducedMotion = (0, import_react_native_reanimated2.useReducedMotion)();
-    const addonsPanelBottomSheetRef = (0, import_react16.useRef)(null);
-    const insets = (0, import_react_native_safe_area_context.useSafeAreaInsets)();
-    const panels = import_manager_api5.addons.getElements(import_types3.Addon_TypesEnum.PANEL);
-    const [addonSelected, setAddonSelected] = (0, import_react16.useState)(Object.keys(panels)[0]);
-    (0, import_react16.useImperativeHandle)(ref, () => ({
-      isAddonsPanelOpen,
-      setAddonsPanelOpen: (open) => {
-        if (open) {
-          setAddonsPanelOpen(true);
-          addonsPanelBottomSheetRef.current?.present();
-        } else {
-          setAddonsPanelOpen(false);
-          addonsPanelBottomSheetRef.current?.dismiss();
-        }
+var MobileAddonsPanel = (0, import_react16.forwardRef)(({ storyId, onStateChange }, ref) => {
+  const reducedMotion = (0, import_react_native_reanimated2.useReducedMotion)();
+  const addonsPanelBottomSheetRef = (0, import_react16.useRef)(null);
+  const insets = (0, import_react_native_safe_area_context2.useSafeAreaInsets)();
+  const panels = import_manager_api.addons.getElements(import_types3.Addon_TypesEnum.PANEL);
+  const [addonSelected, setAddonSelected] = (0, import_react16.useState)(Object.keys(panels)[0]);
+  const animatedPosition = (0, import_react_native_reanimated2.useSharedValue)(0);
+  (0, import_react_native_reanimated2.useAnimatedKeyboard)();
+  (0, import_react16.useImperativeHandle)(ref, () => ({
+    setAddonsPanelOpen: (open) => {
+      if (open) {
+        onStateChange(true);
+        addonsPanelBottomSheetRef.current?.present();
+      } else {
+        onStateChange(false);
+        addonsPanelBottomSheetRef.current?.dismiss();
       }
-    }));
-    return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
-      import_bottom_sheet3.BottomSheetModal,
-      {
-        ref: addonsPanelBottomSheetRef,
-        index: 1,
-        animateOnMount: !reducedMotion,
-        onDismiss: () => {
-          setAddonsPanelOpen(false);
-        },
-        snapPoints: ["25%", "50%"],
-        style: {
-          paddingTop: 8
-        },
-        containerStyle: {},
-        backgroundStyle: {
-          borderRadius: 0,
-          borderTopColor: "lightgrey",
-          borderTopWidth: 1
-        },
-        keyboardBehavior: "interactive",
-        keyboardBlurBehavior: "restore",
-        enableDismissOnClose: true,
-        enableHandlePanningGesture: true,
-        enableContentPanningGesture: true,
-        stackBehavior: "replace",
-        children: /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(import_react_native8.View, { style: { flex: 1 }, children: [
-          /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(import_react_native8.View, { style: { flexDirection: "row" }, children: [
-            /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
-              import_react_native_gesture_handler.ScrollView,
-              {
-                horizontal: true,
-                showsHorizontalScrollIndicator: false,
-                contentContainerStyle: {
-                  paddingHorizontal: 8,
-                  // alignItems: 'center',
-                  justifyContent: "center"
-                },
-                children: Object.values(panels).map(({ id, title }) => {
-                  const resolvedTitle = typeof title === "function" ? title({}) : title;
-                  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
-                    Tab,
-                    {
-                      active: id === addonSelected,
-                      onPress: () => setAddonSelected(id),
-                      text: resolvedTitle
-                    },
-                    id
-                  );
-                })
-              }
-            ),
-            /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
-              IconButton,
-              {
-                style: {
-                  marginRight: 4,
-                  marginBottom: 4,
-                  alignItems: "center",
-                  justifyContent: "center"
-                },
-                hitSlop: { top: 10, right: 10, bottom: 10, left: 10 },
-                Icon: CloseIcon,
-                onPress: () => {
-                  setAddonsPanelOpen(false);
-                  addonsPanelBottomSheetRef.current?.dismiss();
-                }
-              }
-            )
-          ] }),
+    }
+  }));
+  const { height } = (0, import_react_native8.useWindowDimensions)();
+  const adjustedBottomSheetSize = (0, import_react_native_reanimated2.useAnimatedStyle)(() => {
+    return {
+      maxHeight: height - animatedPosition.value - insets.bottom
+    };
+  }, [animatedPosition.value, height, insets.bottom]);
+  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+    import_bottom_sheet3.BottomSheetModal,
+    {
+      ref: addonsPanelBottomSheetRef,
+      index: 1,
+      animateOnMount: !reducedMotion,
+      onDismiss: () => {
+        onStateChange(false);
+      },
+      snapPoints: ["25%", "50%", "75%"],
+      style: {
+        paddingTop: 8
+      },
+      animatedPosition,
+      containerStyle: {},
+      backgroundStyle: {
+        borderRadius: 0,
+        borderTopColor: "lightgrey",
+        borderTopWidth: 1
+      },
+      keyboardBehavior: "extend",
+      enableDismissOnClose: true,
+      enableHandlePanningGesture: true,
+      stackBehavior: "replace",
+      children: /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(import_react_native_reanimated2.default.View, { style: [{ flex: 1 }, adjustedBottomSheetSize], children: [
+        /* @__PURE__ */ (0, import_jsx_runtime23.jsxs)(import_react_native8.View, { style: { flexDirection: "row" }, children: [
           /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
-            import_bottom_sheet3.BottomSheetScrollView,
+            import_react_native_gesture_handler.ScrollView,
             {
-              keyboardShouldPersistTaps: "handled",
+              horizontal: true,
+              showsHorizontalScrollIndicator: false,
               contentContainerStyle: {
-                paddingBottom: insets.bottom + 16,
-                marginTop: 10,
-                paddingHorizontal: 16
+                paddingHorizontal: 8,
+                justifyContent: "center"
+              },
+              children: Object.values(panels).map(({ id, title }) => {
+                const resolvedTitle = typeof title === "function" ? title({}) : title;
+                return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+                  Tab,
+                  {
+                    active: id === addonSelected,
+                    onPress: () => setAddonSelected(id),
+                    text: resolvedTitle
+                  },
+                  id
+                );
+              })
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+            IconButton,
+            {
+              style: {
+                marginRight: 4,
+                marginBottom: 4,
+                alignItems: "center",
+                justifyContent: "center"
               },
-              children: (() => {
-                if (!storyId) {
-                  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_react_native8.View, { style: { alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_react_native8.Text, { children: "No Story Selected" }) });
-                }
-                if (Object.keys(panels).length === 0) {
-                  return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_react_native8.View, { style: { alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_react_native8.Text, { children: "No addons loaded." }) });
-                }
-                return panels[addonSelected].render({ active: true });
-              })()
+              hitSlop: { top: 10, right: 10, bottom: 10, left: 10 },
+              Icon: CloseIcon,
+              onPress: () => {
+                onStateChange(false);
+                addonsPanelBottomSheetRef.current?.dismiss();
+              }
             }
           )
-        ] })
-      }
-    );
-  }
-);
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(
+          import_react_native_gesture_handler.ScrollView,
+          {
+            style: { flex: 1 },
+            keyboardShouldPersistTaps: "handled",
+            contentContainerStyle: {
+              paddingBottom: insets.bottom + 16,
+              marginTop: 10,
+              paddingHorizontal: 16
+            },
+            children: (() => {
+              if (!storyId) {
+                return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_react_native8.View, { style: { alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_react_native8.Text, { children: "No Story Selected" }) });
+              }
+              if (Object.keys(panels).length === 0) {
+                return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_react_native8.View, { style: { alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_react_native8.Text, { children: "No addons loaded." }) });
+              }
+              return panels[addonSelected].render({ active: true });
+            })()
+          }
+        )
+      ] })
+    }
+  );
+});
 var Tab = ({ active, onPress, text }) => {
   return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(TabButton, { active, onPress, children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(TabText, { active, children: text }) });
 };
@@ -2742,7 +4765,7 @@ var TabText = import_react_native_theming10.styled.Text(({ theme, active }) => (
   color: active ? theme.barSelectedColor : theme.color.mediumdark,
   textAlign: "center",
   fontWeight: "bold",
-  fontSize: 13,
+  fontSize: 12,
   lineHeight: 12
 }));
 
@@ -2755,11 +4778,13 @@ var Layout = ({
 }) => {
   const theme = (0, import_react_native_theming11.useTheme)();
   const mobileMenuDrawerRef = (0, import_react17.useRef)(null);
+  const [menuOpen, setMenuOpen] = (0, import_react17.useState)(false);
+  const [drawerOpen, setDrawerOpen] = (0, import_react17.useState)(false);
   const addonPanelRef = (0, import_react17.useRef)(null);
-  const insets = (0, import_react_native_safe_area_context2.useSafeAreaInsets)();
+  const insets = (0, import_react_native_safe_area_context3.useSafeAreaInsets)();
   return /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_react_native9.View, { style: { flex: 1, paddingTop: insets.top }, children: [
     /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(import_react_native9.View, { style: { flex: 1 }, children }),
-    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(MobileMenuDrawer, { ref: mobileMenuDrawerRef, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(MobileMenuDrawer, { ref: mobileMenuDrawerRef, onStateChange: setDrawerOpen, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
       Sidebar,
       {
         extra: [],
@@ -2767,8 +4792,8 @@ var Layout = ({
         indexError: void 0,
         refs: {},
         setSelection: ({ storyId: newStoryId }) => {
-          const channel = import_manager_api6.addons.getChannel();
-          channel.emit(import_core_events2.SET_CURRENT_STORY, { storyId: newStoryId });
+          const channel = import_manager_api2.addons.getChannel();
+          channel.emit(import_core_events.SET_CURRENT_STORY, { storyId: newStoryId });
         },
         status: {},
         index: storyHash,
@@ -2776,19 +4801,22 @@ var Layout = ({
         refId: DEFAULT_REF_ID
       }
     ) }),
-    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(MobileAddonsPanel, { ref: addonPanelRef, storyId: story.id }),
-    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(Container3, { style: { marginBottom: insets.bottom }, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(Nav, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(MobileAddonsPanel, { ref: addonPanelRef, storyId: story?.id, onStateChange: setMenuOpen }),
+    (import_react_native9.Platform.OS !== "android" || !menuOpen && !drawerOpen) && /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(Container3, { style: { marginBottom: insets.bottom }, children: /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(Nav, { children: [
       /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(
         Button2,
         {
+          style: { flexShrink: 1 },
           hitSlop: { bottom: 10, left: 10, right: 10, top: 10 },
-          onPress: () => mobileMenuDrawerRef.current.setMobileMenuOpen(true),
+          onPress: () => {
+            mobileMenuDrawerRef.current.setMobileMenuOpen(true);
+          },
           children: [
             /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(MenuIcon, { color: theme.color.mediumdark }),
-            /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_react_native9.Text, { children: [
-              story.title,
+            /* @__PURE__ */ (0, import_jsx_runtime24.jsxs)(import_react_native9.Text, { style: { flexShrink: 1 }, numberOfLines: 1, children: [
+              story?.title,
               "/",
-              story.name
+              story?.name
             ] })
           ]
         }
@@ -2830,6 +4858,296 @@ var Button2 = import_react_native_theming11.styled.TouchableOpacity(({ theme })
   paddingHorizontal: 7,
   fontWeight: theme.typography.weight.bold
 }));
+
+// ../../node_modules/@storybook/csf/dist/index.mjs
+var C = Object.create;
+var u = Object.defineProperty;
+var B = Object.getOwnPropertyDescriptor;
+var F = Object.getOwnPropertyNames;
+var h = Object.getPrototypeOf;
+var w = Object.prototype.hasOwnProperty;
+var v = (r, e) => () => (e || r((e = { exports: {} }).exports, e), e.exports);
+var E = (r, e, n, t) => {
+  if (e && typeof e == "object" || typeof e == "function")
+    for (let a of F(e))
+      !w.call(r, a) && a !== n && u(r, a, { get: () => e[a], enumerable: !(t = B(e, a)) || t.enumerable });
+  return r;
+};
+var I = (r, e, n) => (n = r != null ? C(h(r)) : {}, E(e || !r || !r.__esModule ? u(n, "default", { value: r, enumerable: true }) : n, r));
+var x = v((T) => {
+  Object.defineProperty(T, "__esModule", { value: true }), T.isEqual = function() {
+    var r = Object.prototype.toString, e = Object.getPrototypeOf, n = Object.getOwnPropertySymbols ? function(t) {
+      return Object.keys(t).concat(Object.getOwnPropertySymbols(t));
+    } : Object.keys;
+    return function(t, a) {
+      return function i(o, s, p) {
+        var y, g, d, c = r.call(o), b = r.call(s);
+        if (o === s)
+          return true;
+        if (o == null || s == null)
+          return false;
+        if (p.indexOf(o) > -1 && p.indexOf(s) > -1)
+          return true;
+        if (p.push(o, s), c != b || (y = n(o), g = n(s), y.length != g.length || y.some(function(A) {
+          return !i(o[A], s[A], p);
+        })))
+          return false;
+        switch (c.slice(8, -1)) {
+          case "Symbol":
+            return o.valueOf() == s.valueOf();
+          case "Date":
+          case "Number":
+            return +o == +s || +o != +o && +s != +s;
+          case "RegExp":
+          case "Function":
+          case "String":
+          case "Boolean":
+            return "" + o == "" + s;
+          case "Set":
+          case "Map":
+            y = o.entries(), g = s.entries();
+            do
+              if (!i((d = y.next()).value, g.next().value, p))
+                return false;
+            while (!d.done);
+            return true;
+          case "ArrayBuffer":
+            o = new Uint8Array(o), s = new Uint8Array(s);
+          case "DataView":
+            o = new Uint8Array(o.buffer), s = new Uint8Array(s.buffer);
+          case "Float32Array":
+          case "Float64Array":
+          case "Int8Array":
+          case "Int16Array":
+          case "Int32Array":
+          case "Uint8Array":
+          case "Uint16Array":
+          case "Uint32Array":
+          case "Uint8ClampedArray":
+          case "Arguments":
+          case "Array":
+            if (o.length != s.length)
+              return false;
+            for (d = 0; d < o.length; d++)
+              if ((d in o || d in s) && (d in o != d in s || !i(o[d], s[d], p)))
+                return false;
+            return true;
+          case "Object":
+            return i(e(o), e(s), p);
+          default:
+            return false;
+        }
+      }(t, a, []);
+    };
+  }();
+});
+var l = I(x());
+var O = (r) => r.toLowerCase().replace(/[ ’–—―′¿'`~!@#$%^&*()_|+\-=?;:'",.<>\{\}\[\]\\\/]/gi, "-").replace(/-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+
+// src/util/StoryHash.ts
+var import_countBy = __toESM(require_countBy());
+
+// ../../node_modules/ts-dedent/esm/index.js
+function dedent(templ) {
+  var values = [];
+  for (var _i = 1; _i < arguments.length; _i++) {
+    values[_i - 1] = arguments[_i];
+  }
+  var strings = Array.from(typeof templ === "string" ? [templ] : templ);
+  strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, "");
+  var indentLengths = strings.reduce(function(arr, str) {
+    var matches = str.match(/\n([\t ]+|(?!\s).)/g);
+    if (matches) {
+      return arr.concat(matches.map(function(match) {
+        var _a, _b;
+        return (_b = (_a = match.match(/[\t ]/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+      }));
+    }
+    return arr;
+  }, []);
+  if (indentLengths.length) {
+    var pattern_1 = new RegExp("\n[	 ]{" + Math.min.apply(Math, indentLengths) + "}", "g");
+    strings = strings.map(function(str) {
+      return str.replace(pattern_1, "\n");
+    });
+  }
+  strings[0] = strings[0].replace(/^\r?\n/, "");
+  var string = strings[0];
+  values.forEach(function(value, i) {
+    var endentations = string.match(/(?:^|\n)( *)$/);
+    var endentation = endentations ? endentations[1] : "";
+    var indentedValue = value;
+    if (typeof value === "string" && value.includes("\n")) {
+      indentedValue = String(value).split("\n").map(function(str, i2) {
+        return i2 === 0 ? str : "" + endentation + str;
+      }).join("\n");
+    }
+    string += indentedValue + strings[i + 1];
+  });
+  return string;
+}
+
+// src/util/StoryHash.ts
+var import_isEqual = __toESM(require_isEqual());
+var import_mergeWith = __toESM(require_mergeWith());
+var import_client_logger = require("@storybook/core/client-logger");
+var merge = (a, b) => (0, import_mergeWith.default)({}, a, b, (objValue, srcValue) => {
+  if (Array.isArray(srcValue) && Array.isArray(objValue)) {
+    srcValue.forEach((s) => {
+      const existing = objValue.find((o) => o === s || (0, import_isEqual.default)(o, s));
+      if (!existing) {
+        objValue.push(s);
+      }
+    });
+    return objValue;
+  }
+  if (Array.isArray(objValue)) {
+    import_client_logger.logger.log(["the types mismatch, picking", objValue]);
+    return objValue;
+  }
+  return void 0;
+});
+var TITLE_PATH_SEPARATOR = /\s*\/\s*/;
+var transformStoryIndexToStoriesHash = (input, { provider, docsOptions, filters, status }) => {
+  if (!input.v) {
+    throw new Error("Composition: Missing stories.json version");
+  }
+  let index = input;
+  index = index.v === 2 ? transformStoryIndexV2toV3(index) : index;
+  index = index.v === 3 ? transformStoryIndexV3toV4(index) : index;
+  index = index;
+  const entryValues = Object.values(index.entries).filter((entry) => {
+    let result = true;
+    Object.values(filters).forEach((filter) => {
+      if (result === false) {
+        return;
+      }
+      result = filter({ ...entry, status: status[entry.id] });
+    });
+    return result;
+  });
+  const { sidebar = {} } = provider.getConfig();
+  const { showRoots, collapsedRoots = [], renderLabel } = sidebar;
+  const setShowRoots = typeof showRoots !== "undefined";
+  const storiesHashOutOfOrder = entryValues.reduce((acc, item) => {
+    if (docsOptions.docsMode && item.type !== "docs") {
+      return acc;
+    }
+    const { title } = item;
+    const groups = title.trim().split(TITLE_PATH_SEPARATOR);
+    const root = (!setShowRoots || showRoots) && groups.length > 1 ? [groups.shift()] : [];
+    const names = [...root, ...groups];
+    const paths = names.reduce((list, name, idx) => {
+      const parent = idx > 0 && list[idx - 1];
+      const id = O(parent ? `${parent}-${name}` : name);
+      if (parent === id) {
+        throw new Error(
+          dedent`
+          Invalid part '${name}', leading to id === parentId ('${id}'), inside title '${title}'
+          
+          Did you create a path that uses the separator char accidentally, such as 'Vue <docs/>' where '/' is a separator char? See https://github.com/storybookjs/storybook/issues/6128
+          `
+        );
+      }
+      list.push(id);
+      return list;
+    }, []);
+    paths.forEach((id, idx) => {
+      const childId = paths[idx + 1] || item.id;
+      if (root.length && idx === 0) {
+        acc[id] = merge(acc[id] || {}, {
+          type: "root",
+          id,
+          name: names[idx],
+          depth: idx,
+          renderLabel,
+          startCollapsed: collapsedRoots.includes(id),
+          // Note that this will later get appended to the previous list of children (see below)
+          children: [childId]
+        });
+      } else if ((!acc[id] || acc[id].type === "component") && idx === paths.length - 1) {
+        acc[id] = merge(acc[id] || {}, {
+          type: "component",
+          id,
+          name: names[idx],
+          parent: paths[idx - 1],
+          depth: idx,
+          renderLabel,
+          ...childId && {
+            children: [childId]
+          }
+        });
+      } else {
+        acc[id] = merge(acc[id] || {}, {
+          type: "group",
+          id,
+          name: names[idx],
+          parent: paths[idx - 1],
+          depth: idx,
+          renderLabel,
+          ...childId && {
+            children: [childId]
+          }
+        });
+      }
+    });
+    acc[item.id] = {
+      type: "story",
+      ...item,
+      depth: paths.length,
+      parent: paths[paths.length - 1],
+      renderLabel,
+      prepared: !!item.parameters
+    };
+    return acc;
+  }, {});
+  function addItem(acc, item) {
+    if (acc[item.id]) {
+      return acc;
+    }
+    acc[item.id] = item;
+    if (item.type === "root" || item.type === "group" || item.type === "component") {
+      item.children.forEach((childId) => addItem(acc, storiesHashOutOfOrder[childId]));
+    }
+    return acc;
+  }
+  const orphanHash = Object.values(storiesHashOutOfOrder).filter((i) => i.type !== "root" && !i.parent).reduce(addItem, {});
+  return Object.values(storiesHashOutOfOrder).filter((i) => i.type === "root").reduce(addItem, orphanHash);
+};
+var transformStoryIndexV2toV3 = (index) => {
+  return {
+    v: 3,
+    stories: Object.values(index.stories).reduce((acc, entry) => {
+      acc[entry.id] = {
+        ...entry,
+        title: entry.kind,
+        name: entry.name || entry.story,
+        importPath: entry.parameters.fileName || ""
+      };
+      return acc;
+    }, {})
+  };
+};
+var transformStoryIndexV3toV4 = (index) => {
+  const countByTitle = (0, import_countBy.default)(Object.values(index.stories), "title");
+  return {
+    v: 4,
+    entries: Object.values(index.stories).reduce((acc, entry) => {
+      let type = "story";
+      if (entry.parameters?.docsOnly || entry.name === "Page" && countByTitle[entry.title] === 1) {
+        type = "docs";
+      }
+      acc[entry.id] = {
+        type,
+        ...type === "docs" && { tags: ["stories-mdx"], storiesImports: [] },
+        ...entry
+      };
+      delete acc[entry.id].story;
+      delete acc[entry.id].kind;
+      return acc;
+    }, {})
+  };
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Button,
@@ -2849,12 +5167,9 @@ var Button2 = import_react_native_theming11.styled.TouchableOpacity(({ theme })
   StoryNode,
   Tree,
   isExpandType,
+  transformStoryIndexToStoriesHash,
+  transformStoryIndexV2toV3,
+  transformStoryIndexV3toV4,
   useCombination,
   useLayout
 });
-/*! Bundled license information:
-
-store2/dist/store2.js:
-  (*! store2 - v2.14.3 - 2024-02-14
-  * Copyright (c) 2024 Nathan Bubna; Licensed MIT *)
-*/