@elmethis/core 1.0.0-alpha.146 → 1.0.0-alpha.148

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsEqualDeep.mjs

@@ -0,0 +1,45 @@
+import Stack from "./_Stack.mjs";
+import equalArrays from "./_equalArrays.mjs";
+import equalByTag from "./_equalByTag.mjs";
+import equalObjects from "./_equalObjects.mjs";
+import getTag from "./_getTag.mjs";
+import isArray from "./isArray.mjs";
+import isBuffer from "./isBuffer.mjs";
+import isTypedArray from "./isTypedArray.mjs";
+var COMPARE_PARTIAL_FLAG = 1;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+  var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack());
+    return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && 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);
+}
+export {
+  baseIsEqualDeep as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsMap.mjs

@@ -0,0 +1,9 @@
+import getTag from "./_getTag.mjs";
+import isObjectLike from "./isObjectLike.mjs";
+var mapTag = "[object Map]";
+function baseIsMap(value) {
+  return isObjectLike(value) && getTag(value) == mapTag;
+}
+export {
+  baseIsMap as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsMatch.mjs

@@ -0,0 +1,35 @@
+import Stack from "./_Stack.mjs";
+import baseIsEqual from "./_baseIsEqual.mjs";
+var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length, length = index;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if (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 (data[2]) {
+      if (objValue === void 0 && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack();
+      var result;
+      if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+export {
+  baseIsMatch as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsNaN.mjs

@@ -0,0 +1,6 @@
+function baseIsNaN(value) {
+  return value !== value;
+}
+export {
+  baseIsNaN as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsNative.mjs

@@ -0,0 +1,22 @@
+import isFunction from "./isFunction.mjs";
+import isMasked from "./_isMasked.mjs";
+import isObject from "./isObject.mjs";
+import toSource from "./_toSource.mjs";
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+export {
+  baseIsNative as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsSet.mjs

@@ -0,0 +1,9 @@
+import getTag from "./_getTag.mjs";
+import isObjectLike from "./isObjectLike.mjs";
+var setTag = "[object Set]";
+function baseIsSet(value) {
+  return isObjectLike(value) && getTag(value) == setTag;
+}
+export {
+  baseIsSet as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIsTypedArray.mjs

@@ -0,0 +1,14 @@
+import baseGetTag from "./_baseGetTag.mjs";
+import isLength from "./isLength.mjs";
+import isObjectLike from "./isObjectLike.mjs";
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+export {
+  baseIsTypedArray as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseIteratee.mjs

@@ -0,0 +1,20 @@
+import baseMatches from "./_baseMatches.mjs";
+import baseMatchesProperty from "./_baseMatchesProperty.mjs";
+import identity from "./identity.mjs";
+import isArray from "./isArray.mjs";
+import property from "./property.mjs";
+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);
+}
+export {
+  baseIteratee as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseKeys.mjs

@@ -0,0 +1,19 @@
+import isPrototype from "./_isPrototype.mjs";
+import nativeKeys from "./_nativeKeys.mjs";
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+export {
+  baseKeys as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseKeysIn.mjs

@@ -0,0 +1,20 @@
+import isObject from "./isObject.mjs";
+import isPrototype from "./_isPrototype.mjs";
+import nativeKeysIn from "./_nativeKeysIn.mjs";
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseKeysIn(object) {
+  if (!isObject(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype(object), result = [];
+  for (var key in object) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+export {
+  baseKeysIn as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseLt.mjs

@@ -0,0 +1,6 @@
+function baseLt(value, other) {
+  return value < other;
+}
+export {
+  baseLt as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseMap.mjs

@@ -0,0 +1,12 @@
+import baseEach from "./_baseEach.mjs";
+import isArrayLike from "./isArrayLike.mjs";
+function baseMap(collection, iteratee) {
+  var index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
+  baseEach(collection, function(value, key, collection2) {
+    result[++index] = iteratee(value, key, collection2);
+  });
+  return result;
+}
+export {
+  baseMap as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseMatches.mjs

@@ -0,0 +1,15 @@
+import baseIsMatch from "./_baseIsMatch.mjs";
+import getMatchData from "./_getMatchData.mjs";
+import matchesStrictComparable from "./_matchesStrictComparable.mjs";
+function baseMatches(source) {
+  var 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);
+  };
+}
+export {
+  baseMatches as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseMatchesProperty.mjs

@@ -0,0 +1,20 @@
+import baseIsEqual from "./_baseIsEqual.mjs";
+import get from "./get.mjs";
+import hasIn from "./hasIn.mjs";
+import isKey from "./_isKey.mjs";
+import isStrictComparable from "./_isStrictComparable.mjs";
+import matchesStrictComparable from "./_matchesStrictComparable.mjs";
+import toKey from "./_toKey.mjs";
+var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
+function baseMatchesProperty(path, srcValue) {
+  if (isKey(path) && isStrictComparable(srcValue)) {
+    return matchesStrictComparable(toKey(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get(object, path);
+    return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+export {
+  baseMatchesProperty as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseMerge.mjs

@@ -0,0 +1,27 @@
+import Stack from "./_Stack.mjs";
+import assignMergeValue from "./_assignMergeValue.mjs";
+import baseFor from "./_baseFor.mjs";
+import baseMergeDeep from "./_baseMergeDeep.mjs";
+import isObject from "./isObject.mjs";
+import keysIn from "./keysIn.mjs";
+import safeGet from "./_safeGet.mjs";
+function baseMerge(object, source, srcIndex, customizer, stack) {
+  if (object === source) {
+    return;
+  }
+  baseFor(source, function(srcValue, key) {
+    stack || (stack = new Stack());
+    if (isObject(srcValue)) {
+      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
+    } else {
+      var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
+      if (newValue === void 0) {
+        newValue = srcValue;
+      }
+      assignMergeValue(object, key, newValue);
+    }
+  }, keysIn);
+}
+export {
+  baseMerge as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseMergeDeep.mjs

@@ -0,0 +1,61 @@
+import assignMergeValue from "./_assignMergeValue.mjs";
+import cloneBuffer from "./_cloneBuffer.mjs";
+import cloneTypedArray from "./_cloneTypedArray.mjs";
+import copyArray from "./_copyArray.mjs";
+import initCloneObject from "./_initCloneObject.mjs";
+import isArguments from "./isArguments.mjs";
+import isArray from "./isArray.mjs";
+import isArrayLikeObject from "./isArrayLikeObject.mjs";
+import isBuffer from "./isBuffer.mjs";
+import isFunction from "./isFunction.mjs";
+import isObject from "./isObject.mjs";
+import isPlainObject from "./isPlainObject.mjs";
+import isTypedArray from "./isTypedArray.mjs";
+import safeGet from "./_safeGet.mjs";
+import toPlainObject from "./toPlainObject.mjs";
+function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
+  var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
+  if (stacked) {
+    assignMergeValue(object, key, stacked);
+    return;
+  }
+  var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
+  var isCommon = newValue === void 0;
+  if (isCommon) {
+    var isArr = isArray(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
+    newValue = srcValue;
+    if (isArr || isBuff || isTyped) {
+      if (isArray(objValue)) {
+        newValue = objValue;
+      } else if (isArrayLikeObject(objValue)) {
+        newValue = copyArray(objValue);
+      } else if (isBuff) {
+        isCommon = false;
+        newValue = cloneBuffer(srcValue, true);
+      } else if (isTyped) {
+        isCommon = false;
+        newValue = cloneTypedArray(srcValue, true);
+      } else {
+        newValue = [];
+      }
+    } else if (isPlainObject(srcValue) || isArguments(srcValue)) {
+      newValue = objValue;
+      if (isArguments(objValue)) {
+        newValue = toPlainObject(objValue);
+      } else if (!isObject(objValue) || isFunction(objValue)) {
+        newValue = initCloneObject(srcValue);
+      }
+    } else {
+      isCommon = false;
+    }
+  }
+  if (isCommon) {
+    stack.set(srcValue, newValue);
+    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
+    stack["delete"](srcValue);
+  }
+  assignMergeValue(object, key, newValue);
+}
+export {
+  baseMergeDeep as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseProperty.mjs

@@ -0,0 +1,8 @@
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? void 0 : object[key];
+  };
+}
+export {
+  baseProperty as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_basePropertyDeep.mjs

@@ -0,0 +1,9 @@
+import baseGet from "./_baseGet.mjs";
+function basePropertyDeep(path) {
+  return function(object) {
+    return baseGet(object, path);
+  };
+}
+export {
+  basePropertyDeep as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseReduce.mjs

@@ -0,0 +1,9 @@
+function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
+  eachFunc(collection, function(value, index, collection2) {
+    accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection2);
+  });
+  return accumulator;
+}
+export {
+  baseReduce as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseRest.mjs

@@ -0,0 +1,9 @@
+import identity from "./identity.mjs";
+import overRest from "./_overRest.mjs";
+import setToString from "./_setToString.mjs";
+function baseRest(func, start) {
+  return setToString(overRest(func, start, identity), func + "");
+}
+export {
+  baseRest as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseSetToString.mjs

@@ -0,0 +1,14 @@
+import constant from "./constant.mjs";
+import defineProperty from "./_defineProperty.mjs";
+import identity from "./identity.mjs";
+var baseSetToString = !defineProperty ? identity : function(func, string) {
+  return defineProperty(func, "toString", {
+    "configurable": true,
+    "enumerable": false,
+    "value": constant(string),
+    "writable": true
+  });
+};
+export {
+  baseSetToString as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseTimes.mjs

@@ -0,0 +1,10 @@
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+export {
+  baseTimes as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseToString.mjs

@@ -0,0 +1,21 @@
+import Symbol$1 from "./_Symbol.mjs";
+import arrayMap from "./_arrayMap.mjs";
+import isArray from "./isArray.mjs";
+import isSymbol from "./isSymbol.mjs";
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray(value)) {
+    return arrayMap(value, baseToString) + "";
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -Infinity ? "-0" : result;
+}
+export {
+  baseToString as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseUnary.mjs

@@ -0,0 +1,8 @@
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+export {
+  baseUnary as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseUniq.mjs

@@ -0,0 +1,46 @@
+import SetCache from "./_SetCache.mjs";
+import arrayIncludes from "./_arrayIncludes.mjs";
+import cacheHas from "./_cacheHas.mjs";
+import createSet from "./_createSet.mjs";
+import setToArray from "./_setToArray.mjs";
+var LARGE_ARRAY_SIZE = 200;
+function baseUniq(array, iteratee, comparator) {
+  var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
+  if (length >= LARGE_ARRAY_SIZE) {
+    var set = iteratee ? null : createSet(array);
+    if (set) {
+      return setToArray(set);
+    }
+    isCommon = false;
+    includes = cacheHas;
+    seen = new SetCache();
+  } else {
+    seen = iteratee ? [] : result;
+  }
+  outer:
+    while (++index < length) {
+      var value = array[index], computed = iteratee ? iteratee(value) : value;
+      value = value !== 0 ? value : 0;
+      if (isCommon && computed === computed) {
+        var seenIndex = seen.length;
+        while (seenIndex--) {
+          if (seen[seenIndex] === computed) {
+            continue outer;
+          }
+        }
+        if (iteratee) {
+          seen.push(computed);
+        }
+        result.push(value);
+      } else if (!includes(seen, computed, comparator)) {
+        if (seen !== result) {
+          seen.push(computed);
+        }
+        result.push(value);
+      }
+    }
+  return result;
+}
+export {
+  baseUniq as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cacheHas.mjs

@@ -0,0 +1,6 @@
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+export {
+  cacheHas as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_castFunction.mjs

@@ -0,0 +1,7 @@
+import identity from "./identity.mjs";
+function castFunction(value) {
+  return typeof value == "function" ? value : identity;
+}
+export {
+  castFunction as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_castPath.mjs

@@ -0,0 +1,13 @@
+import isArray from "./isArray.mjs";
+import isKey from "./_isKey.mjs";
+import stringToPath from "./_stringToPath.mjs";
+import toString from "./toString.mjs";
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+export {
+  castPath as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneArrayBuffer.mjs

@@ -0,0 +1,9 @@
+import Uint8Array from "./_Uint8Array.mjs";
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+  return result;
+}
+export {
+  cloneArrayBuffer as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneBuffer.mjs

@@ -0,0 +1,16 @@
+import root from "./_root.mjs";
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer = moduleExports ? root.Buffer : void 0, allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
+function cloneBuffer(buffer, isDeep) {
+  if (isDeep) {
+    return buffer.slice();
+  }
+  var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+  buffer.copy(result);
+  return result;
+}
+export {
+  cloneBuffer as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneDataView.mjs

@@ -0,0 +1,7 @@
+function cloneDataView(dataView, isDeep) {
+  var buffer = dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+export {
+  cloneDataView as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneRegExp.mjs

@@ -0,0 +1,9 @@
+var reFlags = /\w*$/;
+function cloneRegExp(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+export {
+  cloneRegExp as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneSymbol.mjs

@@ -0,0 +1,8 @@
+import Symbol$1 from "./_Symbol.mjs";
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function cloneSymbol(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+export {
+  cloneSymbol as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_cloneTypedArray.mjs

@@ -0,0 +1,8 @@
+import cloneArrayBuffer from "./_cloneArrayBuffer.mjs";
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+export {
+  cloneTypedArray as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_copyArray.mjs

@@ -0,0 +1,11 @@
+function copyArray(source, array) {
+  var index = -1, length = source.length;
+  array || (array = Array(length));
+  while (++index < length) {
+    array[index] = source[index];
+  }
+  return array;
+}
+export {
+  copyArray as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_copyObject.mjs

@@ -0,0 +1,23 @@
+import assignValue from "./_assignValue.mjs";
+import baseAssignValue from "./_baseAssignValue.mjs";
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+  var index = -1, length = props.length;
+  while (++index < length) {
+    var key = props[index];
+    var newValue = void 0;
+    if (newValue === void 0) {
+      newValue = source[key];
+    }
+    if (isNew) {
+      baseAssignValue(object, key, newValue);
+    } else {
+      assignValue(object, key, newValue);
+    }
+  }
+  return object;
+}
+export {
+  copyObject as default
+};

package/dist/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_copySymbols.mjs

@@ -0,0 +1,8 @@
+import copyObject from "./_copyObject.mjs";
+import getSymbols from "./_getSymbols.mjs";
+function copySymbols(source, object) {
+  return copyObject(source, getSymbols(source), object);
+}
+export {
+  copySymbols as default
+};