@hkyhy/marsun-components-core 0.1.89 → 0.1.99

package/dist/node_modules/es-toolkit/dist/compat/object/mergeWith.js

@@ -0,0 +1,53 @@
+import { isPrimitive as O } from "../../predicate/isPrimitive.js";
+import { clone as K } from "../../object/clone.js";
+import { getSymbols as P } from "../_internal/getSymbols.js";
+import { isBuffer as w } from "../../predicate/isBuffer.js";
+import { isUnsafeProperty as D } from "../../_internal/isUnsafeProperty.js";
+import { isPlainObject as A } from "../predicate/isPlainObject.js";
+import { cloneDeep as j } from "./cloneDeep.js";
+import { isArguments as u } from "../predicate/isArguments.js";
+import { isObjectLike as v } from "../predicate/isObjectLike.js";
+import { isArrayLikeObject as L } from "../predicate/isArrayLikeObject.js";
+import { isTypedArray as d } from "../predicate/isTypedArray.js";
+function z(f, ...o) {
+  const t = o.slice(0, -1), r = o[o.length - 1];
+  let s = f;
+  for (let l = 0; l < t.length; l++) {
+    const n = t[l];
+    s = p(s, n, r, /* @__PURE__ */ new Map());
+  }
+  return s;
+}
+function p(f, o, t, r) {
+  if (O(f) && (f = Object(f)), o == null || typeof o != "object") return f;
+  if (r.has(o)) return K(r.get(o));
+  if (r.set(o, f), Array.isArray(o)) {
+    o = o.slice();
+    for (let l = 0; l < o.length; l++) l in o || (o[l] = void 0);
+  }
+  const s = [...Object.keys(o), ...P(o)];
+  for (let l = 0; l < s.length; l++) {
+    const n = s[l];
+    if (D(n)) continue;
+    let e = o[n], i = f[n];
+    if (u(e) && (e = { ...e }), u(i) && (i = { ...i }), w(e) && (e = j(e)), Array.isArray(e)) if (Array.isArray(i)) {
+      const y = [], m = Reflect.ownKeys(i);
+      for (let c = 0; c < m.length; c++) {
+        const h = m[c];
+        y[h] = i[h];
+      }
+      i = y;
+    } else if (L(i)) {
+      const y = [];
+      for (let m = 0; m < i.length; m++) y[m] = i[m];
+      i = y;
+    } else i = [];
+    const b = t(i, e, n, f, o, r);
+    b !== void 0 ? f[n] = b : Array.isArray(e) || v(i) && v(e) && (A(i) || A(e) || d(i) || d(e)) ? f[n] = p(i, e, t, r) : i == null && A(e) ? f[n] = p({}, e, t, r) : i == null && d(e) ? f[n] = j(e) : (i === void 0 || e !== void 0) && (f[n] = e);
+  }
+  return f;
+}
+export {
+  z as mergeWith
+};
+//# sourceMappingURL=mergeWith.js.map

package/dist/node_modules/es-toolkit/dist/compat/object/mergeWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeWith.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/object/mergeWith.mjs"],"sourcesContent":["import { isPrimitive } from \"../../predicate/isPrimitive.mjs\";\nimport { clone } from \"../../object/clone.mjs\";\nimport { getSymbols } from \"../_internal/getSymbols.mjs\";\nimport { isBuffer } from \"../../predicate/isBuffer.mjs\";\nimport { isUnsafeProperty } from \"../../_internal/isUnsafeProperty.mjs\";\nimport { isPlainObject } from \"../predicate/isPlainObject.mjs\";\nimport { cloneDeep } from \"./cloneDeep.mjs\";\nimport { isArguments } from \"../predicate/isArguments.mjs\";\nimport { isObjectLike } from \"../predicate/isObjectLike.mjs\";\nimport { isArrayLikeObject } from \"../predicate/isArrayLikeObject.mjs\";\nimport { isTypedArray } from \"../predicate/isTypedArray.mjs\";\n//#region src/compat/object/mergeWith.ts\n/**\n* Merges the properties of one or more source objects into the target object using a customizer function.\n*\n* This function performs a deep merge, recursively merging nested objects and arrays.\n* If a property in the source object is an array or object and the corresponding property in the target object is also an array or object, they will be merged.\n* If a property in the source object is `undefined`, it will not overwrite a defined property in the target object.\n*\n* You can provide a custom `merge` function to control how properties are merged. The `merge` function is called for each property that is being merged and receives the following arguments:\n*\n* - `targetValue`: The current value of the property in the target object.\n* - `sourceValue`: The value of the property in the source object.\n* - `key`: The key of the property being merged.\n* - `target`: The target object.\n* - `source`: The source object.\n* - `stack`: A `Map` used to keep track of objects that have already been processed to handle circular references.\n*\n* The `merge` function should return the value to be set in the target object. If it returns `undefined`, a default deep merge will be applied for arrays and objects.\n*\n* The function can handle multiple source objects and will merge them all into the target object.\n*\n* @param object - The target object into which the source object properties will be merged. This object is modified in place.\n* @param otherArgs - Additional source objects to merge into the target object, including the custom `merge` function.\n* @returns The updated target object with properties from the source object(s) merged in.\n*\n* @example\n* const target = { a: 1, b: 2 };\n* const source = { b: 3, c: 4 };\n*\n* mergeWith(target, source, (targetValue, sourceValue) => {\n*   if (typeof targetValue === 'number' && typeof sourceValue === 'number') {\n*     return targetValue + sourceValue;\n*   }\n* });\n* // Returns { a: 1, b: 5, c: 4 }\n* @example\n* const target = { a: [1], b: [2] };\n* const source = { a: [3], b: [4] };\n*\n* const result = mergeWith(target, source, (objValue, srcValue) => {\n*   if (Array.isArray(objValue)) {\n*     return objValue.concat(srcValue);\n*   }\n* });\n*\n* expect(result).toEqual({ a: [1, 3], b: [2, 4] });\n*/\nfunction mergeWith(object, ...otherArgs) {\n\tconst sources = otherArgs.slice(0, -1);\n\tconst merge = otherArgs[otherArgs.length - 1];\n\tlet result = object;\n\tfor (let i = 0; i < sources.length; i++) {\n\t\tconst source = sources[i];\n\t\tresult = mergeWithDeep(result, source, merge, /* @__PURE__ */ new Map());\n\t}\n\treturn result;\n}\nfunction mergeWithDeep(target, source, merge, stack) {\n\tif (isPrimitive(target)) target = Object(target);\n\tif (source == null || typeof source !== \"object\") return target;\n\tif (stack.has(source)) return clone(stack.get(source));\n\tstack.set(source, target);\n\tif (Array.isArray(source)) {\n\t\tsource = source.slice();\n\t\tfor (let i = 0; i < source.length; i++) if (!(i in source)) source[i] = void 0;\n\t}\n\tconst sourceKeys = [...Object.keys(source), ...getSymbols(source)];\n\tfor (let i = 0; i < sourceKeys.length; i++) {\n\t\tconst key = sourceKeys[i];\n\t\tif (isUnsafeProperty(key)) continue;\n\t\tlet sourceValue = source[key];\n\t\tlet targetValue = target[key];\n\t\tif (isArguments(sourceValue)) sourceValue = { ...sourceValue };\n\t\tif (isArguments(targetValue)) targetValue = { ...targetValue };\n\t\tif (isBuffer(sourceValue)) sourceValue = cloneDeep(sourceValue);\n\t\tif (Array.isArray(sourceValue)) if (Array.isArray(targetValue)) {\n\t\t\tconst cloned = [];\n\t\t\tconst targetKeys = Reflect.ownKeys(targetValue);\n\t\t\tfor (let i = 0; i < targetKeys.length; i++) {\n\t\t\t\tconst targetKey = targetKeys[i];\n\t\t\t\tcloned[targetKey] = targetValue[targetKey];\n\t\t\t}\n\t\t\ttargetValue = cloned;\n\t\t} else if (isArrayLikeObject(targetValue)) {\n\t\t\tconst cloned = [];\n\t\t\tfor (let i = 0; i < targetValue.length; i++) cloned[i] = targetValue[i];\n\t\t\ttargetValue = cloned;\n\t\t} else targetValue = [];\n\t\tconst merged = merge(targetValue, sourceValue, key, target, source, stack);\n\t\tif (merged !== void 0) target[key] = merged;\n\t\telse if (Array.isArray(sourceValue)) target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);\n\t\telse if (isObjectLike(targetValue) && isObjectLike(sourceValue) && (isPlainObject(targetValue) || isPlainObject(sourceValue) || isTypedArray(targetValue) || isTypedArray(sourceValue))) target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);\n\t\telse if (targetValue == null && isPlainObject(sourceValue)) target[key] = mergeWithDeep({}, sourceValue, merge, stack);\n\t\telse if (targetValue == null && isTypedArray(sourceValue)) target[key] = cloneDeep(sourceValue);\n\t\telse if (targetValue === void 0 || sourceValue !== void 0) target[key] = sourceValue;\n\t}\n\treturn target;\n}\n//#endregion\nexport { mergeWith };\n"],"names":["mergeWith","object","otherArgs","sources","merge","result","i","source","mergeWithDeep","target","stack","isPrimitive","clone","sourceKeys","getSymbols","key","isUnsafeProperty","sourceValue","targetValue","isArguments","isBuffer","cloneDeep","cloned","targetKeys","targetKey","isArrayLikeObject","merged","isObjectLike","isPlainObject","isTypedArray"],"mappings":";;;;;;;;;;;AA0DA,SAASA,EAAUC,MAAWC,GAAW;AACxC,QAAMC,IAAUD,EAAU,MAAM,GAAG,EAAE,GAC/BE,IAAQF,EAAUA,EAAU,SAAS,CAAC;AAC5C,MAAIG,IAASJ;AACb,WAASK,IAAI,GAAGA,IAAIH,EAAQ,QAAQG,KAAK;AACxC,UAAMC,IAASJ,EAAQG,CAAC;AACxB,IAAAD,IAASG,EAAcH,GAAQE,GAAQH,GAAuB,oBAAI,KAAK;AAAA,EACxE;AACA,SAAOC;AACR;AACA,SAASG,EAAcC,GAAQF,GAAQH,GAAOM,GAAO;AAEpD,MADIC,EAAYF,CAAM,MAAGA,IAAS,OAAOA,CAAM,IAC3CF,KAAU,QAAQ,OAAOA,KAAW,SAAU,QAAOE;AACzD,MAAIC,EAAM,IAAIH,CAAM,EAAG,QAAOK,EAAMF,EAAM,IAAIH,CAAM,CAAC;AAErD,MADAG,EAAM,IAAIH,GAAQE,CAAM,GACpB,MAAM,QAAQF,CAAM,GAAG;AAC1B,IAAAA,IAASA,EAAO,MAAK;AACrB,aAASD,IAAI,GAAGA,IAAIC,EAAO,QAAQD,IAAK,CAAMA,KAAKC,MAASA,EAAOD,CAAC,IAAI;AAAA,EACzE;AACA,QAAMO,IAAa,CAAC,GAAG,OAAO,KAAKN,CAAM,GAAG,GAAGO,EAAWP,CAAM,CAAC;AACjE,WAASD,IAAI,GAAGA,IAAIO,EAAW,QAAQP,KAAK;AAC3C,UAAMS,IAAMF,EAAWP,CAAC;AACxB,QAAIU,EAAiBD,CAAG,EAAG;AAC3B,QAAIE,IAAcV,EAAOQ,CAAG,GACxBG,IAAcT,EAAOM,CAAG;AAI5B,QAHII,EAAYF,CAAW,MAAGA,IAAc,EAAE,GAAGA,EAAW,IACxDE,EAAYD,CAAW,MAAGA,IAAc,EAAE,GAAGA,EAAW,IACxDE,EAASH,CAAW,MAAGA,IAAcI,EAAUJ,CAAW,IAC1D,MAAM,QAAQA,CAAW,EAAG,KAAI,MAAM,QAAQC,CAAW,GAAG;AAC/D,YAAMI,IAAS,CAAA,GACTC,IAAa,QAAQ,QAAQL,CAAW;AAC9C,eAASZ,IAAI,GAAGA,IAAIiB,EAAW,QAAQjB,KAAK;AAC3C,cAAMkB,IAAYD,EAAWjB,CAAC;AAC9B,QAAAgB,EAAOE,CAAS,IAAIN,EAAYM,CAAS;AAAA,MAC1C;AACA,MAAAN,IAAcI;AAAA,IACf,WAAWG,EAAkBP,CAAW,GAAG;AAC1C,YAAMI,IAAS,CAAA;AACf,eAAShB,IAAI,GAAGA,IAAIY,EAAY,QAAQZ,IAAK,CAAAgB,EAAOhB,CAAC,IAAIY,EAAYZ,CAAC;AACtE,MAAAY,IAAcI;AAAA,IACf,MAAO,CAAAJ,IAAc,CAAA;AACrB,UAAMQ,IAAStB,EAAMc,GAAaD,GAAaF,GAAKN,GAAQF,GAAQG,CAAK;AACzE,IAAIgB,MAAW,SAAQjB,EAAOM,CAAG,IAAIW,IAC5B,MAAM,QAAQT,CAAW,KACzBU,EAAaT,CAAW,KAAKS,EAAaV,CAAW,MAAMW,EAAcV,CAAW,KAAKU,EAAcX,CAAW,KAAKY,EAAaX,CAAW,KAAKW,EAAaZ,CAAW,KADhJR,EAAOM,CAAG,IAAIP,EAAcU,GAAaD,GAAab,GAAOM,CAAK,IAE9FQ,KAAe,QAAQU,EAAcX,CAAW,IAAGR,EAAOM,CAAG,IAAIP,EAAc,CAAA,GAAIS,GAAab,GAAOM,CAAK,IAC5GQ,KAAe,QAAQW,EAAaZ,CAAW,IAAGR,EAAOM,CAAG,IAAIM,EAAUJ,CAAW,KACrFC,MAAgB,UAAUD,MAAgB,YAAQR,EAAOM,CAAG,IAAIE;AAAA,EAC1E;AACA,SAAOR;AACR;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/object/property.js

