@krainovsd/js-helpers 0.2.2

package/lib/cjs/index.cjs

@@ -0,0 +1,2914 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const DATE_TYPES = {
+    Days: "days",
+    Months: "months",
+    Years: "years",
+    Seconds: "seconds",
+    Minutes: "minutes",
+    Hours: "hours",
+};
+
+const API_MIDDLEWARES = {
+    Auth: "auth",
+    Logger: "logger",
+};
+
+/* eslint-disable no-restricted-globals */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const IS_JEST = typeof process != "undefined" && process.env.JEST_WORKER_ID !== undefined;
+const IS_BUN = typeof process !== "undefined" && process.versions != null && process.versions.bun != null;
+const IS_DENO = // @ts-expect-error
+ typeof Deno !== "undefined" &&
+    // @ts-expect-error
+    typeof Deno.version !== "undefined" &&
+    // @ts-expect-error
+    typeof Deno.version.deno !== "undefined";
+const IS_NODE = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+const IS_WEB_WORKER = typeof self === "object" &&
+    self.constructor &&
+    self.constructor.name === "DedicatedWorkerGlobalScope";
+const IS_BROWSER = typeof window !== "undefined" && typeof window.document !== "undefined";
+
+const COLOR_FORMATS = {
+    Hex: "HEX",
+    Rgb: "RGB",
+    Rgba: "RGBA",
+    Hsl: "HSL",
+};
+
+const FIELD_TYPES = {
+    Date: "date",
+    Time: "time",
+    DateTime: "dateTime",
+    String: "string",
+    Number: "number",
+    Array: "array",
+};
+
+const index$6 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    API_MIDDLEWARES,
+    COLOR_FORMATS,
+    DATE_TYPES,
+    FIELD_TYPES,
+    IS_BROWSER,
+    IS_BUN,
+    IS_DENO,
+    IS_JEST,
+    IS_NODE,
+    IS_WEB_WORKER
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const waitUntil = (condition, checkInterval = 100) => {
+    return new Promise((resolve) => {
+        const interval = setInterval(() => {
+            if (condition())
+                return;
+            clearInterval(interval);
+            resolve(true);
+        }, checkInterval);
+    });
+};
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+/**
+ * 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_1;
+var hasRequiredIsArray;
+
+function requireIsArray () {
+	if (hasRequiredIsArray) return isArray_1;
+	hasRequiredIsArray = 1;
+	var isArray = Array.isArray;
+
+	isArray_1 = isArray;
+	return isArray_1;
+}
+
+/** Detect free variable `global` from Node.js. */
+
+var _freeGlobal;
+var hasRequired_freeGlobal;
+
+function require_freeGlobal () {
+	if (hasRequired_freeGlobal) return _freeGlobal;
+	hasRequired_freeGlobal = 1;
+	var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+	_freeGlobal = freeGlobal;
+	return _freeGlobal;
+}
+
+var _root;
+var hasRequired_root;
+
+function require_root () {
+	if (hasRequired_root) return _root;
+	hasRequired_root = 1;
+	var freeGlobal = require_freeGlobal();
+
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+	/** Used as a reference to the global object. */
+	var root = freeGlobal || freeSelf || Function('return this')();
+
+	_root = root;
+	return _root;
+}
+
+var _Symbol;
+var hasRequired_Symbol;
+
+function require_Symbol () {
+	if (hasRequired_Symbol) return _Symbol;
+	hasRequired_Symbol = 1;
+	var root = require_root();
+
+	/** Built-in value references. */
+	var Symbol = root.Symbol;
+
+	_Symbol = Symbol;
+	return _Symbol;
+}
+
+var _getRawTag;
+var hasRequired_getRawTag;
+
+function require_getRawTag () {
+	if (hasRequired_getRawTag) return _getRawTag;
+	hasRequired_getRawTag = 1;
+	var Symbol = require_Symbol();
+
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+
+	/**
+	 * Used to resolve the
+	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	 * of values.
+	 */
+	var nativeObjectToString = objectProto.toString;
+
+	/** Built-in value references. */
+	var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+	/**
+	 * 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(value) {
+	  var isOwn = hasOwnProperty.call(value, symToStringTag),
+	      tag = value[symToStringTag];
+
+	  try {
+	    value[symToStringTag] = undefined;
+	    var unmasked = true;
+	  } catch (e) {}
+
+	  var result = nativeObjectToString.call(value);
+	  if (unmasked) {
+	    if (isOwn) {
+	      value[symToStringTag] = tag;
+	    } else {
+	      delete value[symToStringTag];
+	    }
+	  }
+	  return result;
+	}
+
+	_getRawTag = getRawTag;
+	return _getRawTag;
+}
+
+/** Used for built-in method references. */
+
+var _objectToString;
+var hasRequired_objectToString;
+
+function require_objectToString () {
+	if (hasRequired_objectToString) return _objectToString;
+	hasRequired_objectToString = 1;
+	var objectProto = Object.prototype;
+
+	/**
+	 * Used to resolve the
+	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	 * of values.
+	 */
+	var nativeObjectToString = objectProto.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(value) {
+	  return nativeObjectToString.call(value);
+	}
+
+	_objectToString = objectToString;
+	return _objectToString;
+}
+
+var _baseGetTag;
+var hasRequired_baseGetTag;
+
+function require_baseGetTag () {
+	if (hasRequired_baseGetTag) return _baseGetTag;
+	hasRequired_baseGetTag = 1;
+	var Symbol = require_Symbol(),
+	    getRawTag = require_getRawTag(),
+	    objectToString = require_objectToString();
+
+	/** `Object#toString` result references. */
+	var nullTag = '[object Null]',
+	    undefinedTag = '[object Undefined]';
+
+	/** Built-in value references. */
+	var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+	/**
+	 * The base implementation of `getTag` without fallbacks for buggy environments.
+	 *
+	 * @private
+	 * @param {*} value The value to query.
+	 * @returns {string} Returns the `toStringTag`.
+	 */
+	function baseGetTag(value) {
+	  if (value == null) {
+	    return value === undefined ? undefinedTag : nullTag;
+	  }
+	  return (symToStringTag && symToStringTag in Object(value))
+	    ? getRawTag(value)
+	    : objectToString(value);
+	}
+
+	_baseGetTag = baseGetTag;
+	return _baseGetTag;
+}
+
+/**
+ * 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
+ */
+
+var isObjectLike_1;
+var hasRequiredIsObjectLike;
+
+function requireIsObjectLike () {
+	if (hasRequiredIsObjectLike) return isObjectLike_1;
+	hasRequiredIsObjectLike = 1;
+	function isObjectLike(value) {
+	  return value != null && typeof value == 'object';
+	}
+
+	isObjectLike_1 = isObjectLike;
+	return isObjectLike_1;
+}
+
+var isSymbol_1;
+var hasRequiredIsSymbol;
+
+function requireIsSymbol () {
+	if (hasRequiredIsSymbol) return isSymbol_1;
+	hasRequiredIsSymbol = 1;
+	var baseGetTag = require_baseGetTag(),
+	    isObjectLike = requireIsObjectLike();
+
+	/** `Object#toString` result references. */
+	var symbolTag = '[object Symbol]';
+
+	/**
+	 * Checks if `value` is classified as a `Symbol` primitive or object.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to check.
+	 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	 * @example
+	 *
+	 * _.isSymbol(Symbol.iterator);
+	 * // => true
+	 *
+	 * _.isSymbol('abc');
+	 * // => false
+	 */
+	function isSymbol(value) {
+	  return typeof value == 'symbol' ||
+	    (isObjectLike(value) && baseGetTag(value) == symbolTag);
+	}
+
+	isSymbol_1 = isSymbol;
+	return isSymbol_1;
+}
+
+var _isKey;
+var hasRequired_isKey;
+
+function require_isKey () {
+	if (hasRequired_isKey) return _isKey;
+	hasRequired_isKey = 1;
+	var isArray = requireIsArray(),
+	    isSymbol = requireIsSymbol();
+
+	/** Used to match property names within property paths. */
+	var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+	    reIsPlainProp = /^\w*$/;
+
+	/**
+	 * Checks if `value` is a property name and not a property path.
+	 *
+	 * @private
+	 * @param {*} value The value to check.
+	 * @param {Object} [object] The object to query keys on.
+	 * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+	 */
+	function isKey(value, object) {
+	  if (isArray(value)) {
+	    return false;
+	  }
+	  var type = typeof value;
+	  if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+	      value == null || isSymbol(value)) {
+	    return true;
+	  }
+	  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+	    (object != null && value in Object(object));
+	}
+
+	_isKey = isKey;
+	return _isKey;
+}
+
+/**
+ * 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
+ */
+
+var isObject_1;
+var hasRequiredIsObject;
+
+function requireIsObject () {
+	if (hasRequiredIsObject) return isObject_1;
+	hasRequiredIsObject = 1;
+	function isObject(value) {
+	  var type = typeof value;
+	  return value != null && (type == 'object' || type == 'function');
+	}
+
+	isObject_1 = isObject;
+	return isObject_1;
+}
+
+var isFunction_1;
+var hasRequiredIsFunction;
+
+function requireIsFunction () {
+	if (hasRequiredIsFunction) return isFunction_1;
+	hasRequiredIsFunction = 1;
+	var baseGetTag = require_baseGetTag(),
+	    isObject = requireIsObject();
+
+	/** `Object#toString` result references. */
+	var asyncTag = '[object AsyncFunction]',
+	    funcTag = '[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(value) {
+	  if (!isObject(value)) {
+	    return false;
+	  }
+	  // The use of `Object#toString` avoids issues with the `typeof` operator
+	  // in Safari 9 which returns 'object' for typed arrays and other constructors.
+	  var tag = baseGetTag(value);
+	  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+	}
+
+	isFunction_1 = isFunction;
+	return isFunction_1;
+}
+
+var _coreJsData;
+var hasRequired_coreJsData;
+
+function require_coreJsData () {
+	if (hasRequired_coreJsData) return _coreJsData;
+	hasRequired_coreJsData = 1;
+	var root = require_root();
+
+	/** Used to detect overreaching core-js shims. */
+	var coreJsData = root['__core-js_shared__'];
+
+	_coreJsData = coreJsData;
+	return _coreJsData;
+}
+
+var _isMasked;
+var hasRequired_isMasked;
+
+function require_isMasked () {
+	if (hasRequired_isMasked) return _isMasked;
+	hasRequired_isMasked = 1;
+	var coreJsData = require_coreJsData();
+
+	/** 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(func) {
+	  return !!maskSrcKey && (maskSrcKey in func);
+	}
+
+	_isMasked = isMasked;
+	return _isMasked;
+}
+
+/** Used for built-in method references. */
+
+var _toSource;
+var hasRequired_toSource;
+
+function require_toSource () {
+	if (hasRequired_toSource) return _toSource;
+	hasRequired_toSource = 1;
+	var funcProto = Function.prototype;
+
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+
+	/**
+	 * Converts `func` to its source code.
+	 *
+	 * @private
+	 * @param {Function} func The function to convert.
+	 * @returns {string} Returns the source code.
+	 */
+	function toSource(func) {
+	  if (func != null) {
+	    try {
+	      return funcToString.call(func);
+	    } catch (e) {}
+	    try {
+	      return (func + '');
+	    } catch (e) {}
+	  }
+	  return '';
+	}
+
+	_toSource = toSource;
+	return _toSource;
+}
+
+var _baseIsNative;
+var hasRequired_baseIsNative;
+
+function require_baseIsNative () {
+	if (hasRequired_baseIsNative) return _baseIsNative;
+	hasRequired_baseIsNative = 1;
+	var isFunction = requireIsFunction(),
+	    isMasked = require_isMasked(),
+	    isObject = requireIsObject(),
+	    toSource = require_toSource();
+
+	/**
+	 * 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 = Function.prototype,
+	    objectProto = Object.prototype;
+
+	/** Used to resolve the decompiled source of functions. */
+	var funcToString = funcProto.toString;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+
+	/** Used to detect if a method is native. */
+	var reIsNative = RegExp('^' +
+	  funcToString.call(hasOwnProperty).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(value) {
+	  if (!isObject(value) || isMasked(value)) {
+	    return false;
+	  }
+	  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+	  return pattern.test(toSource(value));
+	}
+
+	_baseIsNative = baseIsNative;
+	return _baseIsNative;
+}
+
+/**
+ * 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.
+ */
+
+var _getValue;
+var hasRequired_getValue;
+
+function require_getValue () {
+	if (hasRequired_getValue) return _getValue;
+	hasRequired_getValue = 1;
+	function getValue(object, key) {
+	  return object == null ? undefined : object[key];
+	}
+
+	_getValue = getValue;
+	return _getValue;
+}
+
+var _getNative;
+var hasRequired_getNative;
+
+function require_getNative () {
+	if (hasRequired_getNative) return _getNative;
+	hasRequired_getNative = 1;
+	var baseIsNative = require_baseIsNative(),
+	    getValue = require_getValue();
+
+	/**
+	 * 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(object, key) {
+	  var value = getValue(object, key);
+	  return baseIsNative(value) ? value : undefined;
+	}
+
+	_getNative = getNative;
+	return _getNative;
+}
+
+var _nativeCreate;
+var hasRequired_nativeCreate;
+
+function require_nativeCreate () {
+	if (hasRequired_nativeCreate) return _nativeCreate;
+	hasRequired_nativeCreate = 1;
+	var getNative = require_getNative();
+
+	/* Built-in method references that are verified to be native. */
+	var nativeCreate = getNative(Object, 'create');
+
+	_nativeCreate = nativeCreate;
+	return _nativeCreate;
+}
+
+var _hashClear;
+var hasRequired_hashClear;
+
+function require_hashClear () {
+	if (hasRequired_hashClear) return _hashClear;
+	hasRequired_hashClear = 1;
+	var nativeCreate = require_nativeCreate();
+
+	/**
+	 * Removes all key-value entries from the hash.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf Hash
+	 */
+	function hashClear() {
+	  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+	  this.size = 0;
+	}
+
+	_hashClear = hashClear;
+	return _hashClear;
+}
+
+/**
+ * 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`.
+ */
+
+var _hashDelete;
+var hasRequired_hashDelete;
+
+function require_hashDelete () {
+	if (hasRequired_hashDelete) return _hashDelete;
+	hasRequired_hashDelete = 1;
+	function hashDelete(key) {
+	  var result = this.has(key) && delete this.__data__[key];
+	  this.size -= result ? 1 : 0;
+	  return result;
+	}
+
+	_hashDelete = hashDelete;
+	return _hashDelete;
+}
+
+var _hashGet;
+var hasRequired_hashGet;
+
+function require_hashGet () {
+	if (hasRequired_hashGet) return _hashGet;
+	hasRequired_hashGet = 1;
+	var nativeCreate = require_nativeCreate();
+
+	/** Used to stand-in for `undefined` hash values. */
+	var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.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(key) {
+	  var data = this.__data__;
+	  if (nativeCreate) {
+	    var result = data[key];
+	    return result === HASH_UNDEFINED ? undefined : result;
+	  }
+	  return hasOwnProperty.call(data, key) ? data[key] : undefined;
+	}
+
+	_hashGet = hashGet;
+	return _hashGet;
+}
+
+var _hashHas;
+var hasRequired_hashHas;
+
+function require_hashHas () {
+	if (hasRequired_hashHas) return _hashHas;
+	hasRequired_hashHas = 1;
+	var nativeCreate = require_nativeCreate();
+
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.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(key) {
+	  var data = this.__data__;
+	  return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
+	}
+
+	_hashHas = hashHas;
+	return _hashHas;
+}
+
+var _hashSet;
+var hasRequired_hashSet;
+
+function require_hashSet () {
+	if (hasRequired_hashSet) return _hashSet;
+	hasRequired_hashSet = 1;
+	var nativeCreate = require_nativeCreate();
+
+	/** 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(key, value) {
+	  var data = this.__data__;
+	  this.size += this.has(key) ? 0 : 1;
+	  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+	  return this;
+	}
+
+	_hashSet = hashSet;
+	return _hashSet;
+}
+
+var _Hash;
+var hasRequired_Hash;
+
+function require_Hash () {
+	if (hasRequired_Hash) return _Hash;
+	hasRequired_Hash = 1;
+	var hashClear = require_hashClear(),
+	    hashDelete = require_hashDelete(),
+	    hashGet = require_hashGet(),
+	    hashHas = require_hashHas(),
+	    hashSet = require_hashSet();
+
+	/**
+	 * Creates a hash object.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	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]);
+	  }
+	}
+
+	// Add methods to `Hash`.
+	Hash.prototype.clear = hashClear;
+	Hash.prototype['delete'] = hashDelete;
+	Hash.prototype.get = hashGet;
+	Hash.prototype.has = hashHas;
+	Hash.prototype.set = hashSet;
+
+	_Hash = Hash;
+	return _Hash;
+}
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+
+var _listCacheClear;
+var hasRequired_listCacheClear;
+
+function require_listCacheClear () {
+	if (hasRequired_listCacheClear) return _listCacheClear;
+	hasRequired_listCacheClear = 1;
+	function listCacheClear() {
+	  this.__data__ = [];
+	  this.size = 0;
+	}
+
+	_listCacheClear = listCacheClear;
+	return _listCacheClear;
+}
+
+/**
+ * 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
+ */
+
+var eq_1;
+var hasRequiredEq;
+
+function requireEq () {
+	if (hasRequiredEq) return eq_1;
+	hasRequiredEq = 1;
+	function eq(value, other) {
+	  return value === other || (value !== value && other !== other);
+	}
+
+	eq_1 = eq;
+	return eq_1;
+}
+
+var _assocIndexOf;
+var hasRequired_assocIndexOf;
+
+function require_assocIndexOf () {
+	if (hasRequired_assocIndexOf) return _assocIndexOf;
+	hasRequired_assocIndexOf = 1;
+	var eq = requireEq();
+
+	/**
+	 * 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(array, key) {
+	  var length = array.length;
+	  while (length--) {
+	    if (eq(array[length][0], key)) {
+	      return length;
+	    }
+	  }
+	  return -1;
+	}
+
+	_assocIndexOf = assocIndexOf;
+	return _assocIndexOf;
+}
+
+var _listCacheDelete;
+var hasRequired_listCacheDelete;
+
+function require_listCacheDelete () {
+	if (hasRequired_listCacheDelete) return _listCacheDelete;
+	hasRequired_listCacheDelete = 1;
+	var assocIndexOf = require_assocIndexOf();
+
+	/** 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(key) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  if (index < 0) {
+	    return false;
+	  }
+	  var lastIndex = data.length - 1;
+	  if (index == lastIndex) {
+	    data.pop();
+	  } else {
+	    splice.call(data, index, 1);
+	  }
+	  --this.size;
+	  return true;
+	}
+
+	_listCacheDelete = listCacheDelete;
+	return _listCacheDelete;
+}
+
+var _listCacheGet;
+var hasRequired_listCacheGet;
+
+function require_listCacheGet () {
+	if (hasRequired_listCacheGet) return _listCacheGet;
+	hasRequired_listCacheGet = 1;
+	var assocIndexOf = require_assocIndexOf();
+
+	/**
+	 * 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(key) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  return index < 0 ? undefined : data[index][1];
+	}
+
+	_listCacheGet = listCacheGet;
+	return _listCacheGet;
+}
+
+var _listCacheHas;
+var hasRequired_listCacheHas;
+
+function require_listCacheHas () {
+	if (hasRequired_listCacheHas) return _listCacheHas;
+	hasRequired_listCacheHas = 1;
+	var assocIndexOf = require_assocIndexOf();
+
+	/**
+	 * 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(key) {
+	  return assocIndexOf(this.__data__, key) > -1;
+	}
+
+	_listCacheHas = listCacheHas;
+	return _listCacheHas;
+}
+
+var _listCacheSet;
+var hasRequired_listCacheSet;
+
+function require_listCacheSet () {
+	if (hasRequired_listCacheSet) return _listCacheSet;
+	hasRequired_listCacheSet = 1;
+	var assocIndexOf = require_assocIndexOf();
+
+	/**
+	 * 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(key, value) {
+	  var data = this.__data__,
+	      index = assocIndexOf(data, key);
+
+	  if (index < 0) {
+	    ++this.size;
+	    data.push([key, value]);
+	  } else {
+	    data[index][1] = value;
+	  }
+	  return this;
+	}
+
+	_listCacheSet = listCacheSet;
+	return _listCacheSet;
+}
+
+var _ListCache;
+var hasRequired_ListCache;
+
+function require_ListCache () {
+	if (hasRequired_ListCache) return _ListCache;
+	hasRequired_ListCache = 1;
+	var listCacheClear = require_listCacheClear(),
+	    listCacheDelete = require_listCacheDelete(),
+	    listCacheGet = require_listCacheGet(),
+	    listCacheHas = require_listCacheHas(),
+	    listCacheSet = require_listCacheSet();
+
+	/**
+	 * Creates an list cache object.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	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]);
+	  }
+	}
+
+	// Add methods to `ListCache`.
+	ListCache.prototype.clear = listCacheClear;
+	ListCache.prototype['delete'] = listCacheDelete;
+	ListCache.prototype.get = listCacheGet;
+	ListCache.prototype.has = listCacheHas;
+	ListCache.prototype.set = listCacheSet;
+
+	_ListCache = ListCache;
+	return _ListCache;
+}
+
+var _Map;
+var hasRequired_Map;
+
+function require_Map () {
+	if (hasRequired_Map) return _Map;
+	hasRequired_Map = 1;
+	var getNative = require_getNative(),
+	    root = require_root();
+
+	/* Built-in method references that are verified to be native. */
+	var Map = getNative(root, 'Map');
+
+	_Map = Map;
+	return _Map;
+}
+
+var _mapCacheClear;
+var hasRequired_mapCacheClear;
+
+function require_mapCacheClear () {
+	if (hasRequired_mapCacheClear) return _mapCacheClear;
+	hasRequired_mapCacheClear = 1;
+	var Hash = require_Hash(),
+	    ListCache = require_ListCache(),
+	    Map = require_Map();
+
+	/**
+	 * Removes all key-value entries from the map.
+	 *
+	 * @private
+	 * @name clear
+	 * @memberOf MapCache
+	 */
+	function mapCacheClear() {
+	  this.size = 0;
+	  this.__data__ = {
+	    'hash': new Hash,
+	    'map': new (Map || ListCache),
+	    'string': new Hash
+	  };
+	}
+
+	_mapCacheClear = mapCacheClear;
+	return _mapCacheClear;
+}
+
+/**
+ * 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`.
+ */
+
+var _isKeyable;
+var hasRequired_isKeyable;
+
+function require_isKeyable () {
+	if (hasRequired_isKeyable) return _isKeyable;
+	hasRequired_isKeyable = 1;
+	function isKeyable(value) {
+	  var type = typeof value;
+	  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+	    ? (value !== '__proto__')
+	    : (value === null);
+	}
+
+	_isKeyable = isKeyable;
+	return _isKeyable;
+}
+
+var _getMapData;
+var hasRequired_getMapData;
+
+function require_getMapData () {
+	if (hasRequired_getMapData) return _getMapData;
+	hasRequired_getMapData = 1;
+	var isKeyable = require_isKeyable();
+
+	/**
+	 * 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(map, key) {
+	  var data = map.__data__;
+	  return isKeyable(key)
+	    ? data[typeof key == 'string' ? 'string' : 'hash']
+	    : data.map;
+	}
+
+	_getMapData = getMapData;
+	return _getMapData;
+}
+
+var _mapCacheDelete;
+var hasRequired_mapCacheDelete;
+
+function require_mapCacheDelete () {
+	if (hasRequired_mapCacheDelete) return _mapCacheDelete;
+	hasRequired_mapCacheDelete = 1;
+	var getMapData = require_getMapData();
+
+	/**
+	 * 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(key) {
+	  var result = getMapData(this, key)['delete'](key);
+	  this.size -= result ? 1 : 0;
+	  return result;
+	}
+
+	_mapCacheDelete = mapCacheDelete;
+	return _mapCacheDelete;
+}
+
+var _mapCacheGet;
+var hasRequired_mapCacheGet;
+
+function require_mapCacheGet () {
+	if (hasRequired_mapCacheGet) return _mapCacheGet;
+	hasRequired_mapCacheGet = 1;
+	var getMapData = require_getMapData();
+
+	/**
+	 * 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(key) {
+	  return getMapData(this, key).get(key);
+	}
+
+	_mapCacheGet = mapCacheGet;
+	return _mapCacheGet;
+}
+
+var _mapCacheHas;
+var hasRequired_mapCacheHas;
+
+function require_mapCacheHas () {
+	if (hasRequired_mapCacheHas) return _mapCacheHas;
+	hasRequired_mapCacheHas = 1;
+	var getMapData = require_getMapData();
+
+	/**
+	 * 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(key) {
+	  return getMapData(this, key).has(key);
+	}
+
+	_mapCacheHas = mapCacheHas;
+	return _mapCacheHas;
+}
+
+var _mapCacheSet;
+var hasRequired_mapCacheSet;
+
+function require_mapCacheSet () {
+	if (hasRequired_mapCacheSet) return _mapCacheSet;
+	hasRequired_mapCacheSet = 1;
+	var getMapData = require_getMapData();
+
+	/**
+	 * 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(key, value) {
+	  var data = getMapData(this, key),
+	      size = data.size;
+
+	  data.set(key, value);
+	  this.size += data.size == size ? 0 : 1;
+	  return this;
+	}
+
+	_mapCacheSet = mapCacheSet;
+	return _mapCacheSet;
+}
+
+var _MapCache;
+var hasRequired_MapCache;
+
+function require_MapCache () {
+	if (hasRequired_MapCache) return _MapCache;
+	hasRequired_MapCache = 1;
+	var mapCacheClear = require_mapCacheClear(),
+	    mapCacheDelete = require_mapCacheDelete(),
+	    mapCacheGet = require_mapCacheGet(),
+	    mapCacheHas = require_mapCacheHas(),
+	    mapCacheSet = require_mapCacheSet();
+
+	/**
+	 * Creates a map cache object to store key-value pairs.
+	 *
+	 * @private
+	 * @constructor
+	 * @param {Array} [entries] The key-value pairs to cache.
+	 */
+	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]);
+	  }
+	}
+
+	// Add methods to `MapCache`.
+	MapCache.prototype.clear = mapCacheClear;
+	MapCache.prototype['delete'] = mapCacheDelete;
+	MapCache.prototype.get = mapCacheGet;
+	MapCache.prototype.has = mapCacheHas;
+	MapCache.prototype.set = mapCacheSet;
+
+	_MapCache = MapCache;
+	return _MapCache;
+}
+
+var memoize_1;
+var hasRequiredMemoize;
+
+function requireMemoize () {
+	if (hasRequiredMemoize) return memoize_1;
+	hasRequiredMemoize = 1;
+	var MapCache = require_MapCache();
+
+	/** Error message constants. */
+	var FUNC_ERROR_TEXT = 'Expected a function';
+
+	/**
+	 * Creates a function that memoizes the result of `func`. If `resolver` is
+	 * provided, it determines the cache key for storing the result based on the
+	 * arguments provided to the memoized function. By default, the first argument
+	 * provided to the memoized function is used as the map cache key. The `func`
+	 * is invoked with the `this` binding of the memoized function.
+	 *
+	 * **Note:** The cache is exposed as the `cache` property on the memoized
+	 * function. Its creation may be customized by replacing the `_.memoize.Cache`
+	 * constructor with one whose instances implement the
+	 * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+	 * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 0.1.0
+	 * @category Function
+	 * @param {Function} func The function to have its output memoized.
+	 * @param {Function} [resolver] The function to resolve the cache key.
+	 * @returns {Function} Returns the new memoized function.
+	 * @example
+	 *
+	 * var object = { 'a': 1, 'b': 2 };
+	 * var other = { 'c': 3, 'd': 4 };
+	 *
+	 * var values = _.memoize(_.values);
+	 * values(object);
+	 * // => [1, 2]
+	 *
+	 * values(other);
+	 * // => [3, 4]
+	 *
+	 * object.a = 2;
+	 * values(object);
+	 * // => [1, 2]
+	 *
+	 * // Modify the result cache.
+	 * values.cache.set(object, ['a', 'b']);
+	 * values(object);
+	 * // => ['a', 'b']
+	 *
+	 * // Replace `_.memoize.Cache`.
+	 * _.memoize.Cache = WeakMap;
+	 */
+	function memoize(func, resolver) {
+	  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
+	    throw new TypeError(FUNC_ERROR_TEXT);
+	  }
+	  var memoized = function() {
+	    var args = arguments,
+	        key = resolver ? resolver.apply(this, args) : args[0],
+	        cache = memoized.cache;
+
+	    if (cache.has(key)) {
+	      return cache.get(key);
+	    }
+	    var result = func.apply(this, args);
+	    memoized.cache = cache.set(key, result) || cache;
+	    return result;
+	  };
+	  memoized.cache = new (memoize.Cache || MapCache);
+	  return memoized;
+	}
+
+	// Expose `MapCache`.
+	memoize.Cache = MapCache;
+
+	memoize_1 = memoize;
+	return memoize_1;
+}
+
+var _memoizeCapped;
+var hasRequired_memoizeCapped;
+
+function require_memoizeCapped () {
+	if (hasRequired_memoizeCapped) return _memoizeCapped;
+	hasRequired_memoizeCapped = 1;
+	var memoize = requireMemoize();
+
+	/** Used as the maximum memoize cache size. */
+	var MAX_MEMOIZE_SIZE = 500;
+
+	/**
+	 * A specialized version of `_.memoize` which clears the memoized function's
+	 * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+	 *
+	 * @private
+	 * @param {Function} func The function to have its output memoized.
+	 * @returns {Function} Returns the new memoized function.
+	 */
+	function memoizeCapped(func) {
+	  var result = memoize(func, function(key) {
+	    if (cache.size === MAX_MEMOIZE_SIZE) {
+	      cache.clear();
+	    }
+	    return key;
+	  });
+
+	  var cache = result.cache;
+	  return result;
+	}
+
+	_memoizeCapped = memoizeCapped;
+	return _memoizeCapped;
+}
+
+var _stringToPath;
+var hasRequired_stringToPath;
+
+function require_stringToPath () {
+	if (hasRequired_stringToPath) return _stringToPath;
+	hasRequired_stringToPath = 1;
+	var memoizeCapped = require_memoizeCapped();
+
+	/** Used to match property names within property paths. */
+	var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+	/** Used to match backslashes in property paths. */
+	var reEscapeChar = /\\(\\)?/g;
+
+	/**
+	 * Converts `string` to a property path array.
+	 *
+	 * @private
+	 * @param {string} string The string to convert.
+	 * @returns {Array} Returns the property path array.
+	 */
+	var stringToPath = memoizeCapped(function(string) {
+	  var result = [];
+	  if (string.charCodeAt(0) === 46 /* . */) {
+	    result.push('');
+	  }
+	  string.replace(rePropName, function(match, number, quote, subString) {
+	    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
+	  });
+	  return result;
+	});
+
+	_stringToPath = stringToPath;
+	return _stringToPath;
+}
+
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+
+var _arrayMap;
+var hasRequired_arrayMap;
+
+function require_arrayMap () {
+	if (hasRequired_arrayMap) return _arrayMap;
+	hasRequired_arrayMap = 1;
+	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;
+	}
+
+	_arrayMap = arrayMap;
+	return _arrayMap;
+}
+
+var _baseToString;
+var hasRequired_baseToString;
+
+function require_baseToString () {
+	if (hasRequired_baseToString) return _baseToString;
+	hasRequired_baseToString = 1;
+	var Symbol = require_Symbol(),
+	    arrayMap = require_arrayMap(),
+	    isArray = requireIsArray(),
+	    isSymbol = requireIsSymbol();
+
+	/** Used as references for various `Number` constants. */
+	var INFINITY = 1 / 0;
+
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol ? Symbol.prototype : undefined,
+	    symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+	/**
+	 * The base implementation of `_.toString` which doesn't convert nullish
+	 * values to empty strings.
+	 *
+	 * @private
+	 * @param {*} value The value to process.
+	 * @returns {string} Returns the string.
+	 */
+	function baseToString(value) {
+	  // Exit early for strings to avoid a performance hit in some environments.
+	  if (typeof value == 'string') {
+	    return value;
+	  }
+	  if (isArray(value)) {
+	    // Recursively convert values (susceptible to call stack limits).
+	    return arrayMap(value, baseToString) + '';
+	  }
+	  if (isSymbol(value)) {
+	    return symbolToString ? symbolToString.call(value) : '';
+	  }
+	  var result = (value + '');
+	  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+	}
+
+	_baseToString = baseToString;
+	return _baseToString;
+}
+
+var toString_1;
+var hasRequiredToString;
+
+function requireToString () {
+	if (hasRequiredToString) return toString_1;
+	hasRequiredToString = 1;
+	var baseToString = require_baseToString();
+
+	/**
+	 * Converts `value` to a string. An empty string is returned for `null`
+	 * and `undefined` values. The sign of `-0` is preserved.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category Lang
+	 * @param {*} value The value to convert.
+	 * @returns {string} Returns the converted string.
+	 * @example
+	 *
+	 * _.toString(null);
+	 * // => ''
+	 *
+	 * _.toString(-0);
+	 * // => '-0'
+	 *
+	 * _.toString([1, 2, 3]);
+	 * // => '1,2,3'
+	 */
+	function toString(value) {
+	  return value == null ? '' : baseToString(value);
+	}
+
+	toString_1 = toString;
+	return toString_1;
+}
+
+var _castPath;
+var hasRequired_castPath;
+
+function require_castPath () {
+	if (hasRequired_castPath) return _castPath;
+	hasRequired_castPath = 1;
+	var isArray = requireIsArray(),
+	    isKey = require_isKey(),
+	    stringToPath = require_stringToPath(),
+	    toString = requireToString();
+
+	/**
+	 * Casts `value` to a path array if it's not one.
+	 *
+	 * @private
+	 * @param {*} value The value to inspect.
+	 * @param {Object} [object] The object to query keys on.
+	 * @returns {Array} Returns the cast property path array.
+	 */
+	function castPath(value, object) {
+	  if (isArray(value)) {
+	    return value;
+	  }
+	  return isKey(value, object) ? [value] : stringToPath(toString(value));
+	}
+
+	_castPath = castPath;
+	return _castPath;
+}
+
+var _toKey;
+var hasRequired_toKey;
+
+function require_toKey () {
+	if (hasRequired_toKey) return _toKey;
+	hasRequired_toKey = 1;
+	var isSymbol = requireIsSymbol();
+
+	/** Used as references for various `Number` constants. */
+	var INFINITY = 1 / 0;
+
+	/**
+	 * Converts `value` to a string key if it's not a string or symbol.
+	 *
+	 * @private
+	 * @param {*} value The value to inspect.
+	 * @returns {string|symbol} Returns the key.
+	 */
+	function toKey(value) {
+	  if (typeof value == 'string' || isSymbol(value)) {
+	    return value;
+	  }
+	  var result = (value + '');
+	  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+	}
+
+	_toKey = toKey;
+	return _toKey;
+}
+
+var _baseGet;
+var hasRequired_baseGet;
+
+function require_baseGet () {
+	if (hasRequired_baseGet) return _baseGet;
+	hasRequired_baseGet = 1;
+	var castPath = require_castPath(),
+	    toKey = require_toKey();
+
+	/**
+	 * The base implementation of `_.get` without support for default values.
+	 *
+	 * @private
+	 * @param {Object} object The object to query.
+	 * @param {Array|string} path The path of the property to get.
+	 * @returns {*} Returns the resolved value.
+	 */
+	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 : undefined;
+	}
+
+	_baseGet = baseGet;
+	return _baseGet;
+}
+
+var get_1;
+var hasRequiredGet;
+
+function requireGet () {
+	if (hasRequiredGet) return get_1;
+	hasRequiredGet = 1;
+	var baseGet = require_baseGet();
+
+	/**
+	 * Gets the value at `path` of `object`. If the resolved value is
+	 * `undefined`, the `defaultValue` is returned in its place.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 3.7.0
+	 * @category Object
+	 * @param {Object} object The object to query.
+	 * @param {Array|string} path The path of the property to get.
+	 * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+	 * @returns {*} Returns the resolved value.
+	 * @example
+	 *
+	 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+	 *
+	 * _.get(object, 'a[0].b.c');
+	 * // => 3
+	 *
+	 * _.get(object, ['a', '0', 'b', 'c']);
+	 * // => 3
+	 *
+	 * _.get(object, 'a.b.c', 'default');
+	 * // => 'default'
+	 */
+	function get(object, path, defaultValue) {
+	  var result = object == null ? undefined : baseGet(object, path);
+	  return result === undefined ? defaultValue : result;
+	}
+
+	get_1 = get;
+	return get_1;
+}
+
+var getExports = requireGet();
+const get = /*@__PURE__*/getDefaultExportFromCjs(getExports);
+
+function checkType(value, condition) {
+    if (condition) {
+        return true;
+    }
+    return false;
+}
+
+function isArray(value) {
+    return Boolean(value && Array.isArray(value));
+}
+
+function isBoolean(value) {
+    return typeof value === "boolean";
+}
+
+function isNumber(value) {
+    return typeof value === "number" && !Number.isNaN(value);
+}
+
+function isString(value) {
+    return typeof value === "string";
+}
+
+function isId(value) {
+    return isNumber(value) || isString(value);
+}
+
+function isNull(value) {
+    return value === null;
+}
+
+function isNullable(value) {
+    return typeof value === "undefined" || value === null;
+}
+
+function isObject(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function isUndefined(value) {
+    return typeof value === "undefined";
+}
+
+function isDate(value) {
+    if (value instanceof Date)
+        return !Number.isNaN(value.valueOf());
+    return false;
+}
+
+const index$5 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    checkType,
+    isArray,
+    isBoolean,
+    isDate,
+    isId,
+    isNull,
+    isNullable,
+    isNumber,
+    isObject,
+    isString,
+    isUndefined
+}, Symbol.toStringTag, { value: 'Module' }));
+
+function getByPath(data, path, defaultValue = undefined) {
+    if ((!isObject(data) && !isArray(data)) || !isString(path))
+        return defaultValue;
+    return get(data, path, defaultValue);
+}
+
+var dayjs_min$1 = {exports: {}};
+
+var dayjs_min = dayjs_min$1.exports;
+
+var hasRequiredDayjs_min;
+
+function requireDayjs_min () {
+	if (hasRequiredDayjs_min) return dayjs_min$1.exports;
+	hasRequiredDayjs_min = 1;
+	(function (module, exports) {
+		!function(t,e){module.exports=e();}(dayjs_min,(function(){var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",c="month",f="quarter",h="year",d="date",l="Invalid Date",$=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function(t){var e=["th","st","nd","rd"],n=t%100;return "["+t+(e[(n-20)%10]||e[n]||e[0])+"]"}},m=function(t,e,n){var r=String(t);return !r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return (e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()<n.date())return -t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,c),s=n-i<0,u=e.clone().add(r+(s?-1:1),c);return +(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return {M:c,y:h,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:f}[t]||String(t||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},g="en",D={};D[g]=M;var p="$isDayjsObject",S=function(t){return t instanceof _||!(!t||!t[p])},w=function t(e,n,r){var i;if(!e)return g;if("string"==typeof e){var s=e.toLowerCase();D[s]&&(i=s),n&&(D[s]=n,i=s);var u=e.split("-");if(!i&&u.length>1)return t(u[0])}else {var a=e.name;D[a]=e,i=a;}return !r&&i&&(g=i),i||!r&&g},O=function(t,e){if(S(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},b=v;b.l=w,b.i=S,b.w=function(t,e){return O(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=w(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[p]=!0;}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(b.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.init();},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds();},m.$utils=function(){return b},m.isValid=function(){return !(this.$d.toString()===l)},m.isSame=function(t,e){var n=O(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return O(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<O(t)},m.$g=function(t,e,n){return b.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!b.u(e)||e,f=b.p(t),l=function(t,e){var i=b.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},$=function(t,e){return b.w(n.toDate()[t].apply(n.toDate("s"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,v="set"+(this.$u?"UTC":"");switch(f){case h:return r?l(1,0):l(31,11);case c:return r?l(1,M):l(0,M+1);case o:var g=this.$locale().weekStart||0,D=(y<g?y+7:y)-g;return l(r?m-D:m+(6-D),M);case a:case d:return $(v+"Hours",0);case u:return $(v+"Minutes",1);case s:return $(v+"Seconds",2);case i:return $(v+"Milliseconds",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=b.p(t),f="set"+(this.$u?"UTC":""),l=(n={},n[a]=f+"Date",n[d]=f+"Date",n[c]=f+"Month",n[h]=f+"FullYear",n[u]=f+"Hours",n[s]=f+"Minutes",n[i]=f+"Seconds",n[r]=f+"Milliseconds",n)[o],$=o===a?this.$D+(e-this.$W):e;if(o===c||o===h){var y=this.clone().set(d,1);y.$d[l]($),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d;}else l&&this.$d[l]($);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[b.p(t)]()},m.add=function(r,f){var d,l=this;r=Number(r);var $=b.p(f),y=function(t){var e=O(l);return b.w(e.date(e.date()+Math.round(t*r)),l)};if($===c)return this.set(c,this.$M+r);if($===h)return this.set(h,this.$y+r);if($===a)return y(1);if($===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[$]||1,m=this.$d.getTime()+r*M;return b.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||l;var r=t||"YYYY-MM-DDTHH:mm:ssZ",i=b.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,c=n.months,f=n.meridiem,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].slice(0,s)},d=function(t){return b.s(s%12||12,t,"0")},$=f||function(t,e,n){var r=t<12?"AM":"PM";return n?r.toLowerCase():r};return r.replace(y,(function(t,r){return r||function(t){switch(t){case"YY":return String(e.$y).slice(-2);case"YYYY":return b.s(e.$y,4,"0");case"M":return a+1;case"MM":return b.s(a+1,2,"0");case"MMM":return h(n.monthsShort,a,c,3);case"MMMM":return h(c,a);case"D":return e.$D;case"DD":return b.s(e.$D,2,"0");case"d":return String(e.$W);case"dd":return h(n.weekdaysMin,e.$W,o,2);case"ddd":return h(n.weekdaysShort,e.$W,o,3);case"dddd":return o[e.$W];case"H":return String(s);case"HH":return b.s(s,2,"0");case"h":return d(1);case"hh":return d(2);case"a":return $(s,u,!0);case"A":return $(s,u,!1);case"m":return String(u);case"mm":return b.s(u,2,"0");case"s":return String(e.$s);case"ss":return b.s(e.$s,2,"0");case"SSS":return b.s(e.$ms,3,"0");case"Z":return i}return null}(t)||i.replace(":","")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,l){var $,y=this,M=b.p(d),m=O(r),v=(m.utcOffset()-this.utcOffset())*e,g=this-m,D=function(){return b.m(y,m)};switch(M){case h:$=D()/12;break;case c:$=D();break;case f:$=D()/3;break;case o:$=(g-v)/6048e5;break;case a:$=(g-v)/864e5;break;case u:$=g/n;break;case s:$=g/e;break;case i:$=g/t;break;default:$=g;}return l?$:b.a($)},m.daysInMonth=function(){return this.endOf(c).$D},m.$locale=function(){return D[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=w(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return b.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),k=_.prototype;return O.prototype=k,[["$ms",r],["$s",i],["$m",s],["$H",u],["$W",a],["$M",c],["$y",h],["$D",d]].forEach((function(t){k[t[1]]=function(e){return this.$g(e,t[0],t[1])};})),O.extend=function(t,e){return t.$i||(t(e,_,O),t.$i=!0),O},O.locale=w,O.isDayjs=S,O.unix=function(t){return O(1e3*t)},O.en=D[g],O.Ls=D,O.p={},O})); 
+	} (dayjs_min$1));
+	return dayjs_min$1.exports;
+}
+
+var dayjs_minExports = requireDayjs_min();
+const dayjs = /*@__PURE__*/getDefaultExportFromCjs(dayjs_minExports);
+
+function dateDifference(type, firstDate, secondDate = new Date(), float = false) {
+    const first = dayjs(firstDate);
+    return first.diff(secondDate, type, float);
+}
+
+function getDateByRules(rules, date = new Date()) {
+    let result = new Date(date);
+    for (const rule of rules) {
+        result = getDate(rule.increment, rule.type, result);
+    }
+    return result;
+}
+function getDate(increment, type, date = new Date()) {
+    const result = new Date(date);
+    switch (type) {
+        case DATE_TYPES.Days: {
+            result.setDate(result.getDate() + increment);
+            return result;
+        }
+        case DATE_TYPES.Months: {
+            result.setMonth(result.getMonth() + increment);
+            return result;
+        }
+        case DATE_TYPES.Years: {
+            result.setFullYear(result.getFullYear() + increment);
+            return result;
+        }
+        case DATE_TYPES.Seconds: {
+            result.setSeconds(result.getSeconds() + increment);
+            return result;
+        }
+        case DATE_TYPES.Minutes: {
+            result.setMinutes(result.getMinutes() + increment);
+            return result;
+        }
+        case DATE_TYPES.Hours: {
+            result.setHours(result.getHours() + increment);
+            return result;
+        }
+        default:
+            return result;
+    }
+}
+
+function getToday() {
+    const startToday = new Date();
+    startToday.setHours(0, 0, 0, 0);
+    const endToday = new Date();
+    endToday.setHours(23, 59, 59, 999);
+    return { startToday, endToday };
+}
+
+function getTomorrow() {
+    const tomorrow = new Date();
+    tomorrow.setHours(0, 0, 0, 0);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    return tomorrow;
+}
+
+function getYesterday() {
+    const yesterday = new Date();
+    yesterday.setHours(0, 0, 0, 0);
+    yesterday.setDate(yesterday.getDate() - 1);
+    return yesterday;
+}
+
+var isToday$2 = {exports: {}};
+
+var isToday$1 = isToday$2.exports;
+
+var hasRequiredIsToday;
+
+function requireIsToday () {
+	if (hasRequiredIsToday) return isToday$2.exports;
+	hasRequiredIsToday = 1;
+	(function (module, exports) {
+		!function(e,o){module.exports=o();}(isToday$1,(function(){return function(e,o,t){o.prototype.isToday=function(){var e="YYYY-MM-DD",o=t();return this.format(e)===o.format(e)};}})); 
+	} (isToday$2));
+	return isToday$2.exports;
+}
+
+var isTodayExports = requireIsToday();
+const todayPlugin = /*@__PURE__*/getDefaultExportFromCjs(isTodayExports);
+
+dayjs.extend(todayPlugin);
+function isToday(date) {
+    try {
+        return dayjs(date).isToday();
+    }
+    catch {
+        return false;
+    }
+}
+
+var isTomorrow$2 = {exports: {}};
+
+var isTomorrow$1 = isTomorrow$2.exports;
+
+var hasRequiredIsTomorrow;
+
+function requireIsTomorrow () {
+	if (hasRequiredIsTomorrow) return isTomorrow$2.exports;
+	hasRequiredIsTomorrow = 1;
+	(function (module, exports) {
+		!function(o,e){module.exports=e();}(isTomorrow$1,(function(){return function(o,e,t){e.prototype.isTomorrow=function(){var o="YYYY-MM-DD",e=t().add(1,"day");return this.format(o)===e.format(o)};}})); 
+	} (isTomorrow$2));
+	return isTomorrow$2.exports;
+}
+
+var isTomorrowExports = requireIsTomorrow();
+const tomorrowPlugin = /*@__PURE__*/getDefaultExportFromCjs(isTomorrowExports);
+
+dayjs.extend(tomorrowPlugin);
+function isTomorrow(date) {
+    try {
+        return dayjs(date).isTomorrow();
+    }
+    catch {
+        return false;
+    }
+}
+
+var isYesterday$2 = {exports: {}};
+
+var isYesterday$1 = isYesterday$2.exports;
+
+var hasRequiredIsYesterday;
+
+function requireIsYesterday () {
+	if (hasRequiredIsYesterday) return isYesterday$2.exports;
+	hasRequiredIsYesterday = 1;
+	(function (module, exports) {
+		!function(e,t){module.exports=t();}(isYesterday$1,(function(){return function(e,t,n){t.prototype.isYesterday=function(){var e="YYYY-MM-DD",t=n().subtract(1,"day");return this.format(e)===t.format(e)};}})); 
+	} (isYesterday$2));
+	return isYesterday$2.exports;
+}
+
+var isYesterdayExports = requireIsYesterday();
+const yesterdayPlugin = /*@__PURE__*/getDefaultExportFromCjs(isYesterdayExports);
+
+dayjs.extend(yesterdayPlugin);
+function isYesterday(date) {
+    try {
+        return dayjs(date).isYesterday();
+    }
+    catch {
+        return false;
+    }
+}
+
+function dateFormat(date, format) {
+    const correctDate = new Date(date);
+    if (!isDate(correctDate))
+        return "";
+    return dayjs(correctDate).format(format);
+}
+
+const index$4 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    dateDifference,
+    dateFormat,
+    getDateByRules,
+    getToday,
+    getTomorrow,
+    getYesterday,
+    isToday,
+    isTomorrow,
+    isYesterday
+}, Symbol.toStringTag, { value: 'Module' }));
+
+function transformToNumber(value) {
+    let result;
+    if (isString(value))
+        result = parseInt(value, 10);
+    else
+        result = Number(value);
+    return Number.isNaN(result) ? 0 : result;
+}
+
+function fieldViewFormat(field, type = "string") {
+    switch (type) {
+        case FIELD_TYPES.Array: {
+            return isArray(field) ? field.join(", ") : "";
+        }
+        case FIELD_TYPES.Date: {
+            return isString(field) || isNumber(field) || isDate(field)
+                ? dateFormat(field, "DD.MM.YYYY")
+                : "";
+        }
+        case FIELD_TYPES.DateTime: {
+            return isString(field) || isNumber(field) || isDate(field)
+                ? dateFormat(field, "DD.MM.YYYY HH:mm")
+                : "";
+        }
+        case FIELD_TYPES.Number: {
+            return isString(field) || isNumber(field) || isBoolean(field)
+                ? String(transformToNumber(field))
+                : "";
+        }
+        case FIELD_TYPES.String: {
+            return isString(field) || isNumber(field) || isBoolean(field) ? String(field) : "";
+        }
+        case FIELD_TYPES.Time: {
+            return isString(field) || isNumber(field) || isDate(field) ? dateFormat(field, "HH:mm") : "";
+        }
+        default: {
+            return isString(field) || isNumber(field) || isBoolean(field) ? String(field) : "";
+        }
+    }
+}
+
+var _defineProperty;
+var hasRequired_defineProperty;
+
+function require_defineProperty () {
+	if (hasRequired_defineProperty) return _defineProperty;
+	hasRequired_defineProperty = 1;
+	var getNative = require_getNative();
+
+	var defineProperty = (function() {
+	  try {
+	    var func = getNative(Object, 'defineProperty');
+	    func({}, '', {});
+	    return func;
+	  } catch (e) {}
+	}());
+
+	_defineProperty = defineProperty;
+	return _defineProperty;
+}
+
+var _baseAssignValue;
+var hasRequired_baseAssignValue;
+
+function require_baseAssignValue () {
+	if (hasRequired_baseAssignValue) return _baseAssignValue;
+	hasRequired_baseAssignValue = 1;
+	var defineProperty = 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(object, key, value) {
+	  if (key == '__proto__' && defineProperty) {
+	    defineProperty(object, key, {
+	      'configurable': true,
+	      'enumerable': true,
+	      'value': value,
+	      'writable': true
+	    });
+	  } else {
+	    object[key] = value;
+	  }
+	}
+
+	_baseAssignValue = baseAssignValue;
+	return _baseAssignValue;
+}
+
+var _assignValue;
+var hasRequired_assignValue;
+
+function require_assignValue () {
+	if (hasRequired_assignValue) return _assignValue;
+	hasRequired_assignValue = 1;
+	var baseAssignValue = require_baseAssignValue(),
+	    eq = requireEq();
+
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.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(object, key, value) {
+	  var objValue = object[key];
+	  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+	      (value === undefined && !(key in object))) {
+	    baseAssignValue(object, key, value);
+	  }
+	}
+
+	_assignValue = assignValue;
+	return _assignValue;
+}
+
+/** Used as references for various `Number` constants. */
+
+var _isIndex;
+var hasRequired_isIndex;
+
+function require_isIndex () {
+	if (hasRequired_isIndex) return _isIndex;
+	hasRequired_isIndex = 1;
+	var MAX_SAFE_INTEGER = 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(value, length) {
+	  var type = typeof value;
+	  length = length == null ? MAX_SAFE_INTEGER : length;
+
+	  return !!length &&
+	    (type == 'number' ||
+	      (type != 'symbol' && reIsUint.test(value))) &&
+	        (value > -1 && value % 1 == 0 && value < length);
+	}
+
+	_isIndex = isIndex;
+	return _isIndex;
+}
+
+var _baseSet;
+var hasRequired_baseSet;
+
+function require_baseSet () {
+	if (hasRequired_baseSet) return _baseSet;
+	hasRequired_baseSet = 1;
+	var assignValue = require_assignValue(),
+	    castPath = require_castPath(),
+	    isIndex = require_isIndex(),
+	    isObject = requireIsObject(),
+	    toKey = require_toKey();
+
+	/**
+	 * The base implementation of `_.set`.
+	 *
+	 * @private
+	 * @param {Object} object The object to modify.
+	 * @param {Array|string} path The path of the property to set.
+	 * @param {*} value The value to set.
+	 * @param {Function} [customizer] The function to customize path creation.
+	 * @returns {Object} Returns `object`.
+	 */
+	function baseSet(object, path, value, customizer) {
+	  if (!isObject(object)) {
+	    return object;
+	  }
+	  path = castPath(path, object);
+
+	  var index = -1,
+	      length = path.length,
+	      lastIndex = length - 1,
+	      nested = object;
+
+	  while (nested != null && ++index < length) {
+	    var key = toKey(path[index]),
+	        newValue = value;
+
+	    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+	      return object;
+	    }
+
+	    if (index != lastIndex) {
+	      var objValue = nested[key];
+	      newValue = customizer ? customizer(objValue, key, nested) : undefined;
+	      if (newValue === undefined) {
+	        newValue = isObject(objValue)
+	          ? objValue
+	          : (isIndex(path[index + 1]) ? [] : {});
+	      }
+	    }
+	    assignValue(nested, key, newValue);
+	    nested = nested[key];
+	  }
+	  return object;
+	}
+
+	_baseSet = baseSet;
+	return _baseSet;
+}
+
+var set_1;
+var hasRequiredSet;
+
+function requireSet () {
+	if (hasRequiredSet) return set_1;
+	hasRequiredSet = 1;
+	var baseSet = require_baseSet();
+
+	/**
+	 * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
+	 * it's created. Arrays are created for missing index properties while objects
+	 * are created for all other missing properties. Use `_.setWith` to customize
+	 * `path` creation.
+	 *
+	 * **Note:** This method mutates `object`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 3.7.0
+	 * @category Object
+	 * @param {Object} object The object to modify.
+	 * @param {Array|string} path The path of the property to set.
+	 * @param {*} value The value to set.
+	 * @returns {Object} Returns `object`.
+	 * @example
+	 *
+	 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+	 *
+	 * _.set(object, 'a[0].b.c', 4);
+	 * console.log(object.a[0].b.c);
+	 * // => 4
+	 *
+	 * _.set(object, ['x', '0', 'y', 'z'], 5);
+	 * console.log(object.x[0].y.z);
+	 * // => 5
+	 */
+	function set(object, path, value) {
+	  return object == null ? object : baseSet(object, path, value);
+	}
+
+	set_1 = set;
+	return set_1;
+}
+
+var setExports = requireSet();
+const set = /*@__PURE__*/getDefaultExportFromCjs(setExports);
+
+function setByPath(data, path, value) {
+    try {
+        if (!isObject(data) && !isArray(data))
+            throw new Error("bad data");
+        set(data, path, value);
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.warn(error);
+    }
+}
+
+function jsonParse(json) {
+    if (!isString(json))
+        return null;
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+}
+
+const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function randomString(length = 10, allowCharacters = characters) {
+    let result = "";
+    let counter = 0;
+    while (counter < length) {
+        result += allowCharacters.charAt(Math.floor(Math.random() * allowCharacters.length));
+        counter += 1;
+    }
+    return result;
+}
+
+function wait(delay) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve(true);
+        }, delay);
+    });
+}
+
+function buildQueryString(params) {
+    const queryString = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (isObject(value) || value == undefined)
+            continue;
+        if (isArray(value)) {
+            for (const item of value) {
+                if (item != undefined && !isObject(item))
+                    queryString.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
+            }
+        }
+        else {
+            queryString.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        }
+    }
+    return queryString.join("&");
+}
+
+function createURLWithParams(options) {
+    const url = options.baseURL.replace(/\/$/, "").replace(/\?$/, "");
+    if (!options.params) {
+        return url;
+    }
+    const queryString = buildQueryString(options.params);
+    return `${url}?${queryString}`;
+}
+
+function trimUrl(url) {
+    return url.replace(/^\//, "").replace(/\/$/, "");
+}
+
+function arrayToMapByKey(array, key) {
+    const map = {};
+    for (const item of array) {
+        const keyValue = item[key];
+        if (isId(keyValue))
+            map[keyValue] = item;
+    }
+    return map;
+}
+
+function syncObjectValues(oldObj, newObj, exception = []) {
+    for (const field in newObj) {
+        if (exception.includes(field))
+            continue;
+        const oldValue = getByPath(oldObj, field, undefined);
+        const newValue = getByPath(newObj, field, undefined);
+        if (isUndefined(oldValue) || isUndefined(newValue))
+            continue;
+        if (oldValue === newValue)
+            continue;
+        setByPath(oldObj, field, newValue);
+    }
+}
+
+function randomNumber(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min) + min);
+}
+
+const filenameVariables = ["filename=", "filename*=UTF-8''"];
+function getFileNameFromHeader(header) {
+    const name = header
+        .split(";")
+        .find((info) => ~info.indexOf(filenameVariables[0]) || ~info.indexOf(filenameVariables[1]))
+        ?.replace(filenameVariables[0], "")
+        ?.replace(filenameVariables[1], "")
+        ?.replace(/"/g, "")
+        ?.trim();
+    return name ? decodeURI(name) : null;
+}
+
+function limitStreamOfRequests({ countRequests, maxCountInParallel, promiseGetter, refetchAfterError, resultCb, collectResult, maxTryCount = 3, }) {
+    let isStopped = false;
+    return {
+        cancel: () => {
+            isStopped = true;
+        },
+        promise: new Promise((resolve) => {
+            let currentRequests = 0;
+            let currentResponses = 0;
+            const results = [];
+            for (let i = 0; i < maxCountInParallel; i++) {
+                request(promiseGetter(++currentRequests), currentRequests);
+            }
+            function request(promise, position, tryCount = 1) {
+                if (isStopped)
+                    return void resolve(results);
+                if (currentResponses === countRequests)
+                    return void resolve(results);
+                if (position > countRequests || promise == undefined)
+                    return;
+                promise
+                    .then((result) => {
+                    if (isStopped)
+                        return void resolve(results);
+                    if (collectResult)
+                        results.push(result);
+                    if (resultCb)
+                        resultCb(result);
+                    currentResponses++;
+                    request(promiseGetter(++currentRequests), currentRequests);
+                })
+                    .catch(() => {
+                    if (isStopped)
+                        return void resolve(results);
+                    if (refetchAfterError && maxTryCount > tryCount) {
+                        void wait(1000).then(() => request(promiseGetter(position), position, tryCount + 1));
+                    }
+                    else {
+                        currentResponses++;
+                        request(promiseGetter(++currentRequests), currentRequests);
+                    }
+                });
+            }
+        }),
+    };
+}
+
+const index$3 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    arrayToMapByKey,
+    buildQueryString,
+    createURLWithParams,
+    fieldViewFormat,
+    getByPath,
+    getFileNameFromHeader,
+    jsonParse,
+    limitStreamOfRequests,
+    randomNumber,
+    randomString,
+    setByPath,
+    syncObjectValues,
+    transformToNumber,
+    trimUrl,
+    wait,
+    waitUntil
+}, Symbol.toStringTag, { value: 'Module' }));
+
+function downloadFile({ data, fileName, mimeType }) {
+    if (!IS_BROWSER && !IS_JEST)
+        return null;
+    const name = getFileNameFromHeader(fileName);
+    if (!name)
+        throw new Error("Bad filename");
+    const blob = new Blob([data], {
+        type: mimeType,
+    });
+    const downloadUrl = window.URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.style.display = "none";
+    link.download = name;
+    link.href = downloadUrl;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    link.remove();
+    window.URL.revokeObjectURL(downloadUrl);
+    return null;
+}
+
+function downloadJson(data, name) {
+    if (!IS_BROWSER && !IS_JEST)
+        return null;
+    const url = `data:text/json;charset=utf-8,${encodeURIComponent(JSON.stringify(data))}`;
+    const link = document.createElement("a");
+    link.style.display = "none";
+    link.download = name;
+    link.href = url;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    link.remove();
+}
+
+function readFile(file) {
+    return new Promise((resolve) => {
+        if (!IS_BROWSER && !IS_JEST) {
+            resolve(null);
+            return;
+        }
+        const reader = new FileReader();
+        reader.readAsText(file);
+        reader.onload = () => {
+            resolve(reader.result);
+        };
+        reader.onerror = () => {
+            resolve(null);
+        };
+    });
+}
+
+const index$2 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    downloadFile,
+    downloadJson,
+    readFile
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const tokenRequest = async (options) => {
+    try {
+        const response = await fetch(options.authTokenUrl, {
+            method: "GET",
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+        const result = (await response.json());
+        const { expiresToken, token } = transformData(result, options.pathToToken, options.pathToExpires);
+        localStorage.setItem(options.storageExpiresTokenName, expiresToken);
+        localStorage.setItem(options.storageTokenName, token);
+        return token;
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.log(error);
+        window.location.replace(options.authRedirectUrl);
+        return null;
+    }
+};
+function transformData(data, pathToToken, pathToExpires) {
+    if (!isObject(data))
+        throw new Error("Bad response data");
+    const token = getByPath(data, pathToToken);
+    const expiresToken = getByPath(data, pathToExpires);
+    if ((!isString(expiresToken) && !isNumber(expiresToken)) || !isString(token))
+        throw new Error("Bad response data");
+    return {
+        expiresToken: String(expiresToken),
+        token,
+    };
+}
+
+let isFetchingAccessToken = false;
+const generateAuthMiddleWare = (options) => async (request) => {
+    if (!options.authRedirectUrl ||
+        !options.authRedirectUrl ||
+        !options.storageExpiresTokenName ||
+        !options.storageTokenName ||
+        !options.pathToExpires ||
+        !options.pathToToken) {
+        // eslint-disable-next-line no-console
+        console.error("Auth middleware hasn't required options");
+        return;
+    }
+    const isSameOrigin = !request.path.includes("http") && !request.path.includes("https");
+    if (request.token && !isSameOrigin) {
+        request.headers = {
+            ...request.headers,
+            Authorization: `Bearer ${request.token}`,
+        };
+        return;
+    }
+    if (isFetchingAccessToken)
+        await waitUntil(() => isFetchingAccessToken);
+    const expires = localStorage.getItem(options.storageExpiresTokenName);
+    let token = localStorage.getItem(options.storageTokenName);
+    if (!expires || Date.now() > +expires || !token) {
+        isFetchingAccessToken = true;
+        token = await tokenRequest(options);
+        isFetchingAccessToken = false;
+    }
+    if (!isSameOrigin)
+        request.headers = {
+            ...request.headers,
+            Authorization: `Bearer ${token}`,
+        };
+};
+
+const consoleMiddleware = (response) => {
+    return new Promise((resolve) => {
+        // eslint-disable-next-line no-console
+        console.log(response);
+        resolve(true);
+    });
+};
+
+function generateMiddlewares(activeMiddlewares, middlewareOptions) {
+    const selectedMiddlewares = [];
+    for (const key of activeMiddlewares) {
+        switch (key) {
+            case API_MIDDLEWARES.Auth: {
+                if (middlewareOptions.auth && (IS_BROWSER || IS_JEST))
+                    selectedMiddlewares.push(generateAuthMiddleWare(middlewareOptions.auth));
+                continue;
+            }
+            case API_MIDDLEWARES.Logger: {
+                selectedMiddlewares.push(consoleMiddleware);
+                continue;
+            }
+            default: {
+                continue;
+            }
+        }
+    }
+    return function executeMiddlewares(request) {
+        return new Promise((resolve) => {
+            void (async () => {
+                for (const middleware of selectedMiddlewares) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await middleware(request);
+                }
+                resolve(1);
+            })();
+        });
+    };
+}
+
+class ResponseError extends Error {
+    status;
+    description;
+    constructor({ message, status, description }) {
+        super(message);
+        this.status = status;
+        this.description = description;
+    }
+}
+function generateRequestsInstance(activeMiddlewares, middlewareOptions) {
+    const executeMiddlewares = generateMiddlewares(activeMiddlewares || [], middlewareOptions || {});
+    async function handleRequest(request, responseWithStatus) {
+        if (request.delay) {
+            await wait(request.delay);
+        }
+        if (request.mock) {
+            const transformedResult = request.transformIncomingData
+                ? request.transformIncomingData(request.mock)
+                : request.mock;
+            return responseWithStatus ? { data: transformedResult, status: 200 } : transformedResult;
+        }
+        await executeMiddlewares(request);
+        const { method, body, path, params, headers } = request;
+        const trimedPath = path.replace(/^\//, "").replace(/\/$/, "");
+        const fullPath = trimedPath.includes("http") || trimedPath.includes("https")
+            ? trimedPath
+            : `${window.location.origin}/${trimedPath}`;
+        const url = createURLWithParams({ baseURL: fullPath, params });
+        let preparedBody = body;
+        if (body && !(preparedBody instanceof FormData)) {
+            if (request.transformOutcomingData) {
+                preparedBody = request.transformOutcomingData(body);
+            }
+            if (isObject(body) || isArray(body))
+                preparedBody = JSON.stringify(preparedBody);
+        }
+        let response;
+        if (IS_BROWSER || IS_JEST) {
+            response = await fetch(url, {
+                method,
+                body: preparedBody,
+                headers: {
+                    ...(body instanceof FormData
+                        ? {}
+                        : { "Content-Type": "application/json; charset=UTF-8" }),
+                    ...headers,
+                },
+                signal: request.signal,
+            });
+        }
+        if (IS_NODE && !IS_JEST) {
+            const nodeFetch = (await import('node-fetch')).default;
+            response = await nodeFetch(url, {
+                method,
+                body: preparedBody,
+                headers: {
+                    ...(body instanceof FormData
+                        ? {}
+                        : { "Content-Type": "application/json; charset=UTF-8" }),
+                    ...headers,
+                },
+                signal: request.signal,
+            });
+        }
+        if (!response) {
+            throw new Error("hasn't response");
+        }
+        if (!response.ok) {
+            throw new ResponseError({
+                status: response.status,
+                message: `HTTP error! Status: ${response.status}`,
+            });
+        }
+        if (request.downloadFile) {
+            const data = await response.blob();
+            const mimeType = response.headers.get("content-type");
+            const fileName = response.headers.get("content-disposition");
+            if (!mimeType || !fileName)
+                throw new Error("Download Error! Empty info!");
+            if (IS_BROWSER)
+                downloadFile({
+                    data,
+                    fileName,
+                    mimeType,
+                });
+            return responseWithStatus
+                ? {
+                    data: data,
+                    status: response.status,
+                }
+                : data;
+        }
+        if (request.withoutResponse)
+            return responseWithStatus ? { data: true, status: response.status } : true;
+        const result = (await response.json());
+        const transformedResult = request.transformIncomingData
+            ? request.transformIncomingData(result)
+            : result;
+        return responseWithStatus
+            ? { data: transformedResult, status: response.status }
+            : transformedResult;
+    }
+    async function requestApi(request) {
+        return handleRequest(request, false);
+    }
+    async function requestApiWithStatus(request) {
+        return handleRequest(request, true);
+    }
+    return {
+        requestApi,
+        requestApiWithStatus,
+    };
+}
+
+const index$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    ResponseError,
+    generateRequestsInstance
+}, Symbol.toStringTag, { value: 'Module' }));
+
+function getColorFormat(color) {
+    if (color.startsWith("#")) {
+        return COLOR_FORMATS.Hex;
+    }
+    if (color.startsWith("rgba")) {
+        return COLOR_FORMATS.Rgba;
+    }
+    if (color.startsWith("rgb")) {
+        return COLOR_FORMATS.Rgb;
+    }
+    if (color.startsWith("hsl")) {
+        return COLOR_FORMATS.Hsl;
+    }
+}
+
+function transformHEXtoRGB(hex) {
+    return `rgb(${hex.match(/\w\w/g)?.map((x) => +`0x${x}`)})`;
+}
+
+function transformRGBtoRGBA(rgb, opacity) {
+    const code = rgb.match(/\d+/g);
+    code?.push(String(opacity / 100));
+    return `rgba(${code?.join(",")})`;
+}
+
+function transformRGBAtoRGB(rgba) {
+    const code = rgba.match(/\d+/g);
+    code?.splice(3);
+    return `rgb(${code?.join(",")})`;
+}
+
+function takeOpacityColors(color, opacities) {
+    let rgbColor = color;
+    if (!rgbColor)
+        return [];
+    if (getColorFormat(rgbColor) === COLOR_FORMATS.Hex) {
+        rgbColor = transformHEXtoRGB(rgbColor);
+    }
+    else if (getColorFormat(rgbColor) === COLOR_FORMATS.Rgba) {
+        rgbColor = transformRGBAtoRGB(rgbColor);
+    }
+    if (getColorFormat(rgbColor) !== COLOR_FORMATS.Rgb)
+        return [];
+    return [...opacities.map((opacity) => transformRGBtoRGBA(rgbColor, opacity))];
+}
+
+function transformToColor(currentColor, defaultColor = "black", defaultFormat = COLOR_FORMATS.Hex) {
+    if (!isString(currentColor))
+        return defaultColor;
+    let correctColor = currentColor;
+    if (!getColorFormat(correctColor)) {
+        switch (defaultFormat) {
+            case COLOR_FORMATS.Hex: {
+                correctColor = `#${correctColor}`;
+                break;
+            }
+            case COLOR_FORMATS.Rgb: {
+                correctColor = `rgb(${correctColor})`;
+                break;
+            }
+            case COLOR_FORMATS.Rgba: {
+                correctColor = `rgba(${correctColor})`;
+                break;
+            }
+            case COLOR_FORMATS.Hsl: {
+                correctColor = `hsl(${correctColor})`;
+                break;
+            }
+            default: {
+                correctColor = `#${correctColor}`;
+                break;
+            }
+        }
+    }
+    return correctColor;
+}
+
+const index = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    getColorFormat,
+    takeOpacityColors,
+    transformHEXtoRGB,
+    transformRGBAtoRGB,
+    transformRGBtoRGBA,
+    transformToColor
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const libs = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    api: index$1,
+    browser: index$2,
+    colors: index,
+    constants: index$6,
+    date: index$4,
+    utils: index$3
+}, Symbol.toStringTag, { value: 'Module' }));
+
+exports.helpers = libs;
+exports.typings = index$5;
+//# sourceMappingURL=index.cjs.map