@kato-lee/utilities 1.0.0

package/fesm2022/kato-lee-utilities.mjs

@@ -0,0 +1,1749 @@
+function groupByKey(data, columnWithKey, columnWithName) {
+    const newArray = [];
+    const dataFrezzed = Object.freeze(data);
+    dataFrezzed.forEach(el => {
+        const tempArray = newArray.filter(j => j.key === el[columnWithKey]);
+        if (tempArray.length > 0) {
+            newArray[newArray.indexOf(tempArray[0])].rows.push(el);
+        }
+        else {
+            newArray.push({
+                key: el[columnWithKey],
+                name: el[columnWithName || columnWithKey],
+                rows: [el],
+            });
+        }
+    });
+    return newArray;
+}
+
+let LARGE_ARRAY_SIZE$1 = 200;
+let HASH_UNDEFINED$1 = '__lodash_hash_undefined__';
+let MAX_SAFE_INTEGER$1 = 9007199254740991;
+let argsTag$1 = '[object Arguments]', arrayTag$1 = '[object Array]', boolTag$1 = '[object Boolean]', dateTag$1 = '[object Date]', errorTag$1 = '[object Error]', funcTag$1 = '[object Function]', genTag$1 = '[object GeneratorFunction]', mapTag$1 = '[object Map]', numberTag$1 = '[object Number]', objectTag$1 = '[object Object]', promiseTag$1 = '[object Promise]', regexpTag$1 = '[object RegExp]', setTag$1 = '[object Set]', stringTag$1 = '[object String]', symbolTag$1 = '[object Symbol]', weakMapTag$1 = '[object WeakMap]';
+let arrayBufferTag$1 = '[object ArrayBuffer]', dataViewTag$1 = '[object DataView]', float32Tag$1 = '[object Float32Array]', float64Tag$1 = '[object Float64Array]', int8Tag$1 = '[object Int8Array]', int16Tag$1 = '[object Int16Array]', int32Tag$1 = '[object Int32Array]', uint8Tag$1 = '[object Uint8Array]', uint8ClampedTag$1 = '[object Uint8ClampedArray]', uint16Tag$1 = '[object Uint16Array]', uint32Tag$1 = '[object Uint32Array]';
+let reRegExpChar$1 = /[\\^$.*+?()[\]{}|]/g;
+let reFlags = /\w*$/;
+let reIsHostCtor$1 = /^\[object .+?Constructor\]$/;
+let reIsUint$1 = /^(?:0|[1-9]\d*)$/;
+let cloneableTags = {};
+cloneableTags[argsTag$1] =
+    cloneableTags[arrayTag$1] =
+        cloneableTags[arrayBufferTag$1] =
+            cloneableTags[dataViewTag$1] =
+                cloneableTags[boolTag$1] =
+                    cloneableTags[dateTag$1] =
+                        cloneableTags[float32Tag$1] =
+                            cloneableTags[float64Tag$1] =
+                                cloneableTags[int8Tag$1] =
+                                    cloneableTags[int16Tag$1] =
+                                        cloneableTags[int32Tag$1] =
+                                            cloneableTags[mapTag$1] =
+                                                cloneableTags[numberTag$1] =
+                                                    cloneableTags[objectTag$1] =
+                                                        cloneableTags[regexpTag$1] =
+                                                            cloneableTags[setTag$1] =
+                                                                cloneableTags[stringTag$1] =
+                                                                    cloneableTags[symbolTag$1] =
+                                                                        cloneableTags[uint8Tag$1] =
+                                                                            cloneableTags[uint8ClampedTag$1] =
+                                                                                cloneableTags[uint16Tag$1] =
+                                                                                    cloneableTags[uint32Tag$1] =
+                                                                                        true;
+cloneableTags[errorTag$1] = cloneableTags[funcTag$1] = cloneableTags[weakMapTag$1] = false;
+let freeGlobal$1 = typeof global == 'object' && global && global.Object === Object && global;
+let freeSelf$1 = typeof self == 'object' && self && self.Object === Object && self;
+let root$1 = freeGlobal$1 || freeSelf$1 || Function('return this')();
+let freeExports$1 = typeof exports == 'object' && exports && !nodeType && exports;
+let freeModule$1 = freeExports$1 && typeof module == 'object' && module && !module.nodeType && module;
+let moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+function addMapEntry(map, pair) {
+    map.set(pair[0], pair[1]);
+    return map;
+}
+function addSetEntry(set, value) {
+    set.add(value);
+    return set;
+}
+function arrayEach(array, iteratee) {
+    let index = -1, length = array ? array.length : 0;
+    while (++index < length) {
+        if (iteratee(array[index], index, array) === false) {
+            break;
+        }
+    }
+    return array;
+}
+function arrayPush(array, values) {
+    let index = -1, length = values.length, offset = array.length;
+    while (++index < length) {
+        array[offset + index] = values[index];
+    }
+    return array;
+}
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+    let index = -1, length = array ? array.length : 0;
+    if (initAccum && length) {
+        accumulator = array[++index];
+    }
+    while (++index < length) {
+        accumulator = iteratee(accumulator, array[index], index, array);
+    }
+    return accumulator;
+}
+function baseTimes$1(n, iteratee) {
+    let index = -1, result = Array(n);
+    while (++index < n) {
+        result[index] = iteratee(index);
+    }
+    return result;
+}
+function getValue$1(object, key) {
+    return object == null ? undefined : object[key];
+}
+function isHostObject$1(value) {
+    let result = false;
+    if (value != null && typeof value.toString != 'function') {
+        try {
+            result = !!(value + '');
+        }
+        catch (e) { }
+    }
+    return result;
+}
+function mapToArray$1(map) {
+    let index = -1, result = Array(map.size);
+    map.forEach(function (value, key) {
+        result[++index] = [key, value];
+    });
+    return result;
+}
+function overArg$1(func, transform) {
+    return function (arg) {
+        return func(transform(arg));
+    };
+}
+function setToArray$1(set) {
+    let index = -1, result = Array(set.size);
+    set.forEach(function (value) {
+        result[++index] = value;
+    });
+    return result;
+}
+let arrayProto$1 = Array.prototype, funcProto$1 = Function.prototype, objectProto$1 = Object.prototype;
+let coreJsData$1 = root$1['__core-js_shared__'];
+let maskSrcKey$1 = (function () {
+    let uid = /[^.]+$/.exec((coreJsData$1 && coreJsData$1.keys && coreJsData$1.keys.IE_PROTO) || '');
+    return uid ? 'Symbol(src)_1.' + uid : '';
+})();
+let funcToString$1 = funcProto$1.toString;
+let hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+let objectToString$1 = objectProto$1.toString;
+let reIsNative$1 = RegExp('^' +
+    funcToString$1
+        .call(hasOwnProperty$1)
+        .replace(reRegExpChar$1, '\\$&')
+        .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') +
+    '$');
+let Buffer = moduleExports$1 ? root$1.Buffer : undefined, Symbol$1 = root$1.Symbol, Uint8Array$1 = root$1.Uint8Array, getPrototype = overArg$1(Object.getPrototypeOf, Object), objectCreate = Object.create, propertyIsEnumerable$1 = objectProto$1.propertyIsEnumerable, splice$1 = arrayProto$1.splice;
+let nativeGetSymbols = Object.getOwnPropertySymbols, nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined, nativeKeys$1 = overArg$1(Object.keys, Object);
+let DataView$1 = getNative$1(root$1, 'DataView'), Map$1 = getNative$1(root$1, 'Map'), Promise$2 = getNative$1(root$1, 'Promise'), Set$1 = getNative$1(root$1, 'Set'), WeakMap$1 = getNative$1(root$1, 'WeakMap'), nativeCreate$1 = getNative$1(Object, 'create');
+let dataViewCtorString$1 = toSource$1(DataView$1), mapCtorString$1 = toSource$1(Map$1), promiseCtorString$1 = toSource$1(Promise$2), setCtorString$1 = toSource$1(Set$1), weakMapCtorString$1 = toSource$1(WeakMap$1);
+let symbolProto$1 = Symbol$1 ? Symbol$1.prototype : undefined, symbolValueOf$1 = symbolProto$1 ? symbolProto$1.valueOf : undefined;
+function Hash$1(entries) {
+    let index = -1, length = entries ? entries.length : 0;
+    this.clear();
+    while (++index < length) {
+        let entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+function hashClear$1() {
+    this.__data__ = nativeCreate$1 ? nativeCreate$1(null) : {};
+}
+function hashDelete$1(key) {
+    return this.has(key) && delete this.__data__[key];
+}
+function hashGet$1(key) {
+    let data = this.__data__;
+    if (nativeCreate$1) {
+        let result = data[key];
+        return result === HASH_UNDEFINED$1 ? undefined : result;
+    }
+    return hasOwnProperty$1.call(data, key) ? data[key] : undefined;
+}
+function hashHas$1(key) {
+    let data = this.__data__;
+    return nativeCreate$1 ? data[key] !== undefined : hasOwnProperty$1.call(data, key);
+}
+function hashSet$1(key, value) {
+    let data = this.__data__;
+    data[key] = nativeCreate$1 && value === undefined ? HASH_UNDEFINED$1 : value;
+    return this;
+}
+Hash$1.prototype.clear = hashClear$1;
+Hash$1.prototype['delete'] = hashDelete$1;
+Hash$1.prototype.get = hashGet$1;
+Hash$1.prototype.has = hashHas$1;
+Hash$1.prototype.set = hashSet$1;
+function ListCache$1(entries) {
+    let index = -1, length = entries ? entries.length : 0;
+    this.clear();
+    while (++index < length) {
+        let entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+function listCacheClear$1() {
+    this.__data__ = [];
+}
+function listCacheDelete$1(key) {
+    let data = this.__data__, index = assocIndexOf$1(data, key);
+    if (index < 0) {
+        return false;
+    }
+    let lastIndex = data.length - 1;
+    if (index == lastIndex) {
+        data.pop();
+    }
+    else {
+        splice$1.call(data, index, 1);
+    }
+    return true;
+}
+function listCacheGet$1(key) {
+    let data = this.__data__, index = assocIndexOf$1(data, key);
+    return index < 0 ? undefined : data[index][1];
+}
+function listCacheHas$1(key) {
+    return assocIndexOf$1(this.__data__, key) > -1;
+}
+function listCacheSet$1(key, value) {
+    let data = this.__data__, index = assocIndexOf$1(data, key);
+    if (index < 0) {
+        data.push([key, value]);
+    }
+    else {
+        data[index][1] = value;
+    }
+    return this;
+}
+ListCache$1.prototype.clear = listCacheClear$1;
+ListCache$1.prototype['delete'] = listCacheDelete$1;
+ListCache$1.prototype.get = listCacheGet$1;
+ListCache$1.prototype.has = listCacheHas$1;
+ListCache$1.prototype.set = listCacheSet$1;
+function MapCache$1(entries) {
+    let index = -1, length = entries ? entries.length : 0;
+    this.clear();
+    while (++index < length) {
+        let entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+function mapCacheClear$1() {
+    this.__data__ = {
+        hash: new Hash$1(),
+        map: new (Map$1 || ListCache$1)(),
+        string: new Hash$1(),
+    };
+}
+function mapCacheDelete$1(key) {
+    return getMapData$1(this, key)['delete'](key);
+}
+function mapCacheGet$1(key) {
+    return getMapData$1(this, key).get(key);
+}
+function mapCacheHas$1(key) {
+    return getMapData$1(this, key).has(key);
+}
+function mapCacheSet$1(key, value) {
+    getMapData$1(this, key).set(key, value);
+    return this;
+}
+MapCache$1.prototype.clear = mapCacheClear$1;
+MapCache$1.prototype['delete'] = mapCacheDelete$1;
+MapCache$1.prototype.get = mapCacheGet$1;
+MapCache$1.prototype.has = mapCacheHas$1;
+MapCache$1.prototype.set = mapCacheSet$1;
+function Stack$1(entries) {
+    this.__data__ = new ListCache$1(entries);
+}
+function stackClear$1() {
+    this.__data__ = new ListCache$1();
+}
+function stackDelete$1(key) {
+    return this.__data__['delete'](key);
+}
+function stackGet$1(key) {
+    return this.__data__.get(key);
+}
+function stackHas$1(key) {
+    return this.__data__.has(key);
+}
+function stackSet$1(key, value) {
+    let cache = this.__data__;
+    if (cache instanceof ListCache$1) {
+        let pairs = cache.__data__;
+        if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE$1 - 1) {
+            pairs.push([key, value]);
+            return this;
+        }
+        cache = this.__data__ = new MapCache$1(pairs);
+    }
+    cache.set(key, value);
+    return this;
+}
+Stack$1.prototype.clear = stackClear$1;
+Stack$1.prototype['delete'] = stackDelete$1;
+Stack$1.prototype.get = stackGet$1;
+Stack$1.prototype.has = stackHas$1;
+Stack$1.prototype.set = stackSet$1;
+function arrayLikeKeys$1(value, inherited) {
+    let result = isArray$1(value) || isArguments$1(value) ? baseTimes$1(value.length, String) : [];
+    let length = result.length, skipIndexes = !!length;
+    for (let key in value) {
+        if ((inherited || hasOwnProperty$1.call(value, key)) &&
+            !(skipIndexes && (key == 'length' || isIndex$1(key, length)))) {
+            result.push(key);
+        }
+    }
+    return result;
+}
+function assignValue(object, key, value) {
+    let objValue = object[key];
+    if (!(hasOwnProperty$1.call(object, key) && eq$1(objValue, value)) ||
+        (value === undefined && !(key in object))) {
+        object[key] = value;
+    }
+}
+function assocIndexOf$1(array, key) {
+    let length = array.length;
+    while (length--) {
+        if (eq$1(array[length][0], key)) {
+            return length;
+        }
+    }
+    return -1;
+}
+function baseAssign(object, source) {
+    return object && copyObject(source, keys$1(source), object);
+}
+function baseClone(value, isDeep, isFull, customizer, key, object, stack) {
+    let result;
+    if (customizer) {
+        result = object ? customizer(value, key, object, stack) : customizer(value);
+    }
+    if (result !== undefined) {
+        return result;
+    }
+    if (!isObject$1(value)) {
+        return value;
+    }
+    let isArr = isArray$1(value);
+    if (isArr) {
+        result = initCloneArray(value);
+        if (!isDeep) {
+            return copyArray(value, result);
+        }
+    }
+    else {
+        let tag = getTag$1(value), isFunc = tag == funcTag$1 || tag == genTag$1;
+        if (isBuffer(value)) {
+            return cloneBuffer(value, isDeep);
+        }
+        if (tag == objectTag$1 || tag == argsTag$1 || (isFunc && !object)) {
+            if (isHostObject$1(value)) {
+                return object ? value : {};
+            }
+            result = initCloneObject(isFunc ? {} : value);
+            if (!isDeep) {
+                return copySymbols(value, baseAssign(result, value));
+            }
+        }
+        else {
+            if (!cloneableTags[tag]) {
+                return object ? value : {};
+            }
+            result = initCloneByTag(value, tag, baseClone, isDeep);
+        }
+    }
+    stack || (stack = new Stack$1());
+    let stacked = stack.get(value);
+    if (stacked) {
+        return stacked;
+    }
+    stack.set(value, result);
+    if (!isArr) {
+        var cloneDeepProps = isFull ? getAllKeys(value) : keys$1(value);
+    }
+    arrayEach(cloneDeepProps || value, function (subValue, key) {
+        if (cloneDeepProps) {
+            key = subValue;
+            subValue = value[key];
+        }
+        assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack));
+    });
+    return result;
+}
+function baseCreate(proto) {
+    return isObject$1(proto) ? objectCreate(proto) : {};
+}
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+    let result = keysFunc(object);
+    return isArray$1(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+function baseGetTag$1(value) {
+    return objectToString$1.call(value);
+}
+function baseIsNative$1(value) {
+    if (!isObject$1(value) || isMasked$1(value)) {
+        return false;
+    }
+    let pattern = isFunction$1(value) || isHostObject$1(value) ? reIsNative$1 : reIsHostCtor$1;
+    return pattern.test(toSource$1(value));
+}
+function baseKeys$1(object) {
+    if (!isPrototype$1(object)) {
+        return nativeKeys$1(object);
+    }
+    let result = [];
+    for (let key in Object(object)) {
+        if (hasOwnProperty$1.call(object, key) && key != 'constructor') {
+            result.push(key);
+        }
+    }
+    return result;
+}
+function cloneBuffer(buffer, isDeep) {
+    if (isDeep) {
+        return buffer.slice();
+    }
+    let result = new buffer.constructor(buffer.length);
+    buffer.copy(result);
+    return result;
+}
+function cloneArrayBuffer(arrayBuffer) {
+    let result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+    new Uint8Array$1(result).set(new Uint8Array$1(arrayBuffer));
+    return result;
+}
+function cloneDataView(dataView, isDeep) {
+    let buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
+    return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+function cloneMap(map, isDeep, cloneFunc) {
+    let array = isDeep ? cloneFunc(mapToArray$1(map), true) : mapToArray$1(map);
+    return arrayReduce(array, addMapEntry, new map.constructor());
+}
+function cloneRegExp(regexp) {
+    let result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+    result.lastIndex = regexp.lastIndex;
+    return result;
+}
+function cloneSet(set, isDeep, cloneFunc) {
+    let array = isDeep ? cloneFunc(setToArray$1(set), true) : setToArray$1(set);
+    return arrayReduce(array, addSetEntry, new set.constructor());
+}
+function cloneSymbol(symbol) {
+    return symbolValueOf$1 ? Object(symbolValueOf$1.call(symbol)) : {};
+}
+function cloneTypedArray(typedArray, isDeep) {
+    let buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+function copyArray(source, array) {
+    let index = -1, length = source.length;
+    array || (array = Array(length));
+    while (++index < length) {
+        array[index] = source[index];
+    }
+    return array;
+}
+function copyObject(source, cloneDeepProps, object, customizer) {
+    object || (object = {});
+    let index = -1, length = cloneDeepProps.length;
+    while (++index < length) {
+        let key = cloneDeepProps[index];
+        let newValue = customizer
+            ? customizer(object[key], source[key], key, object, source)
+            : undefined;
+        assignValue(object, key, newValue === undefined ? source[key] : newValue);
+    }
+    return object;
+}
+function copySymbols(source, object) {
+    return copyObject(source, getSymbols(source), object);
+}
+function getAllKeys(object) {
+    return baseGetAllKeys(object, keys$1, getSymbols);
+}
+function getMapData$1(map, key) {
+    let data = map.__data__;
+    return isKeyable$1(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
+}
+function getNative$1(object, key) {
+    let value = getValue$1(object, key);
+    return baseIsNative$1(value) ? value : undefined;
+}
+let getSymbols = nativeGetSymbols ? overArg$1(nativeGetSymbols, Object) : stubArray;
+let getTag$1 = baseGetTag$1;
+if ((DataView$1 && getTag$1(new DataView$1(new ArrayBuffer(1))) != dataViewTag$1) ||
+    (Map$1 && getTag$1(new Map$1()) != mapTag$1) ||
+    (Promise$2 && getTag$1(Promise$2.resolve()) != promiseTag$1) ||
+    (Set$1 && getTag$1(new Set$1()) != setTag$1) ||
+    (WeakMap$1 && getTag$1(new WeakMap$1()) != weakMapTag$1)) {
+    getTag$1 = function (value) {
+        let result = objectToString$1.call(value), Ctor = result == objectTag$1 ? value.constructor : undefined, ctorString = Ctor ? toSource$1(Ctor) : undefined;
+        if (ctorString) {
+            switch (ctorString) {
+                case dataViewCtorString$1:
+                    return dataViewTag$1;
+                case mapCtorString$1:
+                    return mapTag$1;
+                case promiseCtorString$1:
+                    return promiseTag$1;
+                case setCtorString$1:
+                    return setTag$1;
+                case weakMapCtorString$1:
+                    return weakMapTag$1;
+            }
+        }
+        return result;
+    };
+}
+function initCloneArray(array) {
+    let length = array.length, result = array.constructor(length);
+    if (length && typeof array[0] == 'string' && hasOwnProperty$1.call(array, 'index')) {
+        result.index = array.index;
+        result.input = array.input;
+    }
+    return result;
+}
+function initCloneObject(object) {
+    return typeof object.constructor == 'function' && !isPrototype$1(object)
+        ? baseCreate(getPrototype(object))
+        : {};
+}
+function initCloneByTag(object, tag, cloneFunc, isDeep) {
+    let Ctor = object.constructor;
+    switch (tag) {
+        case arrayBufferTag$1:
+            return cloneArrayBuffer(object);
+        case boolTag$1:
+        case dateTag$1:
+            return new Ctor(+object);
+        case dataViewTag$1:
+            return cloneDataView(object, isDeep);
+        case float32Tag$1:
+        case float64Tag$1:
+        case int8Tag$1:
+        case int16Tag$1:
+        case int32Tag$1:
+        case uint8Tag$1:
+        case uint8ClampedTag$1:
+        case uint16Tag$1:
+        case uint32Tag$1:
+            return cloneTypedArray(object, isDeep);
+        case mapTag$1:
+            return cloneMap(object, isDeep, cloneFunc);
+        case numberTag$1:
+        case stringTag$1:
+            return new Ctor(object);
+        case regexpTag$1:
+            return cloneRegExp(object);
+        case setTag$1:
+            return cloneSet(object, isDeep, cloneFunc);
+        case symbolTag$1:
+            return cloneSymbol(object);
+    }
+}
+function isIndex$1(value, length) {
+    length = length == null ? MAX_SAFE_INTEGER$1 : length;
+    return (!!length &&
+        (typeof value == 'number' || reIsUint$1.test(value)) &&
+        value > -1 &&
+        value % 1 == 0 &&
+        value < length);
+}
+function isKeyable$1(value) {
+    let type = typeof value;
+    return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean'
+        ? value !== '__proto__'
+        : value === null;
+}
+function isMasked$1(func) {
+    return !!maskSrcKey$1 && maskSrcKey$1 in func;
+}
+function isPrototype$1(value) {
+    let Ctor = value && value.constructor, proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$1;
+    return value === proto;
+}
+function toSource$1(func) {
+    if (func != null) {
+        try {
+            return funcToString$1.call(func);
+        }
+        catch (e) { }
+        try {
+            return func + '';
+        }
+        catch (e) { }
+    }
+    return '';
+}
+function zxhiddenCustomCloneDeepByJeremyAshkenas(value) {
+    return baseClone(value, true, true);
+}
+function eq$1(value, other) {
+    return value === other || (value !== value && other !== other);
+}
+function isArguments$1(value) {
+    return (isArrayLikeObject$1(value) &&
+        hasOwnProperty$1.call(value, 'callee') &&
+        (!propertyIsEnumerable$1.call(value, 'callee') || objectToString$1.call(value) == argsTag$1));
+}
+let isArray$1 = Array.isArray;
+function isArrayLike$1(value) {
+    return value != null && isLength$1(value.length) && !isFunction$1(value);
+}
+function isArrayLikeObject$1(value) {
+    return isObjectLike$1(value) && isArrayLike$1(value);
+}
+let isBuffer = nativeIsBuffer || stubFalse;
+function isFunction$1(value) {
+    let tag = isObject$1(value) ? objectToString$1.call(value) : '';
+    return tag == funcTag$1 || tag == genTag$1;
+}
+function isLength$1(value) {
+    return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$1;
+}
+function isObject$1(value) {
+    let type = typeof value;
+    return !!value && (type == 'object' || type == 'function');
+}
+function isObjectLike$1(value) {
+    return !!value && typeof value == 'object';
+}
+function keys$1(object) {
+    return isArrayLike$1(object) ? arrayLikeKeys$1(object) : baseKeys$1(object);
+}
+function stubArray() {
+    return [];
+}
+function stubFalse() {
+    return false;
+}
+
+let LARGE_ARRAY_SIZE = 200;
+let FUNC_ERROR_TEXT = 'Expected a function';
+let HASH_UNDEFINED = '__lodash_hash_undefined__';
+let UNORDERED_COMPARE_FLAG = 1, PARTIAL_COMPARE_FLAG = 2;
+let INFINITY = 1 / 0, MAX_SAFE_INTEGER = 9007199254740991;
+let argsTag = '[object Arguments]', arrayTag = '[object Array]', boolTag = '[object Boolean]', dateTag = '[object Date]', errorTag = '[object Error]', funcTag = '[object Function]', genTag = '[object GeneratorFunction]', mapTag = '[object Map]', numberTag = '[object Number]', objectTag = '[object Object]', promiseTag = '[object Promise]', regexpTag = '[object RegExp]', setTag = '[object Set]', stringTag = '[object String]', symbolTag = '[object Symbol]', weakMapTag = '[object WeakMap]';
+let arrayBufferTag = '[object ArrayBuffer]', dataViewTag = '[object DataView]', float32Tag = '[object Float32Array]', float64Tag = '[object Float64Array]', int8Tag = '[object Int8Array]', int16Tag = '[object Int16Array]', int32Tag = '[object Int32Array]', uint8Tag = '[object Uint8Array]', uint8ClampedTag = '[object Uint8ClampedArray]', uint16Tag = '[object Uint16Array]', uint32Tag = '[object Uint32Array]';
+let reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, reLeadingDot = /^\./, rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+let reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+let reEscapeChar = /\\(\\)?/g;
+let reIsHostCtor = /^\[object .+?Constructor\]$/;
+let reIsUint = /^(?:0|[1-9]\d*)$/;
+let typedArrayTags = {};
+typedArrayTags[float32Tag] =
+    typedArrayTags[float64Tag] =
+        typedArrayTags[int8Tag] =
+            typedArrayTags[int16Tag] =
+                typedArrayTags[int32Tag] =
+                    typedArrayTags[uint8Tag] =
+                        typedArrayTags[uint8ClampedTag] =
+                            typedArrayTags[uint16Tag] =
+                                typedArrayTags[uint32Tag] =
+                                    true;
+typedArrayTags[argsTag] =
+    typedArrayTags[arrayTag] =
+        typedArrayTags[arrayBufferTag] =
+            typedArrayTags[boolTag] =
+                typedArrayTags[dataViewTag] =
+                    typedArrayTags[dateTag] =
+                        typedArrayTags[errorTag] =
+                            typedArrayTags[funcTag] =
+                                typedArrayTags[mapTag] =
+                                    typedArrayTags[numberTag] =
+                                        typedArrayTags[objectTag] =
+                                            typedArrayTags[regexpTag] =
+                                                typedArrayTags[setTag] =
+                                                    typedArrayTags[stringTag] =
+                                                        typedArrayTags[weakMapTag] =
+                                                            false;
+let freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+let freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+let root = freeGlobal || freeSelf || Function('return this')();
+let freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+let freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+let moduleExports = freeModule && freeModule.exports === freeExports;
+let freeProcess = moduleExports && freeGlobal.process;
+let nodeUtil = (function () {
+    try {
+        return freeProcess && freeProcess.binding('util');
+    }
+    catch (e) { }
+})();
+let nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+function arrayMap(array, iteratee) {
+    let index = -1, length = array ? array.length : 0, result = Array(length);
+    while (++index < length) {
+        result[index] = iteratee(array[index], index, array);
+    }
+    return result;
+}
+function arraySome(array, predicate) {
+    let index = -1, length = array ? array.length : 0;
+    while (++index < length) {
+        if (predicate(array[index], index, array)) {
+            return true;
+        }
+    }
+    return false;
+}
+function baseProperty(key) {
+    return function (object) {
+        return object == null ? undefined : object[key];
+    };
+}
+function baseSortBy(array, comparer) {
+    let length = array.length;
+    array.sort(comparer);
+    while (length--) {
+        array[length] = array[length].value;
+    }
+    return array;
+}
+function baseTimes(n, iteratee) {
+    let index = -1, result = Array(n);
+    while (++index < n) {
+        result[index] = iteratee(index);
+    }
+    return result;
+}
+function baseUnary(func) {
+    return function (value) {
+        return func(value);
+    };
+}
+function getValue(object, key) {
+    return object == null ? undefined : object[key];
+}
+function isHostObject(value) {
+    let result = false;
+    if (value != null && typeof value.toString != 'function') {
+        try {
+            result = !!(value + '');
+        }
+        catch (e) { }
+    }
+    return result;
+}
+function mapToArray(map) {
+    let index = -1, result = Array(map.size);
+    map.forEach(function (value, key) {
+        result[++index] = [key, value];
+    });
+    return result;
+}
+function overArg(func, transform) {
+    return function (arg) {
+        return func(transform(arg));
+    };
+}
+function setToArray(set) {
+    let index = -1, result = Array(set.size);
+    set.forEach(function (value) {
+        result[++index] = value;
+    });
+    return result;
+}
+let arrayProto = Array.prototype, funcProto = Function.prototype, objectProto = Object.prototype;
+let coreJsData = root['__core-js_shared__'];
+let maskSrcKey = (function () {
+    let uid = /[^.]+$/.exec((coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO) || '');
+    return uid ? 'Symbol(src)_1.' + uid : '';
+})();
+let funcToString = funcProto.toString;
+let hasOwnProperty = objectProto.hasOwnProperty;
+let objectToString = objectProto.toString;
+let reIsNative = RegExp('^' +
+    funcToString
+        .call(hasOwnProperty)
+        .replace(reRegExpChar, '\\$&')
+        .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') +
+    '$');
+let Symbol = root.Symbol, Uint8Array = root.Uint8Array, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice;
+let nativeKeys = overArg(Object.keys, Object);
+let DataView = getNative(root, 'DataView'), Map = getNative(root, 'Map'), Promise$1 = getNative(root, 'Promise'), Set = getNative(root, 'Set'), WeakMap = getNative(root, 'WeakMap'), nativeCreate = getNative(Object, 'create');
+let dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set), weakMapCtorString = toSource(WeakMap);
+let symbolProto = Symbol ? Symbol.prototype : undefined, symbolValueOf = symbolProto ? symbolProto.valueOf : undefined, symbolToString = symbolProto ? symbolProto.toString : undefined;
+function Hash(entries) {
+    let index = -1, length = entries ? entries.length : 0;
+    this.clear();
+    while (++index < length) {
+        let entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+function hashClear() {
+    this.__data__ = nativeCreate ? nativeCreate(null) : {};
+}
+function hashDelete(key) {
+    return this.has(key) && delete this.__data__[key];
+}
+function hashGet(key) {
+    let data = this.__data__;
+    if (nativeCreate) {
+        let result = data[key];
+        return result === HASH_UNDEFINED ? undefined : result;
+    }
+    return hasOwnProperty.call(data, key) ? data[key] : undefined;
+}
+function hashHas(key) {
+    let data = this.__data__;
+    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+}
+function hashSet(key, value) {
+    let data = this.__data__;
+    data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
+    return this;
+}
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+function ListCache(entries) {
+    let index = -1, length = entries ? entries.length : 0;
+    this.clear();
+    while (++index < length) {
+        let entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+function listCacheClear() {
+    this.__data__ = [];
+}
+function listCacheDelete(key) {
+    let data = this.__data__, index = assocIndexOf(data, key);
+    if (index < 0) {
+        return false;
+    }
+    let lastIndex = data.length - 1;
+    if (index == lastIndex) {
+        data.pop();
+    }
+    else {
+        splice.call(data, index, 1);
+    }
+    return true;
+}
+function listCacheGet(key) {
+    let data = this.__data__, index = assocIndexOf(data, key);
+    return index < 0 ? undefined : data[index][1];
+}
+function listCacheHas(key) {
+    return assocIndexOf(this.__data__, key) > -1;
+}
+function listCacheSet(key, value) {
+    let data = this.__data__, index = assocIndexOf(data, key);
+    if (index < 0) {
+        data.push([key, value]);
+    }
+    else {
+        data[index][1] = value;
+    }
+    return this;
+}
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+function MapCache(entries) {
+    let index = -1, length = entries ? entries.length : 0;
+    this.clear();
+    while (++index < length) {
+        let entry = entries[index];
+        this.set(entry[0], entry[1]);
+    }
+}
+function mapCacheClear() {
+    this.__data__ = {
+        hash: new Hash(),
+        map: new (Map || ListCache)(),
+        string: new Hash(),
+    };
+}
+function mapCacheDelete(key) {
+    return getMapData(this, key)['delete'](key);
+}
+function mapCacheGet(key) {
+    return getMapData(this, key).get(key);
+}
+function mapCacheHas(key) {
+    return getMapData(this, key).has(key);
+}
+function mapCacheSet(key, value) {
+    getMapData(this, key).set(key, value);
+    return this;
+}
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+function SetCache(values) {
+    let index = -1, length = values ? values.length : 0;
+    this.__data__ = new MapCache();
+    while (++index < length) {
+        this.add(values[index]);
+    }
+}
+function setCacheAdd(value) {
+    this.__data__.set(value, HASH_UNDEFINED);
+    return this;
+}
+function setCacheHas(value) {
+    return this.__data__.has(value);
+}
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+function Stack(entries) {
+    this.__data__ = new ListCache(entries);
+}
+function stackClear() {
+    this.__data__ = new ListCache();
+}
+function stackDelete(key) {
+    return this.__data__['delete'](key);
+}
+function stackGet(key) {
+    return this.__data__.get(key);
+}
+function stackHas(key) {
+    return this.__data__.has(key);
+}
+function stackSet(key, value) {
+    let cache = this.__data__;
+    if (cache instanceof ListCache) {
+        let pairs = cache.__data__;
+        if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+            pairs.push([key, value]);
+            return this;
+        }
+        cache = this.__data__ = new MapCache(pairs);
+    }
+    cache.set(key, value);
+    return this;
+}
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+function arrayLikeKeys(value, inherited) {
+    let result = isArray(value) || isArguments(value) ? baseTimes(value.length, String) : [];
+    let length = result.length, skipIndexes = !!length;
+    for (let key in value) {
+        if ((inherited || hasOwnProperty.call(value, key)) &&
+            !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
+            result.push(key);
+        }
+    }
+    return result;
+}
+function assocIndexOf(array, key) {
+    let length = array.length;
+    while (length--) {
+        if (eq(array[length][0], key)) {
+            return length;
+        }
+    }
+    return -1;
+}
+let baseEach = createBaseEach(baseForOwn);
+let baseFor = createBaseFor();
+function baseForOwn(object, iteratee) {
+    return object && baseFor(object, iteratee, keys);
+}
+function baseGet(object, path) {
+    path = isKey(path, object) ? [path] : castPath(path);
+    let index = 0, length = path.length;
+    while (object != null && index < length) {
+        object = object[toKey(path[index++])];
+    }
+    return index && index == length ? object : undefined;
+}
+function baseGetTag(value) {
+    return objectToString.call(value);
+}
+function baseHasIn(object, key) {
+    return object != null && key in Object(object);
+}
+function baseIsEqual(value, other, customizer, bitmask, stack) {
+    if (value === other) {
+        return true;
+    }
+    if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
+        return value !== value && other !== other;
+    }
+    return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);
+}
+function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
+    let objIsArr = isArray(object), othIsArr = isArray(other), objTag = arrayTag, othTag = arrayTag;
+    if (!objIsArr) {
+        objTag = getTag(object);
+        objTag = objTag == argsTag ? objectTag : objTag;
+    }
+    if (!othIsArr) {
+        othTag = getTag(other);
+        othTag = othTag == argsTag ? objectTag : othTag;
+    }
+    let objIsObj = objTag == objectTag && !isHostObject(object), othIsObj = othTag == objectTag && !isHostObject(other), isSameTag = objTag == othTag;
+    if (isSameTag && !objIsObj) {
+        stack || (stack = new Stack());
+        return objIsArr || isTypedArray(object)
+            ? equalArrays(object, other, equalFunc, customizer, bitmask, stack)
+            : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
+    }
+    if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
+        let objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+        if (objIsWrapped || othIsWrapped) {
+            let objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+            stack || (stack = new Stack());
+            return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
+        }
+    }
+    if (!isSameTag) {
+        return false;
+    }
+    stack || (stack = new Stack());
+    return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
+}
+function baseIsMatch(object, source, matchData, customizer) {
+    let index = matchData.length, length = index, noCustomizer = !customizer;
+    if (object == null) {
+        return !length;
+    }
+    object = Object(object);
+    while (index--) {
+        let data = matchData[index];
+        if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+            return false;
+        }
+    }
+    while (++index < length) {
+        data = matchData[index];
+        let key = data[0], objValue = object[key], srcValue = data[1];
+        if (noCustomizer && data[2]) {
+            if (objValue === undefined && !(key in object)) {
+                return false;
+            }
+        }
+        else {
+            let stack = new Stack();
+            if (customizer) {
+                let result = customizer(objValue, srcValue, key, object, source, stack);
+            }
+            if (!(result === undefined
+                ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack)
+                : result)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function baseIsNative(value) {
+    if (!isObject(value) || isMasked(value)) {
+        return false;
+    }
+    let pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
+    return pattern.test(toSource(value));
+}
+function baseIsTypedArray(value) {
+    return (isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objectToString.call(value)]);
+}
+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 baseKeys(object) {
+    if (!isPrototype(object)) {
+        return nativeKeys(object);
+    }
+    let result = [];
+    for (let key in Object(object)) {
+        if (hasOwnProperty.call(object, key) && key != 'constructor') {
+            result.push(key);
+        }
+    }
+    return result;
+}
+function baseMap(collection, iteratee) {
+    let index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
+    baseEach(collection, function (value, key, collection) {
+        result[++index] = iteratee(value, key, collection);
+    });
+    return result;
+}
+function baseMatches(source) {
+    let matchData = getMatchData(source);
+    if (matchData.length == 1 && matchData[0][2]) {
+        return matchesStrictComparable(matchData[0][0], matchData[0][1]);
+    }
+    return function (object) {
+        return object === source || baseIsMatch(object, source, matchData);
+    };
+}
+function baseMatchesProperty(path, srcValue) {
+    if (isKey(path) && isStrictComparable(srcValue)) {
+        return matchesStrictComparable(toKey(path), srcValue);
+    }
+    return function (object) {
+        let objValue = get(object, path);
+        return objValue === undefined && objValue === srcValue
+            ? hasIn(object, path)
+            : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
+    };
+}
+function baseOrderBy(collection, iteratees, orders) {
+    let index = -1;
+    iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));
+    let result = baseMap(collection, function (value, key, collection) {
+        let criteria = arrayMap(iteratees, function (iteratee) {
+            return iteratee(value);
+        });
+        return { criteria: criteria, index: ++index, value: value };
+    });
+    return baseSortBy(result, function (object, other) {
+        return compareMultiple(object, other, orders);
+    });
+}
+function basePropertyDeep(path) {
+    return function (object) {
+        return baseGet(object, path);
+    };
+}
+function baseToString(value) {
+    if (typeof value == 'string') {
+        return value;
+    }
+    if (isSymbol(value)) {
+        return symbolToString ? symbolToString.call(value) : '';
+    }
+    let result = value + '';
+    return result == '0' && 1 / value == -INFINITY ? '-0' : result;
+}
+function castPath(value) {
+    return isArray(value) ? value : stringToPath(value);
+}
+function compareAscending(value, other) {
+    if (value !== other) {
+        let valIsDefined = value !== undefined, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
+        let othIsDefined = other !== undefined, othIsNull = other === null, othIsReflexive = other === other, 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;
+}
+function compareMultiple(object, other, orders) {
+    let index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
+    while (++index < length) {
+        let result = compareAscending(objCriteria[index], othCriteria[index]);
+        if (result) {
+            if (index >= ordersLength) {
+                return result;
+            }
+            let order = orders[index];
+            return result * (order == 'desc' ? -1 : 1);
+        }
+    }
+    return object.index - other.index;
+}
+function createBaseEach(eachFunc, fromRight) {
+    return function (collection, iteratee) {
+        if (collection == null) {
+            return collection;
+        }
+        if (!isArrayLike(collection)) {
+            return eachFunc(collection, iteratee);
+        }
+        let length = collection.length;
+        let index = fromRight ? length : -1;
+        let iterable = Object(collection);
+        while (fromRight ? index-- : ++index < length) {
+            if (iteratee(iterable[index], index, iterable) === false) {
+                break;
+            }
+        }
+        return collection;
+    };
+}
+function createBaseFor(fromRight) {
+    return function (object, iteratee, keysFunc) {
+        let index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+        while (length--) {
+            let key = props[fromRight ? length : ++index];
+            if (iteratee(iterable[key], key, iterable) === false) {
+                break;
+            }
+        }
+        return object;
+    };
+}
+function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
+    let isPartial = bitmask & PARTIAL_COMPARE_FLAG, arrLength = array.length, othLength = other.length;
+    if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+        return false;
+    }
+    let stacked = stack.get(array);
+    if (stacked && stack.get(other)) {
+        return stacked == other;
+    }
+    let index = -1, result = true, seen = bitmask & UNORDERED_COMPARE_FLAG ? new SetCache() : undefined;
+    stack.set(array, other);
+    stack.set(other, array);
+    while (++index < arrLength) {
+        let arrValue = array[index], othValue = other[index];
+        if (customizer) {
+            let compared = isPartial
+                ? customizer(othValue, arrValue, index, other, array, stack)
+                : customizer(arrValue, othValue, index, array, other, stack);
+        }
+        if (compared !== undefined) {
+            if (compared) {
+                continue;
+            }
+            result = false;
+            break;
+        }
+        if (seen) {
+            if (!arraySome(other, function (othValue, othIndex) {
+                if (!seen.has(othIndex) &&
+                    (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
+                    return seen.add(othIndex);
+                }
+            })) {
+                result = false;
+                break;
+            }
+        }
+        else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
+            result = false;
+            break;
+        }
+    }
+    stack['delete'](array);
+    stack['delete'](other);
+    return result;
+}
+function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
+    switch (tag) {
+        case dataViewTag:
+            if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+                return false;
+            }
+            object = object.buffer;
+            other = other.buffer;
+        case arrayBufferTag:
+            if (object.byteLength != other.byteLength ||
+                !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+                return false;
+            }
+            return true;
+        case boolTag:
+        case dateTag:
+        case numberTag:
+            return eq(+object, +other);
+        case errorTag:
+            return object.name == other.name && object.message == other.message;
+        case regexpTag:
+        case stringTag:
+            return object == other + '';
+        case mapTag:
+            let convert = mapToArray;
+        case setTag:
+            let isPartial = bitmask & PARTIAL_COMPARE_FLAG;
+            convert || (convert = setToArray);
+            if (object.size != other.size && !isPartial) {
+                return false;
+            }
+            let stacked = stack.get(object);
+            if (stacked) {
+                return stacked == other;
+            }
+            bitmask |= UNORDERED_COMPARE_FLAG;
+            stack.set(object, other);
+            let result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
+            stack['delete'](object);
+            return result;
+        case symbolTag:
+            if (symbolValueOf) {
+                return symbolValueOf.call(object) == symbolValueOf.call(other);
+            }
+    }
+    return false;
+}
+function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
+    let isPartial = bitmask & PARTIAL_COMPARE_FLAG, objProps = keys(object), objLength = objProps.length, othProps = keys(other), othLength = othProps.length;
+    if (objLength != othLength && !isPartial) {
+        return false;
+    }
+    let index = objLength;
+    while (index--) {
+        let key = objProps[index];
+        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+            return false;
+        }
+    }
+    let stacked = stack.get(object);
+    if (stacked && stack.get(other)) {
+        return stacked == other;
+    }
+    let result = true;
+    stack.set(object, other);
+    stack.set(other, object);
+    let skipCtor = isPartial;
+    while (++index < objLength) {
+        key = objProps[index];
+        let objValue = object[key], othValue = other[key];
+        if (customizer) {
+            let compared = isPartial
+                ? customizer(othValue, objValue, key, other, object, stack)
+                : customizer(objValue, othValue, key, object, other, stack);
+        }
+        if (!(compared === undefined
+            ? objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack)
+            : compared)) {
+            result = false;
+            break;
+        }
+        skipCtor || (skipCtor = key == 'constructor');
+    }
+    if (result && !skipCtor) {
+        let objCtor = object.constructor, othCtor = other.constructor;
+        if (objCtor != othCtor &&
+            'constructor' in object &&
+            'constructor' in other &&
+            !(typeof objCtor == 'function' &&
+                objCtor instanceof objCtor &&
+                typeof othCtor == 'function' &&
+                othCtor instanceof othCtor)) {
+            result = false;
+        }
+    }
+    stack['delete'](object);
+    stack['delete'](other);
+    return result;
+}
+function getMapData(map, key) {
+    let data = map.__data__;
+    return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
+}
+function getMatchData(object) {
+    let result = keys(object), length = result.length;
+    while (length--) {
+        let key = result[length], value = object[key];
+        result[length] = [key, value, isStrictComparable(value)];
+    }
+    return result;
+}
+function getNative(object, key) {
+    let value = getValue(object, key);
+    return baseIsNative(value) ? value : undefined;
+}
+let getTag = baseGetTag;
+if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
+    (Map && getTag(new Map()) != mapTag) ||
+    (Promise$1 && getTag(Promise$1.resolve()) != promiseTag) ||
+    (Set && getTag(new Set()) != setTag) ||
+    (WeakMap && getTag(new WeakMap()) != weakMapTag)) {
+    getTag = function (value) {
+        let result = objectToString.call(value), Ctor = result == objectTag ? value.constructor : undefined, ctorString = Ctor ? toSource(Ctor) : undefined;
+        if (ctorString) {
+            switch (ctorString) {
+                case dataViewCtorString:
+                    return dataViewTag;
+                case mapCtorString:
+                    return mapTag;
+                case promiseCtorString:
+                    return promiseTag;
+                case setCtorString:
+                    return setTag;
+                case weakMapCtorString:
+                    return weakMapTag;
+            }
+        }
+        return result;
+    };
+}
+function hasPath(object, path, hasFunc) {
+    path = isKey(path, object) ? [path] : castPath(path);
+    let result;
+    let index = -1;
+    let length = path.length;
+    while (++index < length) {
+        let key = toKey(path[index]);
+        if (!(result = object != null && hasFunc(object, key))) {
+            break;
+        }
+        object = object[key];
+    }
+    if (result) {
+        return result;
+    }
+    length = object ? object.length : 0;
+    return (!!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object)));
+}
+function isIndex(value, length) {
+    length = length == null ? MAX_SAFE_INTEGER : length;
+    return (!!length &&
+        (typeof value == 'number' || reIsUint.test(value)) &&
+        value > -1 &&
+        value % 1 == 0 &&
+        value < length);
+}
+function isKey(value, object) {
+    if (isArray(value)) {
+        return false;
+    }
+    let 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 isKeyable(value) {
+    let type = typeof value;
+    return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean'
+        ? value !== '__proto__'
+        : value === null;
+}
+function isMasked(func) {
+    return !!maskSrcKey && maskSrcKey in func;
+}
+function isPrototype(value) {
+    let Ctor = value && value.constructor, proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
+    return value === proto;
+}
+function isStrictComparable(value) {
+    return value === value && !isObject(value);
+}
+function matchesStrictComparable(key, srcValue) {
+    return function (object) {
+        if (object == null) {
+            return false;
+        }
+        return object[key] === srcValue && (srcValue !== undefined || key in Object(object));
+    };
+}
+let stringToPath = memoize(function (string) {
+    string = toString(string);
+    let result = [];
+    if (reLeadingDot.test(string)) {
+        result.push('');
+    }
+    string.replace(rePropName, function (match, number, quote, string) {
+        result.push(quote ? string.replace(reEscapeChar, '$1') : number || match);
+    });
+    return result;
+});
+function toKey(value) {
+    if (typeof value == 'string' || isSymbol(value)) {
+        return value;
+    }
+    let result = value + '';
+    return result == '0' && 1 / value == -INFINITY ? '-0' : result;
+}
+function toSource(func) {
+    if (func != null) {
+        try {
+            return funcToString.call(func);
+        }
+        catch (e) { }
+        try {
+            return func + '';
+        }
+        catch (e) { }
+    }
+    return '';
+}
+function zxhiddenCustomOrderByByJeremyAshkenas(collection, iteratees, orders) {
+    if (collection == null) {
+        return [];
+    }
+    if (!isArray(iteratees)) {
+        iteratees = iteratees == null ? [] : [iteratees];
+    }
+    if (!isArray(orders)) {
+        orders = orders == null ? [] : [orders];
+    }
+    return baseOrderBy(collection, iteratees, orders);
+}
+function memoize(func, resolver) {
+    if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
+        throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    let memoized = function () {
+        let args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        let result = func.apply(this, args);
+        memoized.cache = cache.set(key, result);
+        return result;
+    };
+    memoized.cache = new (memoize.Cache || MapCache)();
+    return memoized;
+}
+memoize.Cache = MapCache;
+function eq(value, other) {
+    return value === other || (value !== value && other !== other);
+}
+function isArguments(value) {
+    return (isArrayLikeObject(value) &&
+        hasOwnProperty.call(value, 'callee') &&
+        (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag));
+}
+let isArray = Array.isArray;
+function isArrayLike(value) {
+    return value != null && isLength(value.length) && !isFunction(value);
+}
+function isArrayLikeObject(value) {
+    return isObjectLike(value) && isArrayLike(value);
+}
+function isFunction(value) {
+    let tag = isObject(value) ? objectToString.call(value) : '';
+    return tag == funcTag || tag == genTag;
+}
+function isLength(value) {
+    return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+function isObject(value) {
+    let type = typeof value;
+    return !!value && (type == 'object' || type == 'function');
+}
+function isObjectLike(value) {
+    return !!value && typeof value == 'object';
+}
+function isSymbol(value) {
+    return (typeof value == 'symbol' || (isObjectLike(value) && objectToString.call(value) == symbolTag));
+}
+let isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+function toString(value) {
+    return value == null ? '' : baseToString(value);
+}
+function get(object, path, defaultValue) {
+    let result = object == null ? undefined : baseGet(object, path);
+    return result === undefined ? defaultValue : result;
+}
+function hasIn(object, path) {
+    return object != null && hasPath(object, path, baseHasIn);
+}
+function keys(object) {
+    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+function identity(value) {
+    return value;
+}
+function property(path) {
+    return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+}
+
+/**
+ * This method is like _.clone except that it recursively clones value.
+ *
+ * @param value The value to recursively clone.
+ * @return Returns the deep cloned value.
+ */
+function cloneDeep(value) {
+    return zxhiddenCustomCloneDeepByJeremyAshkenas(value);
+}
+/**
+ * Creates a shallow clone of value.
+ *
+ * @param value The value to clone.
+ * @return Returns the cloned value.
+ */
+function clone(value) {
+    if (value instanceof Date)
+        return new Date(value.getTime());
+    if (value instanceof Array)
+        return value.slice();
+    if (typeof value === 'object')
+        return JSON.parse(JSON.stringify(value));
+    return value;
+}
+/**
+ * Creates an array of elements, sorted in ascending / descending order by
+ * the results of running each element in a collection through each iteratee.
+ * This method performs a stable sort, that is, it preserves the original
+ * sort order of equal elements. The iteratees are invoked with one argument:
+ * (value).
+ *
+ * @category Collection
+ * @param collection The collection to iterate over.
+ * @param [iteratees=[_.identity]] The iteratees to sort by.
+ * @param [orders] The sort orders of `iteratees`.
+ * @param- {Object} [guard] Enables use as an iteratee for functions like `_.reduce`.
+ * @returns Returns the new sorted array.
+ * @example
+ *
+ * const users = [
+ *   { 'user': 'fred',   'age': 48 },
+ *   { 'user': 'barney', 'age': 34 },
+ *   { 'user': 'fred',   'age': 42 },
+ *   { 'user': 'barney', 'age': 36 }
+ * ];
+ *
+ * // sort by `user` in ascending order and by `age` in descending order
+ * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]
+ */
+function orderBy(collection, iteratees, orders) {
+    return zxhiddenCustomOrderByByJeremyAshkenas(collection, iteratees, orders);
+}
+/**
+ * Return a clone without duplicated values.
+ *
+ * @param collection
+ * @param key
+ * @example
+ *
+ * const data = [1,2,2,3,4,4];
+ * const result = uniq(data); // [1,2,3,4]
+ *
+ * const dataArr = [
+ * {nombre : 'Enrique', lastName : 'Cuello'},
+ * {nombre : 'Maria', lastName : 'Aponte'},
+ * {nombre : 'Enrique', lastName : 'De Armas'},
+ * ];
+ *
+ * const resultArr = uniq(dataArr, 'nombre');
+ * // [{nombre : 'Enrique', lastName : 'Cuello'},{nombre : 'Maria', lastName : 'Aponte'}]
+ */
+function uniq(collection, key) {
+    let result = [];
+    collection.forEach((_, i) => {
+        if (!i)
+            result.push(_);
+        if (!key) {
+            if (!result.filter(_2 => _2 === _).length)
+                result.push(_);
+        }
+        else {
+            if (!result.filter(_2 => _2[key] === _[key]).length)
+                result.push(_);
+        }
+    });
+    return result;
+}
+
+const isDefined = (object) => typeof object !== 'undefined' && object !== null;
+const isLeft = (value) => isDefined(value.left);
+const isRight = (value) => isDefined(value.right);
+const makeLeft = (value) => ({ left: value });
+const makeRight = (value) => ({ right: value });
+const unwrapEither = (value) => {
+    const { left, right } = value;
+    const errorMsn_1 = 'Received both left and right values at runtime';
+    const errorMsn_2 = 'Received no left or right values at runtime when opening Either';
+    if (isDefined(right) && isDefined(left))
+        throw new Error(errorMsn_1);
+    if (isDefined(left))
+        return left;
+    if (isDefined(right))
+        return right;
+    throw new Error(errorMsn_2);
+};
+const getErrorMessage = (error) => {
+    if (error) {
+        if (error.error)
+            return error.error.message || error.error.status;
+        else
+            return error.message || error;
+    }
+    else
+        return error;
+};
+class Either {
+    constructor(value) {
+        this.value = value;
+    }
+    fold(resolver) {
+        if (isRight(this.value) && resolver.right)
+            return resolver.right(unwrapEither(this.value));
+        if (isLeft(this.value) && resolver.left)
+            return resolver.left(unwrapEither(this.value));
+        return undefined;
+    }
+    static left(value, isErr = true) {
+        if (typeof value === 'object' && isErr)
+            return new Either(makeLeft(getErrorMessage(value)));
+        else
+            return new Either(makeLeft(value));
+    }
+    static right(value) {
+        return new Either(makeRight(value));
+    }
+}
+
+// Regex to split a windows path into three parts: [*, device, slash,
+// tail] windows-only
+const splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+// Regex to split the tail part of the above into [*, dir, basename, ext]
+const splitTailRe = /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
+// Function to split a filename into [root, dir, basename, ext]
+function win32SplitPath(filename) {
+    // Separate device+slash from tail
+    const result = splitDeviceRe.exec(filename), device = (result[1] || '') + (result[2] || ''), tail = result[3] || '';
+    // Split the tail into dir, basename and extension
+    const result2 = splitTailRe.exec(tail), dir = result2[1], basename = result2[2], ext = result2[3];
+    return [device, dir, basename, ext];
+}
+const extname = (path) => {
+    return win32SplitPath(path)[3];
+};
+
+/*
+ * Public API Surface of @kato-lee/utilities
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { Either, clone, cloneDeep, extname, groupByKey, orderBy, uniq };
+//# sourceMappingURL=kato-lee-utilities.mjs.map