@@ -0,0 +1,10 @@
+import { get as n } from "./get.js";
+function e(r) {
+  return function(t) {
+    return n(t, r);
+  };
+}
+export {
+  e as property
+};
+//# sourceMappingURL=property.js.map

package/dist/node_modules/es-toolkit/dist/compat/object/property.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"property.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/object/property.mjs"],"sourcesContent":["import { get } from \"./get.mjs\";\n//#region src/compat/object/property.ts\n/**\n* Creates a function that returns the value at a given path of an object.\n*\n* @template T - The type of object.\n* @template R - The type of the value to return.\n* @param path - The path of the property to get.\n* @returns Returns a new function that takes an object and returns the value at the specified path.\n*\n* @example\n* const getObjectValue = property('a.b.c');\n* const result = getObjectValue({ a: { b: { c: 3 } } });\n* console.log(result); // => 3\n*\n* @example\n* const getObjectValue = property(['a', 'b', 'c']);\n* const result = getObjectValue({ a: { b: { c: 3 } } });\n* console.log(result); // => 3\n*/\nfunction property(path) {\n\treturn function(object) {\n\t\treturn get(object, path);\n\t};\n}\n//#endregion\nexport { property };\n"],"names":["property","path","object","get"],"mappings":";AAoBA,SAASA,EAASC,GAAM;AACvB,SAAO,SAASC,GAAQ;AACvB,WAAOC,EAAID,GAAQD,CAAI;AAAA,EACxB;AACD;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/object/set.js

@@ -0,0 +1,9 @@
+import { updateWith as e } from "./updateWith.js";
+function n(t, o, r) {
+  return e(t, o, () => r, () => {
+  });
+}
+export {
+  n as set
+};
+//# sourceMappingURL=set.js.map

package/dist/node_modules/es-toolkit/dist/compat/object/set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/object/set.mjs"],"sourcesContent":["import { updateWith } from \"./updateWith.mjs\";\n//#region src/compat/object/set.ts\n/**\n* Sets the value at the specified path of the given object. If any part of the path does not exist, it will be created.\n*\n* @template T - The type of the object.\n* @param obj - The object to modify.\n* @param path - The path of the property to set.\n* @param value - The value to set.\n* @returns The modified object.\n*\n* @example\n* // Set a value in a nested object\n* const obj = { a: { b: { c: 3 } } };\n* set(obj, 'a.b.c', 4);\n* console.log(obj.a.b.c); // 4\n*\n* @example\n* // Set a value in an array\n* const arr = [1, 2, 3];\n* set(arr, 1, 4);\n* console.log(arr[1]); // 4\n*\n* @example\n* // Create non-existent path and set value\n* const obj = {};\n* set(obj, 'a.b.c', 4);\n* console.log(obj); // { a: { b: { c: 4 } } }\n*/\nfunction set(obj, path, value) {\n\treturn updateWith(obj, path, () => value, () => void 0);\n}\n//#endregion\nexport { set };\n"],"names":["set","obj","path","value","updateWith"],"mappings":";AA6BA,SAASA,EAAIC,GAAKC,GAAMC,GAAO;AAC9B,SAAOC,EAAWH,GAAKC,GAAM,MAAMC,GAAO,MAAA;AAAA,GAAY;AACvD;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/object/updateWith.js

