@vielzeug/arsenal 2.1.0 → 26.10.0

package/dist/math/standardDeviation.js.map

@@ -1 +1 @@
-{"version":3,"file":"standardDeviation.js","names":[],"sources":["../../src/math/standardDeviation.ts"],"sourcesContent":["import { variance } from './variance';\n\n/**\n * Computes the population standard deviation (square root of `variance`) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]); // 2\n * standardDeviation([]); // 0\n * ```\n *\n * @param array - The array to compute standard deviation over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population standard deviation, or `0` for an empty array.\n */\nexport function standardDeviation<T>(array: T[], callback?: (item: T) => number): number {\n  return Math.sqrt(variance(array, callback));\n}\n"],"mappings":";;AAgBA,SAAgB,EAAqB,GAAY,GAAwC;CACvF,OAAO,KAAK,KAAK,EAAS,GAAO,CAAQ,CAAC;AAC5C"}
+{"version":3,"file":"standardDeviation.js","names":[],"sources":["../../src/math/standardDeviation.ts"],"sourcesContent":["import { variance } from './variance';\n\n/**\n * Computes the population standard deviation (square root of `variance`) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * standardDeviation([2, 4, 4, 4, 5, 5, 7, 9]); // 2\n * standardDeviation([]); // 0\n * ```\n *\n * @param array - The array to compute standard deviation over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population standard deviation, or `0` for an empty array.\n */\nexport function standardDeviation<T>(array: readonly T[], callback?: (item: T) => number): number {\n  return Math.sqrt(variance(array, callback));\n}\n"],"mappings":"yCAgBA,SAAgB,kBAAqB,EAAqB,EAAwC,CAChG,OAAO,KAAK,KAAK,EAAS,EAAO,CAAQ,CAAC,CAC5C"}

package/dist/math/sum.cjs

@@ -1,2 +1,2 @@
-function e(e,t){return e.length===0?0:e.reduce((e,n)=>{let r=t?t(n):n;if(typeof r!=`number`||Number.isNaN(r))throw TypeError(`sum: encountered a non-numeric value; provide a callback to map non-number items`);return e+r},0)}exports.sum=e;
+function sum(e,t){return e.length===0?0:e.reduce((e,n)=>{let r=t?t(n):n;if(!Number.isFinite(r))throw TypeError(`sum: encountered a non-numeric value; provide a callback to map non-number items`);return e+r},0)}exports.sum=sum;
 //# sourceMappingURL=sum.cjs.map

