@inditextech/weave-store-azure-web-pubsub 0.68.0 → 0.68.1

package/dist/client.cjs

@@ -1,4 +1,3 @@
-"use strict";
 //#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -6,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __copyProps = (to, from$1, except, desc) => {
 	if (from$1 && typeof from$1 === "object" || typeof from$1 === "function") for (var keys$1 = __getOwnPropNames(from$1), i = 0, n = keys$1.length, key; i < n; i++) {
 		key = keys$1[i];
@@ -29,6 +31,2309 @@ const buffer = __toESM(require("buffer"));
 const uuid = __toESM(require("uuid"));
 const reconnecting_websocket = __toESM(require("reconnecting-websocket"));
 
+//#region ../../node_modules/lodash/_listCacheClear.js
+var require__listCacheClear = __commonJS({ "../../node_modules/lodash/_listCacheClear.js"(exports, module) {
+	/**
+	* Removes all key-value entries from the list cache.
+	*
+	* @private
+	* @name clear
+	* @memberOf ListCache
+	*/
+	function listCacheClear$1() {
+		this.__data__ = [];
+		this.size = 0;
+	}
+	module.exports = listCacheClear$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/eq.js
+var require_eq = __commonJS({ "../../node_modules/lodash/eq.js"(exports, module) {
+	/**
+	* Performs a
+	* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	* comparison between two values to determine if they are equivalent.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to compare.
+	* @param {*} other The other value to compare.
+	* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	* @example
+	*
+	* var object = { 'a': 1 };
+	* var other = { 'a': 1 };
+	*
+	* _.eq(object, object);
+	* // => true
+	*
+	* _.eq(object, other);
+	* // => false
+	*
+	* _.eq('a', 'a');
+	* // => true
+	*
+	* _.eq('a', Object('a'));
+	* // => false
+	*
+	* _.eq(NaN, NaN);
+	* // => true
+	*/
+	function eq$4(value, other) {
+		return value === other || value !== value && other !== other;
+	}
+	module.exports = eq$4;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_assocIndexOf.js
+var require__assocIndexOf = __commonJS({ "../../node_modules/lodash/_assocIndexOf.js"(exports, module) {
+	var eq$3 = require_eq();
+	/**
+	* Gets the index at which the `key` is found in `array` of key-value pairs.
+	*
+	* @private
+	* @param {Array} array The array to inspect.
+	* @param {*} key The key to search for.
+	* @returns {number} Returns the index of the matched value, else `-1`.
+	*/
+	function assocIndexOf$4(array, key) {
+		var length$2 = array.length;
+		while (length$2--) if (eq$3(array[length$2][0], key)) return length$2;
+		return -1;
+	}
+	module.exports = assocIndexOf$4;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_listCacheDelete.js
+var require__listCacheDelete = __commonJS({ "../../node_modules/lodash/_listCacheDelete.js"(exports, module) {
+	var assocIndexOf$3 = require__assocIndexOf();
+	/** Used for built-in method references. */
+	var arrayProto = Array.prototype;
+	/** Built-in value references. */
+	var splice = arrayProto.splice;
+	/**
+	* Removes `key` and its value from the list cache.
+	*
+	* @private
+	* @name delete
+	* @memberOf ListCache
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function listCacheDelete$1(key) {
+		var data = this.__data__, index = assocIndexOf$3(data, key);
+		if (index < 0) return false;
+		var lastIndex = data.length - 1;
+		if (index == lastIndex) data.pop();
+		else splice.call(data, index, 1);
+		--this.size;
+		return true;
+	}
+	module.exports = listCacheDelete$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_listCacheGet.js
+var require__listCacheGet = __commonJS({ "../../node_modules/lodash/_listCacheGet.js"(exports, module) {
+	var assocIndexOf$2 = require__assocIndexOf();
+	/**
+	* Gets the list cache value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf ListCache
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function listCacheGet$1(key) {
+		var data = this.__data__, index = assocIndexOf$2(data, key);
+		return index < 0 ? void 0 : data[index][1];
+	}
+	module.exports = listCacheGet$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_listCacheHas.js
+var require__listCacheHas = __commonJS({ "../../node_modules/lodash/_listCacheHas.js"(exports, module) {
+	var assocIndexOf$1 = require__assocIndexOf();
+	/**
+	* Checks if a list cache value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf ListCache
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function listCacheHas$1(key) {
+		return assocIndexOf$1(this.__data__, key) > -1;
+	}
+	module.exports = listCacheHas$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_listCacheSet.js
+var require__listCacheSet = __commonJS({ "../../node_modules/lodash/_listCacheSet.js"(exports, module) {
+	var assocIndexOf = require__assocIndexOf();
+	/**
+	* Sets the list cache `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf ListCache
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the list cache instance.
+	*/
+	function listCacheSet$1(key, value) {
+		var data = this.__data__, index = assocIndexOf(data, key);
+		if (index < 0) {
+			++this.size;
+			data.push([key, value]);
+		} else data[index][1] = value;
+		return this;
+	}
+	module.exports = listCacheSet$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_ListCache.js
+var require__ListCache = __commonJS({ "../../node_modules/lodash/_ListCache.js"(exports, module) {
+	var listCacheClear = require__listCacheClear(), listCacheDelete = require__listCacheDelete(), listCacheGet = require__listCacheGet(), listCacheHas = require__listCacheHas(), listCacheSet = require__listCacheSet();
+	/**
+	* Creates an list cache object.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function ListCache$4(entries) {
+		var index = -1, length$2 = entries == null ? 0 : entries.length;
+		this.clear();
+		while (++index < length$2) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	ListCache$4.prototype.clear = listCacheClear;
+	ListCache$4.prototype["delete"] = listCacheDelete;
+	ListCache$4.prototype.get = listCacheGet;
+	ListCache$4.prototype.has = listCacheHas;
+	ListCache$4.prototype.set = listCacheSet;
+	module.exports = ListCache$4;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_stackClear.js
+var require__stackClear = __commonJS({ "../../node_modules/lodash/_stackClear.js"(exports, module) {
+	var ListCache$3 = require__ListCache();
+	/**
+	* Removes all key-value entries from the stack.
+	*
+	* @private
+	* @name clear
+	* @memberOf Stack
+	*/
+	function stackClear$1() {
+		this.__data__ = new ListCache$3();
+		this.size = 0;
+	}
+	module.exports = stackClear$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_stackDelete.js
+var require__stackDelete = __commonJS({ "../../node_modules/lodash/_stackDelete.js"(exports, module) {
+	/**
+	* Removes `key` and its value from the stack.
+	*
+	* @private
+	* @name delete
+	* @memberOf Stack
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function stackDelete$1(key) {
+		var data = this.__data__, result = data["delete"](key);
+		this.size = data.size;
+		return result;
+	}
+	module.exports = stackDelete$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_stackGet.js
+var require__stackGet = __commonJS({ "../../node_modules/lodash/_stackGet.js"(exports, module) {
+	/**
+	* Gets the stack value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf Stack
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function stackGet$1(key) {
+		return this.__data__.get(key);
+	}
+	module.exports = stackGet$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_stackHas.js
+var require__stackHas = __commonJS({ "../../node_modules/lodash/_stackHas.js"(exports, module) {
+	/**
+	* Checks if a stack value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf Stack
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function stackHas$1(key) {
+		return this.__data__.has(key);
+	}
+	module.exports = stackHas$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_freeGlobal.js
+var require__freeGlobal = __commonJS({ "../../node_modules/lodash/_freeGlobal.js"(exports, module) {
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal$2 = typeof global == "object" && global && global.Object === Object && global;
+	module.exports = freeGlobal$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_root.js
+var require__root = __commonJS({ "../../node_modules/lodash/_root.js"(exports, module) {
+	var freeGlobal$1 = require__freeGlobal();
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+	/** Used as a reference to the global object. */
+	var root$6 = freeGlobal$1 || freeSelf || Function("return this")();
+	module.exports = root$6;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_Symbol.js
+var require__Symbol = __commonJS({ "../../node_modules/lodash/_Symbol.js"(exports, module) {
+	var root$5 = require__root();
+	/** Built-in value references. */
+	var Symbol$3 = root$5.Symbol;
+	module.exports = Symbol$3;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_getRawTag.js
+var require__getRawTag = __commonJS({ "../../node_modules/lodash/_getRawTag.js"(exports, module) {
+	var Symbol$2 = require__Symbol();
+	/** Used for built-in method references. */
+	var objectProto$10 = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty$8 = objectProto$10.hasOwnProperty;
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var nativeObjectToString$1 = objectProto$10.toString;
+	/** Built-in value references. */
+	var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : void 0;
+	/**
+	* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+	*
+	* @private
+	* @param {*} value The value to query.
+	* @returns {string} Returns the raw `toStringTag`.
+	*/
+	function getRawTag$1(value) {
+		var isOwn = hasOwnProperty$8.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+		try {
+			value[symToStringTag$1] = void 0;
+			var unmasked = true;
+		} catch (e) {}
+		var result = nativeObjectToString$1.call(value);
+		if (unmasked) if (isOwn) value[symToStringTag$1] = tag;
+		else delete value[symToStringTag$1];
+		return result;
+	}
+	module.exports = getRawTag$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_objectToString.js
+var require__objectToString = __commonJS({ "../../node_modules/lodash/_objectToString.js"(exports, module) {
+	/** Used for built-in method references. */
+	var objectProto$9 = Object.prototype;
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var nativeObjectToString = objectProto$9.toString;
+	/**
+	* Converts `value` to a string using `Object.prototype.toString`.
+	*
+	* @private
+	* @param {*} value The value to convert.
+	* @returns {string} Returns the converted string.
+	*/
+	function objectToString$1(value) {
+		return nativeObjectToString.call(value);
+	}
+	module.exports = objectToString$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseGetTag.js
+var require__baseGetTag = __commonJS({ "../../node_modules/lodash/_baseGetTag.js"(exports, module) {
+	var Symbol$1 = require__Symbol(), getRawTag = require__getRawTag(), objectToString = require__objectToString();
+	/** `Object#toString` result references. */
+	var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+	/** Built-in value references. */
+	var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
+	/**
+	* The base implementation of `getTag` without fallbacks for buggy environments.
+	*
+	* @private
+	* @param {*} value The value to query.
+	* @returns {string} Returns the `toStringTag`.
+	*/
+	function baseGetTag$4(value) {
+		if (value == null) return value === void 0 ? undefinedTag : nullTag;
+		return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+	}
+	module.exports = baseGetTag$4;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isObject.js
+var require_isObject = __commonJS({ "../../node_modules/lodash/isObject.js"(exports, module) {
+	/**
+	* Checks if `value` is the
+	* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	* @example
+	*
+	* _.isObject({});
+	* // => true
+	*
+	* _.isObject([1, 2, 3]);
+	* // => true
+	*
+	* _.isObject(_.noop);
+	* // => true
+	*
+	* _.isObject(null);
+	* // => false
+	*/
+	function isObject$7(value) {
+		var type = typeof value;
+		return value != null && (type == "object" || type == "function");
+	}
+	module.exports = isObject$7;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isFunction.js
+var require_isFunction = __commonJS({ "../../node_modules/lodash/isFunction.js"(exports, module) {
+	var baseGetTag$3 = require__baseGetTag(), isObject$6 = require_isObject();
+	/** `Object#toString` result references. */
+	var asyncTag = "[object AsyncFunction]", funcTag$1 = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+	/**
+	* Checks if `value` is classified as a `Function` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	* @example
+	*
+	* _.isFunction(_);
+	* // => true
+	*
+	* _.isFunction(/abc/);
+	* // => false
+	*/
+	function isFunction$3(value) {
+		if (!isObject$6(value)) return false;
+		var tag = baseGetTag$3(value);
+		return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+	}
+	module.exports = isFunction$3;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_coreJsData.js
+var require__coreJsData = __commonJS({ "../../node_modules/lodash/_coreJsData.js"(exports, module) {
+	var root$4 = require__root();
+	/** Used to detect overreaching core-js shims. */
+	var coreJsData$1 = root$4["__core-js_shared__"];
+	module.exports = coreJsData$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_isMasked.js
+var require__isMasked = __commonJS({ "../../node_modules/lodash/_isMasked.js"(exports, module) {
+	var coreJsData = require__coreJsData();
+	/** Used to detect methods masquerading as native. */
+	var maskSrcKey = function() {
+		var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+		return uid ? "Symbol(src)_1." + uid : "";
+	}();
+	/**
+	* Checks if `func` has its source masked.
+	*
+	* @private
+	* @param {Function} func The function to check.
+	* @returns {boolean} Returns `true` if `func` is masked, else `false`.
+	*/
+	function isMasked$1(func) {
+		return !!maskSrcKey && maskSrcKey in func;
+	}
+	module.exports = isMasked$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_toSource.js
+var require__toSource = __commonJS({ "../../node_modules/lodash/_toSource.js"(exports, module) {
+	/** Used for built-in method references. */
+	var funcProto$2 = Function.prototype;
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString$2 = funcProto$2.toString;
+	/**
+	* Converts `func` to its source code.
+	*
+	* @private
+	* @param {Function} func The function to convert.
+	* @returns {string} Returns the source code.
+	*/
+	function toSource$1(func) {
+		if (func != null) {
+			try {
+				return funcToString$2.call(func);
+			} catch (e) {}
+			try {
+				return func + "";
+			} catch (e) {}
+		}
+		return "";
+	}
+	module.exports = toSource$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseIsNative.js
+var require__baseIsNative = __commonJS({ "../../node_modules/lodash/_baseIsNative.js"(exports, module) {
+	var isFunction$2 = require_isFunction(), isMasked = require__isMasked(), isObject$5 = require_isObject(), toSource = require__toSource();
+	/**
+	* Used to match `RegExp`
+	* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+	*/
+	var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+	/** Used to detect host constructors (Safari). */
+	var reIsHostCtor = /^\[object .+?Constructor\]$/;
+	/** Used for built-in method references. */
+	var funcProto$1 = Function.prototype, objectProto$8 = Object.prototype;
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString$1 = funcProto$1.toString;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
+	/** Used to detect if a method is native. */
+	var reIsNative = RegExp("^" + funcToString$1.call(hasOwnProperty$7).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+	/**
+	* The base implementation of `_.isNative` without bad shim checks.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a native function,
+	*  else `false`.
+	*/
+	function baseIsNative$1(value) {
+		if (!isObject$5(value) || isMasked(value)) return false;
+		var pattern = isFunction$2(value) ? reIsNative : reIsHostCtor;
+		return pattern.test(toSource(value));
+	}
+	module.exports = baseIsNative$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_getValue.js
+var require__getValue = __commonJS({ "../../node_modules/lodash/_getValue.js"(exports, module) {
+	/**
+	* Gets the value at `key` of `object`.
+	*
+	* @private
+	* @param {Object} [object] The object to query.
+	* @param {string} key The key of the property to get.
+	* @returns {*} Returns the property value.
+	*/
+	function getValue$1(object, key) {
+		return object == null ? void 0 : object[key];
+	}
+	module.exports = getValue$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_getNative.js
+var require__getNative = __commonJS({ "../../node_modules/lodash/_getNative.js"(exports, module) {
+	var baseIsNative = require__baseIsNative(), getValue = require__getValue();
+	/**
+	* Gets the native function at `key` of `object`.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @param {string} key The key of the method to get.
+	* @returns {*} Returns the function if it's native, else `undefined`.
+	*/
+	function getNative$3(object, key) {
+		var value = getValue(object, key);
+		return baseIsNative(value) ? value : void 0;
+	}
+	module.exports = getNative$3;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_Map.js
+var require__Map = __commonJS({ "../../node_modules/lodash/_Map.js"(exports, module) {
+	var getNative$2 = require__getNative(), root$3 = require__root();
+	var Map$3 = getNative$2(root$3, "Map");
+	module.exports = Map$3;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_nativeCreate.js
+var require__nativeCreate = __commonJS({ "../../node_modules/lodash/_nativeCreate.js"(exports, module) {
+	var getNative$1 = require__getNative();
+	var nativeCreate$4 = getNative$1(Object, "create");
+	module.exports = nativeCreate$4;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_hashClear.js
+var require__hashClear = __commonJS({ "../../node_modules/lodash/_hashClear.js"(exports, module) {
+	var nativeCreate$3 = require__nativeCreate();
+	/**
+	* Removes all key-value entries from the hash.
+	*
+	* @private
+	* @name clear
+	* @memberOf Hash
+	*/
+	function hashClear$1() {
+		this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
+		this.size = 0;
+	}
+	module.exports = hashClear$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_hashDelete.js
+var require__hashDelete = __commonJS({ "../../node_modules/lodash/_hashDelete.js"(exports, module) {
+	/**
+	* Removes `key` and its value from the hash.
+	*
+	* @private
+	* @name delete
+	* @memberOf Hash
+	* @param {Object} hash The hash to modify.
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function hashDelete$1(key) {
+		var result = this.has(key) && delete this.__data__[key];
+		this.size -= result ? 1 : 0;
+		return result;
+	}
+	module.exports = hashDelete$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_hashGet.js
+var require__hashGet = __commonJS({ "../../node_modules/lodash/_hashGet.js"(exports, module) {
+	var nativeCreate$2 = require__nativeCreate();
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+	/** Used for built-in method references. */
+	var objectProto$7 = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+	/**
+	* Gets the hash value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf Hash
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function hashGet$1(key) {
+		var data = this.__data__;
+		if (nativeCreate$2) {
+			var result = data[key];
+			return result === HASH_UNDEFINED$1 ? void 0 : result;
+		}
+		return hasOwnProperty$6.call(data, key) ? data[key] : void 0;
+	}
+	module.exports = hashGet$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_hashHas.js
+var require__hashHas = __commonJS({ "../../node_modules/lodash/_hashHas.js"(exports, module) {
+	var nativeCreate$1 = require__nativeCreate();
+	/** Used for built-in method references. */
+	var objectProto$6 = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+	/**
+	* Checks if a hash value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf Hash
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function hashHas$1(key) {
+		var data = this.__data__;
+		return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty$5.call(data, key);
+	}
+	module.exports = hashHas$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_hashSet.js
+var require__hashSet = __commonJS({ "../../node_modules/lodash/_hashSet.js"(exports, module) {
+	var nativeCreate = require__nativeCreate();
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED = "__lodash_hash_undefined__";
+	/**
+	* Sets the hash `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf Hash
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the hash instance.
+	*/
+	function hashSet$1(key, value) {
+		var data = this.__data__;
+		this.size += this.has(key) ? 0 : 1;
+		data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+		return this;
+	}
+	module.exports = hashSet$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_Hash.js
+var require__Hash = __commonJS({ "../../node_modules/lodash/_Hash.js"(exports, module) {
+	var hashClear = require__hashClear(), hashDelete = require__hashDelete(), hashGet = require__hashGet(), hashHas = require__hashHas(), hashSet = require__hashSet();
+	/**
+	* Creates a hash object.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function Hash$1(entries) {
+		var index = -1, length$2 = entries == null ? 0 : entries.length;
+		this.clear();
+		while (++index < length$2) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	Hash$1.prototype.clear = hashClear;
+	Hash$1.prototype["delete"] = hashDelete;
+	Hash$1.prototype.get = hashGet;
+	Hash$1.prototype.has = hashHas;
+	Hash$1.prototype.set = hashSet;
+	module.exports = Hash$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_mapCacheClear.js
+var require__mapCacheClear = __commonJS({ "../../node_modules/lodash/_mapCacheClear.js"(exports, module) {
+	var Hash = require__Hash(), ListCache$2 = require__ListCache(), Map$2 = require__Map();
+	/**
+	* Removes all key-value entries from the map.
+	*
+	* @private
+	* @name clear
+	* @memberOf MapCache
+	*/
+	function mapCacheClear$1() {
+		this.size = 0;
+		this.__data__ = {
+			"hash": new Hash(),
+			"map": new (Map$2 || ListCache$2)(),
+			"string": new Hash()
+		};
+	}
+	module.exports = mapCacheClear$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_isKeyable.js
+var require__isKeyable = __commonJS({ "../../node_modules/lodash/_isKeyable.js"(exports, module) {
+	/**
+	* Checks if `value` is suitable for use as unique object key.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+	*/
+	function isKeyable$1(value) {
+		var type = typeof value;
+		return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+	}
+	module.exports = isKeyable$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_getMapData.js
+var require__getMapData = __commonJS({ "../../node_modules/lodash/_getMapData.js"(exports, module) {
+	var isKeyable = require__isKeyable();
+	/**
+	* Gets the data for `map`.
+	*
+	* @private
+	* @param {Object} map The map to query.
+	* @param {string} key The reference key.
+	* @returns {*} Returns the map data.
+	*/
+	function getMapData$4(map, key) {
+		var data = map.__data__;
+		return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+	}
+	module.exports = getMapData$4;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_mapCacheDelete.js
+var require__mapCacheDelete = __commonJS({ "../../node_modules/lodash/_mapCacheDelete.js"(exports, module) {
+	var getMapData$3 = require__getMapData();
+	/**
+	* Removes `key` and its value from the map.
+	*
+	* @private
+	* @name delete
+	* @memberOf MapCache
+	* @param {string} key The key of the value to remove.
+	* @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	*/
+	function mapCacheDelete$1(key) {
+		var result = getMapData$3(this, key)["delete"](key);
+		this.size -= result ? 1 : 0;
+		return result;
+	}
+	module.exports = mapCacheDelete$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_mapCacheGet.js
+var require__mapCacheGet = __commonJS({ "../../node_modules/lodash/_mapCacheGet.js"(exports, module) {
+	var getMapData$2 = require__getMapData();
+	/**
+	* Gets the map value for `key`.
+	*
+	* @private
+	* @name get
+	* @memberOf MapCache
+	* @param {string} key The key of the value to get.
+	* @returns {*} Returns the entry value.
+	*/
+	function mapCacheGet$1(key) {
+		return getMapData$2(this, key).get(key);
+	}
+	module.exports = mapCacheGet$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_mapCacheHas.js
+var require__mapCacheHas = __commonJS({ "../../node_modules/lodash/_mapCacheHas.js"(exports, module) {
+	var getMapData$1 = require__getMapData();
+	/**
+	* Checks if a map value for `key` exists.
+	*
+	* @private
+	* @name has
+	* @memberOf MapCache
+	* @param {string} key The key of the entry to check.
+	* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	*/
+	function mapCacheHas$1(key) {
+		return getMapData$1(this, key).has(key);
+	}
+	module.exports = mapCacheHas$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_mapCacheSet.js
+var require__mapCacheSet = __commonJS({ "../../node_modules/lodash/_mapCacheSet.js"(exports, module) {
+	var getMapData = require__getMapData();
+	/**
+	* Sets the map `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf MapCache
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the map cache instance.
+	*/
+	function mapCacheSet$1(key, value) {
+		var data = getMapData(this, key), size = data.size;
+		data.set(key, value);
+		this.size += data.size == size ? 0 : 1;
+		return this;
+	}
+	module.exports = mapCacheSet$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_MapCache.js
+var require__MapCache = __commonJS({ "../../node_modules/lodash/_MapCache.js"(exports, module) {
+	var mapCacheClear = require__mapCacheClear(), mapCacheDelete = require__mapCacheDelete(), mapCacheGet = require__mapCacheGet(), mapCacheHas = require__mapCacheHas(), mapCacheSet = require__mapCacheSet();
+	/**
+	* Creates a map cache object to store key-value pairs.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function MapCache$1(entries) {
+		var index = -1, length$2 = entries == null ? 0 : entries.length;
+		this.clear();
+		while (++index < length$2) {
+			var entry = entries[index];
+			this.set(entry[0], entry[1]);
+		}
+	}
+	MapCache$1.prototype.clear = mapCacheClear;
+	MapCache$1.prototype["delete"] = mapCacheDelete;
+	MapCache$1.prototype.get = mapCacheGet;
+	MapCache$1.prototype.has = mapCacheHas;
+	MapCache$1.prototype.set = mapCacheSet;
+	module.exports = MapCache$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_stackSet.js
+var require__stackSet = __commonJS({ "../../node_modules/lodash/_stackSet.js"(exports, module) {
+	var ListCache$1 = require__ListCache(), Map$1 = require__Map(), MapCache = require__MapCache();
+	/** Used as the size to enable large array optimizations. */
+	var LARGE_ARRAY_SIZE = 200;
+	/**
+	* Sets the stack `key` to `value`.
+	*
+	* @private
+	* @name set
+	* @memberOf Stack
+	* @param {string} key The key of the value to set.
+	* @param {*} value The value to set.
+	* @returns {Object} Returns the stack cache instance.
+	*/
+	function stackSet$1(key, value) {
+		var data = this.__data__;
+		if (data instanceof ListCache$1) {
+			var pairs = data.__data__;
+			if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+				pairs.push([key, value]);
+				this.size = ++data.size;
+				return this;
+			}
+			data = this.__data__ = new MapCache(pairs);
+		}
+		data.set(key, value);
+		this.size = data.size;
+		return this;
+	}
+	module.exports = stackSet$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_Stack.js
+var require__Stack = __commonJS({ "../../node_modules/lodash/_Stack.js"(exports, module) {
+	var ListCache = require__ListCache(), stackClear = require__stackClear(), stackDelete = require__stackDelete(), stackGet = require__stackGet(), stackHas = require__stackHas(), stackSet = require__stackSet();
+	/**
+	* Creates a stack cache object to store key-value pairs.
+	*
+	* @private
+	* @constructor
+	* @param {Array} [entries] The key-value pairs to cache.
+	*/
+	function Stack$1(entries) {
+		var data = this.__data__ = new ListCache(entries);
+		this.size = data.size;
+	}
+	Stack$1.prototype.clear = stackClear;
+	Stack$1.prototype["delete"] = stackDelete;
+	Stack$1.prototype.get = stackGet;
+	Stack$1.prototype.has = stackHas;
+	Stack$1.prototype.set = stackSet;
+	module.exports = Stack$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_defineProperty.js
+var require__defineProperty = __commonJS({ "../../node_modules/lodash/_defineProperty.js"(exports, module) {
+	var getNative = require__getNative();
+	var defineProperty$2 = function() {
+		try {
+			var func = getNative(Object, "defineProperty");
+			func({}, "", {});
+			return func;
+		} catch (e) {}
+	}();
+	module.exports = defineProperty$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseAssignValue.js
+var require__baseAssignValue = __commonJS({ "../../node_modules/lodash/_baseAssignValue.js"(exports, module) {
+	var defineProperty$1 = require__defineProperty();
+	/**
+	* The base implementation of `assignValue` and `assignMergeValue` without
+	* value checks.
+	*
+	* @private
+	* @param {Object} object The object to modify.
+	* @param {string} key The key of the property to assign.
+	* @param {*} value The value to assign.
+	*/
+	function baseAssignValue$3(object, key, value) {
+		if (key == "__proto__" && defineProperty$1) defineProperty$1(object, key, {
+			"configurable": true,
+			"enumerable": true,
+			"value": value,
+			"writable": true
+		});
+		else object[key] = value;
+	}
+	module.exports = baseAssignValue$3;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_assignMergeValue.js
+var require__assignMergeValue = __commonJS({ "../../node_modules/lodash/_assignMergeValue.js"(exports, module) {
+	var baseAssignValue$2 = require__baseAssignValue(), eq$2 = require_eq();
+	/**
+	* This function is like `assignValue` except that it doesn't assign
+	* `undefined` values.
+	*
+	* @private
+	* @param {Object} object The object to modify.
+	* @param {string} key The key of the property to assign.
+	* @param {*} value The value to assign.
+	*/
+	function assignMergeValue$2(object, key, value) {
+		if (value !== void 0 && !eq$2(object[key], value) || value === void 0 && !(key in object)) baseAssignValue$2(object, key, value);
+	}
+	module.exports = assignMergeValue$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_createBaseFor.js
+var require__createBaseFor = __commonJS({ "../../node_modules/lodash/_createBaseFor.js"(exports, module) {
+	/**
+	* Creates a base function for methods like `_.forIn` and `_.forOwn`.
+	*
+	* @private
+	* @param {boolean} [fromRight] Specify iterating from right to left.
+	* @returns {Function} Returns the new base function.
+	*/
+	function createBaseFor$1(fromRight) {
+		return function(object, iteratee, keysFunc) {
+			var index = -1, iterable = Object(object), props = keysFunc(object), length$2 = props.length;
+			while (length$2--) {
+				var key = props[fromRight ? length$2 : ++index];
+				if (iteratee(iterable[key], key, iterable) === false) break;
+			}
+			return object;
+		};
+	}
+	module.exports = createBaseFor$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseFor.js
+var require__baseFor = __commonJS({ "../../node_modules/lodash/_baseFor.js"(exports, module) {
+	var createBaseFor = require__createBaseFor();
+	/**
+	* The base implementation of `baseForOwn` which iterates over `object`
+	* properties returned by `keysFunc` and invokes `iteratee` for each property.
+	* Iteratee functions may exit iteration early by explicitly returning `false`.
+	*
+	* @private
+	* @param {Object} object The object to iterate over.
+	* @param {Function} iteratee The function invoked per iteration.
+	* @param {Function} keysFunc The function to get the keys of `object`.
+	* @returns {Object} Returns `object`.
+	*/
+	var baseFor$1 = createBaseFor();
+	module.exports = baseFor$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_cloneBuffer.js
+var require__cloneBuffer = __commonJS({ "../../node_modules/lodash/_cloneBuffer.js"(exports, module) {
+	var root$2 = require__root();
+	/** Detect free variable `exports`. */
+	var freeExports$2 = typeof exports == "object" && exports && !exports.nodeType && exports;
+	/** Detect free variable `module`. */
+	var freeModule$2 = freeExports$2 && typeof module == "object" && module && !module.nodeType && module;
+	/** Detect the popular CommonJS extension `module.exports`. */
+	var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2;
+	/** Built-in value references. */
+	var Buffer$3 = moduleExports$2 ? root$2.Buffer : void 0, allocUnsafe = Buffer$3 ? Buffer$3.allocUnsafe : void 0;
+	/**
+	* Creates a clone of  `buffer`.
+	*
+	* @private
+	* @param {Buffer} buffer The buffer to clone.
+	* @param {boolean} [isDeep] Specify a deep clone.
+	* @returns {Buffer} Returns the cloned buffer.
+	*/
+	function cloneBuffer$1(buffer$1, isDeep) {
+		if (isDeep) return buffer$1.slice();
+		var length$2 = buffer$1.length, result = allocUnsafe ? allocUnsafe(length$2) : new buffer$1.constructor(length$2);
+		buffer$1.copy(result);
+		return result;
+	}
+	module.exports = cloneBuffer$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_Uint8Array.js
+var require__Uint8Array = __commonJS({ "../../node_modules/lodash/_Uint8Array.js"(exports, module) {
+	var root$1 = require__root();
+	/** Built-in value references. */
+	var Uint8Array$2 = root$1.Uint8Array;
+	module.exports = Uint8Array$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_cloneArrayBuffer.js
+var require__cloneArrayBuffer = __commonJS({ "../../node_modules/lodash/_cloneArrayBuffer.js"(exports, module) {
+	var Uint8Array$1 = require__Uint8Array();
+	/**
+	* Creates a clone of `arrayBuffer`.
+	*
+	* @private
+	* @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+	* @returns {ArrayBuffer} Returns the cloned array buffer.
+	*/
+	function cloneArrayBuffer$1(arrayBuffer) {
+		var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+		new Uint8Array$1(result).set(new Uint8Array$1(arrayBuffer));
+		return result;
+	}
+	module.exports = cloneArrayBuffer$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_cloneTypedArray.js
+var require__cloneTypedArray = __commonJS({ "../../node_modules/lodash/_cloneTypedArray.js"(exports, module) {
+	var cloneArrayBuffer = require__cloneArrayBuffer();
+	/**
+	* Creates a clone of `typedArray`.
+	*
+	* @private
+	* @param {Object} typedArray The typed array to clone.
+	* @param {boolean} [isDeep] Specify a deep clone.
+	* @returns {Object} Returns the cloned typed array.
+	*/
+	function cloneTypedArray$1(typedArray, isDeep) {
+		var buffer$1 = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+		return new typedArray.constructor(buffer$1, typedArray.byteOffset, typedArray.length);
+	}
+	module.exports = cloneTypedArray$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_copyArray.js
+var require__copyArray = __commonJS({ "../../node_modules/lodash/_copyArray.js"(exports, module) {
+	/**
+	* Copies the values of `source` to `array`.
+	*
+	* @private
+	* @param {Array} source The array to copy values from.
+	* @param {Array} [array=[]] The array to copy values to.
+	* @returns {Array} Returns `array`.
+	*/
+	function copyArray$1(source, array) {
+		var index = -1, length$2 = source.length;
+		array || (array = Array(length$2));
+		while (++index < length$2) array[index] = source[index];
+		return array;
+	}
+	module.exports = copyArray$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseCreate.js
+var require__baseCreate = __commonJS({ "../../node_modules/lodash/_baseCreate.js"(exports, module) {
+	var isObject$4 = require_isObject();
+	/** Built-in value references. */
+	var objectCreate = Object.create;
+	/**
+	* The base implementation of `_.create` without support for assigning
+	* properties to the created object.
+	*
+	* @private
+	* @param {Object} proto The object to inherit from.
+	* @returns {Object} Returns the new object.
+	*/
+	var baseCreate$1 = function() {
+		function object() {}
+		return function(proto) {
+			if (!isObject$4(proto)) return {};
+			if (objectCreate) return objectCreate(proto);
+			object.prototype = proto;
+			var result = new object();
+			object.prototype = void 0;
+			return result;
+		};
+	}();
+	module.exports = baseCreate$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_overArg.js
+var require__overArg = __commonJS({ "../../node_modules/lodash/_overArg.js"(exports, module) {
+	/**
+	* Creates a unary function that invokes `func` with its argument transformed.
+	*
+	* @private
+	* @param {Function} func The function to wrap.
+	* @param {Function} transform The argument transform.
+	* @returns {Function} Returns the new function.
+	*/
+	function overArg$1(func, transform) {
+		return function(arg) {
+			return func(transform(arg));
+		};
+	}
+	module.exports = overArg$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_getPrototype.js
+var require__getPrototype = __commonJS({ "../../node_modules/lodash/_getPrototype.js"(exports, module) {
+	var overArg = require__overArg();
+	/** Built-in value references. */
+	var getPrototype$2 = overArg(Object.getPrototypeOf, Object);
+	module.exports = getPrototype$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_isPrototype.js
+var require__isPrototype = __commonJS({ "../../node_modules/lodash/_isPrototype.js"(exports, module) {
+	/** Used for built-in method references. */
+	var objectProto$5 = Object.prototype;
+	/**
+	* Checks if `value` is likely a prototype object.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+	*/
+	function isPrototype$2(value) {
+		var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$5;
+		return value === proto;
+	}
+	module.exports = isPrototype$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_initCloneObject.js
+var require__initCloneObject = __commonJS({ "../../node_modules/lodash/_initCloneObject.js"(exports, module) {
+	var baseCreate = require__baseCreate(), getPrototype$1 = require__getPrototype(), isPrototype$1 = require__isPrototype();
+	/**
+	* Initializes an object clone.
+	*
+	* @private
+	* @param {Object} object The object to clone.
+	* @returns {Object} Returns the initialized clone.
+	*/
+	function initCloneObject$1(object) {
+		return typeof object.constructor == "function" && !isPrototype$1(object) ? baseCreate(getPrototype$1(object)) : {};
+	}
+	module.exports = initCloneObject$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isObjectLike.js
+var require_isObjectLike = __commonJS({ "../../node_modules/lodash/isObjectLike.js"(exports, module) {
+	/**
+	* Checks if `value` is object-like. A value is object-like if it's not `null`
+	* and has a `typeof` result of "object".
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	* @example
+	*
+	* _.isObjectLike({});
+	* // => true
+	*
+	* _.isObjectLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isObjectLike(_.noop);
+	* // => false
+	*
+	* _.isObjectLike(null);
+	* // => false
+	*/
+	function isObjectLike$5(value) {
+		return value != null && typeof value == "object";
+	}
+	module.exports = isObjectLike$5;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseIsArguments.js
+var require__baseIsArguments = __commonJS({ "../../node_modules/lodash/_baseIsArguments.js"(exports, module) {
+	var baseGetTag$2 = require__baseGetTag(), isObjectLike$4 = require_isObjectLike();
+	/** `Object#toString` result references. */
+	var argsTag$1 = "[object Arguments]";
+	/**
+	* The base implementation of `_.isArguments`.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	*/
+	function baseIsArguments$1(value) {
+		return isObjectLike$4(value) && baseGetTag$2(value) == argsTag$1;
+	}
+	module.exports = baseIsArguments$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isArguments.js
+var require_isArguments = __commonJS({ "../../node_modules/lodash/isArguments.js"(exports, module) {
+	var baseIsArguments = require__baseIsArguments(), isObjectLike$3 = require_isObjectLike();
+	/** Used for built-in method references. */
+	var objectProto$4 = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty$4 = objectProto$4.hasOwnProperty;
+	/** Built-in value references. */
+	var propertyIsEnumerable = objectProto$4.propertyIsEnumerable;
+	/**
+	* Checks if `value` is likely an `arguments` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	*  else `false`.
+	* @example
+	*
+	* _.isArguments(function() { return arguments; }());
+	* // => true
+	*
+	* _.isArguments([1, 2, 3]);
+	* // => false
+	*/
+	var isArguments$2 = baseIsArguments(function() {
+		return arguments;
+	}()) ? baseIsArguments : function(value) {
+		return isObjectLike$3(value) && hasOwnProperty$4.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+	};
+	module.exports = isArguments$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isArray.js
+var require_isArray = __commonJS({ "../../node_modules/lodash/isArray.js"(exports, module) {
+	/**
+	* Checks if `value` is classified as an `Array` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an array, else `false`.
+	* @example
+	*
+	* _.isArray([1, 2, 3]);
+	* // => true
+	*
+	* _.isArray(document.body.children);
+	* // => false
+	*
+	* _.isArray('abc');
+	* // => false
+	*
+	* _.isArray(_.noop);
+	* // => false
+	*/
+	var isArray$4 = Array.isArray;
+	module.exports = isArray$4;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isLength.js
+var require_isLength = __commonJS({ "../../node_modules/lodash/isLength.js"(exports, module) {
+	/** Used as references for various `Number` constants. */
+	var MAX_SAFE_INTEGER$2 = 9007199254740991;
+	/**
+	* Checks if `value` is a valid array-like length.
+	*
+	* **Note:** This method is loosely based on
+	* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+	* @example
+	*
+	* _.isLength(3);
+	* // => true
+	*
+	* _.isLength(Number.MIN_VALUE);
+	* // => false
+	*
+	* _.isLength(Infinity);
+	* // => false
+	*
+	* _.isLength('3');
+	* // => false
+	*/
+	function isLength$2(value) {
+		return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$2;
+	}
+	module.exports = isLength$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isArrayLike.js
+var require_isArrayLike = __commonJS({ "../../node_modules/lodash/isArrayLike.js"(exports, module) {
+	var isFunction$1 = require_isFunction(), isLength$1 = require_isLength();
+	/**
+	* Checks if `value` is array-like. A value is considered array-like if it's
+	* not a function and has a `value.length` that's an integer greater than or
+	* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+	* @example
+	*
+	* _.isArrayLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isArrayLike(document.body.children);
+	* // => true
+	*
+	* _.isArrayLike('abc');
+	* // => true
+	*
+	* _.isArrayLike(_.noop);
+	* // => false
+	*/
+	function isArrayLike$3(value) {
+		return value != null && isLength$1(value.length) && !isFunction$1(value);
+	}
+	module.exports = isArrayLike$3;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isArrayLikeObject.js
+var require_isArrayLikeObject = __commonJS({ "../../node_modules/lodash/isArrayLikeObject.js"(exports, module) {
+	var isArrayLike$2 = require_isArrayLike(), isObjectLike$2 = require_isObjectLike();
+	/**
+	* This method is like `_.isArrayLike` except that it also checks if `value`
+	* is an object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an array-like object,
+	*  else `false`.
+	* @example
+	*
+	* _.isArrayLikeObject([1, 2, 3]);
+	* // => true
+	*
+	* _.isArrayLikeObject(document.body.children);
+	* // => true
+	*
+	* _.isArrayLikeObject('abc');
+	* // => false
+	*
+	* _.isArrayLikeObject(_.noop);
+	* // => false
+	*/
+	function isArrayLikeObject$1(value) {
+		return isObjectLike$2(value) && isArrayLike$2(value);
+	}
+	module.exports = isArrayLikeObject$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/stubFalse.js
+var require_stubFalse = __commonJS({ "../../node_modules/lodash/stubFalse.js"(exports, module) {
+	/**
+	* This method returns `false`.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.13.0
+	* @category Util
+	* @returns {boolean} Returns `false`.
+	* @example
+	*
+	* _.times(2, _.stubFalse);
+	* // => [false, false]
+	*/
+	function stubFalse$1() {
+		return false;
+	}
+	module.exports = stubFalse$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isBuffer.js
+var require_isBuffer = __commonJS({ "../../node_modules/lodash/isBuffer.js"(exports, module) {
+	var root = require__root(), stubFalse = require_stubFalse();
+	/** Detect free variable `exports`. */
+	var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
+	/** Detect free variable `module`. */
+	var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
+	/** Detect the popular CommonJS extension `module.exports`. */
+	var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+	/** Built-in value references. */
+	var Buffer$2 = moduleExports$1 ? root.Buffer : void 0;
+	var nativeIsBuffer = Buffer$2 ? Buffer$2.isBuffer : void 0;
+	/**
+	* Checks if `value` is a buffer.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.3.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+	* @example
+	*
+	* _.isBuffer(new Buffer(2));
+	* // => true
+	*
+	* _.isBuffer(new Uint8Array(2));
+	* // => false
+	*/
+	var isBuffer$2 = nativeIsBuffer || stubFalse;
+	module.exports = isBuffer$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isPlainObject.js
+var require_isPlainObject = __commonJS({ "../../node_modules/lodash/isPlainObject.js"(exports, module) {
+	var baseGetTag$1 = require__baseGetTag(), getPrototype = require__getPrototype(), isObjectLike$1 = require_isObjectLike();
+	/** `Object#toString` result references. */
+	var objectTag$1 = "[object Object]";
+	/** Used for built-in method references. */
+	var funcProto = Function.prototype, objectProto$3 = Object.prototype;
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
+	/** Used to infer the `Object` constructor. */
+	var objectCtorString = funcToString.call(Object);
+	/**
+	* Checks if `value` is a plain object, that is, an object created by the
+	* `Object` constructor or one with a `[[Prototype]]` of `null`.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.8.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+	* @example
+	*
+	* function Foo() {
+	*   this.a = 1;
+	* }
+	*
+	* _.isPlainObject(new Foo);
+	* // => false
+	*
+	* _.isPlainObject([1, 2, 3]);
+	* // => false
+	*
+	* _.isPlainObject({ 'x': 0, 'y': 0 });
+	* // => true
+	*
+	* _.isPlainObject(Object.create(null));
+	* // => true
+	*/
+	function isPlainObject$1(value) {
+		if (!isObjectLike$1(value) || baseGetTag$1(value) != objectTag$1) return false;
+		var proto = getPrototype(value);
+		if (proto === null) return true;
+		var Ctor = hasOwnProperty$3.call(proto, "constructor") && proto.constructor;
+		return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+	}
+	module.exports = isPlainObject$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseIsTypedArray.js
+var require__baseIsTypedArray = __commonJS({ "../../node_modules/lodash/_baseIsTypedArray.js"(exports, module) {
+	var baseGetTag = require__baseGetTag(), isLength = require_isLength(), isObjectLike = require_isObjectLike();
+	/** `Object#toString` result references. */
+	var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", weakMapTag = "[object WeakMap]";
+	var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+	/** Used to identify `toStringTag` values of typed arrays. */
+	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;
+	/**
+	* The base implementation of `_.isTypedArray` without Node.js optimizations.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+	*/
+	function baseIsTypedArray$1(value) {
+		return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+	}
+	module.exports = baseIsTypedArray$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseUnary.js
+var require__baseUnary = __commonJS({ "../../node_modules/lodash/_baseUnary.js"(exports, module) {
+	/**
+	* The base implementation of `_.unary` without support for storing metadata.
+	*
+	* @private
+	* @param {Function} func The function to cap arguments for.
+	* @returns {Function} Returns the new capped function.
+	*/
+	function baseUnary$1(func) {
+		return function(value) {
+			return func(value);
+		};
+	}
+	module.exports = baseUnary$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_nodeUtil.js
+var require__nodeUtil = __commonJS({ "../../node_modules/lodash/_nodeUtil.js"(exports, module) {
+	var freeGlobal = require__freeGlobal();
+	/** Detect free variable `exports`. */
+	var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+	/** Detect free variable `module`. */
+	var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+	/** Detect the popular CommonJS extension `module.exports`. */
+	var moduleExports = freeModule && freeModule.exports === freeExports;
+	/** Detect free variable `process` from Node.js. */
+	var freeProcess = moduleExports && freeGlobal.process;
+	/** Used to access faster Node.js helpers. */
+	var nodeUtil$1 = function() {
+		try {
+			var types = freeModule && freeModule.require && freeModule.require("util").types;
+			if (types) return types;
+			return freeProcess && freeProcess.binding && freeProcess.binding("util");
+		} catch (e) {}
+	}();
+	module.exports = nodeUtil$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/isTypedArray.js
+var require_isTypedArray = __commonJS({ "../../node_modules/lodash/isTypedArray.js"(exports, module) {
+	var baseIsTypedArray = require__baseIsTypedArray(), baseUnary = require__baseUnary(), nodeUtil = require__nodeUtil();
+	var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+	/**
+	* Checks if `value` is classified as a typed array.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+	* @example
+	*
+	* _.isTypedArray(new Uint8Array);
+	* // => true
+	*
+	* _.isTypedArray([]);
+	* // => false
+	*/
+	var isTypedArray$2 = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+	module.exports = isTypedArray$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_safeGet.js
+var require__safeGet = __commonJS({ "../../node_modules/lodash/_safeGet.js"(exports, module) {
+	/**
+	* Gets the value at `key`, unless `key` is "__proto__" or "constructor".
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @param {string} key The key of the property to get.
+	* @returns {*} Returns the property value.
+	*/
+	function safeGet$2(object, key) {
+		if (key === "constructor" && typeof object[key] === "function") return;
+		if (key == "__proto__") return;
+		return object[key];
+	}
+	module.exports = safeGet$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_assignValue.js
+var require__assignValue = __commonJS({ "../../node_modules/lodash/_assignValue.js"(exports, module) {
+	var baseAssignValue$1 = require__baseAssignValue(), eq$1 = require_eq();
+	/** Used for built-in method references. */
+	var objectProto$2 = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+	/**
+	* Assigns `value` to `key` of `object` if the existing value is not equivalent
+	* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	* for equality comparisons.
+	*
+	* @private
+	* @param {Object} object The object to modify.
+	* @param {string} key The key of the property to assign.
+	* @param {*} value The value to assign.
+	*/
+	function assignValue$1(object, key, value) {
+		var objValue = object[key];
+		if (!(hasOwnProperty$2.call(object, key) && eq$1(objValue, value)) || value === void 0 && !(key in object)) baseAssignValue$1(object, key, value);
+	}
+	module.exports = assignValue$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_copyObject.js
+var require__copyObject = __commonJS({ "../../node_modules/lodash/_copyObject.js"(exports, module) {
+	var assignValue = require__assignValue(), baseAssignValue = require__baseAssignValue();
+	/**
+	* Copies properties of `source` to `object`.
+	*
+	* @private
+	* @param {Object} source The object to copy properties from.
+	* @param {Array} props The property identifiers to copy.
+	* @param {Object} [object={}] The object to copy properties to.
+	* @param {Function} [customizer] The function to customize copied values.
+	* @returns {Object} Returns `object`.
+	*/
+	function copyObject$1(source, props, object, customizer) {
+		var isNew = !object;
+		object || (object = {});
+		var index = -1, length$2 = props.length;
+		while (++index < length$2) {
+			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;
+	}
+	module.exports = copyObject$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseTimes.js
+var require__baseTimes = __commonJS({ "../../node_modules/lodash/_baseTimes.js"(exports, module) {
+	/**
+	* The base implementation of `_.times` without support for iteratee shorthands
+	* or max array length checks.
+	*
+	* @private
+	* @param {number} n The number of times to invoke `iteratee`.
+	* @param {Function} iteratee The function invoked per iteration.
+	* @returns {Array} Returns the array of results.
+	*/
+	function baseTimes$1(n, iteratee) {
+		var index = -1, result = Array(n);
+		while (++index < n) result[index] = iteratee(index);
+		return result;
+	}
+	module.exports = baseTimes$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_isIndex.js
+var require__isIndex = __commonJS({ "../../node_modules/lodash/_isIndex.js"(exports, module) {
+	/** Used as references for various `Number` constants. */
+	var MAX_SAFE_INTEGER$1 = 9007199254740991;
+	/** Used to detect unsigned integer values. */
+	var reIsUint = /^(?:0|[1-9]\d*)$/;
+	/**
+	* Checks if `value` is a valid array-like index.
+	*
+	* @private
+	* @param {*} value The value to check.
+	* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+	* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+	*/
+	function isIndex$2(value, length$2) {
+		var type = typeof value;
+		length$2 = length$2 == null ? MAX_SAFE_INTEGER$1 : length$2;
+		return !!length$2 && (type == "number" || type != "symbol" && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length$2;
+	}
+	module.exports = isIndex$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_arrayLikeKeys.js
+var require__arrayLikeKeys = __commonJS({ "../../node_modules/lodash/_arrayLikeKeys.js"(exports, module) {
+	var baseTimes = require__baseTimes(), isArguments$1 = require_isArguments(), isArray$3 = require_isArray(), isBuffer$1 = require_isBuffer(), isIndex$1 = require__isIndex(), isTypedArray$1 = require_isTypedArray();
+	/** Used for built-in method references. */
+	var objectProto$1 = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+	/**
+	* Creates an array of the enumerable property names of the array-like `value`.
+	*
+	* @private
+	* @param {*} value The value to query.
+	* @param {boolean} inherited Specify returning inherited property names.
+	* @returns {Array} Returns the array of property names.
+	*/
+	function arrayLikeKeys$1(value, inherited) {
+		var isArr = isArray$3(value), isArg = !isArr && isArguments$1(value), isBuff = !isArr && !isArg && isBuffer$1(value), isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length$2 = result.length;
+		for (var key in value) if ((inherited || hasOwnProperty$1.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex$1(key, length$2)))) result.push(key);
+		return result;
+	}
+	module.exports = arrayLikeKeys$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_nativeKeysIn.js
+var require__nativeKeysIn = __commonJS({ "../../node_modules/lodash/_nativeKeysIn.js"(exports, module) {
+	/**
+	* This function is like
+	* [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+	* except that it includes inherited enumerable properties.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @returns {Array} Returns the array of property names.
+	*/
+	function nativeKeysIn$1(object) {
+		var result = [];
+		if (object != null) for (var key in Object(object)) result.push(key);
+		return result;
+	}
+	module.exports = nativeKeysIn$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseKeysIn.js
+var require__baseKeysIn = __commonJS({ "../../node_modules/lodash/_baseKeysIn.js"(exports, module) {
+	var isObject$3 = require_isObject(), isPrototype = require__isPrototype(), nativeKeysIn = require__nativeKeysIn();
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+	/**
+	* The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @returns {Array} Returns the array of property names.
+	*/
+	function baseKeysIn$1(object) {
+		if (!isObject$3(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;
+	}
+	module.exports = baseKeysIn$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/keysIn.js
+var require_keysIn = __commonJS({ "../../node_modules/lodash/keysIn.js"(exports, module) {
+	var arrayLikeKeys = require__arrayLikeKeys(), baseKeysIn = require__baseKeysIn(), isArrayLike$1 = require_isArrayLike();
+	/**
+	* Creates an array of the own and inherited enumerable property names of `object`.
+	*
+	* **Note:** Non-object values are coerced to objects.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category Object
+	* @param {Object} object The object to query.
+	* @returns {Array} Returns the array of property names.
+	* @example
+	*
+	* function Foo() {
+	*   this.a = 1;
+	*   this.b = 2;
+	* }
+	*
+	* Foo.prototype.c = 3;
+	*
+	* _.keysIn(new Foo);
+	* // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+	*/
+	function keysIn$2(object) {
+		return isArrayLike$1(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+	}
+	module.exports = keysIn$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/toPlainObject.js
+var require_toPlainObject = __commonJS({ "../../node_modules/lodash/toPlainObject.js"(exports, module) {
+	var copyObject = require__copyObject(), keysIn$1 = require_keysIn();
+	/**
+	* Converts `value` to a plain object flattening inherited enumerable string
+	* keyed properties of `value` to own properties of the plain object.
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category Lang
+	* @param {*} value The value to convert.
+	* @returns {Object} Returns the converted plain object.
+	* @example
+	*
+	* function Foo() {
+	*   this.b = 2;
+	* }
+	*
+	* Foo.prototype.c = 3;
+	*
+	* _.assign({ 'a': 1 }, new Foo);
+	* // => { 'a': 1, 'b': 2 }
+	*
+	* _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+	* // => { 'a': 1, 'b': 2, 'c': 3 }
+	*/
+	function toPlainObject$1(value) {
+		return copyObject(value, keysIn$1(value));
+	}
+	module.exports = toPlainObject$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseMergeDeep.js
+var require__baseMergeDeep = __commonJS({ "../../node_modules/lodash/_baseMergeDeep.js"(exports, module) {
+	var assignMergeValue$1 = require__assignMergeValue(), cloneBuffer = require__cloneBuffer(), cloneTypedArray = require__cloneTypedArray(), copyArray = require__copyArray(), initCloneObject = require__initCloneObject(), isArguments = require_isArguments(), isArray$2 = require_isArray(), isArrayLikeObject = require_isArrayLikeObject(), isBuffer = require_isBuffer(), isFunction = require_isFunction(), isObject$2 = require_isObject(), isPlainObject = require_isPlainObject(), isTypedArray = require_isTypedArray(), safeGet$1 = require__safeGet(), toPlainObject = require_toPlainObject();
+	/**
+	* A specialized version of `baseMerge` for arrays and objects which performs
+	* deep merges and tracks traversed objects enabling objects with circular
+	* references to be merged.
+	*
+	* @private
+	* @param {Object} object The destination object.
+	* @param {Object} source The source object.
+	* @param {string} key The key of the value to merge.
+	* @param {number} srcIndex The index of `source`.
+	* @param {Function} mergeFunc The function to merge values.
+	* @param {Function} [customizer] The function to customize assigned values.
+	* @param {Object} [stack] Tracks traversed source values and their merged
+	*  counterparts.
+	*/
+	function baseMergeDeep$1(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+		var objValue = safeGet$1(object, key), srcValue = safeGet$1(source, key), stacked = stack.get(srcValue);
+		if (stacked) {
+			assignMergeValue$1(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$2(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+			newValue = srcValue;
+			if (isArr || isBuff || isTyped) if (isArray$2(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 = [];
+			else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+				newValue = objValue;
+				if (isArguments(objValue)) newValue = toPlainObject(objValue);
+				else if (!isObject$2(objValue) || isFunction(objValue)) newValue = initCloneObject(srcValue);
+			} else isCommon = false;
+		}
+		if (isCommon) {
+			stack.set(srcValue, newValue);
+			mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+			stack["delete"](srcValue);
+		}
+		assignMergeValue$1(object, key, newValue);
+	}
+	module.exports = baseMergeDeep$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseMerge.js
+var require__baseMerge = __commonJS({ "../../node_modules/lodash/_baseMerge.js"(exports, module) {
+	var Stack = require__Stack(), assignMergeValue = require__assignMergeValue(), baseFor = require__baseFor(), baseMergeDeep = require__baseMergeDeep(), isObject$1 = require_isObject(), keysIn = require_keysIn(), safeGet = require__safeGet();
+	/**
+	* The base implementation of `_.merge` without support for multiple sources.
+	*
+	* @private
+	* @param {Object} object The destination object.
+	* @param {Object} source The source object.
+	* @param {number} srcIndex The index of `source`.
+	* @param {Function} [customizer] The function to customize merged values.
+	* @param {Object} [stack] Tracks traversed source values and their merged
+	*  counterparts.
+	*/
+	function baseMerge$1(object, source, srcIndex, customizer, stack) {
+		if (object === source) return;
+		baseFor(source, function(srcValue, key) {
+			stack || (stack = new Stack());
+			if (isObject$1(srcValue)) baseMergeDeep(object, source, key, srcIndex, baseMerge$1, customizer, stack);
+			else {
+				var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
+				if (newValue === void 0) newValue = srcValue;
+				assignMergeValue(object, key, newValue);
+			}
+		}, keysIn);
+	}
+	module.exports = baseMerge$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/identity.js
+var require_identity = __commonJS({ "../../node_modules/lodash/identity.js"(exports, module) {
+	/**
+	* This method returns the first argument it receives.
+	*
+	* @static
+	* @since 0.1.0
+	* @memberOf _
+	* @category Util
+	* @param {*} value Any value.
+	* @returns {*} Returns `value`.
+	* @example
+	*
+	* var object = { 'a': 1 };
+	*
+	* console.log(_.identity(object) === object);
+	* // => true
+	*/
+	function identity$2(value) {
+		return value;
+	}
+	module.exports = identity$2;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_apply.js
+var require__apply = __commonJS({ "../../node_modules/lodash/_apply.js"(exports, module) {
+	/**
+	* A faster alternative to `Function#apply`, this function invokes `func`
+	* with the `this` binding of `thisArg` and the arguments of `args`.
+	*
+	* @private
+	* @param {Function} func The function to invoke.
+	* @param {*} thisArg The `this` binding of `func`.
+	* @param {Array} args The arguments to invoke `func` with.
+	* @returns {*} Returns the result of `func`.
+	*/
+	function apply$1(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);
+	}
+	module.exports = apply$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_overRest.js
+var require__overRest = __commonJS({ "../../node_modules/lodash/_overRest.js"(exports, module) {
+	var apply = require__apply();
+	var nativeMax = Math.max;
+	/**
+	* A specialized version of `baseRest` which transforms the rest array.
+	*
+	* @private
+	* @param {Function} func The function to apply a rest parameter to.
+	* @param {number} [start=func.length-1] The start position of the rest parameter.
+	* @param {Function} transform The rest array transform.
+	* @returns {Function} Returns the new function.
+	*/
+	function overRest$1(func, start, transform) {
+		start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
+		return function() {
+			var args = arguments, index = -1, length$2 = nativeMax(args.length - start, 0), array = Array(length$2);
+			while (++index < length$2) 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);
+		};
+	}
+	module.exports = overRest$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/constant.js
+var require_constant = __commonJS({ "../../node_modules/lodash/constant.js"(exports, module) {
+	/**
+	* Creates a function that returns `value`.
+	*
+	* @static
+	* @memberOf _
+	* @since 2.4.0
+	* @category Util
+	* @param {*} value The value to return from the new function.
+	* @returns {Function} Returns the new constant function.
+	* @example
+	*
+	* var objects = _.times(2, _.constant({ 'a': 1 }));
+	*
+	* console.log(objects);
+	* // => [{ 'a': 1 }, { 'a': 1 }]
+	*
+	* console.log(objects[0] === objects[1]);
+	* // => true
+	*/
+	function constant$1(value) {
+		return function() {
+			return value;
+		};
+	}
+	module.exports = constant$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseSetToString.js
+var require__baseSetToString = __commonJS({ "../../node_modules/lodash/_baseSetToString.js"(exports, module) {
+	var constant = require_constant(), defineProperty = require__defineProperty(), identity$1 = require_identity();
+	/**
+	* The base implementation of `setToString` without support for hot loop shorting.
+	*
+	* @private
+	* @param {Function} func The function to modify.
+	* @param {Function} string The `toString` result.
+	* @returns {Function} Returns `func`.
+	*/
+	var baseSetToString$1 = !defineProperty ? identity$1 : function(func, string) {
+		return defineProperty(func, "toString", {
+			"configurable": true,
+			"enumerable": false,
+			"value": constant(string),
+			"writable": true
+		});
+	};
+	module.exports = baseSetToString$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_shortOut.js
+var require__shortOut = __commonJS({ "../../node_modules/lodash/_shortOut.js"(exports, module) {
+	/** Used to detect hot functions by number of calls within a span of milliseconds. */
+	var HOT_COUNT = 800, HOT_SPAN = 16;
+	var nativeNow = Date.now;
+	/**
+	* Creates a function that'll short out and invoke `identity` instead
+	* of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
+	* milliseconds.
+	*
+	* @private
+	* @param {Function} func The function to restrict.
+	* @returns {Function} Returns the new shortable function.
+	*/
+	function shortOut$1(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);
+		};
+	}
+	module.exports = shortOut$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_setToString.js
+var require__setToString = __commonJS({ "../../node_modules/lodash/_setToString.js"(exports, module) {
+	var baseSetToString = require__baseSetToString(), shortOut = require__shortOut();
+	/**
+	* Sets the `toString` method of `func` to return `string`.
+	*
+	* @private
+	* @param {Function} func The function to modify.
+	* @param {Function} string The `toString` result.
+	* @returns {Function} Returns `func`.
+	*/
+	var setToString$1 = shortOut(baseSetToString);
+	module.exports = setToString$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_baseRest.js
+var require__baseRest = __commonJS({ "../../node_modules/lodash/_baseRest.js"(exports, module) {
+	var identity = require_identity(), overRest = require__overRest(), setToString = require__setToString();
+	/**
+	* The base implementation of `_.rest` which doesn't validate or coerce arguments.
+	*
+	* @private
+	* @param {Function} func The function to apply a rest parameter to.
+	* @param {number} [start=func.length-1] The start position of the rest parameter.
+	* @returns {Function} Returns the new function.
+	*/
+	function baseRest$1(func, start) {
+		return setToString(overRest(func, start, identity), func + "");
+	}
+	module.exports = baseRest$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_isIterateeCall.js
+var require__isIterateeCall = __commonJS({ "../../node_modules/lodash/_isIterateeCall.js"(exports, module) {
+	var eq = require_eq(), isArrayLike = require_isArrayLike(), isIndex = require__isIndex(), isObject = require_isObject();
+	/**
+	* Checks if the given arguments are from an iteratee call.
+	*
+	* @private
+	* @param {*} value The potential iteratee value argument.
+	* @param {*} index The potential iteratee index or key argument.
+	* @param {*} object The potential iteratee object argument.
+	* @returns {boolean} Returns `true` if the arguments are from an iteratee call,
+	*  else `false`.
+	*/
+	function isIterateeCall$1(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;
+	}
+	module.exports = isIterateeCall$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/_createAssigner.js
+var require__createAssigner = __commonJS({ "../../node_modules/lodash/_createAssigner.js"(exports, module) {
+	var baseRest = require__baseRest(), isIterateeCall = require__isIterateeCall();
+	/**
+	* Creates a function like `_.assign`.
+	*
+	* @private
+	* @param {Function} assigner The function to assign values.
+	* @returns {Function} Returns the new assigner function.
+	*/
+	function createAssigner$1(assigner) {
+		return baseRest(function(object, sources) {
+			var index = -1, length$2 = sources.length, customizer = length$2 > 1 ? sources[length$2 - 1] : void 0, guard = length$2 > 2 ? sources[2] : void 0;
+			customizer = assigner.length > 3 && typeof customizer == "function" ? (length$2--, customizer) : void 0;
+			if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+				customizer = length$2 < 3 ? void 0 : customizer;
+				length$2 = 1;
+			}
+			object = Object(object);
+			while (++index < length$2) {
+				var source = sources[index];
+				if (source) assigner(object, source, index, customizer);
+			}
+			return object;
+		});
+	}
+	module.exports = createAssigner$1;
+} });
+
+//#endregion
+//#region ../../node_modules/lodash/merge.js
+var require_merge = __commonJS({ "../../node_modules/lodash/merge.js"(exports, module) {
+	var baseMerge = require__baseMerge(), createAssigner = require__createAssigner();
+	/**
+	* This method is like `_.assign` except that it recursively merges own and
+	* inherited enumerable string keyed properties of source objects into the
+	* destination object. Source properties that resolve to `undefined` are
+	* skipped if a destination value exists. Array and plain object properties
+	* are merged recursively. Other objects and value types are overridden by
+	* assignment. Source objects are applied from left to right. Subsequent
+	* sources overwrite property assignments of previous sources.
+	*
+	* **Note:** This method mutates `object`.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.5.0
+	* @category Object
+	* @param {Object} object The destination object.
+	* @param {...Object} [sources] The source objects.
+	* @returns {Object} Returns `object`.
+	* @example
+	*
+	* var object = {
+	*   'a': [{ 'b': 2 }, { 'd': 4 }]
+	* };
+	*
+	* var other = {
+	*   'a': [{ 'c': 3 }, { 'e': 5 }]
+	* };
+	*
+	* _.merge(object, other);
+	* // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+	*/
+	var merge = createAssigner(function(object, source, srcIndex) {
+		baseMerge(object, source, srcIndex);
+	});
+	module.exports = merge;
+} });
+var import_merge = __toESM(require_merge(), 1);
+
+//#endregion
 //#region ../types/dist/types.js
 const WEAVE_TRANSFORMER_ANCHORS = {
 	["TOP_LEFT"]: "top-left",
@@ -1665,6 +3970,7 @@ const WEAVE_STORE_HORIZONTAL_SYNC_HANDLER_CLIENT_TYPE = {
 	["PUB"]: "pub",
 	["SUB"]: "sub"
 };
+const WEAVE_STORE_AZURE_WEB_PUBSUB_DEFAULT_CONFIG = { resyncIntervalMs: 15e3 };
 
 //#endregion
 //#region src/store-azure-web-pubsub.ts
@@ -1674,14 +3980,14 @@ var WeaveStoreAzureWebPubsub = class extends __inditextech_weave_sdk.WeaveStore
 	constructor(storeOptions, azureWebPubsubOptions) {
 		super(storeOptions);
 		const { roomId } = azureWebPubsubOptions;
-		this.azureWebPubsubOptions = azureWebPubsubOptions;
+		this.azureWebPubsubOptions = (0, import_merge.default)(WEAVE_STORE_AZURE_WEB_PUBSUB_DEFAULT_CONFIG, azureWebPubsubOptions);
 		this.roomId = roomId;
 		this.init();
 	}
 	init() {
 		const { url } = this.azureWebPubsubOptions;
 		this.provider = new WeaveStoreAzureWebPubSubSyncClient(this, url, this.roomId, this.getDocument(), {
-			resyncInterval: 1e3,
+			resyncInterval: this.azureWebPubsubOptions.resyncIntervalMs,
 			tokenProvider: null
 		});
 		window.addEventListener("beforeunload", () => {
@@ -1732,5 +4038,6 @@ var WeaveStoreAzureWebPubsub = class extends __inditextech_weave_sdk.WeaveStore
 
 //#endregion
 exports.WEAVE_STORE_AZURE_WEB_PUBSUB = WEAVE_STORE_AZURE_WEB_PUBSUB
+exports.WEAVE_STORE_AZURE_WEB_PUBSUB_DEFAULT_CONFIG = WEAVE_STORE_AZURE_WEB_PUBSUB_DEFAULT_CONFIG
 exports.WEAVE_STORE_HORIZONTAL_SYNC_HANDLER_CLIENT_TYPE = WEAVE_STORE_HORIZONTAL_SYNC_HANDLER_CLIENT_TYPE
 exports.WeaveStoreAzureWebPubsub = WeaveStoreAzureWebPubsub