@@ -0,0 +1,31 @@
+import { toKey as y } from "../_internal/toKey.js";
+import { toPath as d } from "../util/toPath.js";
+import { get as c } from "./get.js";
+import { isObject as u } from "../predicate/isObject.js";
+import { isIndex as g } from "../_internal/isIndex.js";
+import { isKey as V } from "../_internal/isKey.js";
+import { assignValue as P } from "../_internal/assignValue.js";
+import { isUnsafeToWriteProperty as v } from "../../_internal/isUnsafeToWriteProperty.js";
+function O(e, t, a, n) {
+  if (e == null && !u(e)) return e;
+  let r;
+  V(t, e) ? r = [t] : Array.isArray(t) ? r = t : r = d(t);
+  const p = a(c(e, r));
+  let i = e;
+  for (let l = 0; l < r.length && i != null; l++) {
+    const o = y(r[l]);
+    if (v(o)) return e;
+    let f;
+    if (l === r.length - 1) f = p;
+    else {
+      const s = i[o], m = n == null ? void 0 : n(s, o, e);
+      f = m !== void 0 ? m : u(s) ? s : g(r[l + 1]) ? [] : {};
+    }
+    P(i, o, f), i = i[o];
+  }
+  return e;
+}
+export {
+  O as updateWith
+};
+//# sourceMappingURL=updateWith.js.map

package/dist/node_modules/es-toolkit/dist/compat/object/updateWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateWith.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/object/updateWith.mjs"],"sourcesContent":["import { toKey } from \"../_internal/toKey.mjs\";\nimport { toPath } from \"../util/toPath.mjs\";\nimport { get } from \"./get.mjs\";\nimport { isObject } from \"../predicate/isObject.mjs\";\nimport { isIndex } from \"../_internal/isIndex.mjs\";\nimport { isKey } from \"../_internal/isKey.mjs\";\nimport { assignValue } from \"../_internal/assignValue.mjs\";\nimport { isUnsafeToWriteProperty } from \"../../_internal/isUnsafeToWriteProperty.mjs\";\n//#region src/compat/object/updateWith.ts\n/**\n* Updates the value at the specified path of the given object using an updater function and a customizer.\n* If any part of the path does not exist, it will be created.\n*\n* @template T - The type of the object.\n* @template R - The type of the return value.\n* @param obj - The object to modify.\n* @param path - The path of the property to update.\n* @param updater - The function to produce the updated value.\n* @param customizer - The function to customize the update process.\n* @returns The modified object.\n*\n* @example\n* const object = { 'a': [{ 'b': { 'c': 3 } }] };\n* updateWith(object, 'a[0].b.c', (n) => n * n);\n* // => { 'a': [{ 'b': { 'c': 9 } }] }\n*/\nfunction updateWith(obj, path, updater, customizer) {\n\tif (obj == null && !isObject(obj)) return obj;\n\tlet resolvedPath;\n\tif (isKey(path, obj)) resolvedPath = [path];\n\telse if (Array.isArray(path)) resolvedPath = path;\n\telse resolvedPath = toPath(path);\n\tconst updateValue = updater(get(obj, resolvedPath));\n\tlet current = obj;\n\tfor (let i = 0; i < resolvedPath.length && current != null; i++) {\n\t\tconst key = toKey(resolvedPath[i]);\n\t\tif (isUnsafeToWriteProperty(key)) return obj;\n\t\tlet newValue;\n\t\tif (i === resolvedPath.length - 1) newValue = updateValue;\n\t\telse {\n\t\t\tconst objValue = current[key];\n\t\t\tconst customizerResult = customizer?.(objValue, key, obj);\n\t\t\tnewValue = customizerResult !== void 0 ? customizerResult : isObject(objValue) ? objValue : isIndex(resolvedPath[i + 1]) ? [] : {};\n\t\t}\n\t\tassignValue(current, key, newValue);\n\t\tcurrent = current[key];\n\t}\n\treturn obj;\n}\n//#endregion\nexport { updateWith };\n"],"names":["updateWith","obj","path","updater","customizer","isObject","resolvedPath","isKey","toPath","updateValue","get","current","i","key","toKey","isUnsafeToWriteProperty","newValue","objValue","customizerResult","isIndex","assignValue"],"mappings":";;;;;;;;AA0BA,SAASA,EAAWC,GAAKC,GAAMC,GAASC,GAAY;AACnD,MAAIH,KAAO,QAAQ,CAACI,EAASJ,CAAG,EAAG,QAAOA;AAC1C,MAAIK;AACJ,EAAIC,EAAML,GAAMD,CAAG,IAAGK,IAAe,CAACJ,CAAI,IACjC,MAAM,QAAQA,CAAI,IAAGI,IAAeJ,IACxCI,IAAeE,EAAON,CAAI;AAC/B,QAAMO,IAAcN,EAAQO,EAAIT,GAAKK,CAAY,CAAC;AAClD,MAAIK,IAAUV;AACd,WAASW,IAAI,GAAGA,IAAIN,EAAa,UAAUK,KAAW,MAAMC,KAAK;AAChE,UAAMC,IAAMC,EAAMR,EAAaM,CAAC,CAAC;AACjC,QAAIG,EAAwBF,CAAG,EAAG,QAAOZ;AACzC,QAAIe;AACJ,QAAIJ,MAAMN,EAAa,SAAS,EAAG,CAAAU,IAAWP;AAAA,SACzC;AACJ,YAAMQ,IAAWN,EAAQE,CAAG,GACtBK,IAAmBd,KAAA,gBAAAA,EAAaa,GAAUJ,GAAKZ;AACrD,MAAAe,IAAWE,MAAqB,SAASA,IAAmBb,EAASY,CAAQ,IAAIA,IAAWE,EAAQb,EAAaM,IAAI,CAAC,CAAC,IAAI,CAAA,IAAK,CAAA;AAAA,IACjI;AACA,IAAAQ,EAAYT,GAASE,GAAKG,CAAQ,GAClCL,IAAUA,EAAQE,CAAG;AAAA,EACtB;AACA,SAAOZ;AACR;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isArguments.js

@@ -0,0 +1,8 @@
+import { getTag as o } from "../_internal/getTag.js";
+function e(t) {
+  return t !== null && typeof t == "object" && o(t) === "[object Arguments]";
+}
+export {
+  e as isArguments
+};
+//# sourceMappingURL=isArguments.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isArguments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isArguments.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isArguments.mjs"],"sourcesContent":["import { getTag } from \"../_internal/getTag.mjs\";\n//#region src/compat/predicate/isArguments.ts\n/**\n* Checks if the given value is an arguments object.\n*\n* This function tests whether the provided value is an arguments object or not.\n* It returns `true` if the value is an arguments object, and `false` otherwise.\n*\n* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an arguments object.\n*\n* @param value - The value to test if it is an arguments object.\n* @returns `true` if the value is an arguments, `false` otherwise.\n*\n* @example\n* const args = (function() { return arguments; })();\n* const strictArgs = (function() { 'use strict'; return arguments; })();\n* const value = [1, 2, 3];\n*\n* console.log(isArguments(args)); // true\n* console.log(isArguments(strictArgs)); // true\n* console.log(isArguments(value)); // false\n*/\nfunction isArguments(value) {\n\treturn value !== null && typeof value === \"object\" && getTag(value) === \"[object Arguments]\";\n}\n//#endregion\nexport { isArguments };\n"],"names":["isArguments","value","getTag"],"mappings":";AAsBA,SAASA,EAAYC,GAAO;AAC3B,SAAOA,MAAU,QAAQ,OAAOA,KAAU,YAAYC,EAAOD,CAAK,MAAM;AACzE;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isArray.js

@@ -0,0 +1,7 @@
+function a(r) {
+  return Array.isArray(r);
+}
+export {
+  a as isArray
+};
+//# sourceMappingURL=isArray.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isArray.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isArray.mjs"],"sourcesContent":["//#region src/compat/predicate/isArray.ts\n/**\n* Checks if the given value is an array.\n*\n* This function tests whether the provided value is an array or not.\n* It returns `true` if the value is an array, and `false` otherwise.\n*\n* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an array.\n*\n* @param value - The value to test if it is an array.\n* @returns `true` if the value is an array, `false` otherwise.\n*\n* @example\n* const value1 = [1, 2, 3];\n* const value2 = 'abc';\n* const value3 = () => {};\n*\n* console.log(isArray(value1)); // true\n* console.log(isArray(value2)); // false\n* console.log(isArray(value3)); // false\n*/\nfunction isArray(value) {\n\treturn Array.isArray(value);\n}\n//#endregion\nexport { isArray };\n"],"names":["isArray","value"],"mappings":"AAqBA,SAASA,EAAQC,GAAO;AACvB,SAAO,MAAM,QAAQA,CAAK;AAC3B;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.js