package/dist/math/sum.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sum.cjs","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["/**\n * Sum numbers in an array or numbers mapped by a callback function.\n *\n * @example\n * ```ts\n * sum([1, 2, 3]) // 6\n * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6\n * sum(['apple', 'banana', 'cherry']) // TypeError\n * ```\n *\n * @param array - The array to sum.\n * @param callback - An optional callback function to map the values.\n *\n * @returns The sum of the numbers in the array or the sum of the mapped values.\n *\n * @throws {TypeError} If (after an optional `callback` mapping) any item is not a finite number.\n */\nexport function sum<T>(array: T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  return array.reduce<number>((acc, item) => {\n    const val = callback ? callback(item) : (item as unknown as number);\n\n    if (typeof val !== 'number' || Number.isNaN(val)) {\n      throw new TypeError('sum: encountered a non-numeric value; provide a callback to map non-number items');\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":"AAiBA,SAAgB,EAAO,EAAY,EAAwC,CAGzE,OAFI,EAAM,SAAW,EAAU,EAExB,EAAM,QAAgB,EAAK,IAAS,CACzC,IAAM,EAAM,EAAW,EAAS,CAAI,EAAK,EAEzC,GAAI,OAAO,GAAQ,UAAY,OAAO,MAAM,CAAG,EAC7C,MAAU,UAAU,kFAAkF,EAGxG,OAAO,EAAM,CACf,EAAG,CAAC,CACN"}
+{"version":3,"file":"sum.cjs","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["/**\n * Sum numbers in an array or numbers mapped by a callback function.\n *\n * @example\n * ```ts\n * sum([1, 2, 3]) // 6\n * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6\n * sum(['apple', 'banana', 'cherry']) // TypeError\n * ```\n *\n * @param array - The array to sum.\n * @param callback - An optional callback function to map the values.\n *\n * @returns The sum of the numbers in the array or the sum of the mapped values.\n *\n * @throws {TypeError} If (after an optional `callback` mapping) any item is not a finite number.\n */\nexport function sum<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  return array.reduce<number>((acc, item) => {\n    const val = callback ? callback(item) : (item as unknown as number);\n\n    if (!Number.isFinite(val)) {\n      throw new TypeError('sum: encountered a non-numeric value; provide a callback to map non-number items');\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":"AAiBA,SAAgB,IAAO,EAAqB,EAAwC,CAGlF,OAFI,EAAM,SAAW,EAAU,EAExB,EAAM,QAAgB,EAAK,IAAS,CACzC,IAAM,EAAM,EAAW,EAAS,CAAI,EAAK,EAEzC,GAAI,CAAC,OAAO,SAAS,CAAG,EACtB,MAAU,UAAU,kFAAkF,EAGxG,OAAO,EAAM,CACf,EAAG,CAAC,CACN"}

package/dist/math/sum.d.ts

@@ -15,5 +15,5 @@
  *
  * @throws {TypeError} If (after an optional `callback` mapping) any item is not a finite number.
  */
-export declare function sum<T>(array: T[], callback?: (item: T) => number): number;
+export declare function sum<T>(array: readonly T[], callback?: (item: T) => number): number;
 //# sourceMappingURL=sum.d.ts.map

package/dist/math/sum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sum.d.ts","sourceRoot":"","sources":["../../src/math/sum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAYzE"}
+{"version":3,"file":"sum.d.ts","sourceRoot":"","sources":["../../src/math/sum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAYlF"}

package/dist/math/sum.js

@@ -1,12 +1,2 @@
-//#region src/math/sum.ts
-function e(e, t) {
-	return e.length === 0 ? 0 : e.reduce((e, n) => {
-		let r = t ? t(n) : n;
-		if (typeof r != "number" || Number.isNaN(r)) throw TypeError("sum: encountered a non-numeric value; provide a callback to map non-number items");
-		return e + r;
-	}, 0);
-}
-//#endregion
-export { e as sum };
-
+function sum(e,t){return e.length===0?0:e.reduce((e,n)=>{let r=t?t(n):n;if(!Number.isFinite(r))throw TypeError(`sum: encountered a non-numeric value; provide a callback to map non-number items`);return e+r},0)}export{sum};
 //# sourceMappingURL=sum.js.map

package/dist/math/sum.js.map

@@ -1 +1 @@
-{"version":3,"file":"sum.js","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["/**\n * Sum numbers in an array or numbers mapped by a callback function.\n *\n * @example\n * ```ts\n * sum([1, 2, 3]) // 6\n * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6\n * sum(['apple', 'banana', 'cherry']) // TypeError\n * ```\n *\n * @param array - The array to sum.\n * @param callback - An optional callback function to map the values.\n *\n * @returns The sum of the numbers in the array or the sum of the mapped values.\n *\n * @throws {TypeError} If (after an optional `callback` mapping) any item is not a finite number.\n */\nexport function sum<T>(array: T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  return array.reduce<number>((acc, item) => {\n    const val = callback ? callback(item) : (item as unknown as number);\n\n    if (typeof val !== 'number' || Number.isNaN(val)) {\n      throw new TypeError('sum: encountered a non-numeric value; provide a callback to map non-number items');\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":";AAiBA,SAAgB,EAAO,GAAY,GAAwC;CAGzE,OAFI,EAAM,WAAW,IAAU,IAExB,EAAM,QAAgB,GAAK,MAAS;EACzC,IAAM,IAAM,IAAW,EAAS,CAAI,IAAK;EAEzC,IAAI,OAAO,KAAQ,YAAY,OAAO,MAAM,CAAG,GAC7C,MAAU,UAAU,kFAAkF;EAGxG,OAAO,IAAM;CACf,GAAG,CAAC;AACN"}
+{"version":3,"file":"sum.js","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["/**\n * Sum numbers in an array or numbers mapped by a callback function.\n *\n * @example\n * ```ts\n * sum([1, 2, 3]) // 6\n * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6\n * sum(['apple', 'banana', 'cherry']) // TypeError\n * ```\n *\n * @param array - The array to sum.\n * @param callback - An optional callback function to map the values.\n *\n * @returns The sum of the numbers in the array or the sum of the mapped values.\n *\n * @throws {TypeError} If (after an optional `callback` mapping) any item is not a finite number.\n */\nexport function sum<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  return array.reduce<number>((acc, item) => {\n    const val = callback ? callback(item) : (item as unknown as number);\n\n    if (!Number.isFinite(val)) {\n      throw new TypeError('sum: encountered a non-numeric value; provide a callback to map non-number items');\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":"AAiBA,SAAgB,IAAO,EAAqB,EAAwC,CAGlF,OAFI,EAAM,SAAW,EAAU,EAExB,EAAM,QAAgB,EAAK,IAAS,CACzC,IAAM,EAAM,EAAW,EAAS,CAAI,EAAK,EAEzC,GAAI,CAAC,OAAO,SAAS,CAAG,EACtB,MAAU,UAAU,kFAAkF,EAGxG,OAAO,EAAM,CACf,EAAG,CAAC,CACN"}

package/dist/math/variance.cjs

@@ -1,2 +1,2 @@
-const e=require("./average.cjs");function t(t,n){if(t.length===0)return 0;let r=n?t.map(n):t,i=e.average(r)??0;return e.average(r.map(e=>(e-i)**2))??0}exports.variance=t;
+const e=require("./average.cjs");function variance(t,n){if(t.length===0)return 0;let r=n?t.map(n):t,i=e.average(r)??0;return e.average(r.map(e=>(e-i)**2))??0}exports.variance=variance;
 //# sourceMappingURL=variance.cjs.map

package/dist/math/variance.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"variance.cjs","names":[],"sources":["../../src/math/variance.ts"],"sourcesContent":["import { average } from './average';\n\n/**\n * Computes the population variance (average squared deviation from the mean) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4\n * variance([{ n: 1 }, { n: 3 }], (item) => item.n); // 1\n * variance([]); // 0\n * ```\n *\n * @param array - The array to compute variance over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population variance, or `0` for an empty array.\n */\nexport function variance<T>(array: T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  const values = callback ? array.map(callback) : (array as unknown as number[]);\n  const mean = average(values) ?? 0;\n\n  return average(values.map((value) => (value - mean) ** 2)) ?? 0;\n}\n"],"mappings":"iCAiBA,SAAgB,EAAY,EAAY,EAAwC,CAC9E,GAAI,EAAM,SAAW,EAAG,MAAO,GAE/B,IAAM,EAAS,EAAW,EAAM,IAAI,CAAQ,EAAK,EAC3C,EAAO,EAAA,QAAQ,CAAM,GAAK,EAEhC,OAAO,EAAA,QAAQ,EAAO,IAAK,IAAW,EAAQ,IAAS,CAAC,CAAC,GAAK,CAChE"}
+{"version":3,"file":"variance.cjs","names":[],"sources":["../../src/math/variance.ts"],"sourcesContent":["import { average } from './average';\n\n/**\n * Computes the population variance (average squared deviation from the mean) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4\n * variance([{ n: 1 }, { n: 3 }], (item) => item.n); // 1\n * variance([]); // 0\n * ```\n *\n * @param array - The array to compute variance over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population variance, or `0` for an empty array.\n */\nexport function variance<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  const values = callback ? array.map(callback) : (array as unknown as number[]);\n  const mean = average(values) ?? 0;\n\n  return average(values.map((value) => (value - mean) ** 2)) ?? 0;\n}\n"],"mappings":"iCAiBA,SAAgB,SAAY,EAAqB,EAAwC,CACvF,GAAI,EAAM,SAAW,EAAG,MAAO,GAE/B,IAAM,EAAS,EAAW,EAAM,IAAI,CAAQ,EAAK,EAC3C,EAAO,EAAA,QAAQ,CAAM,GAAK,EAEhC,OAAO,EAAA,QAAQ,EAAO,IAAK,IAAW,EAAQ,IAAS,CAAC,CAAC,GAAK,CAChE"}

package/dist/math/variance.d.ts

@@ -13,5 +13,5 @@
  * @param callback - An optional callback to map each item to a number.
  * @returns The population variance, or `0` for an empty array.
  */
-export declare function variance<T>(array: T[], callback?: (item: T) => number): number;
+export declare function variance<T>(array: readonly T[], callback?: (item: T) => number): number;
 //# sourceMappingURL=variance.d.ts.map

package/dist/math/variance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variance.d.ts","sourceRoot":"","sources":["../../src/math/variance.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAO9E"}
+{"version":3,"file":"variance.d.ts","sourceRoot":"","sources":["../../src/math/variance.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAOvF"}

package/dist/math/variance.js

@@ -1,11 +1,2 @@
-import { average as e } from "./average.js";
-//#region src/math/variance.ts
-function t(t, n) {
-	if (t.length === 0) return 0;
-	let r = n ? t.map(n) : t, i = e(r) ?? 0;
-	return e(r.map((e) => (e - i) ** 2)) ?? 0;
-}
-//#endregion
-export { t as variance };
-
+import{average as e}from"./average.js";function variance(t,n){if(t.length===0)return 0;let r=n?t.map(n):t,i=e(r)??0;return e(r.map(e=>(e-i)**2))??0}export{variance};
 //# sourceMappingURL=variance.js.map

package/dist/math/variance.js.map

@@ -1 +1 @@
-{"version":3,"file":"variance.js","names":[],"sources":["../../src/math/variance.ts"],"sourcesContent":["import { average } from './average';\n\n/**\n * Computes the population variance (average squared deviation from the mean) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4\n * variance([{ n: 1 }, { n: 3 }], (item) => item.n); // 1\n * variance([]); // 0\n * ```\n *\n * @param array - The array to compute variance over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population variance, or `0` for an empty array.\n */\nexport function variance<T>(array: T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  const values = callback ? array.map(callback) : (array as unknown as number[]);\n  const mean = average(values) ?? 0;\n\n  return average(values.map((value) => (value - mean) ** 2)) ?? 0;\n}\n"],"mappings":";;AAiBA,SAAgB,EAAY,GAAY,GAAwC;CAC9E,IAAI,EAAM,WAAW,GAAG,OAAO;CAE/B,IAAM,IAAS,IAAW,EAAM,IAAI,CAAQ,IAAK,GAC3C,IAAO,EAAQ,CAAM,KAAK;CAEhC,OAAO,EAAQ,EAAO,KAAK,OAAW,IAAQ,MAAS,CAAC,CAAC,KAAK;AAChE"}
+{"version":3,"file":"variance.js","names":[],"sources":["../../src/math/variance.ts"],"sourcesContent":["import { average } from './average';\n\n/**\n * Computes the population variance (average squared deviation from the mean) of an array of\n * numbers, or of values mapped by a callback.\n *\n * @example\n * ```ts\n * variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4\n * variance([{ n: 1 }, { n: 3 }], (item) => item.n); // 1\n * variance([]); // 0\n * ```\n *\n * @param array - The array to compute variance over.\n * @param callback - An optional callback to map each item to a number.\n * @returns The population variance, or `0` for an empty array.\n */\nexport function variance<T>(array: readonly T[], callback?: (item: T) => number): number {\n  if (array.length === 0) return 0;\n\n  const values = callback ? array.map(callback) : (array as unknown as number[]);\n  const mean = average(values) ?? 0;\n\n  return average(values.map((value) => (value - mean) ** 2)) ?? 0;\n}\n"],"mappings":"uCAiBA,SAAgB,SAAY,EAAqB,EAAwC,CACvF,GAAI,EAAM,SAAW,EAAG,MAAO,GAE/B,IAAM,EAAS,EAAW,EAAM,IAAI,CAAQ,EAAK,EAC3C,EAAO,EAAQ,CAAM,GAAK,EAEhC,OAAO,EAAQ,EAAO,IAAK,IAAW,EAAQ,IAAS,CAAC,CAAC,GAAK,CAChE"}

package/dist/object/defaults.cjs

@@ -1,2 +1,2 @@
-const e=require("../_common/unsafePaths.cjs"),t=require("../guards/isPlainObject.cjs");function n(n,...r){let i={...n};for(let n of r)if(t.isPlainObject(n))for(let t of Object.keys(n))e.isUnsafeKey(t)||i[t]===void 0&&(i[t]=n[t]);return i}exports.defaults=n;
+const e=require("../_common/unsafePaths.cjs"),t=require("../guards/isPlainObject.cjs");function defaults(n,...r){let i={...n};for(let n of r)if(t.isPlainObject(n))for(let t of Object.keys(n))e.isUnsafeKey(t)||i[t]===void 0&&(i[t]=n[t]);return i}exports.defaults=defaults;
 //# sourceMappingURL=defaults.cjs.map

package/dist/object/defaults.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.cjs","names":[],"sources":["../../src/object/defaults.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\nimport type { Obj } from '../types';\n\n/**\n * Fills in `undefined` properties in `target` with values from `sources`. First source wins\n * — unlike `shallowMerge`, already-set keys are never overwritten.\n *\n * @example\n * ```ts\n * defaults({ a: 1, b: undefined }, { a: 99, b: 2, c: 3 });\n * // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @param target - The object to fill in.\n * @param sources - One or more partial objects supplying default values.\n * @returns A new object with missing keys filled from `sources`.\n */\nexport function defaults<T extends Obj>(target: T, ...sources: Array<Partial<T>>): T {\n  const out = { ...target };\n\n  for (const source of sources) {\n    if (!isPlainObject(source)) continue;\n\n    for (const key of Object.keys(source) as Array<keyof T>) {\n      if (isUnsafeKey(key as PropertyKey)) continue;\n\n      if (out[key] === undefined) {\n        out[key] = source[key] as T[keyof T];\n      }\n    }\n  }\n\n  return out;\n}\n"],"mappings":"uFAkBA,SAAgB,EAAwB,EAAW,GAAG,EAA+B,CACnF,IAAM,EAAM,CAAE,GAAG,CAAO,EAExB,IAAK,IAAM,KAAU,EACd,KAAA,cAAc,CAAM,EAEzB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAM,EAC9B,EAAA,YAAY,CAAkB,GAE9B,EAAI,KAAS,IAAA,KACf,EAAI,GAAO,EAAO,IAKxB,OAAO,CACT"}
+{"version":3,"file":"defaults.cjs","names":[],"sources":["../../src/object/defaults.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\nimport type { Obj } from '../types';\n\n/**\n * Fills in `undefined` properties in `target` with values from `sources`. First source wins\n * — unlike `shallowMerge`, already-set keys are never overwritten.\n *\n * @example\n * ```ts\n * defaults({ a: 1, b: undefined }, { a: 99, b: 2, c: 3 });\n * // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @param target - The object to fill in.\n * @param sources - One or more partial objects supplying default values.\n * @returns A new object with missing keys filled from `sources`.\n */\nexport function defaults<T extends Obj>(target: T, ...sources: Array<Partial<T>>): T {\n  const out = { ...target };\n\n  for (const source of sources) {\n    if (!isPlainObject(source)) continue;\n\n    for (const key of Object.keys(source) as Array<keyof T>) {\n      if (isUnsafeKey(key as PropertyKey)) continue;\n\n      if (out[key] === undefined) {\n        out[key] = source[key] as T[keyof T];\n      }\n    }\n  }\n\n  return out;\n}\n"],"mappings":"uFAkBA,SAAgB,SAAwB,EAAW,GAAG,EAA+B,CACnF,IAAM,EAAM,CAAE,GAAG,CAAO,EAExB,IAAK,IAAM,KAAU,EACd,KAAA,cAAc,CAAM,EAEzB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAM,EAC9B,EAAA,YAAY,CAAkB,GAE9B,EAAI,KAAS,IAAA,KACf,EAAI,GAAO,EAAO,IAKxB,OAAO,CACT"}

package/dist/object/defaults.js

@@ -1,12 +1,2 @@
-import { isUnsafeKey as e } from "../_common/unsafePaths.js";
-import { isPlainObject as t } from "../guards/isPlainObject.js";
-//#region src/object/defaults.ts
-function n(n, ...r) {
-	let i = { ...n };
-	for (let n of r) if (t(n)) for (let t of Object.keys(n)) e(t) || i[t] === void 0 && (i[t] = n[t]);
-	return i;
-}
-//#endregion
-export { n as defaults };
-
+import{isUnsafeKey as e}from"../_common/unsafePaths.js";import{isPlainObject as t}from"../guards/isPlainObject.js";function defaults(n,...r){let i={...n};for(let n of r)if(t(n))for(let t of Object.keys(n))e(t)||i[t]===void 0&&(i[t]=n[t]);return i}export{defaults};
 //# sourceMappingURL=defaults.js.map

package/dist/object/defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.js","names":[],"sources":["../../src/object/defaults.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\nimport type { Obj } from '../types';\n\n/**\n * Fills in `undefined` properties in `target` with values from `sources`. First source wins\n * — unlike `shallowMerge`, already-set keys are never overwritten.\n *\n * @example\n * ```ts\n * defaults({ a: 1, b: undefined }, { a: 99, b: 2, c: 3 });\n * // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @param target - The object to fill in.\n * @param sources - One or more partial objects supplying default values.\n * @returns A new object with missing keys filled from `sources`.\n */\nexport function defaults<T extends Obj>(target: T, ...sources: Array<Partial<T>>): T {\n  const out = { ...target };\n\n  for (const source of sources) {\n    if (!isPlainObject(source)) continue;\n\n    for (const key of Object.keys(source) as Array<keyof T>) {\n      if (isUnsafeKey(key as PropertyKey)) continue;\n\n      if (out[key] === undefined) {\n        out[key] = source[key] as T[keyof T];\n      }\n    }\n  }\n\n  return out;\n}\n"],"mappings":";;;AAkBA,SAAgB,EAAwB,GAAW,GAAG,GAA+B;CACnF,IAAM,IAAM,EAAE,GAAG,EAAO;CAExB,KAAK,IAAM,KAAU,GACd,MAAc,CAAM,GAEzB,KAAK,IAAM,KAAO,OAAO,KAAK,CAAM,GAC9B,EAAY,CAAkB,KAE9B,EAAI,OAAS,KAAA,MACf,EAAI,KAAO,EAAO;CAKxB,OAAO;AACT"}
+{"version":3,"file":"defaults.js","names":[],"sources":["../../src/object/defaults.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\nimport type { Obj } from '../types';\n\n/**\n * Fills in `undefined` properties in `target` with values from `sources`. First source wins\n * — unlike `shallowMerge`, already-set keys are never overwritten.\n *\n * @example\n * ```ts\n * defaults({ a: 1, b: undefined }, { a: 99, b: 2, c: 3 });\n * // { a: 1, b: 2, c: 3 }\n * ```\n *\n * @param target - The object to fill in.\n * @param sources - One or more partial objects supplying default values.\n * @returns A new object with missing keys filled from `sources`.\n */\nexport function defaults<T extends Obj>(target: T, ...sources: Array<Partial<T>>): T {\n  const out = { ...target };\n\n  for (const source of sources) {\n    if (!isPlainObject(source)) continue;\n\n    for (const key of Object.keys(source) as Array<keyof T>) {\n      if (isUnsafeKey(key as PropertyKey)) continue;\n\n      if (out[key] === undefined) {\n        out[key] = source[key] as T[keyof T];\n      }\n    }\n  }\n\n  return out;\n}\n"],"mappings":"mHAkBA,SAAgB,SAAwB,EAAW,GAAG,EAA+B,CACnF,IAAM,EAAM,CAAE,GAAG,CAAO,EAExB,IAAK,IAAM,KAAU,EACd,KAAc,CAAM,EAEzB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAM,EAC9B,EAAY,CAAkB,GAE9B,EAAI,KAAS,IAAA,KACf,EAAI,GAAO,EAAO,IAKxB,OAAO,CACT"}

package/dist/object/diff.cjs

@@ -1,2 +1,2 @@
-const e=require("../guards/isEqual.cjs"),t=require("../_common/unsafePaths.cjs");function n(n={},r={},i=e.isEqual){let a=[],o=[],s={},c=new Set(Object.keys(n)),l=new Set(Object.keys(r));for(let e of l)c.has(e)?!t.isUnsafeKey(e)&&!i(n[e],r[e])&&(s[e]={after:r[e],before:n[e]}):a.push(e);for(let e of c)l.has(e)||o.push(e);return{added:a,changed:s,removed:o}}function r(t,n,r){let i=r?.compareFn??((t,n)=>e.isEqual(t,n));return{added:n.filter(e=>!t.some(t=>i(t,e))),removed:t.filter(e=>!n.some(t=>i(e,t)))}}exports.diff=n,exports.diffArrays=r;
+const e=require("../guards/isEqual.cjs"),t=require("../_common/unsafePaths.cjs");function diff(n={},r={},i=e.isEqual){let a=[],o=[],s={},c=new Set(Object.keys(n)),l=new Set(Object.keys(r));for(let e of l)c.has(e)?!t.isUnsafeKey(e)&&!i(n[e],r[e])&&(s[e]={after:r[e],before:n[e]}):a.push(e);for(let e of c)l.has(e)||o.push(e);return{added:a,changed:s,removed:o}}function diffArrays(t,n,r){let i=r?.compareFn??((t,n)=>e.isEqual(t,n));return{added:n.filter(e=>!t.some(t=>i(t,e))),removed:t.filter(e=>!n.some(t=>i(e,t)))}}exports.diff=diff,exports.diffArrays=diffArrays;
 //# sourceMappingURL=diff.cjs.map

package/dist/object/diff.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"diff.cjs","names":[],"sources":["../../src/object/diff.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isEqual } from '../guards/isEqual';\nimport type { Obj } from '../types';\n\nexport type DiffResult<T extends Obj> = {\n  /** Keys present in `after` but not in `before`. */\n  added: Array<keyof T & string>;\n  /** Keys present in both objects whose values differ. Maps key → `{ before, after }`. */\n  changed: { [K in keyof T]?: { after: T[K]; before: T[K] } };\n  /** Keys present in `before` but not in `after`. */\n  removed: Array<keyof T & string>;\n};\n\n/**\n * Computes the structural difference between two plain objects.\n * Returns an `{ added, removed, changed }` result — no sentinel symbols needed.\n * Dangerous keys (`__proto__`, `constructor`, `prototype`) are omitted from `changed`.\n *\n * @example\n * ```ts\n * diff({ a: 1, b: 2, c: 3 }, { a: 1, b: 99 });\n * // { added: [], removed: ['c'], changed: { b: { before: 2, after: 99 } } }\n *\n * diff({ x: { n: 1 } }, { x: { n: 2 } });\n * // { added: [], removed: [], changed: { x: { before: { n: 1 }, after: { n: 2 } } } }\n * ```\n *\n * @param before - The original object.\n * @param after - The updated object.\n * @param compareFn - Custom equality function. Defaults to deep `isEqual`.\n */\nexport function diff<T extends Obj>(\n  before: T = {} as T,\n  after: T = {} as T,\n  compareFn: (a: unknown, b: unknown) => boolean = isEqual,\n): DiffResult<T> {\n  const added: Array<keyof T & string> = [];\n  const removed: Array<keyof T & string> = [];\n  const changed: Record<string, { after: unknown; before: unknown }> = {};\n\n  const beforeKeys = new Set(Object.keys(before));\n  const afterKeys = new Set(Object.keys(after));\n\n  for (const key of afterKeys) {\n    if (!beforeKeys.has(key)) {\n      added.push(key as keyof T & string);\n    } else if (!isUnsafeKey(key) && !compareFn(before[key], after[key])) {\n      changed[key] = { after: after[key], before: before[key] };\n    }\n  }\n\n  for (const key of beforeKeys) {\n    if (!afterKeys.has(key)) {\n      removed.push(key as keyof T & string);\n    }\n  }\n\n  return { added, changed: changed as DiffResult<T>['changed'], removed };\n}\n\nexport type ArrayDiff<T> = {\n  added: T[];\n  removed: T[];\n};\n\nexport type ArrayDiffOptions<T> = {\n  compareFn?: (a: T, b: T) => boolean;\n};\n\n/**\n * Computes the set-difference between two arrays.\n * Items present in `after` but not `before` are `added`.\n * Items present in `before` but not `after` are `removed`.\n * Order-independent; uses deep equality by default.\n *\n * @example\n * ```ts\n * diffArrays([1, 2, 3], [2, 3, 4]); // { added: [4], removed: [1] }\n * diffArrays(\n *   [{ id: 1 }, { id: 2 }],\n *   [{ id: 2 }, { id: 3 }],\n *   { compareFn: (a, b) => a.id === b.id },\n * ); // { added: [{ id: 3 }], removed: [{ id: 1 }] }\n * ```\n *\n * @param before - The original array.\n * @param after - The updated array.\n * @param [options.compareFn] - Custom equality function. Defaults to deep `isEqual`.\n * @returns An object with `added` and `removed` arrays.\n */\nexport function diffArrays<T>(before: T[], after: T[], options?: ArrayDiffOptions<T>): ArrayDiff<T> {\n  const compareFn = options?.compareFn ?? ((a: T, b: T) => isEqual(a, b));\n\n  return {\n    added: after.filter((item) => !before.some((b) => compareFn(b, item))),\n    removed: before.filter((item) => !after.some((a) => compareFn(item, a))),\n  };\n}\n"],"mappings":"iFA+BA,SAAgB,EACd,EAAY,CAAC,EACb,EAAW,CAAC,EACZ,EAAiD,EAAA,QAClC,CACf,IAAM,EAAiC,CAAC,EAClC,EAAmC,CAAC,EACpC,EAA+D,CAAC,EAEhE,EAAa,IAAI,IAAI,OAAO,KAAK,CAAM,CAAC,EACxC,EAAY,IAAI,IAAI,OAAO,KAAK,CAAK,CAAC,EAE5C,IAAK,IAAM,KAAO,EACX,EAAW,IAAI,CAAG,EAEZ,CAAC,EAAA,YAAY,CAAG,GAAK,CAAC,EAAU,EAAO,GAAM,EAAM,EAAI,IAChE,EAAQ,GAAO,CAAE,MAAO,EAAM,GAAM,OAAQ,EAAO,EAAK,GAFxD,EAAM,KAAK,CAAuB,EAMtC,IAAK,IAAM,KAAO,EACX,EAAU,IAAI,CAAG,GACpB,EAAQ,KAAK,CAAuB,EAIxC,MAAO,CAAE,QAAgB,UAAqC,SAAQ,CACxE,CAgCA,SAAgB,EAAc,EAAa,EAAY,EAA6C,CAClG,IAAM,EAAY,GAAS,aAAe,EAAM,IAAS,EAAA,QAAQ,EAAG,CAAC,GAErE,MAAO,CACL,MAAO,EAAM,OAAQ,GAAS,CAAC,EAAO,KAAM,GAAM,EAAU,EAAG,CAAI,CAAC,CAAC,EACrE,QAAS,EAAO,OAAQ,GAAS,CAAC,EAAM,KAAM,GAAM,EAAU,EAAM,CAAC,CAAC,CAAC,CACzE,CACF"}
+{"version":3,"file":"diff.cjs","names":[],"sources":["../../src/object/diff.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isEqual } from '../guards/isEqual';\nimport type { Obj } from '../types';\n\nexport type DiffResult<T extends Obj> = {\n  /** Keys present in `after` but not in `before`. */\n  added: Array<keyof T & string>;\n  /** Keys present in both objects whose values differ. Maps key → `{ before, after }`. */\n  changed: { [K in keyof T]?: { after: T[K]; before: T[K] } };\n  /** Keys present in `before` but not in `after`. */\n  removed: Array<keyof T & string>;\n};\n\n/**\n * Computes the structural difference between two plain objects.\n * Returns an `{ added, removed, changed }` result — no sentinel symbols needed.\n * Dangerous keys (`__proto__`, `constructor`, `prototype`) are omitted from `changed`.\n *\n * @example\n * ```ts\n * diff({ a: 1, b: 2, c: 3 }, { a: 1, b: 99 });\n * // { added: [], removed: ['c'], changed: { b: { before: 2, after: 99 } } }\n *\n * diff({ x: { n: 1 } }, { x: { n: 2 } });\n * // { added: [], removed: [], changed: { x: { before: { n: 1 }, after: { n: 2 } } } }\n * ```\n *\n * @param before - The original object.\n * @param after - The updated object.\n * @param compareFn - Custom equality function. Defaults to deep `isEqual`.\n */\nexport function diff<T extends Obj>(\n  before: T = {} as T,\n  after: T = {} as T,\n  compareFn: (a: unknown, b: unknown) => boolean = isEqual,\n): DiffResult<T> {\n  const added: Array<keyof T & string> = [];\n  const removed: Array<keyof T & string> = [];\n  const changed: Record<string, { after: unknown; before: unknown }> = {};\n\n  const beforeKeys = new Set(Object.keys(before));\n  const afterKeys = new Set(Object.keys(after));\n\n  for (const key of afterKeys) {\n    if (!beforeKeys.has(key)) {\n      added.push(key as keyof T & string);\n    } else if (!isUnsafeKey(key) && !compareFn(before[key], after[key])) {\n      changed[key] = { after: after[key], before: before[key] };\n    }\n  }\n\n  for (const key of beforeKeys) {\n    if (!afterKeys.has(key)) {\n      removed.push(key as keyof T & string);\n    }\n  }\n\n  return { added, changed: changed as DiffResult<T>['changed'], removed };\n}\n\nexport type ArrayDiff<T> = {\n  added: T[];\n  removed: T[];\n};\n\nexport type ArrayDiffOptions<T> = {\n  compareFn?: (a: T, b: T) => boolean;\n};\n\n/**\n * Computes the set-difference between two arrays.\n * Items present in `after` but not `before` are `added`.\n * Items present in `before` but not `after` are `removed`.\n * Order-independent; uses deep equality by default.\n *\n * @example\n * ```ts\n * diffArrays([1, 2, 3], [2, 3, 4]); // { added: [4], removed: [1] }\n * diffArrays(\n *   [{ id: 1 }, { id: 2 }],\n *   [{ id: 2 }, { id: 3 }],\n *   { compareFn: (a, b) => a.id === b.id },\n * ); // { added: [{ id: 3 }], removed: [{ id: 1 }] }\n * ```\n *\n * @param before - The original array.\n * @param after - The updated array.\n * @param [options.compareFn] - Custom equality function. Defaults to deep `isEqual`.\n * @returns An object with `added` and `removed` arrays.\n */\nexport function diffArrays<T>(before: readonly T[], after: readonly T[], options?: ArrayDiffOptions<T>): ArrayDiff<T> {\n  const compareFn = options?.compareFn ?? ((a: T, b: T) => isEqual(a, b));\n\n  return {\n    added: after.filter((item) => !before.some((b) => compareFn(b, item))),\n    removed: before.filter((item) => !after.some((a) => compareFn(item, a))),\n  };\n}\n"],"mappings":"iFA+BA,SAAgB,KACd,EAAY,CAAC,EACb,EAAW,CAAC,EACZ,EAAiD,EAAA,QAClC,CACf,IAAM,EAAiC,CAAC,EAClC,EAAmC,CAAC,EACpC,EAA+D,CAAC,EAEhE,EAAa,IAAI,IAAI,OAAO,KAAK,CAAM,CAAC,EACxC,EAAY,IAAI,IAAI,OAAO,KAAK,CAAK,CAAC,EAE5C,IAAK,IAAM,KAAO,EACX,EAAW,IAAI,CAAG,EAEZ,CAAC,EAAA,YAAY,CAAG,GAAK,CAAC,EAAU,EAAO,GAAM,EAAM,EAAI,IAChE,EAAQ,GAAO,CAAE,MAAO,EAAM,GAAM,OAAQ,EAAO,EAAK,GAFxD,EAAM,KAAK,CAAuB,EAMtC,IAAK,IAAM,KAAO,EACX,EAAU,IAAI,CAAG,GACpB,EAAQ,KAAK,CAAuB,EAIxC,MAAO,CAAE,QAAgB,UAAqC,SAAQ,CACxE,CAgCA,SAAgB,WAAc,EAAsB,EAAqB,EAA6C,CACpH,IAAM,EAAY,GAAS,aAAe,EAAM,IAAS,EAAA,QAAQ,EAAG,CAAC,GAErE,MAAO,CACL,MAAO,EAAM,OAAQ,GAAS,CAAC,EAAO,KAAM,GAAM,EAAU,EAAG,CAAI,CAAC,CAAC,EACrE,QAAS,EAAO,OAAQ,GAAS,CAAC,EAAM,KAAM,GAAM,EAAU,EAAM,CAAC,CAAC,CAAC,CACzE,CACF"}

package/dist/object/diff.d.ts

@@ -59,5 +59,5 @@ export type ArrayDiffOptions<T> = {
  * @param [options.compareFn] - Custom equality function. Defaults to deep `isEqual`.
  * @returns An object with `added` and `removed` arrays.
  */
-export declare function diffArrays<T>(before: T[], after: T[], options?: ArrayDiffOptions<T>): ArrayDiff<T>;
+export declare function diffArrays<T>(before: readonly T[], after: readonly T[], options?: ArrayDiffOptions<T>): ArrayDiff<T>;
 //# sourceMappingURL=diff.d.ts.map

package/dist/object/diff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/object/diff.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEpC,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,GAAG,IAAI;IACtC,mDAAmD;IACnD,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;IAC/B,wFAAwF;IACxF,OAAO,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE;YAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;SAAE;KAAE,CAAC;IAC5D,mDAAmD;IACnD,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,GAAG,EAChC,MAAM,GAAE,CAAW,EACnB,KAAK,GAAE,CAAW,EAClB,SAAS,GAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAiB,GACvD,UAAU,CAAC,CAAC,CAAC,CAuBf;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IACzB,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,OAAO,EAAE,CAAC,EAAE,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAChC,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;CACrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAOlG"}
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/object/diff.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEpC,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,GAAG,IAAI;IACtC,mDAAmD;IACnD,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;IAC/B,wFAAwF;IACxF,OAAO,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE;YAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;SAAE;KAAE,CAAC;IAC5D,mDAAmD;IACnD,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,GAAG,EAChC,MAAM,GAAE,CAAW,EACnB,KAAK,GAAE,CAAW,EAClB,SAAS,GAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAiB,GACvD,UAAU,CAAC,CAAC,CAAC,CAuBf;AAED,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IACzB,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,OAAO,EAAE,CAAC,EAAE,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAChC,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;CACrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAOpH"}

package/dist/object/diff.js

@@ -1,27 +1,2 @@
-import { isEqual as e } from "../guards/isEqual.js";
-import { isUnsafeKey as t } from "../_common/unsafePaths.js";
-//#region src/object/diff.ts
-function n(n = {}, r = {}, i = e) {
-	let a = [], o = [], s = {}, c = new Set(Object.keys(n)), l = new Set(Object.keys(r));
-	for (let e of l) c.has(e) ? !t(e) && !i(n[e], r[e]) && (s[e] = {
-		after: r[e],
-		before: n[e]
-	}) : a.push(e);
-	for (let e of c) l.has(e) || o.push(e);
-	return {
-		added: a,
-		changed: s,
-		removed: o
-	};
-}
-function r(t, n, r) {
-	let i = r?.compareFn ?? ((t, n) => e(t, n));
-	return {
-		added: n.filter((e) => !t.some((t) => i(t, e))),
-		removed: t.filter((e) => !n.some((t) => i(e, t)))
-	};
-}
-//#endregion
-export { n as diff, r as diffArrays };
-
+import{isEqual as e}from"../guards/isEqual.js";import{isUnsafeKey as t}from"../_common/unsafePaths.js";function diff(n={},r={},i=e){let a=[],o=[],s={},c=new Set(Object.keys(n)),l=new Set(Object.keys(r));for(let e of l)c.has(e)?!t(e)&&!i(n[e],r[e])&&(s[e]={after:r[e],before:n[e]}):a.push(e);for(let e of c)l.has(e)||o.push(e);return{added:a,changed:s,removed:o}}function diffArrays(t,n,r){let i=r?.compareFn??((t,n)=>e(t,n));return{added:n.filter(e=>!t.some(t=>i(t,e))),removed:t.filter(e=>!n.some(t=>i(e,t)))}}export{diff,diffArrays};
 //# sourceMappingURL=diff.js.map

package/dist/object/diff.js.map

@@ -1 +1 @@
-{"version":3,"file":"diff.js","names":[],"sources":["../../src/object/diff.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isEqual } from '../guards/isEqual';\nimport type { Obj } from '../types';\n\nexport type DiffResult<T extends Obj> = {\n  /** Keys present in `after` but not in `before`. */\n  added: Array<keyof T & string>;\n  /** Keys present in both objects whose values differ. Maps key → `{ before, after }`. */\n  changed: { [K in keyof T]?: { after: T[K]; before: T[K] } };\n  /** Keys present in `before` but not in `after`. */\n  removed: Array<keyof T & string>;\n};\n\n/**\n * Computes the structural difference between two plain objects.\n * Returns an `{ added, removed, changed }` result — no sentinel symbols needed.\n * Dangerous keys (`__proto__`, `constructor`, `prototype`) are omitted from `changed`.\n *\n * @example\n * ```ts\n * diff({ a: 1, b: 2, c: 3 }, { a: 1, b: 99 });\n * // { added: [], removed: ['c'], changed: { b: { before: 2, after: 99 } } }\n *\n * diff({ x: { n: 1 } }, { x: { n: 2 } });\n * // { added: [], removed: [], changed: { x: { before: { n: 1 }, after: { n: 2 } } } }\n * ```\n *\n * @param before - The original object.\n * @param after - The updated object.\n * @param compareFn - Custom equality function. Defaults to deep `isEqual`.\n */\nexport function diff<T extends Obj>(\n  before: T = {} as T,\n  after: T = {} as T,\n  compareFn: (a: unknown, b: unknown) => boolean = isEqual,\n): DiffResult<T> {\n  const added: Array<keyof T & string> = [];\n  const removed: Array<keyof T & string> = [];\n  const changed: Record<string, { after: unknown; before: unknown }> = {};\n\n  const beforeKeys = new Set(Object.keys(before));\n  const afterKeys = new Set(Object.keys(after));\n\n  for (const key of afterKeys) {\n    if (!beforeKeys.has(key)) {\n      added.push(key as keyof T & string);\n    } else if (!isUnsafeKey(key) && !compareFn(before[key], after[key])) {\n      changed[key] = { after: after[key], before: before[key] };\n    }\n  }\n\n  for (const key of beforeKeys) {\n    if (!afterKeys.has(key)) {\n      removed.push(key as keyof T & string);\n    }\n  }\n\n  return { added, changed: changed as DiffResult<T>['changed'], removed };\n}\n\nexport type ArrayDiff<T> = {\n  added: T[];\n  removed: T[];\n};\n\nexport type ArrayDiffOptions<T> = {\n  compareFn?: (a: T, b: T) => boolean;\n};\n\n/**\n * Computes the set-difference between two arrays.\n * Items present in `after` but not `before` are `added`.\n * Items present in `before` but not `after` are `removed`.\n * Order-independent; uses deep equality by default.\n *\n * @example\n * ```ts\n * diffArrays([1, 2, 3], [2, 3, 4]); // { added: [4], removed: [1] }\n * diffArrays(\n *   [{ id: 1 }, { id: 2 }],\n *   [{ id: 2 }, { id: 3 }],\n *   { compareFn: (a, b) => a.id === b.id },\n * ); // { added: [{ id: 3 }], removed: [{ id: 1 }] }\n * ```\n *\n * @param before - The original array.\n * @param after - The updated array.\n * @param [options.compareFn] - Custom equality function. Defaults to deep `isEqual`.\n * @returns An object with `added` and `removed` arrays.\n */\nexport function diffArrays<T>(before: T[], after: T[], options?: ArrayDiffOptions<T>): ArrayDiff<T> {\n  const compareFn = options?.compareFn ?? ((a: T, b: T) => isEqual(a, b));\n\n  return {\n    added: after.filter((item) => !before.some((b) => compareFn(b, item))),\n    removed: before.filter((item) => !after.some((a) => compareFn(item, a))),\n  };\n}\n"],"mappings":";;;AA+BA,SAAgB,EACd,IAAY,CAAC,GACb,IAAW,CAAC,GACZ,IAAiD,GAClC;CACf,IAAM,IAAiC,CAAC,GAClC,IAAmC,CAAC,GACpC,IAA+D,CAAC,GAEhE,IAAa,IAAI,IAAI,OAAO,KAAK,CAAM,CAAC,GACxC,IAAY,IAAI,IAAI,OAAO,KAAK,CAAK,CAAC;CAE5C,KAAK,IAAM,KAAO,GAChB,AAAK,EAAW,IAAI,CAAG,IAEZ,CAAC,EAAY,CAAG,KAAK,CAAC,EAAU,EAAO,IAAM,EAAM,EAAI,MAChE,EAAQ,KAAO;EAAE,OAAO,EAAM;EAAM,QAAQ,EAAO;CAAK,KAFxD,EAAM,KAAK,CAAuB;CAMtC,KAAK,IAAM,KAAO,GAChB,AAAK,EAAU,IAAI,CAAG,KACpB,EAAQ,KAAK,CAAuB;CAIxC,OAAO;EAAE;EAAgB;EAAqC;CAAQ;AACxE;AAgCA,SAAgB,EAAc,GAAa,GAAY,GAA6C;CAClG,IAAM,IAAY,GAAS,eAAe,GAAM,MAAS,EAAQ,GAAG,CAAC;CAErE,OAAO;EACL,OAAO,EAAM,QAAQ,MAAS,CAAC,EAAO,MAAM,MAAM,EAAU,GAAG,CAAI,CAAC,CAAC;EACrE,SAAS,EAAO,QAAQ,MAAS,CAAC,EAAM,MAAM,MAAM,EAAU,GAAM,CAAC,CAAC,CAAC;CACzE;AACF"}
+{"version":3,"file":"diff.js","names":[],"sources":["../../src/object/diff.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { isEqual } from '../guards/isEqual';\nimport type { Obj } from '../types';\n\nexport type DiffResult<T extends Obj> = {\n  /** Keys present in `after` but not in `before`. */\n  added: Array<keyof T & string>;\n  /** Keys present in both objects whose values differ. Maps key → `{ before, after }`. */\n  changed: { [K in keyof T]?: { after: T[K]; before: T[K] } };\n  /** Keys present in `before` but not in `after`. */\n  removed: Array<keyof T & string>;\n};\n\n/**\n * Computes the structural difference between two plain objects.\n * Returns an `{ added, removed, changed }` result — no sentinel symbols needed.\n * Dangerous keys (`__proto__`, `constructor`, `prototype`) are omitted from `changed`.\n *\n * @example\n * ```ts\n * diff({ a: 1, b: 2, c: 3 }, { a: 1, b: 99 });\n * // { added: [], removed: ['c'], changed: { b: { before: 2, after: 99 } } }\n *\n * diff({ x: { n: 1 } }, { x: { n: 2 } });\n * // { added: [], removed: [], changed: { x: { before: { n: 1 }, after: { n: 2 } } } }\n * ```\n *\n * @param before - The original object.\n * @param after - The updated object.\n * @param compareFn - Custom equality function. Defaults to deep `isEqual`.\n */\nexport function diff<T extends Obj>(\n  before: T = {} as T,\n  after: T = {} as T,\n  compareFn: (a: unknown, b: unknown) => boolean = isEqual,\n): DiffResult<T> {\n  const added: Array<keyof T & string> = [];\n  const removed: Array<keyof T & string> = [];\n  const changed: Record<string, { after: unknown; before: unknown }> = {};\n\n  const beforeKeys = new Set(Object.keys(before));\n  const afterKeys = new Set(Object.keys(after));\n\n  for (const key of afterKeys) {\n    if (!beforeKeys.has(key)) {\n      added.push(key as keyof T & string);\n    } else if (!isUnsafeKey(key) && !compareFn(before[key], after[key])) {\n      changed[key] = { after: after[key], before: before[key] };\n    }\n  }\n\n  for (const key of beforeKeys) {\n    if (!afterKeys.has(key)) {\n      removed.push(key as keyof T & string);\n    }\n  }\n\n  return { added, changed: changed as DiffResult<T>['changed'], removed };\n}\n\nexport type ArrayDiff<T> = {\n  added: T[];\n  removed: T[];\n};\n\nexport type ArrayDiffOptions<T> = {\n  compareFn?: (a: T, b: T) => boolean;\n};\n\n/**\n * Computes the set-difference between two arrays.\n * Items present in `after` but not `before` are `added`.\n * Items present in `before` but not `after` are `removed`.\n * Order-independent; uses deep equality by default.\n *\n * @example\n * ```ts\n * diffArrays([1, 2, 3], [2, 3, 4]); // { added: [4], removed: [1] }\n * diffArrays(\n *   [{ id: 1 }, { id: 2 }],\n *   [{ id: 2 }, { id: 3 }],\n *   { compareFn: (a, b) => a.id === b.id },\n * ); // { added: [{ id: 3 }], removed: [{ id: 1 }] }\n * ```\n *\n * @param before - The original array.\n * @param after - The updated array.\n * @param [options.compareFn] - Custom equality function. Defaults to deep `isEqual`.\n * @returns An object with `added` and `removed` arrays.\n */\nexport function diffArrays<T>(before: readonly T[], after: readonly T[], options?: ArrayDiffOptions<T>): ArrayDiff<T> {\n  const compareFn = options?.compareFn ?? ((a: T, b: T) => isEqual(a, b));\n\n  return {\n    added: after.filter((item) => !before.some((b) => compareFn(b, item))),\n    removed: before.filter((item) => !after.some((a) => compareFn(item, a))),\n  };\n}\n"],"mappings":"uGA+BA,SAAgB,KACd,EAAY,CAAC,EACb,EAAW,CAAC,EACZ,EAAiD,EAClC,CACf,IAAM,EAAiC,CAAC,EAClC,EAAmC,CAAC,EACpC,EAA+D,CAAC,EAEhE,EAAa,IAAI,IAAI,OAAO,KAAK,CAAM,CAAC,EACxC,EAAY,IAAI,IAAI,OAAO,KAAK,CAAK,CAAC,EAE5C,IAAK,IAAM,KAAO,EACX,EAAW,IAAI,CAAG,EAEZ,CAAC,EAAY,CAAG,GAAK,CAAC,EAAU,EAAO,GAAM,EAAM,EAAI,IAChE,EAAQ,GAAO,CAAE,MAAO,EAAM,GAAM,OAAQ,EAAO,EAAK,GAFxD,EAAM,KAAK,CAAuB,EAMtC,IAAK,IAAM,KAAO,EACX,EAAU,IAAI,CAAG,GACpB,EAAQ,KAAK,CAAuB,EAIxC,MAAO,CAAE,QAAgB,UAAqC,SAAQ,CACxE,CAgCA,SAAgB,WAAc,EAAsB,EAAqB,EAA6C,CACpH,IAAM,EAAY,GAAS,aAAe,EAAM,IAAS,EAAQ,EAAG,CAAC,GAErE,MAAO,CACL,MAAO,EAAM,OAAQ,GAAS,CAAC,EAAO,KAAM,GAAM,EAAU,EAAG,CAAI,CAAC,CAAC,EACrE,QAAS,EAAO,OAAQ,GAAS,CAAC,EAAM,KAAM,GAAM,EAAU,EAAM,CAAC,CAAC,CAAC,CACzE,CACF"}

package/dist/object/filterValues.cjs

@@ -1,2 +1,2 @@
-const e=require("../_common/unsafePaths.cjs");function t(t,n){let r={};for(let i of Object.keys(t))e.isUnsafeKey(i)||n(t[i],i,t)&&(r[i]=t[i]);return r}exports.filterValues=t;
+const e=require("../_common/unsafePaths.cjs");function filterValues(t,n){let r={};for(let i of Object.keys(t))e.isUnsafeKey(i)||n(t[i],i,t)&&(r[i]=t[i]);return r}exports.filterValues=filterValues;
 //# sourceMappingURL=filterValues.cjs.map

package/dist/object/filterValues.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"filterValues.cjs","names":[],"sources":["../../src/object/filterValues.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport type { Obj } from '../types';\n\n/**\n * Filters object entries using a value predicate. Dangerous keys (`__proto__`, `constructor`,\n * `prototype`) are always skipped.\n *\n * @example\n * ```ts\n * filterValues({ a: 1, b: 2, c: 3 }, (value) => value > 1); // { b: 2, c: 3 }\n * ```\n *\n * @param obj - The source object.\n * @param predicate - Returns `true` to keep an entry.\n * @returns A new object containing only entries for which `predicate` returned `true`.\n */\nexport function filterValues<T extends Obj>(\n  obj: T,\n  predicate: (value: T[keyof T], key: keyof T, obj: T) => boolean,\n): Partial<T> {\n  const out: Partial<T> = {};\n\n  for (const key of Object.keys(obj) as Array<keyof T>) {\n    if (isUnsafeKey(key as PropertyKey)) continue;\n\n    if (predicate(obj[key], key, obj)) {\n      out[key] = obj[key];\n    }\n  }\n\n  return out;\n}\n"],"mappings":"8CAgBA,SAAgB,EACd,EACA,EACY,CACZ,IAAM,EAAkB,CAAC,EAEzB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAG,EAC3B,EAAA,YAAY,CAAkB,GAE9B,EAAU,EAAI,GAAM,EAAK,CAAG,IAC9B,EAAI,GAAO,EAAI,IAInB,OAAO,CACT"}
+{"version":3,"file":"filterValues.cjs","names":[],"sources":["../../src/object/filterValues.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport type { Obj } from '../types';\n\n/**\n * Filters object entries using a value predicate. Dangerous keys (`__proto__`, `constructor`,\n * `prototype`) are always skipped.\n *\n * @example\n * ```ts\n * filterValues({ a: 1, b: 2, c: 3 }, (value) => value > 1); // { b: 2, c: 3 }\n * ```\n *\n * @param obj - The source object.\n * @param predicate - Returns `true` to keep an entry.\n * @returns A new object containing only entries for which `predicate` returned `true`.\n */\nexport function filterValues<T extends Obj>(\n  obj: T,\n  predicate: (value: T[keyof T], key: keyof T, obj: T) => boolean,\n): Partial<T> {\n  const out: Partial<T> = {};\n\n  for (const key of Object.keys(obj) as Array<keyof T>) {\n    if (isUnsafeKey(key as PropertyKey)) continue;\n\n    if (predicate(obj[key], key, obj)) {\n      out[key] = obj[key];\n    }\n  }\n\n  return out;\n}\n"],"mappings":"8CAgBA,SAAgB,aACd,EACA,EACY,CACZ,IAAM,EAAkB,CAAC,EAEzB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAG,EAC3B,EAAA,YAAY,CAAkB,GAE9B,EAAU,EAAI,GAAM,EAAK,CAAG,IAC9B,EAAI,GAAO,EAAI,IAInB,OAAO,CACT"}

package/dist/object/filterValues.js

@@ -1,11 +1,2 @@
-import { isUnsafeKey as e } from "../_common/unsafePaths.js";
-//#region src/object/filterValues.ts
-function t(t, n) {
-	let r = {};
-	for (let i of Object.keys(t)) e(i) || n(t[i], i, t) && (r[i] = t[i]);
-	return r;
-}
-//#endregion
-export { t as filterValues };
-
+import{isUnsafeKey as e}from"../_common/unsafePaths.js";function filterValues(t,n){let r={};for(let i of Object.keys(t))e(i)||n(t[i],i,t)&&(r[i]=t[i]);return r}export{filterValues};
 //# sourceMappingURL=filterValues.js.map

package/dist/object/filterValues.js.map

@@ -1 +1 @@
-{"version":3,"file":"filterValues.js","names":[],"sources":["../../src/object/filterValues.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport type { Obj } from '../types';\n\n/**\n * Filters object entries using a value predicate. Dangerous keys (`__proto__`, `constructor`,\n * `prototype`) are always skipped.\n *\n * @example\n * ```ts\n * filterValues({ a: 1, b: 2, c: 3 }, (value) => value > 1); // { b: 2, c: 3 }\n * ```\n *\n * @param obj - The source object.\n * @param predicate - Returns `true` to keep an entry.\n * @returns A new object containing only entries for which `predicate` returned `true`.\n */\nexport function filterValues<T extends Obj>(\n  obj: T,\n  predicate: (value: T[keyof T], key: keyof T, obj: T) => boolean,\n): Partial<T> {\n  const out: Partial<T> = {};\n\n  for (const key of Object.keys(obj) as Array<keyof T>) {\n    if (isUnsafeKey(key as PropertyKey)) continue;\n\n    if (predicate(obj[key], key, obj)) {\n      out[key] = obj[key];\n    }\n  }\n\n  return out;\n}\n"],"mappings":";;AAgBA,SAAgB,EACd,GACA,GACY;CACZ,IAAM,IAAkB,CAAC;CAEzB,KAAK,IAAM,KAAO,OAAO,KAAK,CAAG,GAC3B,EAAY,CAAkB,KAE9B,EAAU,EAAI,IAAM,GAAK,CAAG,MAC9B,EAAI,KAAO,EAAI;CAInB,OAAO;AACT"}
+{"version":3,"file":"filterValues.js","names":[],"sources":["../../src/object/filterValues.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport type { Obj } from '../types';\n\n/**\n * Filters object entries using a value predicate. Dangerous keys (`__proto__`, `constructor`,\n * `prototype`) are always skipped.\n *\n * @example\n * ```ts\n * filterValues({ a: 1, b: 2, c: 3 }, (value) => value > 1); // { b: 2, c: 3 }\n * ```\n *\n * @param obj - The source object.\n * @param predicate - Returns `true` to keep an entry.\n * @returns A new object containing only entries for which `predicate` returned `true`.\n */\nexport function filterValues<T extends Obj>(\n  obj: T,\n  predicate: (value: T[keyof T], key: keyof T, obj: T) => boolean,\n): Partial<T> {\n  const out: Partial<T> = {};\n\n  for (const key of Object.keys(obj) as Array<keyof T>) {\n    if (isUnsafeKey(key as PropertyKey)) continue;\n\n    if (predicate(obj[key], key, obj)) {\n      out[key] = obj[key];\n    }\n  }\n\n  return out;\n}\n"],"mappings":"wDAgBA,SAAgB,aACd,EACA,EACY,CACZ,IAAM,EAAkB,CAAC,EAEzB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAG,EAC3B,EAAY,CAAkB,GAE9B,EAAU,EAAI,GAAM,EAAK,CAAG,IAC9B,EAAI,GAAO,EAAI,IAInB,OAAO,CACT"}

package/dist/object/flattenPaths.cjs

@@ -1,2 +1,2 @@
-const e=require("../_common/unsafePaths.cjs"),t=require("../guards/isPlainObject.cjs");var n=10;function r(i,a,o){let s={};for(let[c,l]of Object.entries(i)){if(e.UNSAFE_PATH_SEGMENTS.has(c))continue;let i=a?`${a}.${c}`:c;t.isPlainObject(l)&&o<n?Object.assign(s,r(l,i,o+1)):s[i]=l}return s}function i(e){return r(e,``,0)}function a(n){let r={};for(let[i,a]of Object.entries(n)){let n=i.split(`.`);if(n.some(t=>e.UNSAFE_PATH_SEGMENTS.has(t)))continue;let o=r;for(let e=0;e<n.length-1;e++)t.isPlainObject(o[n[e]])||(o[n[e]]={}),o=o[n[e]];o[n[n.length-1]]=a}return r}exports.flattenPaths=i,exports.unflattenPaths=a;
+const e=require("../_common/unsafePaths.cjs"),t=require("../guards/isPlainObject.cjs");var n=10;function _flattenPaths(r,i,a){let o={};for(let[s,c]of Object.entries(r)){if(e.UNSAFE_PATH_SEGMENTS.has(s))continue;let r=i?`${i}.${s}`:s;t.isPlainObject(c)&&a<n?Object.assign(o,_flattenPaths(c,r,a+1)):o[r]=c}return o}function flattenPaths(e){return _flattenPaths(e,``,0)}function unflattenPaths(n){let r={};for(let[i,a]of Object.entries(n)){let n=i.split(`.`);if(n.some(t=>e.UNSAFE_PATH_SEGMENTS.has(t)))continue;let o=r;for(let e=0;e<n.length-1;e++)t.isPlainObject(o[n[e]])||(o[n[e]]={}),o=o[n[e]];o[n[n.length-1]]=a}return r}exports.flattenPaths=flattenPaths,exports.unflattenPaths=unflattenPaths;
 //# sourceMappingURL=flattenPaths.cjs.map

package/dist/object/flattenPaths.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"flattenPaths.cjs","names":[],"sources":["../../src/object/flattenPaths.ts"],"sourcesContent":["import { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\n\n/**\n * Flattens a nested plain object into a map of dot-notation path keys to leaf values.\n * Keys containing unsafe segments (`__proto__`, `constructor`, `prototype`) are silently skipped.\n * Nesting beyond MAX_FLATTEN_DEPTH is treated as an opaque leaf value to prevent stack overflows.\n *\n * @example\n * ```ts\n * flattenPaths({ a: { b: 1, c: 2 }, d: 3 })\n * // { 'a.b': 1, 'a.c': 2, 'd': 3 }\n * ```\n */\nconst MAX_FLATTEN_DEPTH = 10;\n\nfunction _flattenPaths(obj: Record<string, unknown>, prefix: string, depth: number): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [key, val] of Object.entries(obj)) {\n    if (UNSAFE_PATH_SEGMENTS.has(key)) continue;\n\n    const fullKey = prefix ? `${prefix}.${key}` : key;\n\n    if (isPlainObject(val) && depth < MAX_FLATTEN_DEPTH) {\n      Object.assign(result, _flattenPaths(val as Record<string, unknown>, fullKey, depth + 1));\n    } else {\n      result[fullKey] = val;\n    }\n  }\n\n  return result;\n}\n\nexport function flattenPaths(obj: Record<string, unknown>): Record<string, unknown> {\n  return _flattenPaths(obj, '', 0);\n}\n\n/**\n * Reconstructs a nested plain object from a map of dot-notation path keys to leaf values.\n * Any path containing an unsafe segment is silently skipped.\n *\n * @example\n * ```ts\n * unflattenPaths({ 'a.b': 1, 'a.c': 2, 'd': 3 })\n * // { a: { b: 1, c: 2 }, d: 3 }\n * ```\n */\nexport function unflattenPaths(flat: Record<string, unknown>): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [key, val] of Object.entries(flat)) {\n    const parts = key.split('.');\n\n    if (parts.some((p) => UNSAFE_PATH_SEGMENTS.has(p))) continue;\n\n    let obj = result;\n\n    for (let i = 0; i < parts.length - 1; i++) {\n      if (!isPlainObject(obj[parts[i]])) {\n        obj[parts[i]] = {};\n      }\n\n      obj = obj[parts[i]] as Record<string, unknown>;\n    }\n\n    obj[parts[parts.length - 1]] = val;\n  }\n\n  return result;\n}\n"],"mappings":"uFAcA,IAAM,EAAoB,GAE1B,SAAS,EAAc,EAA8B,EAAgB,EAAwC,CAC3G,IAAM,EAAkC,CAAC,EAEzC,IAAK,GAAM,CAAC,EAAK,KAAQ,OAAO,QAAQ,CAAG,EAAG,CAC5C,GAAI,EAAA,qBAAqB,IAAI,CAAG,EAAG,SAEnC,IAAM,EAAU,EAAS,GAAG,EAAO,GAAG,IAAQ,EAE1C,EAAA,cAAc,CAAG,GAAK,EAAQ,EAChC,OAAO,OAAO,EAAQ,EAAc,EAAgC,EAAS,EAAQ,CAAC,CAAC,EAEvF,EAAO,GAAW,CAEtB,CAEA,OAAO,CACT,CAEA,SAAgB,EAAa,EAAuD,CAClF,OAAO,EAAc,EAAK,GAAI,CAAC,CACjC,CAYA,SAAgB,EAAe,EAAwD,CACrF,IAAM,EAAkC,CAAC,EAEzC,IAAK,GAAM,CAAC,EAAK,KAAQ,OAAO,QAAQ,CAAI,EAAG,CAC7C,IAAM,EAAQ,EAAI,MAAM,GAAG,EAE3B,GAAI,EAAM,KAAM,GAAM,EAAA,qBAAqB,IAAI,CAAC,CAAC,EAAG,SAEpD,IAAI,EAAM,EAEV,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAS,EAAG,IAC/B,EAAA,cAAc,EAAI,EAAM,GAAG,IAC9B,EAAI,EAAM,IAAM,CAAC,GAGnB,EAAM,EAAI,EAAM,IAGlB,EAAI,EAAM,EAAM,OAAS,IAAM,CACjC,CAEA,OAAO,CACT"}
+{"version":3,"file":"flattenPaths.cjs","names":[],"sources":["../../src/object/flattenPaths.ts"],"sourcesContent":["import { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\n\n/**\n * Flattens a nested plain object into a map of dot-notation path keys to leaf values.\n * Keys containing unsafe segments (`__proto__`, `constructor`, `prototype`) are silently skipped.\n * Nesting beyond MAX_FLATTEN_DEPTH is treated as an opaque leaf value to prevent stack overflows.\n *\n * @example\n * ```ts\n * flattenPaths({ a: { b: 1, c: 2 }, d: 3 })\n * // { 'a.b': 1, 'a.c': 2, 'd': 3 }\n * ```\n */\nconst MAX_FLATTEN_DEPTH = 10;\n\nfunction _flattenPaths(obj: Record<string, unknown>, prefix: string, depth: number): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [key, val] of Object.entries(obj)) {\n    if (UNSAFE_PATH_SEGMENTS.has(key)) continue;\n\n    const fullKey = prefix ? `${prefix}.${key}` : key;\n\n    if (isPlainObject(val) && depth < MAX_FLATTEN_DEPTH) {\n      Object.assign(result, _flattenPaths(val as Record<string, unknown>, fullKey, depth + 1));\n    } else {\n      result[fullKey] = val;\n    }\n  }\n\n  return result;\n}\n\nexport function flattenPaths(obj: Record<string, unknown>): Record<string, unknown> {\n  return _flattenPaths(obj, '', 0);\n}\n\n/**\n * Reconstructs a nested plain object from a map of dot-notation path keys to leaf values.\n * Any path containing an unsafe segment is silently skipped.\n *\n * @example\n * ```ts\n * unflattenPaths({ 'a.b': 1, 'a.c': 2, 'd': 3 })\n * // { a: { b: 1, c: 2 }, d: 3 }\n * ```\n */\nexport function unflattenPaths(flat: Record<string, unknown>): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [key, val] of Object.entries(flat)) {\n    const parts = key.split('.');\n\n    if (parts.some((p) => UNSAFE_PATH_SEGMENTS.has(p))) continue;\n\n    let obj = result;\n\n    for (let i = 0; i < parts.length - 1; i++) {\n      if (!isPlainObject(obj[parts[i]])) {\n        obj[parts[i]] = {};\n      }\n\n      obj = obj[parts[i]] as Record<string, unknown>;\n    }\n\n    obj[parts[parts.length - 1]] = val;\n  }\n\n  return result;\n}\n"],"mappings":"uFAcA,IAAM,EAAoB,GAE1B,SAAS,cAAc,EAA8B,EAAgB,EAAwC,CAC3G,IAAM,EAAkC,CAAC,EAEzC,IAAK,GAAM,CAAC,EAAK,KAAQ,OAAO,QAAQ,CAAG,EAAG,CAC5C,GAAI,EAAA,qBAAqB,IAAI,CAAG,EAAG,SAEnC,IAAM,EAAU,EAAS,GAAG,EAAO,GAAG,IAAQ,EAE1C,EAAA,cAAc,CAAG,GAAK,EAAQ,EAChC,OAAO,OAAO,EAAQ,cAAc,EAAgC,EAAS,EAAQ,CAAC,CAAC,EAEvF,EAAO,GAAW,CAEtB,CAEA,OAAO,CACT,CAEA,SAAgB,aAAa,EAAuD,CAClF,OAAO,cAAc,EAAK,GAAI,CAAC,CACjC,CAYA,SAAgB,eAAe,EAAwD,CACrF,IAAM,EAAkC,CAAC,EAEzC,IAAK,GAAM,CAAC,EAAK,KAAQ,OAAO,QAAQ,CAAI,EAAG,CAC7C,IAAM,EAAQ,EAAI,MAAM,GAAG,EAE3B,GAAI,EAAM,KAAM,GAAM,EAAA,qBAAqB,IAAI,CAAC,CAAC,EAAG,SAEpD,IAAI,EAAM,EAEV,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAS,EAAG,IAC/B,EAAA,cAAc,EAAI,EAAM,GAAG,IAC9B,EAAI,EAAM,IAAM,CAAC,GAGnB,EAAM,EAAI,EAAM,IAGlB,EAAI,EAAM,EAAM,OAAS,IAAM,CACjC,CAEA,OAAO,CACT"}

package/dist/object/flattenPaths.js

@@ -1,31 +1,2 @@
-import { UNSAFE_PATH_SEGMENTS as e } from "../_common/unsafePaths.js";
-import { isPlainObject as t } from "../guards/isPlainObject.js";
-//#region src/object/flattenPaths.ts
-var n = 10;
-function r(i, a, o) {
-	let s = {};
-	for (let [c, l] of Object.entries(i)) {
-		if (e.has(c)) continue;
-		let i = a ? `${a}.${c}` : c;
-		t(l) && o < n ? Object.assign(s, r(l, i, o + 1)) : s[i] = l;
-	}
-	return s;
-}
-function i(e) {
-	return r(e, "", 0);
-}
-function a(n) {
-	let r = {};
-	for (let [i, a] of Object.entries(n)) {
-		let n = i.split(".");
-		if (n.some((t) => e.has(t))) continue;
-		let o = r;
-		for (let e = 0; e < n.length - 1; e++) t(o[n[e]]) || (o[n[e]] = {}), o = o[n[e]];
-		o[n[n.length - 1]] = a;
-	}
-	return r;
-}
-//#endregion
-export { i as flattenPaths, a as unflattenPaths };
-
+import{UNSAFE_PATH_SEGMENTS as e}from"../_common/unsafePaths.js";import{isPlainObject as t}from"../guards/isPlainObject.js";var n=10;function _flattenPaths(r,i,a){let o={};for(let[s,c]of Object.entries(r)){if(e.has(s))continue;let r=i?`${i}.${s}`:s;t(c)&&a<n?Object.assign(o,_flattenPaths(c,r,a+1)):o[r]=c}return o}function flattenPaths(e){return _flattenPaths(e,``,0)}function unflattenPaths(n){let r={};for(let[i,a]of Object.entries(n)){let n=i.split(`.`);if(n.some(t=>e.has(t)))continue;let o=r;for(let e=0;e<n.length-1;e++)t(o[n[e]])||(o[n[e]]={}),o=o[n[e]];o[n[n.length-1]]=a}return r}export{flattenPaths,unflattenPaths};
 //# sourceMappingURL=flattenPaths.js.map

package/dist/object/flattenPaths.js.map

@@ -1 +1 @@
-{"version":3,"file":"flattenPaths.js","names":[],"sources":["../../src/object/flattenPaths.ts"],"sourcesContent":["import { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\n\n/**\n * Flattens a nested plain object into a map of dot-notation path keys to leaf values.\n * Keys containing unsafe segments (`__proto__`, `constructor`, `prototype`) are silently skipped.\n * Nesting beyond MAX_FLATTEN_DEPTH is treated as an opaque leaf value to prevent stack overflows.\n *\n * @example\n * ```ts\n * flattenPaths({ a: { b: 1, c: 2 }, d: 3 })\n * // { 'a.b': 1, 'a.c': 2, 'd': 3 }\n * ```\n */\nconst MAX_FLATTEN_DEPTH = 10;\n\nfunction _flattenPaths(obj: Record<string, unknown>, prefix: string, depth: number): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [key, val] of Object.entries(obj)) {\n    if (UNSAFE_PATH_SEGMENTS.has(key)) continue;\n\n    const fullKey = prefix ? `${prefix}.${key}` : key;\n\n    if (isPlainObject(val) && depth < MAX_FLATTEN_DEPTH) {\n      Object.assign(result, _flattenPaths(val as Record<string, unknown>, fullKey, depth + 1));\n    } else {\n      result[fullKey] = val;\n    }\n  }\n\n  return result;\n}\n\nexport function flattenPaths(obj: Record<string, unknown>): Record<string, unknown> {\n  return _flattenPaths(obj, '', 0);\n}\n\n/**\n * Reconstructs a nested plain object from a map of dot-notation path keys to leaf values.\n * Any path containing an unsafe segment is silently skipped.\n *\n * @example\n * ```ts\n * unflattenPaths({ 'a.b': 1, 'a.c': 2, 'd': 3 })\n * // { a: { b: 1, c: 2 }, d: 3 }\n * ```\n */\nexport function unflattenPaths(flat: Record<string, unknown>): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [key, val] of Object.entries(flat)) {\n    const parts = key.split('.');\n\n    if (parts.some((p) => UNSAFE_PATH_SEGMENTS.has(p))) continue;\n\n    let obj = result;\n\n    for (let i = 0; i < parts.length - 1; i++) {\n      if (!isPlainObject(obj[parts[i]])) {\n        obj[parts[i]] = {};\n      }\n\n      obj = obj[parts[i]] as Record<string, unknown>;\n    }\n\n    obj[parts[parts.length - 1]] = val;\n  }\n\n  return result;\n}\n"],"mappings":";;;AAcA,IAAM,IAAoB;AAE1B,SAAS,EAAc,GAA8B,GAAgB,GAAwC;CAC3G,IAAM,IAAkC,CAAC;CAEzC,KAAK,IAAM,CAAC,GAAK,MAAQ,OAAO,QAAQ,CAAG,GAAG;EAC5C,IAAI,EAAqB,IAAI,CAAG,GAAG;EAEnC,IAAM,IAAU,IAAS,GAAG,EAAO,GAAG,MAAQ;EAE9C,AAAI,EAAc,CAAG,KAAK,IAAQ,IAChC,OAAO,OAAO,GAAQ,EAAc,GAAgC,GAAS,IAAQ,CAAC,CAAC,IAEvF,EAAO,KAAW;CAEtB;CAEA,OAAO;AACT;AAEA,SAAgB,EAAa,GAAuD;CAClF,OAAO,EAAc,GAAK,IAAI,CAAC;AACjC;AAYA,SAAgB,EAAe,GAAwD;CACrF,IAAM,IAAkC,CAAC;CAEzC,KAAK,IAAM,CAAC,GAAK,MAAQ,OAAO,QAAQ,CAAI,GAAG;EAC7C,IAAM,IAAQ,EAAI,MAAM,GAAG;EAE3B,IAAI,EAAM,MAAM,MAAM,EAAqB,IAAI,CAAC,CAAC,GAAG;EAEpD,IAAI,IAAM;EAEV,KAAK,IAAI,IAAI,GAAG,IAAI,EAAM,SAAS,GAAG,KAKpC,AAJK,EAAc,EAAI,EAAM,GAAG,MAC9B,EAAI,EAAM,MAAM,CAAC,IAGnB,IAAM,EAAI,EAAM;EAGlB,EAAI,EAAM,EAAM,SAAS,MAAM;CACjC;CAEA,OAAO;AACT"}
+{"version":3,"file":"flattenPaths.js","names":[],"sources":["../../src/object/flattenPaths.ts"],"sourcesContent":["import { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\n\n/**\n * Flattens a nested plain object into a map of dot-notation path keys to leaf values.\n * Keys containing unsafe segments (`__proto__`, `constructor`, `prototype`) are silently skipped.\n * Nesting beyond MAX_FLATTEN_DEPTH is treated as an opaque leaf value to prevent stack overflows.\n *\n * @example\n * ```ts\n * flattenPaths({ a: { b: 1, c: 2 }, d: 3 })\n * // { 'a.b': 1, 'a.c': 2, 'd': 3 }\n * ```\n */\nconst MAX_FLATTEN_DEPTH = 10;\n\nfunction _flattenPaths(obj: Record<string, unknown>, prefix: string, depth: number): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [key, val] of Object.entries(obj)) {\n    if (UNSAFE_PATH_SEGMENTS.has(key)) continue;\n\n    const fullKey = prefix ? `${prefix}.${key}` : key;\n\n    if (isPlainObject(val) && depth < MAX_FLATTEN_DEPTH) {\n      Object.assign(result, _flattenPaths(val as Record<string, unknown>, fullKey, depth + 1));\n    } else {\n      result[fullKey] = val;\n    }\n  }\n\n  return result;\n}\n\nexport function flattenPaths(obj: Record<string, unknown>): Record<string, unknown> {\n  return _flattenPaths(obj, '', 0);\n}\n\n/**\n * Reconstructs a nested plain object from a map of dot-notation path keys to leaf values.\n * Any path containing an unsafe segment is silently skipped.\n *\n * @example\n * ```ts\n * unflattenPaths({ 'a.b': 1, 'a.c': 2, 'd': 3 })\n * // { a: { b: 1, c: 2 }, d: 3 }\n * ```\n */\nexport function unflattenPaths(flat: Record<string, unknown>): Record<string, unknown> {\n  const result: Record<string, unknown> = {};\n\n  for (const [key, val] of Object.entries(flat)) {\n    const parts = key.split('.');\n\n    if (parts.some((p) => UNSAFE_PATH_SEGMENTS.has(p))) continue;\n\n    let obj = result;\n\n    for (let i = 0; i < parts.length - 1; i++) {\n      if (!isPlainObject(obj[parts[i]])) {\n        obj[parts[i]] = {};\n      }\n\n      obj = obj[parts[i]] as Record<string, unknown>;\n    }\n\n    obj[parts[parts.length - 1]] = val;\n  }\n\n  return result;\n}\n"],"mappings":"4HAcA,IAAM,EAAoB,GAE1B,SAAS,cAAc,EAA8B,EAAgB,EAAwC,CAC3G,IAAM,EAAkC,CAAC,EAEzC,IAAK,GAAM,CAAC,EAAK,KAAQ,OAAO,QAAQ,CAAG,EAAG,CAC5C,GAAI,EAAqB,IAAI,CAAG,EAAG,SAEnC,IAAM,EAAU,EAAS,GAAG,EAAO,GAAG,IAAQ,EAE1C,EAAc,CAAG,GAAK,EAAQ,EAChC,OAAO,OAAO,EAAQ,cAAc,EAAgC,EAAS,EAAQ,CAAC,CAAC,EAEvF,EAAO,GAAW,CAEtB,CAEA,OAAO,CACT,CAEA,SAAgB,aAAa,EAAuD,CAClF,OAAO,cAAc,EAAK,GAAI,CAAC,CACjC,CAYA,SAAgB,eAAe,EAAwD,CACrF,IAAM,EAAkC,CAAC,EAEzC,IAAK,GAAM,CAAC,EAAK,KAAQ,OAAO,QAAQ,CAAI,EAAG,CAC7C,IAAM,EAAQ,EAAI,MAAM,GAAG,EAE3B,GAAI,EAAM,KAAM,GAAM,EAAqB,IAAI,CAAC,CAAC,EAAG,SAEpD,IAAI,EAAM,EAEV,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAS,EAAG,IAC/B,EAAc,EAAI,EAAM,GAAG,IAC9B,EAAI,EAAM,IAAM,CAAC,GAGnB,EAAM,EAAI,EAAM,IAGlB,EAAI,EAAM,EAAM,OAAS,IAAM,CACjC,CAEA,OAAO,CACT"}

package/dist/object/getPath.cjs

@@ -1,2 +1,2 @@
-const e=require("../_common/unsafePaths.cjs");function t(e){return e.replace(/\[(\d+)\]/g,`.$1`).replace(/^\.|\.$/g,``).split(`.`).filter(Boolean)}function n(n,r){let i=n;for(let n of t(r))if(e.UNSAFE_PATH_SEGMENTS.has(n)||typeof i!=`object`||!i||(i=i[n],i===void 0))return;return i}function r(e,t){return n(e,t)}function i(e,t,r){let i=n(e,t);return i===void 0?r:i}function a(e,t){let r=n(e,t);if(r===void 0)throw TypeError(`Path does not exist: '${t}'`);return r}exports.getPath=r,exports.getPathOr=i,exports.requirePath=a;
+const e=require("../_common/unsafePaths.cjs");function pathSegments(e){return e.replace(/\[(\d+)\]/g,`.$1`).replace(/^\.|\.$/g,``).split(`.`).filter(Boolean)}function readPath(t,n){let r=t;for(let t of pathSegments(n))if(e.UNSAFE_PATH_SEGMENTS.has(t)||typeof r!=`object`||!r||(r=r[t],r===void 0))return;return r}function getPath(e,t){return readPath(e,t)}function getPathOr(e,t,n){let r=readPath(e,t);return r===void 0?n:r}function requirePath(e,t){let n=readPath(e,t);if(n===void 0)throw TypeError(`Path does not exist: '${t}'`);return n}exports.getPath=getPath,exports.getPathOr=getPathOr,exports.requirePath=requirePath;
 //# sourceMappingURL=getPath.cjs.map

package/dist/object/getPath.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getPath.cjs","names":[],"sources":["../../src/object/getPath.ts"],"sourcesContent":["import { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\nimport type { Obj } from '../types';\n\ntype PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}`\n  ? Key extends keyof T\n    ? PathValue<T[Key], Rest>\n    : undefined\n  : P extends keyof T\n    ? T[P]\n    : undefined;\n\nfunction pathSegments(path: string): string[] {\n  return path\n    .replace(/\\[(\\d+)\\]/g, '.$1')\n    .replace(/^\\.|\\.$/g, '')\n    .split('.')\n    .filter(Boolean);\n}\n\nfunction readPath(item: Obj, path: string): unknown {\n  let current: unknown = item;\n\n  for (const segment of pathSegments(path)) {\n    if (UNSAFE_PATH_SEGMENTS.has(segment) || current == null || typeof current !== 'object') return undefined;\n\n    current = (current as Record<string, unknown>)[segment];\n\n    if (current === undefined) return undefined;\n  }\n\n  return current;\n}\n\n/**\n * Retrieves a value at a dot-notation or numeric bracket-notation path.\n * Returns `undefined` when the path is missing or contains an unsafe segment.\n * Use `getPathOr` to supply a fallback or `requirePath` to throw on a missing path.\n */\nexport function getPath<T extends Obj, P extends string>(item: T, path: P): PathValue<T, P> | undefined {\n  return readPath(item, path) as PathValue<T, P> | undefined;\n}\n\n/**\n * Retrieves a value at a path or returns `fallback` when the path is missing.\n */\nexport function getPathOr<T extends Obj, P extends string, F>(item: T, path: P, fallback: F): PathValue<T, P> | F {\n  const value = readPath(item, path);\n\n  return (value === undefined ? fallback : value) as PathValue<T, P> | F;\n}\n\n/**\n * Retrieves a value at a path or throws when the path is missing.\n */\nexport function requirePath<T extends Obj, P extends string>(item: T, path: P): Exclude<PathValue<T, P>, undefined> {\n  const value = readPath(item, path);\n\n  if (value === undefined) throw new TypeError(`Path does not exist: '${path}'`);\n\n  return value as Exclude<PathValue<T, P>, undefined>;\n}\n"],"mappings":"8CAWA,SAAS,EAAa,EAAwB,CAC5C,OAAO,EACJ,QAAQ,aAAc,KAAK,CAAC,CAC5B,QAAQ,WAAY,EAAE,CAAC,CACvB,MAAM,GAAG,CAAC,CACV,OAAO,OAAO,CACnB,CAEA,SAAS,EAAS,EAAW,EAAuB,CAClD,IAAI,EAAmB,EAEvB,IAAK,IAAM,KAAW,EAAa,CAAI,EAKrC,GAJI,EAAA,qBAAqB,IAAI,CAAO,GAAwB,OAAO,GAAY,WAAtC,IAEzC,EAAW,EAAoC,GAE3C,IAAY,IAAA,IAAW,OAG7B,OAAO,CACT,CAOA,SAAgB,EAAyC,EAAS,EAAsC,CACtG,OAAO,EAAS,EAAM,CAAI,CAC5B,CAKA,SAAgB,EAA8C,EAAS,EAAS,EAAkC,CAChH,IAAM,EAAQ,EAAS,EAAM,CAAI,EAEjC,OAAQ,IAAU,IAAA,GAAY,EAAW,CAC3C,CAKA,SAAgB,EAA6C,EAAS,EAA8C,CAClH,IAAM,EAAQ,EAAS,EAAM,CAAI,EAEjC,GAAI,IAAU,IAAA,GAAW,MAAU,UAAU,yBAAyB,EAAK,EAAE,EAE7E,OAAO,CACT"}
+{"version":3,"file":"getPath.cjs","names":[],"sources":["../../src/object/getPath.ts"],"sourcesContent":["import { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\nimport type { Obj } from '../types';\n\ntype PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}`\n  ? Key extends keyof T\n    ? PathValue<T[Key], Rest>\n    : undefined\n  : P extends keyof T\n    ? T[P]\n    : undefined;\n\nfunction pathSegments(path: string): string[] {\n  return path\n    .replace(/\\[(\\d+)\\]/g, '.$1')\n    .replace(/^\\.|\\.$/g, '')\n    .split('.')\n    .filter(Boolean);\n}\n\nfunction readPath(item: Obj, path: string): unknown {\n  let current: unknown = item;\n\n  for (const segment of pathSegments(path)) {\n    if (UNSAFE_PATH_SEGMENTS.has(segment) || current == null || typeof current !== 'object') return undefined;\n\n    current = (current as Record<string, unknown>)[segment];\n\n    if (current === undefined) return undefined;\n  }\n\n  return current;\n}\n\n/**\n * Retrieves a value at a dot-notation or numeric bracket-notation path.\n * Returns `undefined` when the path is missing or contains an unsafe segment.\n * Use `getPathOr` to supply a fallback or `requirePath` to throw on a missing path.\n */\nexport function getPath<T extends Obj, P extends string>(item: T, path: P): PathValue<T, P> | undefined {\n  return readPath(item, path) as PathValue<T, P> | undefined;\n}\n\n/**\n * Retrieves a value at a path or returns `fallback` when the path is missing.\n */\nexport function getPathOr<T extends Obj, P extends string, F>(item: T, path: P, fallback: F): PathValue<T, P> | F {\n  const value = readPath(item, path);\n\n  return (value === undefined ? fallback : value) as PathValue<T, P> | F;\n}\n\n/**\n * Retrieves a value at a path or throws when the path is missing.\n */\nexport function requirePath<T extends Obj, P extends string>(item: T, path: P): Exclude<PathValue<T, P>, undefined> {\n  const value = readPath(item, path);\n\n  if (value === undefined) throw new TypeError(`Path does not exist: '${path}'`);\n\n  return value as Exclude<PathValue<T, P>, undefined>;\n}\n"],"mappings":"8CAWA,SAAS,aAAa,EAAwB,CAC5C,OAAO,EACJ,QAAQ,aAAc,KAAK,CAAC,CAC5B,QAAQ,WAAY,EAAE,CAAC,CACvB,MAAM,GAAG,CAAC,CACV,OAAO,OAAO,CACnB,CAEA,SAAS,SAAS,EAAW,EAAuB,CAClD,IAAI,EAAmB,EAEvB,IAAK,IAAM,KAAW,aAAa,CAAI,EAKrC,GAJI,EAAA,qBAAqB,IAAI,CAAO,GAAwB,OAAO,GAAY,WAAtC,IAEzC,EAAW,EAAoC,GAE3C,IAAY,IAAA,IAAW,OAG7B,OAAO,CACT,CAOA,SAAgB,QAAyC,EAAS,EAAsC,CACtG,OAAO,SAAS,EAAM,CAAI,CAC5B,CAKA,SAAgB,UAA8C,EAAS,EAAS,EAAkC,CAChH,IAAM,EAAQ,SAAS,EAAM,CAAI,EAEjC,OAAQ,IAAU,IAAA,GAAY,EAAW,CAC3C,CAKA,SAAgB,YAA6C,EAAS,EAA8C,CAClH,IAAM,EAAQ,SAAS,EAAM,CAAI,EAEjC,GAAI,IAAU,IAAA,GAAW,MAAU,UAAU,yBAAyB,EAAK,EAAE,EAE7E,OAAO,CACT"}

package/dist/object/getPath.js

@@ -1,26 +1,2 @@
-import { UNSAFE_PATH_SEGMENTS as e } from "../_common/unsafePaths.js";
-//#region src/object/getPath.ts
-function t(e) {
-	return e.replace(/\[(\d+)\]/g, ".$1").replace(/^\.|\.$/g, "").split(".").filter(Boolean);
-}
-function n(n, r) {
-	let i = n;
-	for (let n of t(r)) if (e.has(n) || typeof i != "object" || !i || (i = i[n], i === void 0)) return;
-	return i;
-}
-function r(e, t) {
-	return n(e, t);
-}
-function i(e, t, r) {
-	let i = n(e, t);
-	return i === void 0 ? r : i;
-}
-function a(e, t) {
-	let r = n(e, t);
-	if (r === void 0) throw TypeError(`Path does not exist: '${t}'`);
-	return r;
-}
-//#endregion
-export { r as getPath, i as getPathOr, a as requirePath };
-
+import{UNSAFE_PATH_SEGMENTS as e}from"../_common/unsafePaths.js";function pathSegments(e){return e.replace(/\[(\d+)\]/g,`.$1`).replace(/^\.|\.$/g,``).split(`.`).filter(Boolean)}function readPath(t,n){let r=t;for(let t of pathSegments(n))if(e.has(t)||typeof r!=`object`||!r||(r=r[t],r===void 0))return;return r}function getPath(e,t){return readPath(e,t)}function getPathOr(e,t,n){let r=readPath(e,t);return r===void 0?n:r}function requirePath(e,t){let n=readPath(e,t);if(n===void 0)throw TypeError(`Path does not exist: '${t}'`);return n}export{getPath,getPathOr,requirePath};
 //# sourceMappingURL=getPath.js.map

package/dist/object/getPath.js.map

@@ -1 +1 @@
-{"version":3,"file":"getPath.js","names":[],"sources":["../../src/object/getPath.ts"],"sourcesContent":["import { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\nimport type { Obj } from '../types';\n\ntype PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}`\n  ? Key extends keyof T\n    ? PathValue<T[Key], Rest>\n    : undefined\n  : P extends keyof T\n    ? T[P]\n    : undefined;\n\nfunction pathSegments(path: string): string[] {\n  return path\n    .replace(/\\[(\\d+)\\]/g, '.$1')\n    .replace(/^\\.|\\.$/g, '')\n    .split('.')\n    .filter(Boolean);\n}\n\nfunction readPath(item: Obj, path: string): unknown {\n  let current: unknown = item;\n\n  for (const segment of pathSegments(path)) {\n    if (UNSAFE_PATH_SEGMENTS.has(segment) || current == null || typeof current !== 'object') return undefined;\n\n    current = (current as Record<string, unknown>)[segment];\n\n    if (current === undefined) return undefined;\n  }\n\n  return current;\n}\n\n/**\n * Retrieves a value at a dot-notation or numeric bracket-notation path.\n * Returns `undefined` when the path is missing or contains an unsafe segment.\n * Use `getPathOr` to supply a fallback or `requirePath` to throw on a missing path.\n */\nexport function getPath<T extends Obj, P extends string>(item: T, path: P): PathValue<T, P> | undefined {\n  return readPath(item, path) as PathValue<T, P> | undefined;\n}\n\n/**\n * Retrieves a value at a path or returns `fallback` when the path is missing.\n */\nexport function getPathOr<T extends Obj, P extends string, F>(item: T, path: P, fallback: F): PathValue<T, P> | F {\n  const value = readPath(item, path);\n\n  return (value === undefined ? fallback : value) as PathValue<T, P> | F;\n}\n\n/**\n * Retrieves a value at a path or throws when the path is missing.\n */\nexport function requirePath<T extends Obj, P extends string>(item: T, path: P): Exclude<PathValue<T, P>, undefined> {\n  const value = readPath(item, path);\n\n  if (value === undefined) throw new TypeError(`Path does not exist: '${path}'`);\n\n  return value as Exclude<PathValue<T, P>, undefined>;\n}\n"],"mappings":";;AAWA,SAAS,EAAa,GAAwB;CAC5C,OAAO,EACJ,QAAQ,cAAc,KAAK,CAAC,CAC5B,QAAQ,YAAY,EAAE,CAAC,CACvB,MAAM,GAAG,CAAC,CACV,OAAO,OAAO;AACnB;AAEA,SAAS,EAAS,GAAW,GAAuB;CAClD,IAAI,IAAmB;CAEvB,KAAK,IAAM,KAAW,EAAa,CAAI,GAKrC,IAJI,EAAqB,IAAI,CAAO,KAAwB,OAAO,KAAY,aAAtC,MAEzC,IAAW,EAAoC,IAE3C,MAAY,KAAA,IAAW;CAG7B,OAAO;AACT;AAOA,SAAgB,EAAyC,GAAS,GAAsC;CACtG,OAAO,EAAS,GAAM,CAAI;AAC5B;AAKA,SAAgB,EAA8C,GAAS,GAAS,GAAkC;CAChH,IAAM,IAAQ,EAAS,GAAM,CAAI;CAEjC,OAAQ,MAAU,KAAA,IAAY,IAAW;AAC3C;AAKA,SAAgB,EAA6C,GAAS,GAA8C;CAClH,IAAM,IAAQ,EAAS,GAAM,CAAI;CAEjC,IAAI,MAAU,KAAA,GAAW,MAAU,UAAU,yBAAyB,EAAK,EAAE;CAE7E,OAAO;AACT"}
+{"version":3,"file":"getPath.js","names":[],"sources":["../../src/object/getPath.ts"],"sourcesContent":["import { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\nimport type { Obj } from '../types';\n\ntype PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}`\n  ? Key extends keyof T\n    ? PathValue<T[Key], Rest>\n    : undefined\n  : P extends keyof T\n    ? T[P]\n    : undefined;\n\nfunction pathSegments(path: string): string[] {\n  return path\n    .replace(/\\[(\\d+)\\]/g, '.$1')\n    .replace(/^\\.|\\.$/g, '')\n    .split('.')\n    .filter(Boolean);\n}\n\nfunction readPath(item: Obj, path: string): unknown {\n  let current: unknown = item;\n\n  for (const segment of pathSegments(path)) {\n    if (UNSAFE_PATH_SEGMENTS.has(segment) || current == null || typeof current !== 'object') return undefined;\n\n    current = (current as Record<string, unknown>)[segment];\n\n    if (current === undefined) return undefined;\n  }\n\n  return current;\n}\n\n/**\n * Retrieves a value at a dot-notation or numeric bracket-notation path.\n * Returns `undefined` when the path is missing or contains an unsafe segment.\n * Use `getPathOr` to supply a fallback or `requirePath` to throw on a missing path.\n */\nexport function getPath<T extends Obj, P extends string>(item: T, path: P): PathValue<T, P> | undefined {\n  return readPath(item, path) as PathValue<T, P> | undefined;\n}\n\n/**\n * Retrieves a value at a path or returns `fallback` when the path is missing.\n */\nexport function getPathOr<T extends Obj, P extends string, F>(item: T, path: P, fallback: F): PathValue<T, P> | F {\n  const value = readPath(item, path);\n\n  return (value === undefined ? fallback : value) as PathValue<T, P> | F;\n}\n\n/**\n * Retrieves a value at a path or throws when the path is missing.\n */\nexport function requirePath<T extends Obj, P extends string>(item: T, path: P): Exclude<PathValue<T, P>, undefined> {\n  const value = readPath(item, path);\n\n  if (value === undefined) throw new TypeError(`Path does not exist: '${path}'`);\n\n  return value as Exclude<PathValue<T, P>, undefined>;\n}\n"],"mappings":"iEAWA,SAAS,aAAa,EAAwB,CAC5C,OAAO,EACJ,QAAQ,aAAc,KAAK,CAAC,CAC5B,QAAQ,WAAY,EAAE,CAAC,CACvB,MAAM,GAAG,CAAC,CACV,OAAO,OAAO,CACnB,CAEA,SAAS,SAAS,EAAW,EAAuB,CAClD,IAAI,EAAmB,EAEvB,IAAK,IAAM,KAAW,aAAa,CAAI,EAKrC,GAJI,EAAqB,IAAI,CAAO,GAAwB,OAAO,GAAY,WAAtC,IAEzC,EAAW,EAAoC,GAE3C,IAAY,IAAA,IAAW,OAG7B,OAAO,CACT,CAOA,SAAgB,QAAyC,EAAS,EAAsC,CACtG,OAAO,SAAS,EAAM,CAAI,CAC5B,CAKA,SAAgB,UAA8C,EAAS,EAAS,EAAkC,CAChH,IAAM,EAAQ,SAAS,EAAM,CAAI,EAEjC,OAAQ,IAAU,IAAA,GAAY,EAAW,CAC3C,CAKA,SAAgB,YAA6C,EAAS,EAA8C,CAClH,IAAM,EAAQ,SAAS,EAAM,CAAI,EAEjC,GAAI,IAAU,IAAA,GAAW,MAAU,UAAU,yBAAyB,EAAK,EAAE,EAE7E,OAAO,CACT"}

package/dist/object/hash.cjs

@@ -1,2 +1,2 @@
-const e=require("../errors.cjs");function t(n,r,i){if(n===void 0)return`undefined`;if(n===null)return`null`;if(typeof n==`bigint`)return`${n}n`;if(typeof n!=`object`)return JSON.stringify(n);if(i.has(n))return`[Circular]`;if(i.add(n),n instanceof Date)return`[Date:${Number.isNaN(n.getTime())?`Invalid`:n.toISOString()}]`;if(n instanceof RegExp)return`[RegExp:${n.source}/${n.flags}]`;if(n instanceof Set)return`[Set:${[...n].map(e=>t(e,r,i)).sort().join(`,`)}]`;if(n instanceof Map)return`[Map:${[...n.entries()].map(([e,n])=>[t(e,r,i),t(n,r,i)]).sort(([e,t],[n,r])=>e===n?t.localeCompare(r):e.localeCompare(n)).map(([e,t])=>`${e}=>${t}`).join(`,`)}]`;if(Array.isArray(n))return`[${n.map(e=>t(e,r,i)).join(`,`)}]`;let a=Object.getPrototypeOf(n);if(a!==Object.prototype&&a!==null){if(r?.onClassInstance===`throw`)throw new e.ArsenalSerializationError(`hash: unsupported type ${n.constructor?.name??`unknown`}`);return String(n)}let o=n;return`{${Object.keys(o).filter(e=>o[e]!==void 0).sort().map(e=>`${JSON.stringify(e)}:${t(o[e],r,i)}`).join(`,`)}}`}function n(e,n){return t(e,n,new Set)}exports.hash=n;
+const e=require("../errors.cjs");function _hash(t,n,r){if(t===void 0)return`undefined`;if(t===null)return`null`;if(typeof t==`bigint`)return`${t}n`;if(typeof t!=`object`)return JSON.stringify(t);if(r.has(t))return`[Circular]`;if(r.add(t),t instanceof Date)return`[Date:${Number.isNaN(t.getTime())?`Invalid`:t.toISOString()}]`;if(t instanceof RegExp)return`[RegExp:${t.source}/${t.flags}]`;if(t instanceof Set)return`[Set:${[...t].map(e=>_hash(e,n,r)).sort().join(`,`)}]`;if(t instanceof Map)return`[Map:${[...t.entries()].map(([e,t])=>[_hash(e,n,r),_hash(t,n,r)]).sort(([e,t],[n,r])=>e===n?t.localeCompare(r):e.localeCompare(n)).map(([e,t])=>`${e}=>${t}`).join(`,`)}]`;if(Array.isArray(t))return`[${t.map(e=>_hash(e,n,r)).join(`,`)}]`;let i=Object.getPrototypeOf(t);if(i!==Object.prototype&&i!==null){if(n?.onClassInstance===`throw`)throw new e.ArsenalSerializationError(`hash: unsupported type ${t.constructor?.name??`unknown`}`);return String(t)}let a=t;return`{${Object.keys(a).filter(e=>a[e]!==void 0).sort().map(e=>`${JSON.stringify(e)}:${_hash(a[e],n,r)}`).join(`,`)}}`}function hash(e,t){return _hash(e,t,new Set)}exports.hash=hash;
 //# sourceMappingURL=hash.cjs.map

package/dist/object/hash.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"hash.cjs","names":[],"sources":["../../src/object/hash.ts"],"sourcesContent":["import { ArsenalSerializationError } from '../errors';\n\nexport type HashOptions = {\n  /**\n   * What to do when a class instance is encountered (an object whose prototype is\n   * neither `Object.prototype` nor `null`).\n   *\n   * - `'coerce'` (default) — calls `String(value)`.\n   * - `'throw'` — throws an `ArsenalSerializationError`.\n   */\n  onClassInstance?: 'coerce' | 'throw';\n};\n\n/**\n * Produces a deterministic, order-independent string representation of any value.\n * Object keys are sorted alphabetically, so `{ b: 1, a: 2 }` and `{ a: 2, b: 1 }` produce\n * the same output. Handles `Date`, `RegExp`, `Set`, `Map`, and `bigint` in addition to plain JSON.\n *\n * Useful for generating stable cache keys from arbitrary query parameters or options objects.\n *\n * Class instances fall back to `String(value)` by default.\n * Pass `{ onClassInstance: 'throw' }` to throw an `ArsenalSerializationError` instead.\n *\n * @example\n * ```ts\n * hash({ b: 2, a: 1 }) // '{\"a\":1,\"b\":2}'\n * hash([3, 1, 2])      // '[3,1,2]'\n * hash(new Date('2024-01-01T00:00:00Z')) // '[Date:2024-01-01T00:00:00.000Z]'\n * hash(new Set([3, 1, 2])) // '[Set:1,2,3]'\n * hash(new MyClass(), { onClassInstance: 'throw' }) // throws ArsenalSerializationError\n * ```\n *\n * @throws {ArsenalSerializationError} If `options.onClassInstance` is `'throw'` and a class instance is encountered.\n */\nfunction _hash(value: unknown, options: HashOptions | undefined, visited: Set<object>): string {\n  if (value === undefined) return 'undefined';\n\n  if (value === null) return 'null';\n\n  if (typeof value === 'bigint') return `${value}n`;\n\n  if (typeof value !== 'object') return JSON.stringify(value);\n\n  if (visited.has(value as object)) return '[Circular]';\n\n  visited.add(value as object);\n\n  if (value instanceof Date) return `[Date:${Number.isNaN(value.getTime()) ? 'Invalid' : value.toISOString()}]`;\n\n  if (value instanceof RegExp) return `[RegExp:${value.source}/${value.flags}]`;\n\n  if (value instanceof Set)\n    return `[Set:${[...value]\n      .map((v) => _hash(v, options, visited))\n      .sort()\n      .join(',')}]`;\n\n  if (value instanceof Map) {\n    const entries = [...value.entries()]\n      .map(([key, entryValue]) => [_hash(key, options, visited), _hash(entryValue, options, visited)] as const)\n      .sort(([leftKey, leftValue], [rightKey, rightValue]) =>\n        leftKey === rightKey ? leftValue.localeCompare(rightValue) : leftKey.localeCompare(rightKey),\n      );\n\n    return `[Map:${entries.map(([key, entryValue]) => `${key}=>${entryValue}`).join(',')}]`;\n  }\n\n  if (Array.isArray(value)) return `[${value.map((v) => _hash(v, options, visited)).join(',')}]`;\n\n  const proto = Object.getPrototypeOf(value) as unknown;\n\n  if (proto !== Object.prototype && proto !== null) {\n    if (options?.onClassInstance === 'throw') {\n      throw new ArsenalSerializationError(\n        `hash: unsupported type ${(value as { constructor?: { name?: string } }).constructor?.name ?? 'unknown'}`,\n      );\n    }\n\n    return String(value);\n  }\n\n  const rec = value as Record<string, unknown>;\n  const keys = Object.keys(rec)\n    .filter((k) => rec[k] !== undefined)\n    .sort();\n\n  return `{${keys.map((k) => `${JSON.stringify(k)}:${_hash(rec[k], options, visited)}`).join(',')}}`;\n}\n\nexport function hash(value: unknown, options?: HashOptions): string {\n  return _hash(value, options, new Set<object>());\n}\n"],"mappings":"iCAkCA,SAAS,EAAM,EAAgB,EAAkC,EAA8B,CAC7F,GAAI,IAAU,IAAA,GAAW,MAAO,YAEhC,GAAI,IAAU,KAAM,MAAO,OAE3B,GAAI,OAAO,GAAU,SAAU,MAAO,GAAG,EAAM,GAE/C,GAAI,OAAO,GAAU,SAAU,OAAO,KAAK,UAAU,CAAK,EAE1D,GAAI,EAAQ,IAAI,CAAe,EAAG,MAAO,aAIzC,GAFA,EAAQ,IAAI,CAAe,EAEvB,aAAiB,KAAM,MAAO,SAAS,OAAO,MAAM,EAAM,QAAQ,CAAC,EAAI,UAAY,EAAM,YAAY,EAAE,GAE3G,GAAI,aAAiB,OAAQ,MAAO,WAAW,EAAM,OAAO,GAAG,EAAM,MAAM,GAE3E,GAAI,aAAiB,IACnB,MAAO,QAAQ,CAAC,GAAG,CAAK,CAAC,CACtB,IAAK,GAAM,EAAM,EAAG,EAAS,CAAO,CAAC,CAAC,CACtC,KAAK,CAAC,CACN,KAAK,GAAG,EAAE,GAEf,GAAI,aAAiB,IAOnB,MAAO,QANS,CAAC,GAAG,EAAM,QAAQ,CAAC,CAAC,CACjC,KAAK,CAAC,EAAK,KAAgB,CAAC,EAAM,EAAK,EAAS,CAAO,EAAG,EAAM,EAAY,EAAS,CAAO,CAAC,CAAU,CAAC,CACxG,MAAM,CAAC,EAAS,GAAY,CAAC,EAAU,KACtC,IAAY,EAAW,EAAU,cAAc,CAAU,EAAI,EAAQ,cAAc,CAAQ,CAGhF,CAAA,CAAQ,KAAK,CAAC,EAAK,KAAgB,GAAG,EAAI,IAAI,GAAY,CAAC,CAAC,KAAK,GAAG,EAAE,GAGvF,GAAI,MAAM,QAAQ,CAAK,EAAG,MAAO,IAAI,EAAM,IAAK,GAAM,EAAM,EAAG,EAAS,CAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,GAE5F,IAAM,EAAQ,OAAO,eAAe,CAAK,EAEzC,GAAI,IAAU,OAAO,WAAa,IAAU,KAAM,CAChD,GAAI,GAAS,kBAAoB,QAC/B,MAAM,IAAI,EAAA,0BACR,0BAA2B,EAA8C,aAAa,MAAQ,WAChG,EAGF,OAAO,OAAO,CAAK,CACrB,CAEA,IAAM,EAAM,EAKZ,MAAO,IAJM,OAAO,KAAK,CAAG,CAAC,CAC1B,OAAQ,GAAM,EAAI,KAAO,IAAA,EAAS,CAAC,CACnC,KAEQ,CAAA,CAAK,IAAK,GAAM,GAAG,KAAK,UAAU,CAAC,EAAE,GAAG,EAAM,EAAI,GAAI,EAAS,CAAO,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,EAClG,CAEA,SAAgB,EAAK,EAAgB,EAA+B,CAClE,OAAO,EAAM,EAAO,EAAS,IAAI,GAAa,CAChD"}
+{"version":3,"file":"hash.cjs","names":[],"sources":["../../src/object/hash.ts"],"sourcesContent":["import { ArsenalSerializationError } from '../errors';\n\nexport type HashOptions = {\n  /**\n   * What to do when a class instance is encountered (an object whose prototype is\n   * neither `Object.prototype` nor `null`).\n   *\n   * - `'coerce'` (default) — calls `String(value)`.\n   * - `'throw'` — throws an `ArsenalSerializationError`.\n   */\n  onClassInstance?: 'coerce' | 'throw';\n};\n\n/**\n * Produces a deterministic, order-independent string representation of any value.\n * Object keys are sorted alphabetically, so `{ b: 1, a: 2 }` and `{ a: 2, b: 1 }` produce\n * the same output. Handles `Date`, `RegExp`, `Set`, `Map`, and `bigint` in addition to plain JSON.\n *\n * Useful for generating stable cache keys from arbitrary query parameters or options objects.\n *\n * Class instances fall back to `String(value)` by default.\n * Pass `{ onClassInstance: 'throw' }` to throw an `ArsenalSerializationError` instead.\n *\n * @example\n * ```ts\n * hash({ b: 2, a: 1 }) // '{\"a\":1,\"b\":2}'\n * hash([3, 1, 2])      // '[3,1,2]'\n * hash(new Date('2024-01-01T00:00:00Z')) // '[Date:2024-01-01T00:00:00.000Z]'\n * hash(new Set([3, 1, 2])) // '[Set:1,2,3]'\n * hash(new MyClass(), { onClassInstance: 'throw' }) // throws ArsenalSerializationError\n * ```\n *\n * @throws {ArsenalSerializationError} If `options.onClassInstance` is `'throw'` and a class instance is encountered.\n */\nfunction _hash(value: unknown, options: HashOptions | undefined, visited: Set<object>): string {\n  if (value === undefined) return 'undefined';\n\n  if (value === null) return 'null';\n\n  if (typeof value === 'bigint') return `${value}n`;\n\n  if (typeof value !== 'object') return JSON.stringify(value);\n\n  if (visited.has(value as object)) return '[Circular]';\n\n  visited.add(value as object);\n\n  if (value instanceof Date) return `[Date:${Number.isNaN(value.getTime()) ? 'Invalid' : value.toISOString()}]`;\n\n  if (value instanceof RegExp) return `[RegExp:${value.source}/${value.flags}]`;\n\n  if (value instanceof Set)\n    return `[Set:${[...value]\n      .map((v) => _hash(v, options, visited))\n      .sort()\n      .join(',')}]`;\n\n  if (value instanceof Map) {\n    const entries = [...value.entries()]\n      .map(([key, entryValue]) => [_hash(key, options, visited), _hash(entryValue, options, visited)] as const)\n      .sort(([leftKey, leftValue], [rightKey, rightValue]) =>\n        leftKey === rightKey ? leftValue.localeCompare(rightValue) : leftKey.localeCompare(rightKey),\n      );\n\n    return `[Map:${entries.map(([key, entryValue]) => `${key}=>${entryValue}`).join(',')}]`;\n  }\n\n  if (Array.isArray(value)) return `[${value.map((v) => _hash(v, options, visited)).join(',')}]`;\n\n  const proto = Object.getPrototypeOf(value) as unknown;\n\n  if (proto !== Object.prototype && proto !== null) {\n    if (options?.onClassInstance === 'throw') {\n      throw new ArsenalSerializationError(\n        `hash: unsupported type ${(value as { constructor?: { name?: string } }).constructor?.name ?? 'unknown'}`,\n      );\n    }\n\n    return String(value);\n  }\n\n  const rec = value as Record<string, unknown>;\n  const keys = Object.keys(rec)\n    .filter((k) => rec[k] !== undefined)\n    .sort();\n\n  return `{${keys.map((k) => `${JSON.stringify(k)}:${_hash(rec[k], options, visited)}`).join(',')}}`;\n}\n\nexport function hash(value: unknown, options?: HashOptions): string {\n  return _hash(value, options, new Set<object>());\n}\n"],"mappings":"iCAkCA,SAAS,MAAM,EAAgB,EAAkC,EAA8B,CAC7F,GAAI,IAAU,IAAA,GAAW,MAAO,YAEhC,GAAI,IAAU,KAAM,MAAO,OAE3B,GAAI,OAAO,GAAU,SAAU,MAAO,GAAG,EAAM,GAE/C,GAAI,OAAO,GAAU,SAAU,OAAO,KAAK,UAAU,CAAK,EAE1D,GAAI,EAAQ,IAAI,CAAe,EAAG,MAAO,aAIzC,GAFA,EAAQ,IAAI,CAAe,EAEvB,aAAiB,KAAM,MAAO,SAAS,OAAO,MAAM,EAAM,QAAQ,CAAC,EAAI,UAAY,EAAM,YAAY,EAAE,GAE3G,GAAI,aAAiB,OAAQ,MAAO,WAAW,EAAM,OAAO,GAAG,EAAM,MAAM,GAE3E,GAAI,aAAiB,IACnB,MAAO,QAAQ,CAAC,GAAG,CAAK,CAAC,CACtB,IAAK,GAAM,MAAM,EAAG,EAAS,CAAO,CAAC,CAAC,CACtC,KAAK,CAAC,CACN,KAAK,GAAG,EAAE,GAEf,GAAI,aAAiB,IAOnB,MAAO,QANS,CAAC,GAAG,EAAM,QAAQ,CAAC,CAAC,CACjC,KAAK,CAAC,EAAK,KAAgB,CAAC,MAAM,EAAK,EAAS,CAAO,EAAG,MAAM,EAAY,EAAS,CAAO,CAAC,CAAU,CAAC,CACxG,MAAM,CAAC,EAAS,GAAY,CAAC,EAAU,KACtC,IAAY,EAAW,EAAU,cAAc,CAAU,EAAI,EAAQ,cAAc,CAAQ,CAGhF,CAAA,CAAQ,KAAK,CAAC,EAAK,KAAgB,GAAG,EAAI,IAAI,GAAY,CAAC,CAAC,KAAK,GAAG,EAAE,GAGvF,GAAI,MAAM,QAAQ,CAAK,EAAG,MAAO,IAAI,EAAM,IAAK,GAAM,MAAM,EAAG,EAAS,CAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,GAE5F,IAAM,EAAQ,OAAO,eAAe,CAAK,EAEzC,GAAI,IAAU,OAAO,WAAa,IAAU,KAAM,CAChD,GAAI,GAAS,kBAAoB,QAC/B,MAAM,IAAI,EAAA,0BACR,0BAA2B,EAA8C,aAAa,MAAQ,WAChG,EAGF,OAAO,OAAO,CAAK,CACrB,CAEA,IAAM,EAAM,EAKZ,MAAO,IAJM,OAAO,KAAK,CAAG,CAAC,CAC1B,OAAQ,GAAM,EAAI,KAAO,IAAA,EAAS,CAAC,CACnC,KAEQ,CAAA,CAAK,IAAK,GAAM,GAAG,KAAK,UAAU,CAAC,EAAE,GAAG,MAAM,EAAI,GAAI,EAAS,CAAO,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,EAClG,CAEA,SAAgB,KAAK,EAAgB,EAA+B,CAClE,OAAO,MAAM,EAAO,EAAS,IAAI,GAAa,CAChD"}

package/dist/object/hash.js

@@ -1,28 +1,2 @@
-import { ArsenalSerializationError as e } from "../errors.js";
-//#region src/object/hash.ts
-function t(n, r, i) {
-	if (n === void 0) return "undefined";
-	if (n === null) return "null";
-	if (typeof n == "bigint") return `${n}n`;
-	if (typeof n != "object") return JSON.stringify(n);
-	if (i.has(n)) return "[Circular]";
-	if (i.add(n), n instanceof Date) return `[Date:${Number.isNaN(n.getTime()) ? "Invalid" : n.toISOString()}]`;
-	if (n instanceof RegExp) return `[RegExp:${n.source}/${n.flags}]`;
-	if (n instanceof Set) return `[Set:${[...n].map((e) => t(e, r, i)).sort().join(",")}]`;
-	if (n instanceof Map) return `[Map:${[...n.entries()].map(([e, n]) => [t(e, r, i), t(n, r, i)]).sort(([e, t], [n, r]) => e === n ? t.localeCompare(r) : e.localeCompare(n)).map(([e, t]) => `${e}=>${t}`).join(",")}]`;
-	if (Array.isArray(n)) return `[${n.map((e) => t(e, r, i)).join(",")}]`;
-	let a = Object.getPrototypeOf(n);
-	if (a !== Object.prototype && a !== null) {
-		if (r?.onClassInstance === "throw") throw new e(`hash: unsupported type ${n.constructor?.name ?? "unknown"}`);
-		return String(n);
-	}
-	let o = n;
-	return `{${Object.keys(o).filter((e) => o[e] !== void 0).sort().map((e) => `${JSON.stringify(e)}:${t(o[e], r, i)}`).join(",")}}`;
-}
-function n(e, n) {
-	return t(e, n, /* @__PURE__ */ new Set());
-}
-//#endregion
-export { n as hash };
-
+import{ArsenalSerializationError as e}from"../errors.js";function _hash(t,n,r){if(t===void 0)return`undefined`;if(t===null)return`null`;if(typeof t==`bigint`)return`${t}n`;if(typeof t!=`object`)return JSON.stringify(t);if(r.has(t))return`[Circular]`;if(r.add(t),t instanceof Date)return`[Date:${Number.isNaN(t.getTime())?`Invalid`:t.toISOString()}]`;if(t instanceof RegExp)return`[RegExp:${t.source}/${t.flags}]`;if(t instanceof Set)return`[Set:${[...t].map(e=>_hash(e,n,r)).sort().join(`,`)}]`;if(t instanceof Map)return`[Map:${[...t.entries()].map(([e,t])=>[_hash(e,n,r),_hash(t,n,r)]).sort(([e,t],[n,r])=>e===n?t.localeCompare(r):e.localeCompare(n)).map(([e,t])=>`${e}=>${t}`).join(`,`)}]`;if(Array.isArray(t))return`[${t.map(e=>_hash(e,n,r)).join(`,`)}]`;let i=Object.getPrototypeOf(t);if(i!==Object.prototype&&i!==null){if(n?.onClassInstance===`throw`)throw new e(`hash: unsupported type ${t.constructor?.name??`unknown`}`);return String(t)}let a=t;return`{${Object.keys(a).filter(e=>a[e]!==void 0).sort().map(e=>`${JSON.stringify(e)}:${_hash(a[e],n,r)}`).join(`,`)}}`}function hash(e,t){return _hash(e,t,new Set)}export{hash};
 //# sourceMappingURL=hash.js.map

package/dist/object/hash.js.map

@@ -1 +1 @@
-{"version":3,"file":"hash.js","names":[],"sources":["../../src/object/hash.ts"],"sourcesContent":["import { ArsenalSerializationError } from '../errors';\n\nexport type HashOptions = {\n  /**\n   * What to do when a class instance is encountered (an object whose prototype is\n   * neither `Object.prototype` nor `null`).\n   *\n   * - `'coerce'` (default) — calls `String(value)`.\n   * - `'throw'` — throws an `ArsenalSerializationError`.\n   */\n  onClassInstance?: 'coerce' | 'throw';\n};\n\n/**\n * Produces a deterministic, order-independent string representation of any value.\n * Object keys are sorted alphabetically, so `{ b: 1, a: 2 }` and `{ a: 2, b: 1 }` produce\n * the same output. Handles `Date`, `RegExp`, `Set`, `Map`, and `bigint` in addition to plain JSON.\n *\n * Useful for generating stable cache keys from arbitrary query parameters or options objects.\n *\n * Class instances fall back to `String(value)` by default.\n * Pass `{ onClassInstance: 'throw' }` to throw an `ArsenalSerializationError` instead.\n *\n * @example\n * ```ts\n * hash({ b: 2, a: 1 }) // '{\"a\":1,\"b\":2}'\n * hash([3, 1, 2])      // '[3,1,2]'\n * hash(new Date('2024-01-01T00:00:00Z')) // '[Date:2024-01-01T00:00:00.000Z]'\n * hash(new Set([3, 1, 2])) // '[Set:1,2,3]'\n * hash(new MyClass(), { onClassInstance: 'throw' }) // throws ArsenalSerializationError\n * ```\n *\n * @throws {ArsenalSerializationError} If `options.onClassInstance` is `'throw'` and a class instance is encountered.\n */\nfunction _hash(value: unknown, options: HashOptions | undefined, visited: Set<object>): string {\n  if (value === undefined) return 'undefined';\n\n  if (value === null) return 'null';\n\n  if (typeof value === 'bigint') return `${value}n`;\n\n  if (typeof value !== 'object') return JSON.stringify(value);\n\n  if (visited.has(value as object)) return '[Circular]';\n\n  visited.add(value as object);\n\n  if (value instanceof Date) return `[Date:${Number.isNaN(value.getTime()) ? 'Invalid' : value.toISOString()}]`;\n\n  if (value instanceof RegExp) return `[RegExp:${value.source}/${value.flags}]`;\n\n  if (value instanceof Set)\n    return `[Set:${[...value]\n      .map((v) => _hash(v, options, visited))\n      .sort()\n      .join(',')}]`;\n\n  if (value instanceof Map) {\n    const entries = [...value.entries()]\n      .map(([key, entryValue]) => [_hash(key, options, visited), _hash(entryValue, options, visited)] as const)\n      .sort(([leftKey, leftValue], [rightKey, rightValue]) =>\n        leftKey === rightKey ? leftValue.localeCompare(rightValue) : leftKey.localeCompare(rightKey),\n      );\n\n    return `[Map:${entries.map(([key, entryValue]) => `${key}=>${entryValue}`).join(',')}]`;\n  }\n\n  if (Array.isArray(value)) return `[${value.map((v) => _hash(v, options, visited)).join(',')}]`;\n\n  const proto = Object.getPrototypeOf(value) as unknown;\n\n  if (proto !== Object.prototype && proto !== null) {\n    if (options?.onClassInstance === 'throw') {\n      throw new ArsenalSerializationError(\n        `hash: unsupported type ${(value as { constructor?: { name?: string } }).constructor?.name ?? 'unknown'}`,\n      );\n    }\n\n    return String(value);\n  }\n\n  const rec = value as Record<string, unknown>;\n  const keys = Object.keys(rec)\n    .filter((k) => rec[k] !== undefined)\n    .sort();\n\n  return `{${keys.map((k) => `${JSON.stringify(k)}:${_hash(rec[k], options, visited)}`).join(',')}}`;\n}\n\nexport function hash(value: unknown, options?: HashOptions): string {\n  return _hash(value, options, new Set<object>());\n}\n"],"mappings":";;AAkCA,SAAS,EAAM,GAAgB,GAAkC,GAA8B;CAC7F,IAAI,MAAU,KAAA,GAAW,OAAO;CAEhC,IAAI,MAAU,MAAM,OAAO;CAE3B,IAAI,OAAO,KAAU,UAAU,OAAO,GAAG,EAAM;CAE/C,IAAI,OAAO,KAAU,UAAU,OAAO,KAAK,UAAU,CAAK;CAE1D,IAAI,EAAQ,IAAI,CAAe,GAAG,OAAO;CAIzC,IAFA,EAAQ,IAAI,CAAe,GAEvB,aAAiB,MAAM,OAAO,SAAS,OAAO,MAAM,EAAM,QAAQ,CAAC,IAAI,YAAY,EAAM,YAAY,EAAE;CAE3G,IAAI,aAAiB,QAAQ,OAAO,WAAW,EAAM,OAAO,GAAG,EAAM,MAAM;CAE3E,IAAI,aAAiB,KACnB,OAAO,QAAQ,CAAC,GAAG,CAAK,CAAC,CACtB,KAAK,MAAM,EAAM,GAAG,GAAS,CAAO,CAAC,CAAC,CACtC,KAAK,CAAC,CACN,KAAK,GAAG,EAAE;CAEf,IAAI,aAAiB,KAOnB,OAAO,QANS,CAAC,GAAG,EAAM,QAAQ,CAAC,CAAC,CACjC,KAAK,CAAC,GAAK,OAAgB,CAAC,EAAM,GAAK,GAAS,CAAO,GAAG,EAAM,GAAY,GAAS,CAAO,CAAC,CAAU,CAAC,CACxG,MAAM,CAAC,GAAS,IAAY,CAAC,GAAU,OACtC,MAAY,IAAW,EAAU,cAAc,CAAU,IAAI,EAAQ,cAAc,CAAQ,CAGhF,CAAA,CAAQ,KAAK,CAAC,GAAK,OAAgB,GAAG,EAAI,IAAI,GAAY,CAAC,CAAC,KAAK,GAAG,EAAE;CAGvF,IAAI,MAAM,QAAQ,CAAK,GAAG,OAAO,IAAI,EAAM,KAAK,MAAM,EAAM,GAAG,GAAS,CAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;CAE5F,IAAM,IAAQ,OAAO,eAAe,CAAK;CAEzC,IAAI,MAAU,OAAO,aAAa,MAAU,MAAM;EAChD,IAAI,GAAS,oBAAoB,SAC/B,MAAM,IAAI,EACR,0BAA2B,EAA8C,aAAa,QAAQ,WAChG;EAGF,OAAO,OAAO,CAAK;CACrB;CAEA,IAAM,IAAM;CAKZ,OAAO,IAJM,OAAO,KAAK,CAAG,CAAC,CAC1B,QAAQ,MAAM,EAAI,OAAO,KAAA,CAAS,CAAC,CACnC,KAEQ,CAAA,CAAK,KAAK,MAAM,GAAG,KAAK,UAAU,CAAC,EAAE,GAAG,EAAM,EAAI,IAAI,GAAS,CAAO,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE;AAClG;AAEA,SAAgB,EAAK,GAAgB,GAA+B;CAClE,OAAO,EAAM,GAAO,mBAAS,IAAI,IAAY,CAAC;AAChD"}
+{"version":3,"file":"hash.js","names":[],"sources":["../../src/object/hash.ts"],"sourcesContent":["import { ArsenalSerializationError } from '../errors';\n\nexport type HashOptions = {\n  /**\n   * What to do when a class instance is encountered (an object whose prototype is\n   * neither `Object.prototype` nor `null`).\n   *\n   * - `'coerce'` (default) — calls `String(value)`.\n   * - `'throw'` — throws an `ArsenalSerializationError`.\n   */\n  onClassInstance?: 'coerce' | 'throw';\n};\n\n/**\n * Produces a deterministic, order-independent string representation of any value.\n * Object keys are sorted alphabetically, so `{ b: 1, a: 2 }` and `{ a: 2, b: 1 }` produce\n * the same output. Handles `Date`, `RegExp`, `Set`, `Map`, and `bigint` in addition to plain JSON.\n *\n * Useful for generating stable cache keys from arbitrary query parameters or options objects.\n *\n * Class instances fall back to `String(value)` by default.\n * Pass `{ onClassInstance: 'throw' }` to throw an `ArsenalSerializationError` instead.\n *\n * @example\n * ```ts\n * hash({ b: 2, a: 1 }) // '{\"a\":1,\"b\":2}'\n * hash([3, 1, 2])      // '[3,1,2]'\n * hash(new Date('2024-01-01T00:00:00Z')) // '[Date:2024-01-01T00:00:00.000Z]'\n * hash(new Set([3, 1, 2])) // '[Set:1,2,3]'\n * hash(new MyClass(), { onClassInstance: 'throw' }) // throws ArsenalSerializationError\n * ```\n *\n * @throws {ArsenalSerializationError} If `options.onClassInstance` is `'throw'` and a class instance is encountered.\n */\nfunction _hash(value: unknown, options: HashOptions | undefined, visited: Set<object>): string {\n  if (value === undefined) return 'undefined';\n\n  if (value === null) return 'null';\n\n  if (typeof value === 'bigint') return `${value}n`;\n\n  if (typeof value !== 'object') return JSON.stringify(value);\n\n  if (visited.has(value as object)) return '[Circular]';\n\n  visited.add(value as object);\n\n  if (value instanceof Date) return `[Date:${Number.isNaN(value.getTime()) ? 'Invalid' : value.toISOString()}]`;\n\n  if (value instanceof RegExp) return `[RegExp:${value.source}/${value.flags}]`;\n\n  if (value instanceof Set)\n    return `[Set:${[...value]\n      .map((v) => _hash(v, options, visited))\n      .sort()\n      .join(',')}]`;\n\n  if (value instanceof Map) {\n    const entries = [...value.entries()]\n      .map(([key, entryValue]) => [_hash(key, options, visited), _hash(entryValue, options, visited)] as const)\n      .sort(([leftKey, leftValue], [rightKey, rightValue]) =>\n        leftKey === rightKey ? leftValue.localeCompare(rightValue) : leftKey.localeCompare(rightKey),\n      );\n\n    return `[Map:${entries.map(([key, entryValue]) => `${key}=>${entryValue}`).join(',')}]`;\n  }\n\n  if (Array.isArray(value)) return `[${value.map((v) => _hash(v, options, visited)).join(',')}]`;\n\n  const proto = Object.getPrototypeOf(value) as unknown;\n\n  if (proto !== Object.prototype && proto !== null) {\n    if (options?.onClassInstance === 'throw') {\n      throw new ArsenalSerializationError(\n        `hash: unsupported type ${(value as { constructor?: { name?: string } }).constructor?.name ?? 'unknown'}`,\n      );\n    }\n\n    return String(value);\n  }\n\n  const rec = value as Record<string, unknown>;\n  const keys = Object.keys(rec)\n    .filter((k) => rec[k] !== undefined)\n    .sort();\n\n  return `{${keys.map((k) => `${JSON.stringify(k)}:${_hash(rec[k], options, visited)}`).join(',')}}`;\n}\n\nexport function hash(value: unknown, options?: HashOptions): string {\n  return _hash(value, options, new Set<object>());\n}\n"],"mappings":"yDAkCA,SAAS,MAAM,EAAgB,EAAkC,EAA8B,CAC7F,GAAI,IAAU,IAAA,GAAW,MAAO,YAEhC,GAAI,IAAU,KAAM,MAAO,OAE3B,GAAI,OAAO,GAAU,SAAU,MAAO,GAAG,EAAM,GAE/C,GAAI,OAAO,GAAU,SAAU,OAAO,KAAK,UAAU,CAAK,EAE1D,GAAI,EAAQ,IAAI,CAAe,EAAG,MAAO,aAIzC,GAFA,EAAQ,IAAI,CAAe,EAEvB,aAAiB,KAAM,MAAO,SAAS,OAAO,MAAM,EAAM,QAAQ,CAAC,EAAI,UAAY,EAAM,YAAY,EAAE,GAE3G,GAAI,aAAiB,OAAQ,MAAO,WAAW,EAAM,OAAO,GAAG,EAAM,MAAM,GAE3E,GAAI,aAAiB,IACnB,MAAO,QAAQ,CAAC,GAAG,CAAK,CAAC,CACtB,IAAK,GAAM,MAAM,EAAG,EAAS,CAAO,CAAC,CAAC,CACtC,KAAK,CAAC,CACN,KAAK,GAAG,EAAE,GAEf,GAAI,aAAiB,IAOnB,MAAO,QANS,CAAC,GAAG,EAAM,QAAQ,CAAC,CAAC,CACjC,KAAK,CAAC,EAAK,KAAgB,CAAC,MAAM,EAAK,EAAS,CAAO,EAAG,MAAM,EAAY,EAAS,CAAO,CAAC,CAAU,CAAC,CACxG,MAAM,CAAC,EAAS,GAAY,CAAC,EAAU,KACtC,IAAY,EAAW,EAAU,cAAc,CAAU,EAAI,EAAQ,cAAc,CAAQ,CAGhF,CAAA,CAAQ,KAAK,CAAC,EAAK,KAAgB,GAAG,EAAI,IAAI,GAAY,CAAC,CAAC,KAAK,GAAG,EAAE,GAGvF,GAAI,MAAM,QAAQ,CAAK,EAAG,MAAO,IAAI,EAAM,IAAK,GAAM,MAAM,EAAG,EAAS,CAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,GAE5F,IAAM,EAAQ,OAAO,eAAe,CAAK,EAEzC,GAAI,IAAU,OAAO,WAAa,IAAU,KAAM,CAChD,GAAI,GAAS,kBAAoB,QAC/B,MAAM,IAAI,EACR,0BAA2B,EAA8C,aAAa,MAAQ,WAChG,EAGF,OAAO,OAAO,CAAK,CACrB,CAEA,IAAM,EAAM,EAKZ,MAAO,IAJM,OAAO,KAAK,CAAG,CAAC,CAC1B,OAAQ,GAAM,EAAI,KAAO,IAAA,EAAS,CAAC,CACnC,KAEQ,CAAA,CAAK,IAAK,GAAM,GAAG,KAAK,UAAU,CAAC,EAAE,GAAG,MAAM,EAAI,GAAI,EAAS,CAAO,GAAG,CAAC,CAAC,KAAK,GAAG,EAAE,EAClG,CAEA,SAAgB,KAAK,EAAgB,EAA+B,CAClE,OAAO,MAAM,EAAO,EAAS,IAAI,GAAa,CAChD"}