@allgemein/base 1.9.1 → 1.10.1

package/generics.js

@@ -0,0 +1,1465 @@
+/**
+ * Generic utility functions replacing lodash.
+ *
+ * The implementations follow lodash 4.17.21 semantics (iteratee shorthands,
+ * path handling, SameValueZero comparisons, clone/merge rules, unicode aware
+ * string casing), without depending on lodash itself.
+ */
+const objectProto = Object.prototype;
+const hasOwnProperty = objectProto.hasOwnProperty;
+const propertyIsEnumerable = objectProto.propertyIsEnumerable;
+const nativeObjectToString = objectProto.toString;
+const funcToString = Function.prototype.toString;
+const objectCtorString = funcToString.call(Object);
+const symToStringTag = Symbol.toStringTag;
+const symbolValueOf = Symbol.prototype.valueOf;
+const symbolToString = Symbol.prototype.toString;
+const spreadableSymbol = Symbol.isConcatSpreadable;
+const INFINITY = 1 / 0;
+const MAX_SAFE_INTEGER = 9007199254740991;
+const MAX_INTEGER = 1.7976931348623157e+308;
+const MAX_MEMOIZE_SIZE = 500;
+const CLONE_DEEP_FLAG = 1;
+const CLONE_SYMBOLS_FLAG = 4;
+const COMPARE_PARTIAL_FLAG = 1;
+const COMPARE_UNORDERED_FLAG = 2;
+const argsTag = '[object Arguments]';
+const arrayTag = '[object Array]';
+const asyncTag = '[object AsyncFunction]';
+const boolTag = '[object Boolean]';
+const dateTag = '[object Date]';
+const errorTag = '[object Error]';
+const funcTag = '[object Function]';
+const genTag = '[object GeneratorFunction]';
+const mapTag = '[object Map]';
+const numberTag = '[object Number]';
+const nullTag = '[object Null]';
+const objectTag = '[object Object]';
+const proxyTag = '[object Proxy]';
+const regexpTag = '[object RegExp]';
+const setTag = '[object Set]';
+const stringTag = '[object String]';
+const symbolTag = '[object Symbol]';
+const undefinedTag = '[object Undefined]';
+const weakMapTag = '[object WeakMap]';
+const arrayBufferTag = '[object ArrayBuffer]';
+const dataViewTag = '[object DataView]';
+const float32Tag = '[object Float32Array]';
+const float64Tag = '[object Float64Array]';
+const int8Tag = '[object Int8Array]';
+const int16Tag = '[object Int16Array]';
+const int32Tag = '[object Int32Array]';
+const uint8Tag = '[object Uint8Array]';
+const uint8ClampedTag = '[object Uint8ClampedArray]';
+const uint16Tag = '[object Uint16Array]';
+const uint32Tag = '[object Uint32Array]';
+const typedArrayTags = {
+    [float32Tag]: true, [float64Tag]: true, [int8Tag]: true, [int16Tag]: true, [int32Tag]: true,
+    [uint8Tag]: true, [uint8ClampedTag]: true, [uint16Tag]: true, [uint32Tag]: true
+};
+const cloneableTags = {
+    ...typedArrayTags,
+    [argsTag]: true, [arrayTag]: true, [arrayBufferTag]: true, [dataViewTag]: true, [boolTag]: true,
+    [dateTag]: true, [mapTag]: true, [numberTag]: true, [objectTag]: true, [regexpTag]: true,
+    [setTag]: true, [stringTag]: true, [symbolTag]: true,
+    [errorTag]: false, [funcTag]: false, [weakMapTag]: false
+};
+const reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+const reIsPlainProp = /^\w*$/;
+const rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+const reEscapeChar = /\\(\\)?/g;
+const reIsUint = /^(?:0|[1-9]\d*)$/;
+const reFlags = /\w*$/;
+const reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+const reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+// Unicode character classes and word patterns (identical to lodash).
+const rsAstralRange = '\\ud800-\\udfff';
+const rsComboMarksRange = '\\u0300-\\u036f';
+const reComboHalfMarksRange = '\\ufe20-\\ufe2f';
+const rsComboSymbolsRange = '\\u20d0-\\u20ff';
+const rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
+const rsDingbatRange = '\\u2700-\\u27bf';
+const rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff';
+const rsMathOpRange = '\\xac\\xb1\\xd7\\xf7';
+const rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf';
+const rsPunctuationRange = '\\u2000-\\u206f';
+const rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000';
+const rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde';
+const rsVarRange = '\\ufe0e\\ufe0f';
+const rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
+const rsApos = '[\'\u2019]';
+const rsAstral = '[' + rsAstralRange + ']';
+const rsBreak = '[' + rsBreakRange + ']';
+const rsCombo = '[' + rsComboRange + ']';
+const rsDigits = '\\d+';
+const rsDingbat = '[' + rsDingbatRange + ']';
+const rsLower = '[' + rsLowerRange + ']';
+const rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']';
+const rsFitz = '\\ud83c[\\udffb-\\udfff]';
+const rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')';
+const rsNonAstral = '[^' + rsAstralRange + ']';
+const rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}';
+const rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]';
+const rsUpper = '[' + rsUpperRange + ']';
+const rsZWJ = '\\u200d';
+const rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')';
+const rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')';
+const rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?';
+const rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?';
+const reOptMod = rsModifier + '?';
+const rsOptVar = '[' + rsVarRange + ']?';
+const rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*';
+const rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])';
+const rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])';
+const rsSeq = rsOptVar + reOptMod + rsOptJoin;
+const rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq;
+const rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
+const reApos = RegExp(rsApos, 'g');
+const reComboMark = RegExp(rsCombo, 'g');
+const reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
+const reUnicodeWord = RegExp([
+    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
+    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
+    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
+    rsUpper + '+' + rsOptContrUpper,
+    rsOrdUpper,
+    rsOrdLower,
+    rsDigits,
+    rsEmoji
+].join('|'), 'g');
+const reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']');
+const reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
+const deburredLetters = {
+    // Latin-1 Supplement block.
+    '\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
+    '\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
+    '\xc7': 'C', '\xe7': 'c',
+    '\xd0': 'D', '\xf0': 'd',
+    '\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
+    '\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
+    '\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
+    '\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i',
+    '\xd1': 'N', '\xf1': 'n',
+    '\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
+    '\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
+    '\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
+    '\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
+    '\xdd': 'Y', '\xfd': 'y', '\xff': 'y',
+    '\xc6': 'Ae', '\xe6': 'ae',
+    '\xde': 'Th', '\xfe': 'th',
+    '\xdf': 'ss',
+    // Latin Extended-A block.
+    '\u0100': 'A', '\u0102': 'A', '\u0104': 'A',
+    '\u0101': 'a', '\u0103': 'a', '\u0105': 'a',
+    '\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
+    '\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
+    '\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
+    '\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
+    '\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
+    '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
+    '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
+    '\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
+    '\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
+    '\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
+    '\u0134': 'J', '\u0135': 'j',
+    '\u0136': 'K', '\u0137': 'k', '\u0138': 'k',
+    '\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
+    '\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
+    '\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
+    '\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
+    '\u014c': 'O', '\u014e': 'O', '\u0150': 'O',
+    '\u014d': 'o', '\u014f': 'o', '\u0151': 'o',
+    '\u0154': 'R', '\u0156': 'R', '\u0158': 'R',
+    '\u0155': 'r', '\u0157': 'r', '\u0159': 'r',
+    '\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
+    '\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's',
+    '\u0162': 'T', '\u0164': 'T', '\u0166': 'T',
+    '\u0163': 't', '\u0165': 't', '\u0167': 't',
+    '\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
+    '\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
+    '\u0174': 'W', '\u0175': 'w',
+    '\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y',
+    '\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z',
+    '\u017a': 'z', '\u017c': 'z', '\u017e': 'z',
+    '\u0132': 'IJ', '\u0133': 'ij',
+    '\u0152': 'Oe', '\u0153': 'oe',
+    '\u0149': '\'n', '\u017f': 's'
+};
+/* ---------------------------------------------------------------------------
+ * internal helpers
+ * ------------------------------------------------------------------------- */
+function identity(value) {
+    return value;
+}
+function eq(value, other) {
+    return value === other || (value !== value && other !== other);
+}
+function baseToString(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (isArray(value)) {
+        // Array.from visits holes, unlike Array#map
+        return Array.from(value, baseToString) + '';
+    }
+    if (isSymbol(value)) {
+        return symbolToString.call(value);
+    }
+    const result = (value + '');
+    return (result === '0' && (1 / value) === -INFINITY) ? '-0' : result;
+}
+function toStr(value) {
+    return value == null ? '' : baseToString(value);
+}
+export function upperFirst(string) {
+    const str = toStr(string);
+    if (!str) {
+        return '';
+    }
+    const strSymbols = reHasUnicode.test(str) ? stringToArray(str) : undefined;
+    const chr = strSymbols ? strSymbols[0] : str.charAt(0);
+    const trailing = strSymbols ? strSymbols.slice(1).join('') : str.slice(1);
+    return chr.toUpperCase() + trailing;
+}
+function getRawTag(value) {
+    const isOwn = hasOwnProperty.call(value, symToStringTag);
+    const tag = value[symToStringTag];
+    let unmasked = false;
+    try {
+        value[symToStringTag] = undefined;
+        unmasked = true;
+    }
+    catch (e) {
+        // read-only tag (built-ins, frozen objects, primitives)
+    }
+    const result = nativeObjectToString.call(value);
+    if (unmasked) {
+        if (isOwn) {
+            value[symToStringTag] = tag;
+        }
+        else {
+            delete value[symToStringTag];
+        }
+    }
+    return result;
+}
+function getTag(value) {
+    if (value == null) {
+        return value === undefined ? undefinedTag : nullTag;
+    }
+    return (symToStringTag in Object(value)) ? getRawTag(value) : nativeObjectToString.call(value);
+}
+function isArguments(value) {
+    return isObjectLike(value) && getTag(value) === argsTag;
+}
+function isSymbol(value) {
+    return typeof value === 'symbol' || (isObjectLike(value) && getTag(value) === symbolTag);
+}
+function isLength(value) {
+    return typeof value === 'number' && value > -1 && value % 1 === 0 && value <= MAX_SAFE_INTEGER;
+}
+function isArrayLike(value) {
+    return value != null && isLength(value.length) && !isFunction(value);
+}
+function isArrayLikeObject(value) {
+    return isObjectLike(value) && isArrayLike(value);
+}
+function isBuffer(value) {
+    const Buf = globalThis.Buffer;
+    return typeof Buf === 'function' && typeof Buf.isBuffer === 'function' ? Buf.isBuffer(value) : false;
+}
+function isTypedArray(value) {
+    return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[getTag(value)];
+}
+function isMap(value) {
+    return isObjectLike(value) && getTag(value) === mapTag;
+}
+function isPrototype(value) {
+    const Ctor = value && value.constructor;
+    const proto = (typeof Ctor === 'function' && Ctor.prototype) || objectProto;
+    return value === proto;
+}
+function isIndex(value, length) {
+    const 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);
+}
+function isIterateeCall(value, index, object) {
+    if (!isObject(object)) {
+        return false;
+    }
+    const type = typeof index;
+    if (type === 'number' ? (isArrayLike(object) && isIndex(index, object.length)) : (type === 'string' && index in object)) {
+        return eq(object[index], value);
+    }
+    return false;
+}
+function isStrictComparable(value) {
+    return value === value && !isObject(value);
+}
+function isFlattenable(value) {
+    return isArray(value) || isArguments(value) || !!(value && value[spreadableSymbol]);
+}
+function toNumber(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (isSymbol(value)) {
+        return NaN;
+    }
+    return Number(value);
+}
+function toFinite(value) {
+    if (!value) {
+        return value === 0 ? value : 0;
+    }
+    value = toNumber(value);
+    if (value === INFINITY || value === -INFINITY) {
+        return (value < 0 ? -1 : 1) * MAX_INTEGER;
+    }
+    return value === value ? value : 0;
+}
+function toInteger(value) {
+    const result = toFinite(value);
+    const remainder = result % 1;
+    return result === result ? (remainder ? result - remainder : result) : 0;
+}
+function toKey(value) {
+    if (typeof value === 'string' || isSymbol(value)) {
+        return value;
+    }
+    const result = (value + '');
+    return (result === '0' && (1 / value) === -INFINITY) ? '-0' : result;
+}
+function copyArray(source, array) {
+    const length = source.length;
+    array || (array = new Array(length));
+    for (let i = 0; i < length; i++) {
+        array[i] = source[i];
+    }
+    return array;
+}
+function arrayPush(array, values) {
+    const offset = array.length;
+    for (let i = 0; i < values.length; i++) {
+        array[offset + i] = values[i];
+    }
+    return array;
+}
+function baseFlatten(array, depth, result = []) {
+    for (const value of array) {
+        if (depth > 0 && isFlattenable(value)) {
+            if (depth > 1) {
+                baseFlatten(value, depth - 1, result);
+            }
+            else {
+                arrayPush(result, value);
+            }
+        }
+        else {
+            result[result.length] = value;
+        }
+    }
+    return result;
+}
+/* ---------------------------------------------------------------------------
+ * keys
+ * ------------------------------------------------------------------------- */
+function arrayLikeKeys(value, inherited) {
+    const isArr = isArray(value);
+    const isArg = !isArr && isArguments(value);
+    const isBuff = !isArr && !isArg && isBuffer(value);
+    const isType = !isArr && !isArg && !isBuff && isTypedArray(value);
+    const skipIndexes = isArr || isArg || isBuff || isType;
+    const result = [];
+    if (skipIndexes) {
+        for (let i = 0; i < value.length; i++) {
+            result.push(String(i));
+        }
+    }
+    const length = result.length;
+    for (const key in value) {
+        if ((inherited || hasOwnProperty.call(value, key)) &&
+            !(skipIndexes && (key === 'length' ||
+                (isBuff && (key === 'offset' || key === 'parent')) ||
+                (isType && (key === 'buffer' || key === 'byteLength' || key === 'byteOffset')) ||
+                isIndex(key, length)))) {
+            result.push(key);
+        }
+    }
+    return result;
+}
+function baseKeys(object) {
+    if (!isPrototype(object)) {
+        return Object.keys(Object(object));
+    }
+    const result = [];
+    for (const key in Object(object)) {
+        if (hasOwnProperty.call(object, key) && key !== 'constructor') {
+            result.push(key);
+        }
+    }
+    return result;
+}
+function baseKeysIn(object) {
+    const result = [];
+    if (!isObject(object)) {
+        if (object != null) {
+            for (const key in Object(object)) {
+                result.push(key);
+            }
+        }
+        return result;
+    }
+    const isProto = isPrototype(object);
+    for (const key in object) {
+        if (!(key === 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
+            result.push(key);
+        }
+    }
+    return result;
+}
+function keysIn(object) {
+    return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+function getSymbols(object) {
+    if (object == null) {
+        return [];
+    }
+    object = Object(object);
+    return Object.getOwnPropertySymbols(object).filter(symbol => propertyIsEnumerable.call(object, symbol));
+}
+function getAllKeys(object) {
+    const result = keys(object);
+    return isArray(object) ? result : arrayPush(result, getSymbols(object));
+}
+/* ---------------------------------------------------------------------------
+ * property paths
+ * ------------------------------------------------------------------------- */
+const pathCache = new Map();
+function stringToPath(string) {
+    const cached = pathCache.get(string);
+    if (cached) {
+        return cached;
+    }
+    const result = [];
+    if (string.charCodeAt(0) === 46 /* . */) {
+        result.push('');
+    }
+    string.replace(rePropName, (match, number, quote, subString) => {
+        result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
+        return '';
+    });
+    if (pathCache.size >= MAX_MEMOIZE_SIZE) {
+        pathCache.clear();
+    }
+    pathCache.set(string, result);
+    return result;
+}
+function isKey(value, object) {
+    if (isArray(value)) {
+        return false;
+    }
+    const 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));
+}
+function castPath(value, object) {
+    if (isArray(value)) {
+        return value;
+    }
+    return isKey(value, object) ? [value] : stringToPath(toStr(value));
+}
+function baseGet(object, path) {
+    path = castPath(path, object);
+    let index = 0;
+    const length = path.length;
+    while (object != null && index < length) {
+        object = object[toKey(path[index++])];
+    }
+    return (index && index === length) ? object : undefined;
+}
+function hasPath(object, path, hasFunc) {
+    path = castPath(path, object);
+    let index = -1;
+    let length = path.length;
+    let result = false;
+    let key;
+    while (++index < length) {
+        key = toKey(path[index]);
+        if (!(result = object != null && hasFunc(object, key))) {
+            break;
+        }
+        object = object[key];
+    }
+    if (result || ++index !== length) {
+        return result;
+    }
+    length = object == null ? 0 : object.length;
+    return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
+}
+function baseHas(object, key) {
+    return object != null && hasOwnProperty.call(object, key);
+}
+function baseHasIn(object, key) {
+    return object != null && key in Object(object);
+}
+function hasIn(object, path) {
+    return object != null && hasPath(object, path, baseHasIn);
+}
+function baseAssignValue(object, key, value) {
+    if (key === '__proto__') {
+        Object.defineProperty(object, key, { configurable: true, enumerable: true, value, writable: true });
+    }
+    else {
+        object[key] = value;
+    }
+}
+function assignValue(object, key, value) {
+    const objValue = object[key];
+    if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || (value === undefined && !(key in object))) {
+        baseAssignValue(object, key, value);
+    }
+}
+function copyObject(source, props, object) {
+    for (const key of props) {
+        assignValue(object, key, source[key]);
+    }
+    return object;
+}
+/* ---------------------------------------------------------------------------
+ * iteratees
+ * ------------------------------------------------------------------------- */
+function baseProperty(key) {
+    return (object) => object == null ? undefined : object[key];
+}
+function property(path) {
+    if (isKey(path)) {
+        return baseProperty(toKey(path));
+    }
+    return (object) => baseGet(object, path);
+}
+function matchesStrictComparable(key, srcValue) {
+    return (object) => {
+        if (object == null) {
+            return false;
+        }
+        return object[key] === srcValue && (srcValue !== undefined || (key in Object(object)));
+    };
+}
+function getMatchData(object) {
+    return keys(object).map(key => {
+        const value = object[key];
+        return [key, value, isStrictComparable(value)];
+    });
+}
+function baseIsMatch(object, source, matchData) {
+    let index = matchData.length;
+    const length = index;
+    if (object == null) {
+        return !length;
+    }
+    object = Object(object);
+    while (index--) {
+        const data = matchData[index];
+        if (data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+            return false;
+        }
+    }
+    while (++index < length) {
+        const [key, srcValue, strict] = matchData[index];
+        const objValue = object[key];
+        if (strict) {
+            if (objValue === undefined && !(key in object)) {
+                return false;
+            }
+        }
+        else if (!baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG)) {
+            return false;
+        }
+    }
+    return true;
+}
+function baseMatches(source) {
+    const matchData = getMatchData(source);
+    if (matchData.length === 1 && matchData[0][2]) {
+        return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+    }
+    return (object) => object === source || baseIsMatch(object, source, matchData);
+}
+function baseMatchesProperty(path, srcValue) {
+    if (isKey(path) && isStrictComparable(srcValue)) {
+        return matchesStrictComparable(toKey(path), srcValue);
+    }
+    return (object) => {
+        const objValue = get(object, path);
+        return (objValue === undefined && objValue === srcValue)
+            ? hasIn(object, path)
+            : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+    };
+}
+function baseIteratee(value) {
+    if (typeof value === 'function') {
+        return value;
+    }
+    if (value == null) {
+        return identity;
+    }
+    if (typeof value === 'object') {
+        return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+    }
+    return property(value);
+}
+function baseEach(collection, iteratee) {
+    if (collection == null) {
+        return;
+    }
+    const iterable = Object(collection);
+    if (isArrayLike(collection)) {
+        const length = collection.length;
+        for (let i = 0; i < length; i++) {
+            if (iteratee(iterable[i], i, iterable) === false) {
+                break;
+            }
+        }
+        return;
+    }
+    for (const key of keys(collection)) {
+        if (iteratee(iterable[key], key, iterable) === false) {
+            break;
+        }
+    }
+}
+function baseUniq(array, iteratee) {
+    const seen = new Set();
+    const result = [];
+    for (let i = 0; i < array.length; i++) {
+        let value = array[i];
+        const computed = iteratee ? iteratee(value) : value;
+        value = value !== 0 ? value : 0;
+        if (!seen.has(computed)) {
+            seen.add(computed);
+            result.push(value);
+        }
+    }
+    return result;
+}
+function baseIsEqual(value, other, bitmask = 0, stack) {
+    if (value === other) {
+        return true;
+    }
+    if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
+        return value !== value && other !== other;
+    }
+    return baseIsEqualDeep(value, other, bitmask, stack);
+}
+function baseIsEqualDeep(object, other, bitmask, stack) {
+    let objIsArr = isArray(object);
+    const othIsArr = isArray(other);
+    let objTag = objIsArr ? arrayTag : getTag(object);
+    let othTag = othIsArr ? arrayTag : getTag(other);
+    objTag = objTag === argsTag ? objectTag : objTag;
+    othTag = othTag === argsTag ? objectTag : othTag;
+    let objIsObj = objTag === objectTag;
+    const isSameTag = objTag === othTag;
+    if (isSameTag && isBuffer(object)) {
+        if (!isBuffer(other)) {
+            return false;
+        }
+        objIsArr = true;
+        objIsObj = false;
+    }
+    if (isSameTag && !objIsObj) {
+        stack || (stack = new Map());
+        return (objIsArr || isTypedArray(object))
+            ? equalArrays(object, other, bitmask, stack)
+            : equalByTag(object, other, objTag, bitmask, stack);
+    }
+    if (!isSameTag) {
+        return false;
+    }
+    stack || (stack = new Map());
+    return equalObjects(object, other, bitmask, stack);
+}
+function equalArrays(array, other, bitmask, stack) {
+    const isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+    const arrLength = array.length;
+    const othLength = other.length;
+    if (arrLength !== othLength && !(isPartial && othLength > arrLength)) {
+        return false;
+    }
+    const arrStacked = stack.get(array);
+    const othStacked = stack.get(other);
+    if (arrStacked && othStacked) {
+        return arrStacked === other && othStacked === array;
+    }
+    let result = true;
+    const seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new Set() : undefined;
+    stack.set(array, other);
+    stack.set(other, array);
+    for (let index = 0; index < arrLength; index++) {
+        const arrValue = array[index];
+        if (seen) {
+            let found = false;
+            for (let othIndex = 0; othIndex < other.length; othIndex++) {
+                const othValue = other[othIndex];
+                if (!seen.has(othIndex) && (arrValue === othValue || baseIsEqual(arrValue, othValue, bitmask, stack))) {
+                    seen.add(othIndex);
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                result = false;
+                break;
+            }
+        }
+        else {
+            const othValue = other[index];
+            if (!(arrValue === othValue || baseIsEqual(arrValue, othValue, bitmask, stack))) {
+                result = false;
+                break;
+            }
+        }
+    }
+    stack.delete(array);
+    stack.delete(other);
+    return result;
+}
+function equalByTag(object, other, tag, bitmask, stack) {
+    switch (tag) {
+        case dataViewTag:
+            if (object.byteLength !== other.byteLength || object.byteOffset !== other.byteOffset) {
+                return false;
+            }
+            return equalByTag(object.buffer, other.buffer, arrayBufferTag, bitmask, stack);
+        case arrayBufferTag:
+            return !(object.byteLength !== other.byteLength || !baseIsEqual(new Uint8Array(object), new Uint8Array(other)));
+        case boolTag:
+        case dateTag:
+        case numberTag:
+            return eq(+object, +other);
+        case errorTag:
+            return object.name === other.name && object.message === other.message;
+        case regexpTag:
+        case stringTag:
+            // loose equality on purpose: compares String/RegExp wrapper objects with primitives
+            // eslint-disable-next-line eqeqeq
+            return object == (other + '');
+        case mapTag:
+        case setTag: {
+            const convert = tag === mapTag
+                ? (map) => Array.from(map.entries())
+                : (set) => Array.from(set.values());
+            const isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+            if (object.size !== other.size && !isPartial) {
+                return false;
+            }
+            const stacked = stack.get(object);
+            if (stacked) {
+                return stacked === other;
+            }
+            stack.set(object, other);
+            const result = equalArrays(convert(object), convert(other), bitmask | COMPARE_UNORDERED_FLAG, stack);
+            stack.delete(object);
+            return result;
+        }
+        case symbolTag:
+            return symbolValueOf.call(object) === symbolValueOf.call(other);
+    }
+    return false;
+}
+function equalObjects(object, other, bitmask, stack) {
+    const isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+    const objProps = getAllKeys(object);
+    const objLength = objProps.length;
+    const othLength = getAllKeys(other).length;
+    if (objLength !== othLength && !isPartial) {
+        return false;
+    }
+    for (let index = objLength - 1; index >= 0; index--) {
+        const key = objProps[index];
+        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+            return false;
+        }
+    }
+    const objStacked = stack.get(object);
+    const othStacked = stack.get(other);
+    if (objStacked && othStacked) {
+        return objStacked === other && othStacked === object;
+    }
+    let result = true;
+    stack.set(object, other);
+    stack.set(other, object);
+    let skipCtor = !!isPartial;
+    for (const key of objProps) {
+        const objValue = object[key];
+        const othValue = other[key];
+        if (!(objValue === othValue || baseIsEqual(objValue, othValue, bitmask, stack))) {
+            result = false;
+            break;
+        }
+        skipCtor || (skipCtor = key === 'constructor');
+    }
+    if (result && !skipCtor) {
+        const objCtor = object.constructor;
+        const othCtor = other.constructor;
+        if (objCtor !== othCtor &&
+            ('constructor' in object && 'constructor' in other) &&
+            !(typeof objCtor === 'function' && objCtor instanceof objCtor &&
+                typeof othCtor === 'function' && othCtor instanceof othCtor)) {
+            result = false;
+        }
+    }
+    stack.delete(object);
+    stack.delete(other);
+    return result;
+}
+/* ---------------------------------------------------------------------------
+ * cloning
+ * ------------------------------------------------------------------------- */
+function initCloneArray(array) {
+    const length = array.length;
+    const result = new array.constructor(length);
+    // results of RegExp#exec
+    if (length && typeof array[0] === 'string' && hasOwnProperty.call(array, 'index')) {
+        result.index = array.index;
+        result.input = array.input;
+    }
+    return result;
+}
+function initCloneObject(object) {
+    if (typeof object.constructor === 'function' && !isPrototype(object)) {
+        const proto = Object.getPrototypeOf(object);
+        return isObject(proto) ? Object.create(proto) : {};
+    }
+    return {};
+}
+function cloneArrayBuffer(arrayBuffer) {
+    const result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+    new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+    return result;
+}
+function cloneBuffer(buffer, isDeep) {
+    if (isDeep) {
+        return buffer.slice();
+    }
+    const Buf = globalThis.Buffer;
+    const result = Buf && Buf.allocUnsafe ? Buf.allocUnsafe(buffer.length) : new buffer.constructor(buffer.length);
+    buffer.copy(result);
+    return result;
+}
+function initCloneByTag(object, tag, isDeep) {
+    const Ctor = object.constructor;
+    switch (tag) {
+        case arrayBufferTag:
+            return cloneArrayBuffer(object);
+        case boolTag:
+        case dateTag:
+            return new Ctor(+object);
+        case dataViewTag: {
+            const buffer = isDeep ? cloneArrayBuffer(object.buffer) : object.buffer;
+            return new Ctor(buffer, object.byteOffset, object.byteLength);
+        }
+        case float32Tag:
+        case float64Tag:
+        case int8Tag:
+        case int16Tag:
+        case int32Tag:
+        case uint8Tag:
+        case uint8ClampedTag:
+        case uint16Tag:
+        case uint32Tag: {
+            const buffer = isDeep ? cloneArrayBuffer(object.buffer) : object.buffer;
+            return new Ctor(buffer, object.byteOffset, object.length);
+        }
+        case mapTag:
+        case setTag:
+            return new Ctor();
+        case numberTag:
+        case stringTag:
+            return new Ctor(object);
+        case regexpTag: {
+            const result = new Ctor(object.source, reFlags.exec(String(object))[0]);
+            result.lastIndex = object.lastIndex;
+            return result;
+        }
+        case symbolTag:
+            return Object(symbolValueOf.call(object));
+    }
+}
+function baseClone(value, bitmask, key, object, stack) {
+    const isDeep = !!(bitmask & CLONE_DEEP_FLAG);
+    const isFull = !!(bitmask & CLONE_SYMBOLS_FLAG);
+    if (!isObject(value)) {
+        return value;
+    }
+    const isArr = isArray(value);
+    let result;
+    if (isArr) {
+        result = initCloneArray(value);
+        if (!isDeep) {
+            return copyArray(value, result);
+        }
+    }
+    else {
+        const tag = getTag(value);
+        const isFunc = tag === funcTag || tag === genTag;
+        if (isBuffer(value)) {
+            return cloneBuffer(value, isDeep);
+        }
+        if (tag === objectTag || tag === argsTag || (isFunc && !object)) {
+            result = isFunc ? {} : initCloneObject(value);
+            if (!isDeep) {
+                copyObject(value, keys(value), result);
+                return copyObject(value, getSymbols(value), result);
+            }
+        }
+        else {
+            if (!cloneableTags[tag]) {
+                return object ? value : {};
+            }
+            result = initCloneByTag(value, tag, isDeep);
+        }
+    }
+    stack || (stack = new Map());
+    const stacked = stack.get(value);
+    if (stacked) {
+        return stacked;
+    }
+    stack.set(value, result);
+    if (isSet(value)) {
+        value.forEach(subValue => {
+            result.add(baseClone(subValue, bitmask, subValue, value, stack));
+        });
+    }
+    else if (isMap(value)) {
+        value.forEach((subValue, subKey) => {
+            result.set(subKey, baseClone(subValue, bitmask, subKey, value, stack));
+        });
+    }
+    if (isArr) {
+        for (let i = 0; i < value.length; i++) {
+            assignValue(result, i, baseClone(value[i], bitmask, i, value, stack));
+        }
+    }
+    else {
+        const props = isFull ? getAllKeys(value) : keys(value);
+        for (const prop of props) {
+            assignValue(result, prop, baseClone(value[prop], bitmask, prop, value, stack));
+        }
+    }
+    return result;
+}
+function safeGet(object, key) {
+    if (key === 'constructor' && typeof object[key] === 'function') {
+        return undefined;
+    }
+    if (key === '__proto__') {
+        return undefined;
+    }
+    return object[key];
+}
+function assignMergeValue(object, key, value) {
+    if ((value !== undefined && !eq(object[key], value)) || (value === undefined && !(key in object))) {
+        baseAssignValue(object, key, value);
+    }
+}
+function baseMerge(object, source, customizer, stack) {
+    if (object === source) {
+        return;
+    }
+    const iterable = Object(source);
+    for (const key of keysIn(source)) {
+        const srcValue = iterable[key];
+        stack || (stack = new Map());
+        if (isObject(srcValue)) {
+            baseMergeDeep(object, source, key, customizer, stack);
+        }
+        else {
+            let newValue = customizer ? customizer(safeGet(object, key), srcValue, key + '', object, source, stack) : undefined;
+            if (newValue === undefined) {
+                newValue = srcValue;
+            }
+            assignMergeValue(object, key, newValue);
+        }
+    }
+}
+function baseMergeDeep(object, source, key, customizer, stack) {
+    const objValue = safeGet(object, key);
+    const srcValue = safeGet(source, key);
+    const stacked = stack.get(srcValue);
+    if (stacked) {
+        assignMergeValue(object, key, stacked);
+        return;
+    }
+    let newValue = customizer ? customizer(objValue, srcValue, key + '', object, source, stack) : undefined;
+    let isCommon = newValue === undefined;
+    if (isCommon) {
+        const isArr = isArray(srcValue);
+        const isBuff = !isArr && isBuffer(srcValue);
+        const isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+        newValue = srcValue;
+        if (isArr || isBuff || isTyped) {
+            if (isArray(objValue)) {
+                newValue = objValue;
+            }
+            else if (isArrayLikeObject(objValue)) {
+                newValue = copyArray(objValue);
+            }
+            else if (isBuff) {
+                isCommon = false;
+                newValue = cloneBuffer(srcValue, true);
+            }
+            else if (isTyped) {
+                isCommon = false;
+                newValue = new srcValue.constructor(cloneArrayBuffer(srcValue.buffer), srcValue.byteOffset, srcValue.length);
+            }
+            else {
+                newValue = [];
+            }
+        }
+        else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+            newValue = objValue;
+            if (isArguments(objValue)) {
+                newValue = copyObject(objValue, keysIn(objValue), {});
+            }
+            else if (!isObject(objValue) || isFunction(objValue)) {
+                newValue = initCloneObject(srcValue);
+            }
+        }
+        else {
+            isCommon = false;
+        }
+    }
+    if (isCommon) {
+        stack.set(srcValue, newValue);
+        baseMerge(newValue, srcValue, customizer, stack);
+        stack.delete(srcValue);
+    }
+    assignMergeValue(object, key, newValue);
+}
+function createAssigner(assigner, withCustomizer) {
+    return (object, ...sources) => {
+        let length = sources.length;
+        let customizer = length > 1 ? sources[length - 1] : undefined;
+        const guard = length > 2 ? sources[2] : undefined;
+        if (withCustomizer && typeof customizer === 'function') {
+            length--;
+        }
+        else {
+            customizer = undefined;
+        }
+        if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+            customizer = length < 3 ? undefined : customizer;
+            length = 1;
+        }
+        object = Object(object);
+        for (let i = 0; i < length; i++) {
+            const source = sources[i];
+            if (source) {
+                assigner(object, source, customizer);
+            }
+        }
+        return object;
+    };
+}
+const baseAssign = createAssigner((object, source) => {
+    if (isPrototype(source) || isArrayLike(source)) {
+        copyObject(source, keys(source), object);
+        return;
+    }
+    for (const key in source) {
+        if (hasOwnProperty.call(source, key)) {
+            assignValue(object, key, source[key]);
+        }
+    }
+}, false);
+const baseMergeAssigner = createAssigner((object, source, customizer) => baseMerge(object, source, customizer), true);
+function customDefaultsMerge(objValue, srcValue, _key, _object, _source, stack) {
+    if (isObject(objValue) && isObject(srcValue)) {
+        stack.set(srcValue, objValue);
+        baseMerge(objValue, srcValue, customDefaultsMerge, stack);
+        stack.delete(srcValue);
+    }
+    return objValue;
+}
+/* ---------------------------------------------------------------------------
+ * strings
+ * ------------------------------------------------------------------------- */
+function deburr(string) {
+    const str = toStr(string);
+    return str && str.replace(reLatin, chr => deburredLetters[chr]).replace(reComboMark, '');
+}
+function words(string) {
+    return (reHasUnicodeWord.test(string) ? string.match(reUnicodeWord) : string.match(reAsciiWord)) || [];
+}
+function createCompounder(callback) {
+    return (string) => words(deburr(string).replace(reApos, '')).reduce(callback, '');
+}
+function stringToArray(string) {
+    return reHasUnicode.test(string) ? (string.match(reUnicode) || []) : string.split('');
+}
+/* ---------------------------------------------------------------------------
+ * type checks
+ * ------------------------------------------------------------------------- */
+export function isArray(value) {
+    return Array.isArray(value);
+}
+export function isNull(value) {
+    return value === null;
+}
+export function isObject(value) {
+    const type = typeof value;
+    return value != null && (type === 'object' || type === 'function');
+}
+export function isObjectLike(value) {
+    return value != null && typeof value === 'object';
+}
+export function isBoolean(value) {
+    return value === true || value === false || (isObjectLike(value) && getTag(value) === boolTag);
+}
+export function isDate(value) {
+    return isObjectLike(value) && getTag(value) === dateTag;
+}
+export function isFunction(value) {
+    if (!isObject(value)) {
+        return false;
+    }
+    const tag = getTag(value);
+    return tag === funcTag || tag === genTag || tag === asyncTag || tag === proxyTag;
+}
+export function isNumber(value) {
+    return typeof value === 'number' || (isObjectLike(value) && getTag(value) === numberTag);
+}
+export function isPlainObject(value) {
+    if (!isObjectLike(value) || getTag(value) !== objectTag) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null) {
+        return true;
+    }
+    const Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+    return typeof Ctor === 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString;
+}
+export function isRegExp(value) {
+    return isObjectLike(value) && getTag(value) === regexpTag;
+}
+export function isSet(value) {
+    return isObjectLike(value) && getTag(value) === setTag;
+}
+export function isString(value) {
+    return typeof value === 'string' || (!isArray(value) && isObjectLike(value) && getTag(value) === stringTag);
+}
+export function isUndefined(value) {
+    return value === undefined;
+}
+export function isEmpty(value) {
+    if (value == null) {
+        return true;
+    }
+    if (isArrayLike(value) &&
+        (isArray(value) || typeof value === 'string' || typeof value.splice === 'function' ||
+            isBuffer(value) || isTypedArray(value) || isArguments(value))) {
+        return !value.length;
+    }
+    const tag = getTag(value);
+    if (tag === mapTag || tag === setTag) {
+        return !value.size;
+    }
+    if (isPrototype(value)) {
+        return !baseKeys(value).length;
+    }
+    for (const key in value) {
+        if (hasOwnProperty.call(value, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isEqual(value, other) {
+    return baseIsEqual(value, other);
+}
+/* ---------------------------------------------------------------------------
+ * arrays & collections
+ * ------------------------------------------------------------------------- */
+export function first(array) {
+    return (array && array.length) ? array[0] : undefined;
+}
+export const head = first;
+export function last(array) {
+    const length = array == null ? 0 : array.length;
+    return length ? array[length - 1] : undefined;
+}
+export function concat(array, ...values) {
+    if (!arguments.length) {
+        return [];
+    }
+    return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(values, 1));
+}
+export function filter(collection, predicate) {
+    const pred = baseIteratee(predicate);
+    const result = [];
+    baseEach(collection, (value, key, coll) => {
+        if (pred(value, key, coll)) {
+            result.push(value);
+        }
+    });
+    return result;
+}
+export function find(collection, predicate, fromIndex) {
+    const iterable = Object(collection);
+    if (!isArrayLike(collection)) {
+        const pred = baseIteratee(predicate);
+        const objKeys = keys(collection);
+        const index = findIndex(objKeys, (key) => pred(iterable[key], key, iterable), fromIndex);
+        return index > -1 ? iterable[objKeys[index]] : undefined;
+    }
+    const index = findIndex(collection, predicate, fromIndex);
+    return index > -1 ? iterable[index] : undefined;
+}
+export function findIndex(array, predicate, fromIndex) {
+    const length = array == null ? 0 : array.length;
+    if (!length) {
+        return -1;
+    }
+    let index = fromIndex == null ? 0 : toInteger(fromIndex);
+    if (index < 0) {
+        index = Math.max(length + index, 0);
+    }
+    const pred = baseIteratee(predicate);
+    for (; index < length; index++) {
+        if (pred(array[index], index, array)) {
+            return index;
+        }
+    }
+    return -1;
+}
+export function map(collection, iteratee) {
+    const fn = baseIteratee(iteratee);
+    const result = isArrayLike(collection) ? new Array(collection.length) : [];
+    let index = -1;
+    baseEach(collection, (value, key, coll) => {
+        result[++index] = fn(value, key, coll);
+    });
+    return result;
+}
+export function remove(array, predicate) {
+    const result = [];
+    if (!(array && array.length)) {
+        return result;
+    }
+    const pred = baseIteratee(predicate);
+    const indexes = [];
+    const length = array.length;
+    for (let i = 0; i < length; i++) {
+        const value = array[i];
+        if (pred(value, i, array)) {
+            result.push(value);
+            indexes.push(i);
+        }
+    }
+    for (let i = indexes.length - 1; i >= 0; i--) {
+        Array.prototype.splice.call(array, indexes[i], 1);
+    }
+    return result;
+}
+export function uniq(array) {
+    return (array && array.length) ? baseUniq(array) : [];
+}
+export function uniqBy(array, iteratee) {
+    if (!(array && array.length)) {
+        return [];
+    }
+    const fn = baseIteratee(iteratee);
+    return baseUniq(array, value => fn(value));
+}
+export function intersection(...arrays) {
+    const mapped = arrays.map(value => isArrayLikeObject(value) ? value : []);
+    if (!(mapped.length && mapped[0] === arrays[0])) {
+        return [];
+    }
+    const [firstArr, ...rest] = mapped;
+    const sets = rest.map(arr => new Set(Array.from(arr)));
+    const seen = new Set();
+    const result = [];
+    for (let i = 0; i < firstArr.length; i++) {
+        let value = firstArr[i];
+        value = value !== 0 ? value : 0;
+        if (!seen.has(value) && sets.every(s => s.has(value))) {
+            seen.add(value);
+            result.push(value);
+        }
+    }
+    return result;
+}
+function compareAscending(value, other) {
+    if (value !== other) {
+        const valIsDefined = value !== undefined;
+        const valIsNull = value === null;
+        const valIsReflexive = value === value;
+        const valIsSymbol = isSymbol(value);
+        const othIsDefined = other !== undefined;
+        const othIsNull = other === null;
+        const othIsReflexive = other === other;
+        const othIsSymbol = isSymbol(other);
+        if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
+            (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
+            (valIsNull && othIsDefined && othIsReflexive) ||
+            (!valIsDefined && othIsReflexive) ||
+            !valIsReflexive) {
+            return 1;
+        }
+        if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
+            (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
+            (othIsNull && valIsDefined && valIsReflexive) ||
+            (!othIsDefined && valIsReflexive) ||
+            !othIsReflexive) {
+            return -1;
+        }
+    }
+    return 0;
+}
+export function orderBy(collection, iteratees, orders) {
+    if (collection == null) {
+        return [];
+    }
+    let itList = isArray(iteratees) ? iteratees : iteratees == null ? [] : [iteratees];
+    const ordList = isArray(orders) ? orders : orders == null ? [] : [orders];
+    if (itList.length) {
+        itList = Array.from(itList, it => isArray(it) ? (value) => baseGet(value, it.length === 1 ? it[0] : it) : it);
+    }
+    else {
+        itList = [identity];
+    }
+    const fns = Array.from(itList, it => {
+        const fn = baseIteratee(it);
+        return (value) => fn(value);
+    });
+    let index = -1;
+    const entries = [];
+    baseEach(collection, value => {
+        entries.push({ criteria: fns.map(fn => fn(value)), index: ++index, value });
+    });
+    entries.sort((object, other) => {
+        for (let i = 0; i < object.criteria.length; i++) {
+            const result = compareAscending(object.criteria[i], other.criteria[i]);
+            if (result) {
+                if (i >= ordList.length) {
+                    return result;
+                }
+                return result * (ordList[i] === 'desc' ? -1 : 1);
+            }
+        }
+        return object.index - other.index;
+    });
+    return entries.map(entry => entry.value);
+}
+/* ---------------------------------------------------------------------------
+ * objects
+ * ------------------------------------------------------------------------- */
+export function keys(object) {
+    return isArrayLike(object) ? arrayLikeKeys(object, false) : baseKeys(object);
+}
+export function values(object) {
+    if (object == null) {
+        return [];
+    }
+    const iterable = Object(object);
+    return keys(object).map(key => iterable[key]);
+}
+export function assign(target, ...sources) {
+    return baseAssign(target, ...sources);
+}
+export function clone(value) {
+    return baseClone(value, CLONE_SYMBOLS_FLAG);
+}
+export function cloneDeep(value) {
+    return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+}
+export function defaults(object, ...sources) {
+    object = Object(object);
+    let length = sources.length;
+    const guard = length > 2 ? sources[2] : undefined;
+    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+        length = 1;
+    }
+    for (let i = 0; i < length; i++) {
+        const source = sources[i];
+        for (const key of keysIn(source)) {
+            const value = object[key];
+            if (value === undefined || (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
+                object[key] = source[key];
+            }
+        }
+    }
+    return object;
+}
+export function defaultsDeep(object, ...sources) {
+    return baseMergeAssigner(object, ...sources, undefined, customDefaultsMerge);
+}
+export function merge(target, ...sources) {
+    return baseMergeAssigner(target, ...sources);
+}
+export function mergeWith(target, ...args) {
+    return baseMergeAssigner(target, ...args);
+}
+export function get(object, path, defaultValue) {
+    const result = object == null ? undefined : baseGet(object, path);
+    return result === undefined ? defaultValue : result;
+}
+export function set(object, path, value) {
+    if (!isObject(object)) {
+        return object;
+    }
+    const keysArr = castPath(path, object);
+    const length = keysArr.length;
+    const lastIndex = length - 1;
+    let nested = object;
+    for (let index = 0; nested != null && index < length; index++) {
+        const key = toKey(keysArr[index]);
+        let newValue = value;
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+            return object;
+        }
+        if (index !== lastIndex) {
+            const objValue = nested[key];
+            newValue = isObject(objValue) ? objValue : (isIndex(keysArr[index + 1]) ? [] : {});
+        }
+        assignValue(nested, key, newValue);
+        nested = nested[key];
+    }
+    return object;
+}
+export function has(object, path) {
+    return object != null && hasPath(object, path, baseHas);
+}
+export function unset(object, path) {
+    if (object == null) {
+        return true;
+    }
+    const keysArr = castPath(path, object);
+    const parent = keysArr.length < 2 ? object : baseGet(object, keysArr.slice(0, -1));
+    if (parent == null) {
+        return true;
+    }
+    return Reflect.deleteProperty(Object(parent), toKey(keysArr[keysArr.length - 1]));
+}
+/* ---------------------------------------------------------------------------
+ * string casing
+ * ------------------------------------------------------------------------- */
+export const camelCase = createCompounder((result, word, index) => {
+    word = word.toLowerCase();
+    return result + (index ? capitalize(word) : word);
+});
+export const kebabCase = createCompounder((result, word, index) => result + (index ? '-' : '') + word.toLowerCase());
+export const snakeCase = createCompounder((result, word, index) => result + (index ? '_' : '') + word.toLowerCase());
+export function capitalize(string) {
+    return upperFirst(toStr(string).toLowerCase());
+}
+//# sourceMappingURL=generics.js.map