@@ -0,0 +1,8 @@
+import { isLength as t } from "../../predicate/isLength.js";
+function i(n) {
+  return n != null && typeof n != "function" && t(n.length);
+}
+export {
+  i as isArrayLike
+};
+//# sourceMappingURL=isArrayLike.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isArrayLike.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isArrayLike.mjs"],"sourcesContent":["import { isLength } from \"../../predicate/isLength.mjs\";\n//#region src/compat/predicate/isArrayLike.ts\n/**\n* Checks if `value` is array-like.\n*\n* @param value The value to check.\n* @returns Returns `true` if `value` is array-like, else `false`.\n*\n* @example\n* isArrayLike([1, 2, 3]); // true\n* isArrayLike('abc'); // true\n* isArrayLike({ 0: 'a', length: 1 }); // true\n* isArrayLike({}); // false\n* isArrayLike(null); // false\n* isArrayLike(undefined); // false\n*/\nfunction isArrayLike(value) {\n\treturn value != null && typeof value !== \"function\" && isLength(value.length);\n}\n//#endregion\nexport { isArrayLike };\n"],"names":["isArrayLike","value","isLength"],"mappings":";AAgBA,SAASA,EAAYC,GAAO;AAC3B,SAAOA,KAAS,QAAQ,OAAOA,KAAU,cAAcC,EAASD,EAAM,MAAM;AAC7E;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.js

@@ -0,0 +1,9 @@
+import { isArrayLike as i } from "./isArrayLike.js";
+import { isObjectLike as t } from "./isObjectLike.js";
+function m(r) {
+  return t(r) && i(r);
+}
+export {
+  m as isArrayLikeObject
+};
+//# sourceMappingURL=isArrayLikeObject.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isArrayLikeObject.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isArrayLikeObject.mjs"],"sourcesContent":["import { isArrayLike } from \"./isArrayLike.mjs\";\nimport { isObjectLike } from \"./isObjectLike.mjs\";\n//#region src/compat/predicate/isArrayLikeObject.ts\n/**\n* Checks if the given value is a non-primitive, array-like object.\n*\n* @param value The value to check.\n* @returns `true` if the value is a non-primitive, array-like object, `false` otherwise.\n*\n* @example\n* isArrayLikeObject([1, 2, 3]); // true\n* isArrayLikeObject({ 0: 'a', length: 1 }); // true\n* isArrayLikeObject('abc'); // false\n* isArrayLikeObject(()=>{}); // false\n*/\nfunction isArrayLikeObject(value) {\n\treturn isObjectLike(value) && isArrayLike(value);\n}\n//#endregion\nexport { isArrayLikeObject };\n"],"names":["isArrayLikeObject","value","isObjectLike","isArrayLike"],"mappings":";;AAeA,SAASA,EAAkBC,GAAO;AACjC,SAAOC,EAAaD,CAAK,KAAKE,EAAYF,CAAK;AAChD;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isElement.js

@@ -0,0 +1,9 @@
+import { isPlainObject as t } from "./isPlainObject.js";
+import { isObjectLike as e } from "./isObjectLike.js";
+function n(i) {
+  return e(i) && i.nodeType === 1 && !t(i);
+}
+export {
+  n as isElement
+};
+//# sourceMappingURL=isElement.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isElement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isElement.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isElement.mjs"],"sourcesContent":["import { isPlainObject } from \"./isPlainObject.mjs\";\nimport { isObjectLike } from \"./isObjectLike.mjs\";\n//#region src/compat/predicate/isElement.ts\n/**\n* Checks if `value` is likely a DOM element.\n*\n* @param value The value to check.\n* @returns Returns `true` if `value` is a DOM element, else `false`.\n*\n* @example\n* console.log(isElement(document.body)); // true\n* console.log(isElement('<body>')); // false\n*/\nfunction isElement(value) {\n\treturn isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n}\n//#endregion\nexport { isElement };\n"],"names":["isElement","value","isObjectLike","isPlainObject"],"mappings":";;AAaA,SAASA,EAAUC,GAAO;AACzB,SAAOC,EAAaD,CAAK,KAAKA,EAAM,aAAa,KAAK,CAACE,EAAcF,CAAK;AAC3E;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.js

@@ -0,0 +1,15 @@
+import { after as f } from "../../function/after.js";
+import { isEqualWith as c } from "../../predicate/isEqualWith.js";
+function n(r, t, o) {
+  return typeof o != "function" && (o = () => {
+  }), c(r, t, (...m) => {
+    const i = o(...m);
+    if (i !== void 0) return !!i;
+    if (r instanceof Map && t instanceof Map) return n(Array.from(r), Array.from(t), f(2, o));
+    if (r instanceof Set && t instanceof Set) return n(Array.from(r), Array.from(t), f(2, o));
+  });
+}
+export {
+  n as isEqualWith
+};
+//# sourceMappingURL=isEqualWith.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isEqualWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEqualWith.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isEqualWith.mjs"],"sourcesContent":["import { after } from \"../../function/after.mjs\";\nimport { isEqualWith as isEqualWith$1 } from \"../../predicate/isEqualWith.mjs\";\n//#region src/compat/predicate/isEqualWith.ts\n/**\n* Compares two values for equality using a custom comparison function.\n*\n* The custom function allows for fine-tuned control over the comparison process. If it returns a boolean, that result determines the equality. If it returns undefined, the function falls back to the default equality comparison.\n*\n* This function also uses the custom equality function to compare values inside objects,\n* arrays, maps, sets, and other complex structures, ensuring a deep comparison.\n*\n* This approach provides flexibility in handling complex comparisons while maintaining efficient default behavior for simpler cases.\n*\n* The custom comparison function can take up to six parameters:\n* - `x`: The value from the first object `a`.\n* - `y`: The value from the second object `b`.\n* - `property`: The property key used to get `x` and `y`.\n* - `xParent`: The parent of the first value `x`.\n* - `yParent`: The parent of the second value `y`.\n* - `stack`: An internal stack (Map) to handle circular references.\n*\n* @param a - The first value to compare.\n* @param b - The second value to compare.\n* @param [areValuesEqual=noop] - A function to customize the comparison.\n*   If it returns a boolean, that result will be used. If it returns undefined,\n*   the default equality comparison will be used.\n* @returns `true` if the values are equal according to the customizer, otherwise `false`.\n*\n* @example\n* const customizer = (a, b) => {\n*   if (typeof a === 'string' && typeof b === 'string') {\n*     return a.toLowerCase() === b.toLowerCase();\n*   }\n* };\n* isEqualWith('Hello', 'hello', customizer); // true\n* isEqualWith({ a: 'Hello' }, { a: 'hello' }, customizer); // true\n* isEqualWith([1, 2, 3], [1, 2, 3], customizer); // true\n*/\nfunction isEqualWith(a, b, areValuesEqual) {\n\tif (typeof areValuesEqual !== \"function\") areValuesEqual = () => void 0;\n\treturn isEqualWith$1(a, b, (...args) => {\n\t\tconst result = areValuesEqual(...args);\n\t\tif (result !== void 0) return Boolean(result);\n\t\tif (a instanceof Map && b instanceof Map) return isEqualWith(Array.from(a), Array.from(b), after(2, areValuesEqual));\n\t\tif (a instanceof Set && b instanceof Set) return isEqualWith(Array.from(a), Array.from(b), after(2, areValuesEqual));\n\t});\n}\n//#endregion\nexport { isEqualWith };\n"],"names":["isEqualWith","a","b","areValuesEqual","isEqualWith$1","args","result","after"],"mappings":";;AAsCA,SAASA,EAAYC,GAAGC,GAAGC,GAAgB;AAC1C,SAAI,OAAOA,KAAmB,eAAYA,IAAiB,MAAA;AAAA,MACpDC,EAAcH,GAAGC,GAAG,IAAIG,MAAS;AACvC,UAAMC,IAASH,EAAe,GAAGE,CAAI;AACrC,QAAIC,MAAW,OAAQ,QAAO,EAAQA;AACtC,QAAIL,aAAa,OAAOC,aAAa,IAAK,QAAOF,EAAY,MAAM,KAAKC,CAAC,GAAG,MAAM,KAAKC,CAAC,GAAGK,EAAM,GAAGJ,CAAc,CAAC;AACnH,QAAIF,aAAa,OAAOC,aAAa,IAAK,QAAOF,EAAY,MAAM,KAAKC,CAAC,GAAG,MAAM,KAAKC,CAAC,GAAGK,EAAM,GAAGJ,CAAc,CAAC;AAAA,EACpH,CAAC;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isFunction.js

@@ -0,0 +1,7 @@
+function t(n) {
+  return typeof n == "function";
+}
+export {
+  t as isFunction
+};
+//# sourceMappingURL=isFunction.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isFunction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFunction.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isFunction.mjs"],"sourcesContent":["//#region src/compat/predicate/isFunction.ts\n/**\n* Checks if `value` is a function.\n*\n* @param value The value to check.\n* @returns Returns `true` if `value` is a function, else `false`.\n*\n* @example\n* isFunction(Array.prototype.slice); // true\n* isFunction(async function () {}); // true\n* isFunction(function* () {}); // true\n* isFunction(Proxy); // true\n* isFunction(Int8Array); // true\n*/\nfunction isFunction(value) {\n\treturn typeof value === \"function\";\n}\n//#endregion\nexport { isFunction };\n"],"names":["isFunction","value"],"mappings":"AAcA,SAASA,EAAWC,GAAO;AAC1B,SAAO,OAAOA,KAAU;AACzB;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isMatch.js

