@rspress/shared 2.0.7 → 2.0.9

package/dist/lodash-es.js

@@ -0,0 +1,678 @@
+import { _isIndex, lodash_es_isArguments, _MapCache, _Uint8Array, _overArg, lodash_es_isObject, lodash_es_isObjectLike, _arrayLikeKeys, _baseFor, _Map, lodash_es_isLength, lodash_es_isTypedArray, _root, lodash_es_eq, _Stack, _isIterateeCall, lodash_es_isArrayLike, _baseAssignValue, _baseGetTag, lodash_es_isBuffer, _isPrototype, lodash_es_identity, _toSource, _getNative, _Symbol, lodash_es_isArray } from "./584.js";
+function baseSlice(array, start, end) {
+    var index = -1, length = array.length;
+    if (start < 0) start = -start > length ? 0 : length + start;
+    end = end > length ? length : end;
+    if (end < 0) end += length;
+    length = start > end ? 0 : end - start >>> 0;
+    start >>>= 0;
+    var result = Array(length);
+    while(++index < length)result[index] = array[index + start];
+    return result;
+}
+const _baseSlice = baseSlice;
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+    var index = string.length;
+    while(index-- && reWhitespace.test(string.charAt(index)));
+    return index;
+}
+const _trimmedEndIndex = trimmedEndIndex;
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+    return string ? string.slice(0, _trimmedEndIndex(string) + 1).replace(reTrimStart, '') : string;
+}
+const _baseTrim = baseTrim;
+var symbolTag = '[object Symbol]';
+function isSymbol(value) {
+    return 'symbol' == typeof value || lodash_es_isObjectLike(value) && _baseGetTag(value) == symbolTag;
+}
+const lodash_es_isSymbol = isSymbol;
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber(value) {
+    if ('number' == typeof value) return value;
+    if (lodash_es_isSymbol(value)) return NAN;
+    if (lodash_es_isObject(value)) {
+        var other = 'function' == typeof value.valueOf ? value.valueOf() : value;
+        value = lodash_es_isObject(other) ? other + '' : other;
+    }
+    if ('string' != typeof value) return 0 === value ? value : +value;
+    value = _baseTrim(value);
+    var isBinary = reIsBinary.test(value);
+    return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+const lodash_es_toNumber = toNumber;
+var INFINITY = 1 / 0, MAX_INTEGER = 1.7976931348623157e+308;
+function toFinite(value) {
+    if (!value) return 0 === value ? value : 0;
+    value = lodash_es_toNumber(value);
+    if (value === INFINITY || value === -INFINITY) {
+        var sign = value < 0 ? -1 : 1;
+        return sign * MAX_INTEGER;
+    }
+    return value === value ? value : 0;
+}
+const lodash_es_toFinite = toFinite;
+function toInteger(value) {
+    var result = lodash_es_toFinite(value), remainder = result % 1;
+    return result === result ? remainder ? result - remainder : result : 0;
+}
+const lodash_es_toInteger = toInteger;
+var nativeCeil = Math.ceil, nativeMax = Math.max;
+function chunk(array, size, guard) {
+    size = (guard ? _isIterateeCall(array, size, guard) : void 0 === size) ? 1 : nativeMax(lodash_es_toInteger(size), 0);
+    var length = null == array ? 0 : array.length;
+    if (!length || size < 1) return [];
+    var index = 0, resIndex = 0, result = Array(nativeCeil(length / size));
+    while(index < length)result[resIndex++] = _baseSlice(array, index, index += size);
+    return result;
+}
+const lodash_es_chunk = chunk;
+var now = function() {
+    return _root.Date.now();
+};
+const lodash_es_now = now;
+var FUNC_ERROR_TEXT = 'Expected a function';
+var debounce_nativeMax = Math.max, nativeMin = Math.min;
+function debounce(func, wait, options) {
+    var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+    if ('function' != typeof func) throw new TypeError(FUNC_ERROR_TEXT);
+    wait = lodash_es_toNumber(wait) || 0;
+    if (lodash_es_isObject(options)) {
+        leading = !!options.leading;
+        maxing = 'maxWait' in options;
+        maxWait = maxing ? debounce_nativeMax(lodash_es_toNumber(options.maxWait) || 0, wait) : maxWait;
+        trailing = 'trailing' in options ? !!options.trailing : trailing;
+    }
+    function invokeFunc(time) {
+        var args = lastArgs, thisArg = lastThis;
+        lastArgs = lastThis = void 0;
+        lastInvokeTime = time;
+        result = func.apply(thisArg, args);
+        return result;
+    }
+    function leadingEdge(time) {
+        lastInvokeTime = time;
+        timerId = setTimeout(timerExpired, wait);
+        return leading ? invokeFunc(time) : result;
+    }
+    function remainingWait(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+        return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+    }
+    function shouldInvoke(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+        return void 0 === lastCallTime || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+    }
+    function timerExpired() {
+        var time = lodash_es_now();
+        if (shouldInvoke(time)) return trailingEdge(time);
+        timerId = setTimeout(timerExpired, remainingWait(time));
+    }
+    function trailingEdge(time) {
+        timerId = void 0;
+        if (trailing && lastArgs) return invokeFunc(time);
+        lastArgs = lastThis = void 0;
+        return result;
+    }
+    function cancel() {
+        if (void 0 !== timerId) clearTimeout(timerId);
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = void 0;
+    }
+    function flush() {
+        return void 0 === timerId ? result : trailingEdge(lodash_es_now());
+    }
+    function debounced() {
+        var time = lodash_es_now(), isInvoking = shouldInvoke(time);
+        lastArgs = arguments;
+        lastThis = this;
+        lastCallTime = time;
+        if (isInvoking) {
+            if (void 0 === timerId) return leadingEdge(lastCallTime);
+            if (maxing) {
+                clearTimeout(timerId);
+                timerId = setTimeout(timerExpired, wait);
+                return invokeFunc(lastCallTime);
+            }
+        }
+        if (void 0 === timerId) timerId = setTimeout(timerExpired, wait);
+        return result;
+    }
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    return debounced;
+}
+const lodash_es_debounce = debounce;
+function arrayAggregator(array, setter, iteratee, accumulator) {
+    var index = -1, length = null == array ? 0 : array.length;
+    while(++index < length){
+        var value = array[index];
+        setter(accumulator, value, iteratee(value), array);
+    }
+    return accumulator;
+}
+const _arrayAggregator = arrayAggregator;
+var nativeKeys = _overArg(Object.keys, Object);
+const _nativeKeys = nativeKeys;
+var objectProto = Object.prototype;
+var _baseKeys_hasOwnProperty = objectProto.hasOwnProperty;
+function baseKeys(object) {
+    if (!_isPrototype(object)) return _nativeKeys(object);
+    var result = [];
+    for(var key in Object(object))if (_baseKeys_hasOwnProperty.call(object, key) && 'constructor' != key) result.push(key);
+    return result;
+}
+const _baseKeys = baseKeys;
+function keys(object) {
+    return lodash_es_isArrayLike(object) ? _arrayLikeKeys(object) : _baseKeys(object);
+}
+const lodash_es_keys = keys;
+function baseForOwn(object, iteratee) {
+    return object && _baseFor(object, iteratee, lodash_es_keys);
+}
+const _baseForOwn = baseForOwn;
+function createBaseEach(eachFunc, fromRight) {
+    return function(collection, iteratee) {
+        if (null == collection) return collection;
+        if (!lodash_es_isArrayLike(collection)) return eachFunc(collection, iteratee);
+        var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
+        while(fromRight ? index-- : ++index < length)if (false === iteratee(iterable[index], index, iterable)) break;
+        return collection;
+    };
+}
+const _createBaseEach = createBaseEach;
+var baseEach = _createBaseEach(_baseForOwn);
+const _baseEach = baseEach;
+function baseAggregator(collection, setter, iteratee, accumulator) {
+    _baseEach(collection, function(value, key, collection) {
+        setter(accumulator, value, iteratee(value), collection);
+    });
+    return accumulator;
+}
+const _baseAggregator = baseAggregator;
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+function setCacheAdd(value) {
+    this.__data__.set(value, HASH_UNDEFINED);
+    return this;
+}
+const _setCacheAdd = setCacheAdd;
+function setCacheHas(value) {
+    return this.__data__.has(value);
+}
+const _setCacheHas = setCacheHas;
+function SetCache(values) {
+    var index = -1, length = null == values ? 0 : values.length;
+    this.__data__ = new _MapCache;
+    while(++index < length)this.add(values[index]);
+}
+SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd;
+SetCache.prototype.has = _setCacheHas;
+const _SetCache = SetCache;
+function arraySome(array, predicate) {
+    var index = -1, length = null == array ? 0 : array.length;
+    while(++index < length)if (predicate(array[index], index, array)) return true;
+    return false;
+}
+const _arraySome = arraySome;
+function cacheHas(cache, key) {
+    return cache.has(key);
+}
+const _cacheHas = cacheHas;
+var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+    if (arrLength != othLength && !(isPartial && othLength > arrLength)) return false;
+    var arrStacked = stack.get(array);
+    var othStacked = stack.get(other);
+    if (arrStacked && othStacked) return arrStacked == other && othStacked == array;
+    var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new _SetCache : void 0;
+    stack.set(array, other);
+    stack.set(other, array);
+    while(++index < arrLength){
+        var arrValue = array[index], othValue = other[index];
+        if (customizer) var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+        if (void 0 !== compared) {
+            if (compared) continue;
+            result = false;
+            break;
+        }
+        if (seen) {
+            if (!_arraySome(other, function(othValue, othIndex) {
+                if (!_cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) return seen.push(othIndex);
+            })) {
+                result = false;
+                break;
+            }
+        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+            result = false;
+            break;
+        }
+    }
+    stack['delete'](array);
+    stack['delete'](other);
+    return result;
+}
+const _equalArrays = equalArrays;
+function mapToArray(map) {
+    var index = -1, result = Array(map.size);
+    map.forEach(function(value, key) {
+        result[++index] = [
+            key,
+            value
+        ];
+    });
+    return result;
+}
+const _mapToArray = mapToArray;
+function setToArray(set) {
+    var index = -1, result = Array(set.size);
+    set.forEach(function(value) {
+        result[++index] = value;
+    });
+    return result;
+}
+const _setToArray = setToArray;
+var _equalByTag_COMPARE_PARTIAL_FLAG = 1, _equalByTag_COMPARE_UNORDERED_FLAG = 2;
+var boolTag = '[object Boolean]', dateTag = '[object Date]', errorTag = '[object Error]', mapTag = '[object Map]', numberTag = '[object Number]', regexpTag = '[object RegExp]', setTag = '[object Set]', stringTag = '[object String]', _equalByTag_symbolTag = '[object Symbol]';
+var arrayBufferTag = '[object ArrayBuffer]', dataViewTag = '[object DataView]';
+var symbolProto = _Symbol ? _Symbol.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+    switch(tag){
+        case dataViewTag:
+            if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) break;
+            object = object.buffer;
+            other = other.buffer;
+        case arrayBufferTag:
+            if (object.byteLength != other.byteLength || !equalFunc(new _Uint8Array(object), new _Uint8Array(other))) break;
+            return true;
+        case boolTag:
+        case dateTag:
+        case numberTag:
+            return lodash_es_eq(+object, +other);
+        case errorTag:
+            return object.name == other.name && object.message == other.message;
+        case regexpTag:
+        case stringTag:
+            return object == other + '';
+        case mapTag:
+            var convert = _mapToArray;
+        case setTag:
+            var isPartial = bitmask & _equalByTag_COMPARE_PARTIAL_FLAG;
+            convert || (convert = _setToArray);
+            if (object.size != other.size && !isPartial) break;
+            var stacked = stack.get(object);
+            if (stacked) return stacked == other;
+            bitmask |= _equalByTag_COMPARE_UNORDERED_FLAG;
+            stack.set(object, other);
+            var result = _equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+            stack['delete'](object);
+            return result;
+        case _equalByTag_symbolTag:
+            if (symbolValueOf) return symbolValueOf.call(object) == symbolValueOf.call(other);
+    }
+    return false;
+}
+const _equalByTag = equalByTag;
+function arrayPush(array, values) {
+    var index = -1, length = values.length, offset = array.length;
+    while(++index < length)array[offset + index] = values[index];
+    return array;
+}
+const _arrayPush = arrayPush;
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+    var result = keysFunc(object);
+    return lodash_es_isArray(object) ? result : _arrayPush(result, symbolsFunc(object));
+}
+const _baseGetAllKeys = baseGetAllKeys;
+function arrayFilter(array, predicate) {
+    var index = -1, length = null == array ? 0 : array.length, resIndex = 0, result = [];
+    while(++index < length){
+        var value = array[index];
+        if (predicate(value, index, array)) result[resIndex++] = value;
+    }
+    return result;
+}
+const _arrayFilter = arrayFilter;
+function stubArray() {
+    return [];
+}
+const lodash_es_stubArray = stubArray;
+var _getSymbols_objectProto = Object.prototype;
+var propertyIsEnumerable = _getSymbols_objectProto.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = nativeGetSymbols ? function(object) {
+    if (null == object) return [];
+    object = Object(object);
+    return _arrayFilter(nativeGetSymbols(object), function(symbol) {
+        return propertyIsEnumerable.call(object, symbol);
+    });
+} : lodash_es_stubArray;
+const _getSymbols = getSymbols;
+function getAllKeys(object) {
+    return _baseGetAllKeys(object, lodash_es_keys, _getSymbols);
+}
+const _getAllKeys = getAllKeys;
+var _equalObjects_COMPARE_PARTIAL_FLAG = 1;
+var _equalObjects_objectProto = Object.prototype;
+var _equalObjects_hasOwnProperty = _equalObjects_objectProto.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+    var isPartial = bitmask & _equalObjects_COMPARE_PARTIAL_FLAG, objProps = _getAllKeys(object), objLength = objProps.length, othProps = _getAllKeys(other), othLength = othProps.length;
+    if (objLength != othLength && !isPartial) return false;
+    var index = objLength;
+    while(index--){
+        var key = objProps[index];
+        if (!(isPartial ? key in other : _equalObjects_hasOwnProperty.call(other, key))) return false;
+    }
+    var objStacked = stack.get(object);
+    var othStacked = stack.get(other);
+    if (objStacked && othStacked) return objStacked == other && othStacked == object;
+    var result = true;
+    stack.set(object, other);
+    stack.set(other, object);
+    var skipCtor = isPartial;
+    while(++index < objLength){
+        key = objProps[index];
+        var objValue = object[key], othValue = other[key];
+        if (customizer) var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+        if (!(void 0 === compared ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+            result = false;
+            break;
+        }
+        skipCtor || (skipCtor = 'constructor' == key);
+    }
+    if (result && !skipCtor) {
+        var objCtor = object.constructor, othCtor = other.constructor;
+        if (objCtor != othCtor && 'constructor' in object && 'constructor' in other && !('function' == typeof objCtor && objCtor instanceof objCtor && 'function' == typeof othCtor && othCtor instanceof othCtor)) result = false;
+    }
+    stack['delete'](object);
+    stack['delete'](other);
+    return result;
+}
+const _equalObjects = equalObjects;
+var DataView = _getNative(_root, 'DataView');
+const _DataView = DataView;
+var Promise = _getNative(_root, 'Promise');
+const _Promise = Promise;
+var Set = _getNative(_root, 'Set');
+const _Set = Set;
+var WeakMap = _getNative(_root, 'WeakMap');
+const _WeakMap = WeakMap;
+var _getTag_mapTag = '[object Map]', objectTag = '[object Object]', promiseTag = '[object Promise]', _getTag_setTag = '[object Set]', weakMapTag = '[object WeakMap]';
+var _getTag_dataViewTag = '[object DataView]';
+var dataViewCtorString = _toSource(_DataView), mapCtorString = _toSource(_Map), promiseCtorString = _toSource(_Promise), setCtorString = _toSource(_Set), weakMapCtorString = _toSource(_WeakMap);
+var getTag = _baseGetTag;
+if (_DataView && getTag(new _DataView(new ArrayBuffer(1))) != _getTag_dataViewTag || _Map && getTag(new _Map) != _getTag_mapTag || _Promise && getTag(_Promise.resolve()) != promiseTag || _Set && getTag(new _Set) != _getTag_setTag || _WeakMap && getTag(new _WeakMap) != weakMapTag) getTag = function(value) {
+    var result = _baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? _toSource(Ctor) : '';
+    if (ctorString) switch(ctorString){
+        case dataViewCtorString:
+            return _getTag_dataViewTag;
+        case mapCtorString:
+            return _getTag_mapTag;
+        case promiseCtorString:
+            return promiseTag;
+        case setCtorString:
+            return _getTag_setTag;
+        case weakMapCtorString:
+            return weakMapTag;
+    }
+    return result;
+};
+const _getTag = getTag;
+var _baseIsEqualDeep_COMPARE_PARTIAL_FLAG = 1;
+var argsTag = '[object Arguments]', arrayTag = '[object Array]', _baseIsEqualDeep_objectTag = '[object Object]';
+var _baseIsEqualDeep_objectProto = Object.prototype;
+var _baseIsEqualDeep_hasOwnProperty = _baseIsEqualDeep_objectProto.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+    var objIsArr = lodash_es_isArray(object), othIsArr = lodash_es_isArray(other), objTag = objIsArr ? arrayTag : _getTag(object), othTag = othIsArr ? arrayTag : _getTag(other);
+    objTag = objTag == argsTag ? _baseIsEqualDeep_objectTag : objTag;
+    othTag = othTag == argsTag ? _baseIsEqualDeep_objectTag : othTag;
+    var objIsObj = objTag == _baseIsEqualDeep_objectTag, othIsObj = othTag == _baseIsEqualDeep_objectTag, isSameTag = objTag == othTag;
+    if (isSameTag && lodash_es_isBuffer(object)) {
+        if (!lodash_es_isBuffer(other)) return false;
+        objIsArr = true;
+        objIsObj = false;
+    }
+    if (isSameTag && !objIsObj) {
+        stack || (stack = new _Stack);
+        return objIsArr || lodash_es_isTypedArray(object) ? _equalArrays(object, other, bitmask, customizer, equalFunc, stack) : _equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+    }
+    if (!(bitmask & _baseIsEqualDeep_COMPARE_PARTIAL_FLAG)) {
+        var objIsWrapped = objIsObj && _baseIsEqualDeep_hasOwnProperty.call(object, '__wrapped__'), othIsWrapped = othIsObj && _baseIsEqualDeep_hasOwnProperty.call(other, '__wrapped__');
+        if (objIsWrapped || othIsWrapped) {
+            var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+            stack || (stack = new _Stack);
+            return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+        }
+    }
+    if (!isSameTag) return false;
+    stack || (stack = new _Stack);
+    return _equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+const _baseIsEqualDeep = baseIsEqualDeep;
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+    if (value === other) return true;
+    if (null == value || null == other || !lodash_es_isObjectLike(value) && !lodash_es_isObjectLike(other)) return value !== value && other !== other;
+    return _baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+const _baseIsEqual = baseIsEqual;
+var _baseIsMatch_COMPARE_PARTIAL_FLAG = 1, _baseIsMatch_COMPARE_UNORDERED_FLAG = 2;
+function baseIsMatch(object, source, matchData, customizer) {
+    var index = matchData.length, length = index, noCustomizer = !customizer;
+    if (null == object) return !length;
+    object = Object(object);
+    while(index--){
+        var data = matchData[index];
+        if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) return false;
+    }
+    while(++index < length){
+        data = matchData[index];
+        var key = data[0], objValue = object[key], srcValue = data[1];
+        if (noCustomizer && data[2]) {
+            if (void 0 === objValue && !(key in object)) return false;
+        } else {
+            var stack = new _Stack;
+            if (customizer) var result = customizer(objValue, srcValue, key, object, source, stack);
+            if (!(void 0 === result ? _baseIsEqual(srcValue, objValue, _baseIsMatch_COMPARE_PARTIAL_FLAG | _baseIsMatch_COMPARE_UNORDERED_FLAG, customizer, stack) : result)) return false;
+        }
+    }
+    return true;
+}
+const _baseIsMatch = baseIsMatch;
+function isStrictComparable(value) {
+    return value === value && !lodash_es_isObject(value);
+}
+const _isStrictComparable = isStrictComparable;
+function getMatchData(object) {
+    var result = lodash_es_keys(object), length = result.length;
+    while(length--){
+        var key = result[length], value = object[key];
+        result[length] = [
+            key,
+            value,
+            _isStrictComparable(value)
+        ];
+    }
+    return result;
+}
+const _getMatchData = getMatchData;
+function matchesStrictComparable(key, srcValue) {
+    return function(object) {
+        if (null == object) return false;
+        return object[key] === srcValue && (void 0 !== srcValue || key in Object(object));
+    };
+}
+const _matchesStrictComparable = matchesStrictComparable;
+function baseMatches(source) {
+    var matchData = _getMatchData(source);
+    if (1 == matchData.length && matchData[0][2]) return _matchesStrictComparable(matchData[0][0], matchData[0][1]);
+    return function(object) {
+        return object === source || _baseIsMatch(object, source, matchData);
+    };
+}
+const _baseMatches = baseMatches;
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+    if (lodash_es_isArray(value)) return false;
+    var type = typeof value;
+    if ('number' == type || 'symbol' == type || 'boolean' == type || null == value || lodash_es_isSymbol(value)) return true;
+    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || null != object && value in Object(object);
+}
+const _isKey = isKey;
+var memoize_FUNC_ERROR_TEXT = 'Expected a function';
+function memoize(func, resolver) {
+    if ('function' != typeof func || null != resolver && 'function' != typeof resolver) throw new TypeError(memoize_FUNC_ERROR_TEXT);
+    var memoized = function() {
+        var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+        if (cache.has(key)) return cache.get(key);
+        var result = func.apply(this, args);
+        memoized.cache = cache.set(key, result) || cache;
+        return result;
+    };
+    memoized.cache = new (memoize.Cache || _MapCache);
+    return memoized;
+}
+memoize.Cache = _MapCache;
+const lodash_es_memoize = memoize;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+    var result = lodash_es_memoize(func, function(key) {
+        if (cache.size === MAX_MEMOIZE_SIZE) cache.clear();
+        return key;
+    });
+    var cache = result.cache;
+    return result;
+}
+const _memoizeCapped = memoizeCapped;
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = _memoizeCapped(function(string) {
+    var result = [];
+    if (46 === string.charCodeAt(0)) result.push('');
+    string.replace(rePropName, function(match, number, quote, subString) {
+        result.push(quote ? subString.replace(reEscapeChar, '$1') : number || match);
+    });
+    return result;
+});
+const _stringToPath = stringToPath;
+function arrayMap(array, iteratee) {
+    var index = -1, length = null == array ? 0 : array.length, result = Array(length);
+    while(++index < length)result[index] = iteratee(array[index], index, array);
+    return result;
+}
+const _arrayMap = arrayMap;
+var _baseToString_INFINITY = 1 / 0;
+var _baseToString_symbolProto = _Symbol ? _Symbol.prototype : void 0, symbolToString = _baseToString_symbolProto ? _baseToString_symbolProto.toString : void 0;
+function baseToString(value) {
+    if ('string' == typeof value) return value;
+    if (lodash_es_isArray(value)) return _arrayMap(value, baseToString) + '';
+    if (lodash_es_isSymbol(value)) return symbolToString ? symbolToString.call(value) : '';
+    var result = value + '';
+    return '0' == result && 1 / value == -_baseToString_INFINITY ? '-0' : result;
+}
+const _baseToString = baseToString;
+function toString_toString(value) {
+    return null == value ? '' : _baseToString(value);
+}
+const lodash_es_toString = toString_toString;
+function castPath(value, object) {
+    if (lodash_es_isArray(value)) return value;
+    return _isKey(value, object) ? [
+        value
+    ] : _stringToPath(lodash_es_toString(value));
+}
+const _castPath = castPath;
+var _toKey_INFINITY = 1 / 0;
+function toKey(value) {
+    if ('string' == typeof value || lodash_es_isSymbol(value)) return value;
+    var result = value + '';
+    return '0' == result && 1 / value == -_toKey_INFINITY ? '-0' : result;
+}
+const _toKey = toKey;
+function baseGet(object, path) {
+    path = _castPath(path, object);
+    var index = 0, length = path.length;
+    while(null != object && index < length)object = object[_toKey(path[index++])];
+    return index && index == length ? object : void 0;
+}
+const _baseGet = baseGet;
+function get(object, path, defaultValue) {
+    var result = null == object ? void 0 : _baseGet(object, path);
+    return void 0 === result ? defaultValue : result;
+}
+const lodash_es_get = get;
+function baseHasIn(object, key) {
+    return null != object && key in Object(object);
+}
+const _baseHasIn = baseHasIn;
+function hasPath(object, path, hasFunc) {
+    path = _castPath(path, object);
+    var index = -1, length = path.length, result = false;
+    while(++index < length){
+        var key = _toKey(path[index]);
+        if (!(result = null != object && hasFunc(object, key))) break;
+        object = object[key];
+    }
+    if (result || ++index != length) return result;
+    length = null == object ? 0 : object.length;
+    return !!length && lodash_es_isLength(length) && _isIndex(key, length) && (lodash_es_isArray(object) || lodash_es_isArguments(object));
+}
+const _hasPath = hasPath;
+function hasIn(object, path) {
+    return null != object && _hasPath(object, path, _baseHasIn);
+}
+const lodash_es_hasIn = hasIn;
+var _baseMatchesProperty_COMPARE_PARTIAL_FLAG = 1, _baseMatchesProperty_COMPARE_UNORDERED_FLAG = 2;
+function baseMatchesProperty(path, srcValue) {
+    if (_isKey(path) && _isStrictComparable(srcValue)) return _matchesStrictComparable(_toKey(path), srcValue);
+    return function(object) {
+        var objValue = lodash_es_get(object, path);
+        return void 0 === objValue && objValue === srcValue ? lodash_es_hasIn(object, path) : _baseIsEqual(srcValue, objValue, _baseMatchesProperty_COMPARE_PARTIAL_FLAG | _baseMatchesProperty_COMPARE_UNORDERED_FLAG);
+    };
+}
+const _baseMatchesProperty = baseMatchesProperty;
+function baseProperty(key) {
+    return function(object) {
+        return null == object ? void 0 : object[key];
+    };
+}
+const _baseProperty = baseProperty;
+function basePropertyDeep(path) {
+    return function(object) {
+        return _baseGet(object, path);
+    };
+}
+const _basePropertyDeep = basePropertyDeep;
+function property(path) {
+    return _isKey(path) ? _baseProperty(_toKey(path)) : _basePropertyDeep(path);
+}
+const lodash_es_property = property;
+function baseIteratee(value) {
+    if ('function' == typeof value) return value;
+    if (null == value) return lodash_es_identity;
+    if ('object' == typeof value) return lodash_es_isArray(value) ? _baseMatchesProperty(value[0], value[1]) : _baseMatches(value);
+    return lodash_es_property(value);
+}
+const _baseIteratee = baseIteratee;
+function createAggregator(setter, initializer) {
+    return function(collection, iteratee) {
+        var func = lodash_es_isArray(collection) ? _arrayAggregator : _baseAggregator, accumulator = initializer ? initializer() : {};
+        return func(collection, setter, _baseIteratee(iteratee, 2), accumulator);
+    };
+}
+const _createAggregator = createAggregator;
+var groupBy_objectProto = Object.prototype;
+var groupBy_hasOwnProperty = groupBy_objectProto.hasOwnProperty;
+var groupBy = _createAggregator(function(result, value, key) {
+    if (groupBy_hasOwnProperty.call(result, key)) result[key].push(value);
+    else _baseAssignValue(result, key, [
+        value
+    ]);
+});
+const lodash_es_groupBy = groupBy;
+export { mergeWith } from "./584.js";
+export { lodash_es_chunk as chunk, lodash_es_debounce as debounce, lodash_es_groupBy as groupBy };