@@ -0,0 +1,9 @@
+import { isMatchWith as o } from "./isMatchWith.js";
+function c(t, i) {
+  return o(t, i, () => {
+  });
+}
+export {
+  c as isMatch
+};
+//# sourceMappingURL=isMatch.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isMatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isMatch.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isMatch.mjs"],"sourcesContent":["import { isMatchWith } from \"./isMatchWith.mjs\";\n//#region src/compat/predicate/isMatch.ts\n/**\n* Checks if the target matches the source by comparing their structures and values.\n* This function supports deep comparison for objects, arrays, maps, and sets.\n*\n* @param target - The target value to match against.\n* @param source - The source value to match with.\n* @returns Returns `true` if the target matches the source, otherwise `false`.\n*\n* @example\n* // Basic usage\n* isMatch({ a: 1, b: 2 }, { a: 1 }); // true\n*\n* @example\n* // Matching arrays\n* isMatch([1, 2, 3], [1, 2, 3]); // true\n*\n* @example\n* // Matching maps\n* const targetMap = new Map([['key1', 'value1'], ['key2', 'value2']]);\n* const sourceMap = new Map([['key1', 'value1']]);\n* isMatch(targetMap, sourceMap); // true\n*\n* @example\n* // Matching sets\n* const targetSet = new Set([1, 2, 3]);\n* const sourceSet = new Set([1, 2]);\n* isMatch(targetSet, sourceSet); // true\n*/\nfunction isMatch(target, source) {\n\treturn isMatchWith(target, source, () => void 0);\n}\n//#endregion\nexport { isMatch };\n"],"names":["isMatch","target","source","isMatchWith"],"mappings":";AA8BA,SAASA,EAAQC,GAAQC,GAAQ;AAChC,SAAOC,EAAYF,GAAQC,GAAQ,MAAA;AAAA,GAAY;AAChD;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.js

@@ -0,0 +1,81 @@
+import { isPrimitive as j } from "../../predicate/isPrimitive.js";
+import { getTag as m } from "../_internal/getTag.js";
+import { eq as M } from "../util/eq.js";
+import { isObject as p } from "./isObject.js";
+function A(f, n, e) {
+  return typeof e != "function" ? A(f, n, () => {
+  }) : o(f, n, function i(t, r, u, l, h, d) {
+    const y = e(t, r, u, l, h, d);
+    return y !== void 0 ? !!y : o(t, r, i, d, !1);
+  }, /* @__PURE__ */ new Map(), !0);
+}
+function o(f, n, e, i, t = !1) {
+  if (n === f) return !0;
+  switch (typeof n) {
+    case "object":
+      return O(f, n, e, i, t);
+    case "function":
+      return Object.keys(n).length > 0 ? o(f, { ...n }, e, i, t) : M(f, n);
+    default:
+      return p(f) ? t ? typeof n == "string" ? n === "" : !0 : M(f, n) : M(f, n);
+  }
+}
+function O(f, n, e, i, t = !1) {
+  if (n == null) return !0;
+  if (Array.isArray(n)) return b(f, n, e, i);
+  if (n instanceof Map) return v(f, n, e, i);
+  if (n instanceof Set) return I(f, n, e, i);
+  const r = Object.keys(n);
+  if (f == null) return t && r.length === 0;
+  if (t)
+    j(f) && (f = Object(f));
+  else {
+    const u = m(f);
+    if (u !== "[object Object]" && u !== "[object Arguments]") return !1;
+  }
+  if (r.length === 0) return !0;
+  if (i != null && i.has(n)) return i.get(n) === f;
+  i == null || i.set(n, f);
+  try {
+    for (let u = 0; u < r.length; u++) {
+      const l = r[u];
+      if (!(l in f) || n[l] === void 0 && f[l] !== void 0 || n[l] === null && f[l] !== null || !e(f[l], n[l], l, f, n, i)) return !1;
+    }
+    return !0;
+  } finally {
+    i == null || i.delete(n);
+  }
+}
+function v(f, n, e, i) {
+  if (n.size === 0) return !0;
+  if (!(f instanceof Map)) return !1;
+  for (const [t, r] of n.entries()) if (e(f.get(t), r, t, f, n, i) === !1) return !1;
+  return !0;
+}
+function b(f, n, e, i) {
+  if (n.length === 0) return !0;
+  if (!Array.isArray(f)) return !1;
+  const t = /* @__PURE__ */ new Set();
+  for (let r = 0; r < n.length; r++) {
+    const u = n[r];
+    let l = !1;
+    for (let h = 0; h < f.length; h++) {
+      if (t.has(h)) continue;
+      const d = f[h];
+      let y = !1;
+      if (e(d, u, r, f, n, i) && (y = !0), y) {
+        t.add(h), l = !0;
+        break;
+      }
+    }
+    if (!l) return !1;
+  }
+  return !0;
+}
+function I(f, n, e, i) {
+  return n.size === 0 ? !0 : f instanceof Set ? b([...f], [...n], e, i) : !1;
+}
+export {
+  A as isMatchWith
+};
+//# sourceMappingURL=isMatchWith.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isMatchWith.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isMatchWith.mjs"],"sourcesContent":["import { isPrimitive } from \"../../predicate/isPrimitive.mjs\";\nimport { getTag } from \"../_internal/getTag.mjs\";\nimport \"../_internal/tags.mjs\";\nimport { eq } from \"../util/eq.mjs\";\nimport { isObject } from \"./isObject.mjs\";\n//#region src/compat/predicate/isMatchWith.ts\n/**\n* Performs a deep comparison between a target value and a source pattern to determine if they match,\n* using a custom comparison function for fine-grained control over the matching logic.\n*\n* This function recursively traverses both values, calling the custom compare function for each\n* property/element pair. If the compare function returns a boolean, that result is used directly.\n* If it returns undefined, the default matching behavior continues recursively.\n*\n* The matching behavior varies by data type:\n* - **Objects**: Matches if all properties in the source exist in the target and match\n* - **Arrays**: Matches if all elements in the source array can be found in the target array (order-independent)\n* - **Maps**: Matches if all key-value pairs in the source Map exist and match in the target Map\n* - **Sets**: Matches if all elements in the source Set can be found in the target Set\n* - **Functions**: Matches using strict equality, or object comparison if the function has properties\n* - **Primitives**: Matches using strict equality\n*\n* Special cases:\n* - Empty arrays, Maps, and Sets always match any target\n* - An empty object matches any target at the top level, but at nested levels it only matches object targets\n* - `null` and `undefined` source values have specific matching rules\n* - Circular references are handled using an internal stack to prevent infinite recursion\n*\n* @param target - The value to be tested for matching\n* @param source - The pattern/template to match against\n* @param [compare] - Optional custom comparison function that receives:\n*   - `objValue` - The value from the target at the current path\n*   - `srcValue` - The value from the source at the current path\n*   - `key` - The property key or array index being compared\n*   - `object` - The parent object/array from the target\n*   - `source` - The parent object/array from the source\n*   - `stack` - Internal Map used for circular reference detection\n*   Should return `true` for a match, `false` for no match, or `undefined` to continue with default behavior\n*\n* @returns `true` if the target matches the source pattern, `false` otherwise\n*\n* @example\n* // Basic matching without custom comparator\n* isMatchWith({ a: 1, b: 2 }, { a: 1 }); // true\n* isMatchWith([1, 2, 3], [1, 3]); // true\n*\n* @example\n* // Custom comparison for case-insensitive string matching\n* const caseInsensitiveCompare = (objVal, srcVal) => {\n*   if (typeof objVal === 'string' && typeof srcVal === 'string') {\n*     return objVal.toLowerCase() === srcVal.toLowerCase();\n*   }\n*   return undefined; // Use default behavior for non-strings\n* };\n*\n* isMatchWith(\n*   { name: 'JOHN', age: 30 },\n*   { name: 'john' },\n*   caseInsensitiveCompare\n* ); // true\n*\n* @example\n* // Custom comparison for range matching\n* const rangeCompare = (objVal, srcVal, key) => {\n*   if (key === 'age' && typeof srcVal === 'object' && srcVal.min !== undefined) {\n*     return objVal >= srcVal.min && objVal <= srcVal.max;\n*   }\n*   return undefined;\n* };\n*\n* isMatchWith(\n*   { name: 'John', age: 25 },\n*   { age: { min: 18, max: 30 } },\n*   rangeCompare\n* ); // true\n*/\nfunction isMatchWith(target, source, compare) {\n\tif (typeof compare !== \"function\") return isMatchWith(target, source, () => void 0);\n\treturn isMatchWithInternal(target, source, function doesMatch(objValue, srcValue, key, object, source, stack) {\n\t\tconst isEqual = compare(objValue, srcValue, key, object, source, stack);\n\t\tif (isEqual !== void 0) return Boolean(isEqual);\n\t\treturn isMatchWithInternal(objValue, srcValue, doesMatch, stack, false);\n\t}, /* @__PURE__ */ new Map(), true);\n}\nfunction isMatchWithInternal(target, source, compare, stack, isRoot = false) {\n\tif (source === target) return true;\n\tswitch (typeof source) {\n\t\tcase \"object\": return isObjectMatch(target, source, compare, stack, isRoot);\n\t\tcase \"function\":\n\t\t\tif (Object.keys(source).length > 0) return isMatchWithInternal(target, { ...source }, compare, stack, isRoot);\n\t\t\treturn eq(target, source);\n\t\tdefault:\n\t\t\tif (!isObject(target)) return eq(target, source);\n\t\t\tif (isRoot) {\n\t\t\t\tif (typeof source === \"string\") return source === \"\";\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn eq(target, source);\n\t}\n}\nfunction isObjectMatch(target, source, compare, stack, isRoot = false) {\n\tif (source == null) return true;\n\tif (Array.isArray(source)) return isArrayMatch(target, source, compare, stack);\n\tif (source instanceof Map) return isMapMatch(target, source, compare, stack);\n\tif (source instanceof Set) return isSetMatch(target, source, compare, stack);\n\tconst keys = Object.keys(source);\n\tif (target == null) return isRoot && keys.length === 0;\n\tif (isRoot) {\n\t\tif (isPrimitive(target)) target = Object(target);\n\t} else {\n\t\tconst tag = getTag(target);\n\t\tif (tag !== \"[object Object]\" && tag !== \"[object Arguments]\") return false;\n\t}\n\tif (keys.length === 0) return true;\n\tif (stack?.has(source)) return stack.get(source) === target;\n\tstack?.set(source, target);\n\ttry {\n\t\tfor (let i = 0; i < keys.length; i++) {\n\t\t\tconst key = keys[i];\n\t\t\tif (!(key in target)) return false;\n\t\t\tif (source[key] === void 0 && target[key] !== void 0) return false;\n\t\t\tif (source[key] === null && target[key] !== null) return false;\n\t\t\tif (!compare(target[key], source[key], key, target, source, stack)) return false;\n\t\t}\n\t\treturn true;\n\t} finally {\n\t\tstack?.delete(source);\n\t}\n}\nfunction isMapMatch(target, source, compare, stack) {\n\tif (source.size === 0) return true;\n\tif (!(target instanceof Map)) return false;\n\tfor (const [key, sourceValue] of source.entries()) if (compare(target.get(key), sourceValue, key, target, source, stack) === false) return false;\n\treturn true;\n}\nfunction isArrayMatch(target, source, compare, stack) {\n\tif (source.length === 0) return true;\n\tif (!Array.isArray(target)) return false;\n\tconst countedIndex = /* @__PURE__ */ new Set();\n\tfor (let i = 0; i < source.length; i++) {\n\t\tconst sourceItem = source[i];\n\t\tlet found = false;\n\t\tfor (let j = 0; j < target.length; j++) {\n\t\t\tif (countedIndex.has(j)) continue;\n\t\t\tconst targetItem = target[j];\n\t\t\tlet matches = false;\n\t\t\tif (compare(targetItem, sourceItem, i, target, source, stack)) matches = true;\n\t\t\tif (matches) {\n\t\t\t\tcountedIndex.add(j);\n\t\t\t\tfound = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif (!found) return false;\n\t}\n\treturn true;\n}\nfunction isSetMatch(target, source, compare, stack) {\n\tif (source.size === 0) return true;\n\tif (!(target instanceof Set)) return false;\n\treturn isArrayMatch([...target], [...source], compare, stack);\n}\n//#endregion\nexport { isMatchWith };\n"],"names":["isMatchWith","target","source","compare","isMatchWithInternal","doesMatch","objValue","srcValue","key","object","stack","isEqual","isRoot","isObjectMatch","eq","isObject","isArrayMatch","isMapMatch","isSetMatch","keys","isPrimitive","tag","getTag","i","sourceValue","countedIndex","sourceItem","found","j","targetItem","matches"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isObject.js

@@ -0,0 +1,7 @@
+function n(t) {
+  return t !== null && (typeof t == "object" || typeof t == "function");
+}
+export {
+  n as isObject
+};
+//# sourceMappingURL=isObject.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObject.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isObject.mjs"],"sourcesContent":["//#region src/compat/predicate/isObject.ts\n/**\n* Checks if the given value is an object. An object is a value that is\n* not a primitive type (string, number, boolean, symbol, null, or undefined).\n*\n* This function tests whether the provided value is an object or not.\n* It returns `true` if the value is an object, and `false` otherwise.\n*\n* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object value.\n*\n* @param value - The value to check if it is an object.\n* @returns `true` if the value is an object, `false` otherwise.\n*\n* @example\n* const value1 = {};\n* const value2 = [1, 2, 3];\n* const value3 = () => {};\n* const value4 = null;\n*\n* console.log(isObject(value1)); // true\n* console.log(isObject(value2)); // true\n* console.log(isObject(value3)); // true\n* console.log(isObject(value4)); // false\n*/\nfunction isObject(value) {\n\treturn value !== null && (typeof value === \"object\" || typeof value === \"function\");\n}\n//#endregion\nexport { isObject };\n"],"names":["isObject","value"],"mappings":"AAwBA,SAASA,EAASC,GAAO;AACxB,SAAOA,MAAU,SAAS,OAAOA,KAAU,YAAY,OAAOA,KAAU;AACzE;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.js

@@ -0,0 +1,7 @@
+function e(t) {
+  return typeof t == "object" && t !== null;
+}
+export {
+  e as isObjectLike
+};
+//# sourceMappingURL=isObjectLike.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isObjectLike.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isObjectLike.mjs"],"sourcesContent":["//#region src/compat/predicate/isObjectLike.ts\n/**\n* Checks if the given value is object-like.\n*\n* A value is object-like if its type is object and it is not null.\n*\n* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object-like value.\n*\n* @param value - The value to test if it is an object-like.\n* @returns `true` if the value is an object-like, `false` otherwise.\n*\n* @example\n* const value1 = { a: 1 };\n* const value2 = [1, 2, 3];\n* const value3 = 'abc';\n* const value4 = () => {};\n* const value5 = null;\n*\n* console.log(isObjectLike(value1)); // true\n* console.log(isObjectLike(value2)); // true\n* console.log(isObjectLike(value3)); // false\n* console.log(isObjectLike(value4)); // false\n* console.log(isObjectLike(value5)); // false\n*/\nfunction isObjectLike(value) {\n\treturn typeof value === \"object\" && value !== null;\n}\n//#endregion\nexport { isObjectLike };\n"],"names":["isObjectLike","value"],"mappings":"AAwBA,SAASA,EAAaC,GAAO;AAC5B,SAAO,OAAOA,KAAU,YAAYA,MAAU;AAC/C;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.js

@@ -0,0 +1,16 @@
+function n(t) {
+  var r;
+  if (typeof t != "object" || t == null) return !1;
+  if (Object.getPrototypeOf(t) === null) return !0;
+  if (Object.prototype.toString.call(t) !== "[object Object]") {
+    const l = t[Symbol.toStringTag];
+    return l == null || !((r = Object.getOwnPropertyDescriptor(t, Symbol.toStringTag)) != null && r.writable) ? !1 : t.toString() === `[object ${l}]`;
+  }
+  let e = t;
+  for (; Object.getPrototypeOf(e) !== null; ) e = Object.getPrototypeOf(e);
+  return Object.getPrototypeOf(t) === e;
+}
+export {
+  n as isPlainObject
+};
+//# sourceMappingURL=isPlainObject.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlainObject.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isPlainObject.mjs"],"sourcesContent":["//#region src/compat/predicate/isPlainObject.ts\n/**\n* Checks if a given value is a plain object.\n*\n* A plain object is an object created by the `{}` literal, `new Object()`, or\n* `Object.create(null)`.\n*\n* This function also handles objects with custom\n* `Symbol.toStringTag` properties.\n*\n* `Symbol.toStringTag` is a built-in symbol that a constructor can use to customize the\n* default string description of objects.\n*\n* @param [object] - The value to check.\n* @returns True if the value is a plain object, otherwise false.\n*\n* @example\n* console.log(isPlainObject({})); // true\n* console.log(isPlainObject([])); // false\n* console.log(isPlainObject(null)); // false\n* console.log(isPlainObject(Object.create(null))); // true\n* console.log(isPlainObject(new Map())); // false\n*/\nfunction isPlainObject(object) {\n\tif (typeof object !== \"object\") return false;\n\tif (object == null) return false;\n\tif (Object.getPrototypeOf(object) === null) return true;\n\tif (Object.prototype.toString.call(object) !== \"[object Object]\") {\n\t\tconst tag = object[Symbol.toStringTag];\n\t\tif (tag == null) return false;\n\t\tif (!Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable) return false;\n\t\treturn object.toString() === `[object ${tag}]`;\n\t}\n\tlet proto = object;\n\twhile (Object.getPrototypeOf(proto) !== null) proto = Object.getPrototypeOf(proto);\n\treturn Object.getPrototypeOf(object) === proto;\n}\n//#endregion\nexport { isPlainObject };\n"],"names":["isPlainObject","object","_a","tag","proto"],"mappings":"AAuBA,SAASA,EAAcC,GAAQ;AAvB/B,MAAAC;AAyBC,MADI,OAAOD,KAAW,YAClBA,KAAU,KAAM,QAAO;AAC3B,MAAI,OAAO,eAAeA,CAAM,MAAM,KAAM,QAAO;AACnD,MAAI,OAAO,UAAU,SAAS,KAAKA,CAAM,MAAM,mBAAmB;AACjE,UAAME,IAAMF,EAAO,OAAO,WAAW;AAErC,WADIE,KAAO,QACP,GAACD,IAAA,OAAO,yBAAyBD,GAAQ,OAAO,WAAW,MAA1D,QAAAC,EAA6D,YAAiB,KAC5ED,EAAO,SAAQ,MAAO,WAAWE,CAAG;AAAA,EAC5C;AACA,MAAIC,IAAQH;AACZ,SAAO,OAAO,eAAeG,CAAK,MAAM,OAAM,CAAAA,IAAQ,OAAO,eAAeA,CAAK;AACjF,SAAO,OAAO,eAAeH,CAAM,MAAMG;AAC1C;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isString.js

@@ -0,0 +1,7 @@
+function t(n) {
+  return typeof n == "string" || n instanceof String;
+}
+export {
+  t as isString
+};
+//# sourceMappingURL=isString.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isString.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isString.mjs"],"sourcesContent":["//#region src/compat/predicate/isString.ts\n/**\n* Checks if a given value is string.\n*\n* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `string`.\n*\n* @param value The value to check if it is string.\n* @returns Returns `true` if `value` is a string, else `false`.\n*\n* @example\n* const value1 = 'abc';\n* const value2 = 123;\n* const value3 = true;\n*\n* console.log(isString(value1)); // true\n* console.log(isString(value2)); // false\n* console.log(isString(value3)); // false\n*/\nfunction isString(value) {\n\treturn typeof value === \"string\" || value instanceof String;\n}\n//#endregion\nexport { isString };\n"],"names":["isString","value"],"mappings":"AAkBA,SAASA,EAASC,GAAO;AACxB,SAAO,OAAOA,KAAU,YAAYA,aAAiB;AACtD;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isSymbol.js

@@ -0,0 +1,7 @@
+function n(o) {
+  return typeof o == "symbol" || o instanceof Symbol;
+}
+export {
+  n as isSymbol
+};
+//# sourceMappingURL=isSymbol.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isSymbol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSymbol.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isSymbol.mjs"],"sourcesContent":["//#region src/compat/predicate/isSymbol.ts\n/**\n* Check whether a value is a symbol.\n*\n* This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`.\n*\n* @param value The value to check.\n* @returns Returns `true` if `value` is a symbol, else `false`.\n* @example\n* isSymbol(Symbol.iterator);\n* // => true\n*\n* isSymbol('abc');\n* // => false\n*/\nfunction isSymbol(value) {\n\treturn typeof value === \"symbol\" || value instanceof Symbol;\n}\n//#endregion\nexport { isSymbol };\n"],"names":["isSymbol","value"],"mappings":"AAeA,SAASA,EAASC,GAAO;AACxB,SAAO,OAAOA,KAAU,YAAYA,aAAiB;AACtD;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.js

@@ -0,0 +1,8 @@
+import { isTypedArray as y } from "../../predicate/isTypedArray.js";
+function i(r) {
+  return y(r);
+}
+export {
+  i as isTypedArray
+};
+//# sourceMappingURL=isTypedArray.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTypedArray.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/isTypedArray.mjs"],"sourcesContent":["import { isTypedArray as isTypedArray$1 } from \"../../predicate/isTypedArray.mjs\";\n//#region src/compat/predicate/isTypedArray.ts\n/**\n* Checks if a value is a TypedArray.\n* @param x The value to check.\n* @returns Returns true if `x` is a TypedArray, false otherwise.\n*\n* @example\n* const arr = new Uint8Array([1, 2, 3]);\n* isTypedArray(arr); // true\n*\n* const regularArray = [1, 2, 3];\n* isTypedArray(regularArray); // false\n*\n* const buffer = new ArrayBuffer(16);\n* isTypedArray(buffer); // false\n*/\nfunction isTypedArray(x) {\n\treturn isTypedArray$1(x);\n}\n//#endregion\nexport { isTypedArray };\n"],"names":["isTypedArray","x","isTypedArray$1"],"mappings":";AAiBA,SAASA,EAAaC,GAAG;AACxB,SAAOC,EAAeD,CAAC;AACxB;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/matches.js

@@ -0,0 +1,9 @@
+import { cloneDeep as e } from "../../object/cloneDeep.js";
+import { isMatch as m } from "./isMatch.js";
+function i(t) {
+  return t = e(t), (r) => m(r, t);
+}
+export {
+  i as matches
+};
+//# sourceMappingURL=matches.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/matches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matches.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/matches.mjs"],"sourcesContent":["import { cloneDeep } from \"../../object/cloneDeep.mjs\";\nimport { isMatch } from \"./isMatch.mjs\";\n//#region src/compat/predicate/matches.ts\n/**\n* Creates a function that performs a deep comparison between a given target and the source object.\n*\n* @template T\n* @template V\n* @param source - The source object to create the matcher from.\n* @returns Returns a function that takes a target object and returns `true` if the target matches the source, otherwise `false`.\n*\n* @example\n* // Basic usage\n* const matcher = matches({ a: 1, b: 2 });\n* matcher({ a: 1, b: 2, c: 3 }); // true\n* matcher({ a: 1, c: 3 }); // false\n*\n* @example\n* // Matching arrays\n* const arrayMatcher = matches([1, 2, 3]);\n* arrayMatcher([1, 2, 3, 4]); // true\n* arrayMatcher([4, 5, 6]); // false\n*\n* @example\n* // Matching objects with nested structures\n* const nestedMatcher = matches({ a: { b: 2 } });\n* nestedMatcher({ a: { b: 2, c: 3 } }); // true\n* nestedMatcher({ a: { c: 3 } }); // false\n*/\nfunction matches(source) {\n\tsource = cloneDeep(source);\n\treturn (target) => {\n\t\treturn isMatch(target, source);\n\t};\n}\n//#endregion\nexport { matches };\n"],"names":["matches","source","cloneDeep","target","isMatch"],"mappings":";;AA6BA,SAASA,EAAQC,GAAQ;AACxB,SAAAA,IAASC,EAAUD,CAAM,GAClB,CAACE,MACAC,EAAQD,GAAQF,CAAM;AAE/B;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.js

@@ -0,0 +1,23 @@
+import { toKey as t } from "../_internal/toKey.js";
+import { get as o } from "../object/get.js";
+import { isMatch as c } from "./isMatch.js";
+import { cloneDeep as e } from "../object/cloneDeep.js";
+import { has as a } from "../object/has.js";
+function d(i, f) {
+  switch (typeof i) {
+    case "object":
+      Object.is(i == null ? void 0 : i.valueOf(), -0) && (i = "-0");
+      break;
+    case "number":
+      i = t(i);
+      break;
+  }
+  return f = e(f), function(n) {
+    const m = o(n, i);
+    return m === void 0 ? a(n, i) : f === void 0 ? m === void 0 : c(m, f);
+  };
+}
+export {
+  d as matchesProperty
+};
+//# sourceMappingURL=matchesProperty.js.map

package/dist/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchesProperty.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/predicate/matchesProperty.mjs"],"sourcesContent":["import { toKey } from \"../_internal/toKey.mjs\";\nimport { get } from \"../object/get.mjs\";\nimport { isMatch } from \"./isMatch.mjs\";\nimport { cloneDeep } from \"../object/cloneDeep.mjs\";\nimport { has } from \"../object/has.mjs\";\n//#region src/compat/predicate/matchesProperty.ts\n/**\n* Creates a function that checks if a given target object matches a specific property value.\n*\n* The returned function takes a target object and determines if the property at the\n* specified path within the target object is equal to the given value.\n*\n* @param property - The property path to check within the target object.\n*     This can be a single property key or an array of property keys.\n* @param source - The value to compare against the property value in the target object.\n*\n* @returns A function that takes a target object and returns\n*     `true` if the property value at the given path in the target object matches the provided value,\n*     otherwise returns `false`.\n*\n* @example\n* // Using a single property key\n* const checkName = matchesProperty('name', 'Alice');\n* console.log(checkName({ name: 'Alice' })); // true\n* console.log(checkName({ name: 'Bob' })); // false\n*\n* // Using an array of property keys\n* const checkNested = matchesProperty(['address', 'city'], 'New York');\n* console.log(checkNested({ address: { city: 'New York' } })); // true\n* console.log(checkNested({ address: { city: 'Los Angeles' } })); // false\n*/\nfunction matchesProperty(property, source) {\n\tswitch (typeof property) {\n\t\tcase \"object\":\n\t\t\tif (Object.is(property?.valueOf(), -0)) property = \"-0\";\n\t\t\tbreak;\n\t\tcase \"number\":\n\t\t\tproperty = toKey(property);\n\t\t\tbreak;\n\t}\n\tsource = cloneDeep(source);\n\treturn function(target) {\n\t\tconst result = get(target, property);\n\t\tif (result === void 0) return has(target, property);\n\t\tif (source === void 0) return result === void 0;\n\t\treturn isMatch(result, source);\n\t};\n}\n//#endregion\nexport { matchesProperty };\n"],"names":["matchesProperty","property","source","toKey","cloneDeep","target","result","get","has","isMatch"],"mappings":";;;;;AA+BA,SAASA,EAAgBC,GAAUC,GAAQ;AAC1C,UAAQ,OAAOD,GAAQ;AAAA,IACtB,KAAK;AACJ,MAAI,OAAO,GAAGA,KAAA,gBAAAA,EAAU,WAAW,EAAE,MAAGA,IAAW;AACnD;AAAA,IACD,KAAK;AACJ,MAAAA,IAAWE,EAAMF,CAAQ;AACzB;AAAA,EACH;AACC,SAAAC,IAASE,EAAUF,CAAM,GAClB,SAASG,GAAQ;AACvB,UAAMC,IAASC,EAAIF,GAAQJ,CAAQ;AACnC,WAAIK,MAAW,SAAeE,EAAIH,GAAQJ,CAAQ,IAC9CC,MAAW,SAAeI,MAAW,SAClCG,EAAQH,GAAQJ,CAAM;AAAA,EAC9B;AACD;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/util/eq.js

@@ -0,0 +1,7 @@
+function e(N, r) {
+  return N === r || Number.isNaN(N) && Number.isNaN(r);
+}
+export {
+  e as eq
+};
+//# sourceMappingURL=eq.js.map

package/dist/node_modules/es-toolkit/dist/compat/util/eq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eq.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/util/eq.mjs"],"sourcesContent":["//#region src/compat/util/eq.ts\n/**\n* Performs a `SameValueZero` comparison between two values to determine if they are equivalent.\n*\n* @param value The value to compare.\n* @param other The other value to compare.\n* @returns Returns `true` if the values are equivalent, else `false`.\n*\n* @example\n* eq(1, 1); // true\n* eq(0, -0); // true\n* eq(NaN, NaN); // true\n* eq('a', Object('a')); // false\n*/\nfunction eq(value, other) {\n\treturn value === other || Number.isNaN(value) && Number.isNaN(other);\n}\n//#endregion\nexport { eq };\n"],"names":["eq","value","other"],"mappings":"AAcA,SAASA,EAAGC,GAAOC,GAAO;AACzB,SAAOD,MAAUC,KAAS,OAAO,MAAMD,CAAK,KAAK,OAAO,MAAMC,CAAK;AACpE;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/util/iteratee.js

@@ -0,0 +1,19 @@
+import { identity as t } from "../../function/identity.js";
+import { property as o } from "../object/property.js";
+import { matches as i } from "../predicate/matches.js";
+import { matchesProperty as e } from "../predicate/matchesProperty.js";
+function c(r) {
+  if (r == null) return t;
+  switch (typeof r) {
+    case "function":
+      return r;
+    case "object":
+      return Array.isArray(r) && r.length === 2 ? e(r[0], r[1]) : i(r);
+    default:
+      return o(r);
+  }
+}
+export {
+  c as iteratee
+};
+//# sourceMappingURL=iteratee.js.map

package/dist/node_modules/es-toolkit/dist/compat/util/iteratee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteratee.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/util/iteratee.mjs"],"sourcesContent":["import { identity } from \"../../function/identity.mjs\";\nimport { property } from \"../object/property.mjs\";\nimport { matches } from \"../predicate/matches.mjs\";\nimport { matchesProperty } from \"../predicate/matchesProperty.mjs\";\n//#region src/compat/util/iteratee.ts\n/**\n* Creates a function that returns a value from an element in a collection.\n*\n* You can call `iteratee` with the following types of arguments:\n*\n* - **Function**: Returns the function as-is, which will be called with the element from the collection.\n* - **Property name**: Returns the value of the specified property from the element.\n* - **Property-value pair**: Returns a boolean indicating whether the element's property matches the given value.\n* - **Partial object**: Returns a boolean indicating whether the element matches the properties of the partial object.\n*\n* If you don't provide any arguments or pass `null`, this function will return a function that simply returns its input unchanged.\n*\n* @param value - The value to convert to an iteratee.\n* @returns Returns the new iteratee function.\n* @example\n* const func = iteratee();\n* [{ a: 1 }, { a: 2 }, { a: 3 }].map(func) // => [{ a: 1 }, { a: 2 }, { a: 3 }]\n*\n* const func = iteratee((object) => object.a);\n* [{ a: 1 }, { a: 2 }, { a: 3 }].map(func) // => [1, 2, 3]\n*\n* const func = iteratee('a');\n* [{ a: 1 }, { a: 2 }, { a: 3 }].map(func) // => [1, 2, 3]\n*\n* const func = iteratee({ a: 1 });\n* [{ a: 1 }, { a: 2 }, { a: 3 }].find(func) // => { a: 1 }\n*\n* const func = iteratee(['a', 1]);\n* [{ a: 1 }, { a: 2 }, { a: 3 }].find(func) // => { a: 1 }\n*/\nfunction iteratee(value) {\n\tif (value == null) return identity;\n\tswitch (typeof value) {\n\t\tcase \"function\": return value;\n\t\tcase \"object\":\n\t\t\tif (Array.isArray(value) && value.length === 2) return matchesProperty(value[0], value[1]);\n\t\t\treturn matches(value);\n\t\tdefault: return property(value);\n\t}\n}\n//#endregion\nexport { iteratee };\n"],"names":["iteratee","value","identity","matchesProperty","matches","property"],"mappings":";;;;AAmCA,SAASA,EAASC,GAAO;AACxB,MAAIA,KAAS,KAAM,QAAOC;AAC1B,UAAQ,OAAOD,GAAK;AAAA,IACnB,KAAK;AAAY,aAAOA;AAAA,IACxB,KAAK;AACJ,aAAI,MAAM,QAAQA,CAAK,KAAKA,EAAM,WAAW,IAAUE,EAAgBF,EAAM,CAAC,GAAGA,EAAM,CAAC,CAAC,IAClFG,EAAQH,CAAK;AAAA,IACrB;AAAS,aAAOI,EAASJ,CAAK;AAAA,EAChC;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/es-toolkit/dist/compat/util/times.js

@@ -0,0 +1,11 @@
+import { toInteger as f } from "./toInteger.js";
+function n(r, e) {
+  if (r = f(r), r < 1 || !Number.isSafeInteger(r)) return [];
+  const o = new Array(r);
+  for (let t = 0; t < r; t++) o[t] = typeof e == "function" ? e(t) : t;
+  return o;
+}
+export {
+  n as times
+};
+//# sourceMappingURL=times.js.map

package/dist/node_modules/es-toolkit/dist/compat/util/times.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"times.js","sources":["../../../../../../node_modules/es-toolkit/dist/compat/util/times.mjs"],"sourcesContent":["import { toInteger } from \"./toInteger.mjs\";\n//#region src/compat/util/times.ts\n/**\n* Invokes the getValue function n times, returning an array of the results.\n*\n* @template R The return type of the getValue function.\n* @param n - The number of times to invoke getValue.\n* @param getValue - The function to invoke for each index.\n* @returns An array containing the results of invoking getValue n times.\n* @example\n* times(3, (i) => i * 2); // => [0, 2, 4]\n* times(2, () => 'es-toolkit'); // => ['es-toolkit', 'es-toolkit']\n*/\nfunction times(n, getValue) {\n\tn = toInteger(n);\n\tif (n < 1 || !Number.isSafeInteger(n)) return [];\n\tconst result = new Array(n);\n\tfor (let i = 0; i < n; i++) result[i] = typeof getValue === \"function\" ? getValue(i) : i;\n\treturn result;\n}\n//#endregion\nexport { times };\n"],"names":["times","n","getValue","toInteger","result","i"],"mappings":";AAaA,SAASA,EAAMC,GAAGC,GAAU;AAE3B,MADAD,IAAIE,EAAUF,CAAC,GACXA,IAAI,KAAK,CAAC,OAAO,cAAcA,CAAC,EAAG,QAAO,CAAA;AAC9C,QAAMG,IAAS,IAAI,MAAMH,CAAC;AAC1B,WAASI,IAAI,GAAGA,IAAIJ,GAAGI,IAAK,CAAAD,EAAOC,CAAC,IAAI,OAAOH,KAAa,aAAaA,EAASG,CAAC,IAAIA;AACvF,SAAOD;AACR;","x_google_ignoreList":[0]}