@vielzeug/arsenal 1.1.1 → 2.0.0

package/dist/math/sum.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sum.cjs","names":[],"sources":["../../src/math/sum.ts"],"sourcesContent":["import { ArsenalValidationError } from '../errors';\n\n/**\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']) // ArsenalValidationError\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 {ArsenalValidationError} 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 ArsenalValidationError(\n        'sum: encountered a non-numeric value; provide a callback to map non-number items',\n      );\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":"iCAmBA,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,MAAM,IAAI,EAAA,uBACR,kFACF,EAGF,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: 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"}

package/dist/math/sum.d.ts

@@ -5,7 +5,7 @@
  * ```ts
  * sum([1, 2, 3]) // 6
  * sum([{value: 1}, {value: 2}, {value: 3}], (item) => item.value) // 6
- * sum(['apple', 'banana', 'cherry']) // ArsenalValidationError
+ * sum(['apple', 'banana', 'cherry']) // TypeError
  * ```
  *
  * @param array - The array to sum.
@@ -13,7 +13,7 @@
  *
  * @returns The sum of the numbers in the array or the sum of the mapped values.
  *
- * @throws {ArsenalValidationError} If (after an optional `callback` mapping) any item is not a finite number.
+ * @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;
 //# 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":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,CAczE"}
+{"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"}

package/dist/math/sum.js

@@ -1,13 +1,12 @@
-import { ArsenalValidationError as e } from "../errors.js";
 //#region src/math/sum.ts
-function t(t, n) {
-	return t.length === 0 ? 0 : t.reduce((t, r) => {
-		let i = n ? n(r) : r;
-		if (typeof i != "number" || Number.isNaN(i)) throw new e("sum: encountered a non-numeric value; provide a callback to map non-number items");
-		return t + i;
+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 { t as sum };
+export { e as 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":["import { ArsenalValidationError } from '../errors';\n\n/**\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']) // ArsenalValidationError\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 {ArsenalValidationError} 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 ArsenalValidationError(\n        'sum: encountered a non-numeric value; provide a callback to map non-number items',\n      );\n    }\n\n    return acc + val;\n  }, 0);\n}\n"],"mappings":";;AAmBA,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,MAAM,IAAI,EACR,kFACF;EAGF,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: 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"}

package/dist/object/getPath.cjs

@@ -1,2 +1,2 @@
-const e=require("../errors.cjs"),t=require("../_common/unsafePaths.cjs");function n(n,r,i={}){let{bracketNotation:a=!0,fallback:o,strict:s=!1}=i;if(/[[\]]/.test(r)){if(!a)throw new e.ArsenalValidationError(`getPath: bracket notation is not supported. Use dot notation: '${r.replace(/\[(\d+)\]/g,`.$1`).replace(/^\.|\.$/g,``)}' or pass { bracketNotation: true }.`);r=r.replace(/\[(\d+)\]/g,`.$1`).replace(/^\.|\.$/g,``)}let c=r.split(`.`).filter(Boolean),l=n;for(let n of c){if(t.UNSAFE_PATH_SEGMENTS.has(n))return o;if(typeof l!=`object`||!l){if(s)throw new e.ArsenalValidationError(`Cannot read property '${n}' of ${l}`);return o}if(l=l[n],l===void 0){if(s)throw new e.ArsenalValidationError(`Property '${n}' does not exist`);return o}}return l}exports.getPath=n;
+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;
 //# 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 type { Obj } from '../types';\n\nimport { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\nimport { ArsenalValidationError } from '../errors';\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\nexport type GetPathOptions = {\n  /**\n   * When `false`, throws an `ArsenalValidationError` on bracket-notation segments instead of\n   * auto-converting them to dot notation. Default: `true`.\n   */\n  bracketNotation?: boolean;\n  /**\n   * Returned when the path is missing or resolves to `undefined`.\n   * Mutually exclusive with `strict` — if both are set, `strict` takes precedence.\n   */\n  fallback?: unknown;\n  /**\n   * When `true`, throws an `ArsenalValidationError` if any path segment is missing.\n   * Default: `false`.\n   */\n  strict?: boolean;\n};\n\n/**\n * Retrieves the value at a dot-notation path of an object.\n *\n * Bracket notation (`a[0].b`) is automatically converted to dot notation by default.\n * Unsafe path segments (`__proto__`, `constructor`, `prototype`) always return `options.fallback`.\n *\n * @example\n * ```ts\n * const obj = { a: { b: { c: 3 } }, d: [1, 2, 3] };\n *\n * getPath(obj, 'a.b.c');                          // 3\n * getPath(obj, 'a.b.x', { fallback: 'fallback' }); // 'fallback'\n * getPath(obj, 'd[1]');                            // 2  (bracket auto-converted)\n * getPath(obj, 'e.f.g', { strict: true });         // throws ArsenalValidationError\n * getPath(obj, 'a[0]', { bracketNotation: false }); // throws ArsenalValidationError\n * ```\n *\n * @template T - The object type.\n * @template P - The path string type.\n * @param item - The object to query.\n * @param path - The dot-separated path.\n * @param [options] - Options: `fallback`, `strict`, `bracketNotation`.\n * @returns The resolved value, or `options.fallback` if missing.\n * @throws {ArsenalValidationError} When `bracketNotation: false` and bracket syntax is used.\n * @throws {ArsenalValidationError} When `strict: true` and the path does not exist.\n */\nexport function getPath<T extends Obj, P extends string>(\n  item: T,\n  path: P,\n  options: GetPathOptions = {},\n): PathValue<T, P> | undefined {\n  const { bracketNotation = true, fallback: defaultValue, strict = false } = options;\n\n  if (/[[\\]]/.test(path)) {\n    if (!bracketNotation) {\n      throw new ArsenalValidationError(\n        `getPath: bracket notation is not supported. Use dot notation: '${path.replace(/\\[(\\d+)\\]/g, '.$1').replace(/^\\.|\\.$/g, '')}' or pass { bracketNotation: true }.`,\n      );\n    }\n\n    path = path.replace(/\\[(\\d+)\\]/g, '.$1').replace(/^\\.|\\.$/g, '') as P;\n  }\n\n  const fragments = path.split('.').filter(Boolean);\n  let current: unknown = item;\n\n  for (const fragment of fragments) {\n    if (UNSAFE_PATH_SEGMENTS.has(fragment)) return defaultValue as PathValue<T, P>;\n\n    if (current == null || typeof current !== 'object') {\n      if (strict) throw new ArsenalValidationError(`Cannot read property '${fragment}' of ${current}`);\n\n      return defaultValue as PathValue<T, P>;\n    }\n\n    current = (current as Record<string, unknown>)[fragment];\n\n    if (current === undefined) {\n      if (strict) throw new ArsenalValidationError(`Property '${fragment}' does not exist`);\n\n      return defaultValue as PathValue<T, P>;\n    }\n  }\n\n  return current as PathValue<T, P>;\n}\n"],"mappings":"yEAyDA,SAAgB,EACd,EACA,EACA,EAA0B,CAAC,EACE,CAC7B,GAAM,CAAE,kBAAkB,GAAM,SAAU,EAAc,SAAS,IAAU,EAE3E,GAAI,QAAQ,KAAK,CAAI,EAAG,CACtB,GAAI,CAAC,EACH,MAAM,IAAI,EAAA,uBACR,kEAAkE,EAAK,QAAQ,aAAc,KAAK,CAAC,CAAC,QAAQ,WAAY,EAAE,EAAE,qCAC9H,EAGF,EAAO,EAAK,QAAQ,aAAc,KAAK,CAAC,CAAC,QAAQ,WAAY,EAAE,CACjE,CAEA,IAAM,EAAY,EAAK,MAAM,GAAG,CAAC,CAAC,OAAO,OAAO,EAC5C,EAAmB,EAEvB,IAAK,IAAM,KAAY,EAAW,CAChC,GAAI,EAAA,qBAAqB,IAAI,CAAQ,EAAG,OAAO,EAE/C,GAAuB,OAAO,GAAY,WAAtC,EAAgD,CAClD,GAAI,EAAQ,MAAM,IAAI,EAAA,uBAAuB,yBAAyB,EAAS,OAAO,GAAS,EAE/F,OAAO,CACT,CAIA,GAFA,EAAW,EAAoC,GAE3C,IAAY,IAAA,GAAW,CACzB,GAAI,EAAQ,MAAM,IAAI,EAAA,uBAAuB,aAAa,EAAS,iBAAiB,EAEpF,OAAO,CACT,CACF,CAEA,OAAO,CACT"}
+{"version":3,"file":"getPath.cjs","names":[],"sources":["../../src/object/getPath.ts"],"sourcesContent":["import type { Obj } from '../types';\n\nimport { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\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":"8CAYA,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"}

package/dist/object/getPath.d.ts

@@ -1,48 +1,18 @@
 import type { Obj } from '../types';
 type PathValue<T, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? PathValue<T[Key], Rest> : undefined : P extends keyof T ? T[P] : undefined;
-export type GetPathOptions = {
-    /**
-     * When `false`, throws an `ArsenalValidationError` on bracket-notation segments instead of
-     * auto-converting them to dot notation. Default: `true`.
-     */
-    bracketNotation?: boolean;
-    /**
-     * Returned when the path is missing or resolves to `undefined`.
-     * Mutually exclusive with `strict` — if both are set, `strict` takes precedence.
-     */
-    fallback?: unknown;
-    /**
-     * When `true`, throws an `ArsenalValidationError` if any path segment is missing.
-     * Default: `false`.
-     */
-    strict?: boolean;
-};
 /**
- * Retrieves the value at a dot-notation path of an object.
- *
- * Bracket notation (`a[0].b`) is automatically converted to dot notation by default.
- * Unsafe path segments (`__proto__`, `constructor`, `prototype`) always return `options.fallback`.
- *
- * @example
- * ```ts
- * const obj = { a: { b: { c: 3 } }, d: [1, 2, 3] };
- *
- * getPath(obj, 'a.b.c');                          // 3
- * getPath(obj, 'a.b.x', { fallback: 'fallback' }); // 'fallback'
- * getPath(obj, 'd[1]');                            // 2  (bracket auto-converted)
- * getPath(obj, 'e.f.g', { strict: true });         // throws ArsenalValidationError
- * getPath(obj, 'a[0]', { bracketNotation: false }); // throws ArsenalValidationError
- * ```
- *
- * @template T - The object type.
- * @template P - The path string type.
- * @param item - The object to query.
- * @param path - The dot-separated path.
- * @param [options] - Options: `fallback`, `strict`, `bracketNotation`.
- * @returns The resolved value, or `options.fallback` if missing.
- * @throws {ArsenalValidationError} When `bracketNotation: false` and bracket syntax is used.
- * @throws {ArsenalValidationError} When `strict: true` and the path does not exist.
+ * Retrieves a value at a dot-notation or numeric bracket-notation path.
+ * Returns `undefined` when the path is missing or contains an unsafe segment.
+ * Use `getPathOr` to supply a fallback or `requirePath` to throw on a missing path.
  */
-export declare function getPath<T extends Obj, P extends string>(item: T, path: P, options?: GetPathOptions): PathValue<T, P> | undefined;
+export declare function getPath<T extends Obj, P extends string>(item: T, path: P): PathValue<T, P> | undefined;
+/**
+ * Retrieves a value at a path or returns `fallback` when the path is missing.
+ */
+export declare function getPathOr<T extends Obj, P extends string, F>(item: T, path: P, fallback: F): PathValue<T, P> | F;
+/**
+ * Retrieves a value at a path or throws when the path is missing.
+ */
+export declare function requirePath<T extends Obj, P extends string>(item: T, path: P): Exclude<PathValue<T, P>, undefined>;
 export {};
 //# sourceMappingURL=getPath.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getPath.d.ts","sourceRoot":"","sources":["../../src/object/getPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAKpC,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,MAAM,GAAG,IAAI,MAAM,IAAI,EAAE,GACxE,GAAG,SAAS,MAAM,CAAC,GACjB,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,GACvB,SAAS,GACX,CAAC,SAAS,MAAM,CAAC,GACf,CAAC,CAAC,CAAC,CAAC,GACJ,SAAS,CAAC;AAEhB,MAAM,MAAM,cAAc,GAAG;IAC3B;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,SAAS,MAAM,EACrD,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,CAAC,EACP,OAAO,GAAE,cAAmB,GAC3B,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAmC7B"}
+{"version":3,"file":"getPath.d.ts","sourceRoot":"","sources":["../../src/object/getPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAIpC,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,GAAG,MAAM,GAAG,IAAI,MAAM,IAAI,EAAE,GACxE,GAAG,SAAS,MAAM,CAAC,GACjB,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,GACvB,SAAS,GACX,CAAC,SAAS,MAAM,CAAC,GACf,CAAC,CAAC,CAAC,CAAC,GACJ,SAAS,CAAC;AAwBhB;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAEtG;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAIhH;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,CAMlH"}

package/dist/object/getPath.js

@@ -1,27 +1,26 @@
-import { ArsenalValidationError as e } from "../errors.js";
-import { UNSAFE_PATH_SEGMENTS as t } from "../_common/unsafePaths.js";
+import { UNSAFE_PATH_SEGMENTS as e } from "../_common/unsafePaths.js";
 //#region src/object/getPath.ts
-function n(n, r, i = {}) {
-	let { bracketNotation: a = !0, fallback: o, strict: s = !1 } = i;
-	if (/[[\]]/.test(r)) {
-		if (!a) throw new e(`getPath: bracket notation is not supported. Use dot notation: '${r.replace(/\[(\d+)\]/g, ".$1").replace(/^\.|\.$/g, "")}' or pass { bracketNotation: true }.`);
-		r = r.replace(/\[(\d+)\]/g, ".$1").replace(/^\.|\.$/g, "");
-	}
-	let c = r.split(".").filter(Boolean), l = n;
-	for (let n of c) {
-		if (t.has(n)) return o;
-		if (typeof l != "object" || !l) {
-			if (s) throw new e(`Cannot read property '${n}' of ${l}`);
-			return o;
-		}
-		if (l = l[n], l === void 0) {
-			if (s) throw new e(`Property '${n}' does not exist`);
-			return o;
-		}
-	}
-	return l;
+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 { n as getPath };
+export { r as getPath, i as getPathOr, a as 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 type { Obj } from '../types';\n\nimport { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\nimport { ArsenalValidationError } from '../errors';\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\nexport type GetPathOptions = {\n  /**\n   * When `false`, throws an `ArsenalValidationError` on bracket-notation segments instead of\n   * auto-converting them to dot notation. Default: `true`.\n   */\n  bracketNotation?: boolean;\n  /**\n   * Returned when the path is missing or resolves to `undefined`.\n   * Mutually exclusive with `strict` — if both are set, `strict` takes precedence.\n   */\n  fallback?: unknown;\n  /**\n   * When `true`, throws an `ArsenalValidationError` if any path segment is missing.\n   * Default: `false`.\n   */\n  strict?: boolean;\n};\n\n/**\n * Retrieves the value at a dot-notation path of an object.\n *\n * Bracket notation (`a[0].b`) is automatically converted to dot notation by default.\n * Unsafe path segments (`__proto__`, `constructor`, `prototype`) always return `options.fallback`.\n *\n * @example\n * ```ts\n * const obj = { a: { b: { c: 3 } }, d: [1, 2, 3] };\n *\n * getPath(obj, 'a.b.c');                          // 3\n * getPath(obj, 'a.b.x', { fallback: 'fallback' }); // 'fallback'\n * getPath(obj, 'd[1]');                            // 2  (bracket auto-converted)\n * getPath(obj, 'e.f.g', { strict: true });         // throws ArsenalValidationError\n * getPath(obj, 'a[0]', { bracketNotation: false }); // throws ArsenalValidationError\n * ```\n *\n * @template T - The object type.\n * @template P - The path string type.\n * @param item - The object to query.\n * @param path - The dot-separated path.\n * @param [options] - Options: `fallback`, `strict`, `bracketNotation`.\n * @returns The resolved value, or `options.fallback` if missing.\n * @throws {ArsenalValidationError} When `bracketNotation: false` and bracket syntax is used.\n * @throws {ArsenalValidationError} When `strict: true` and the path does not exist.\n */\nexport function getPath<T extends Obj, P extends string>(\n  item: T,\n  path: P,\n  options: GetPathOptions = {},\n): PathValue<T, P> | undefined {\n  const { bracketNotation = true, fallback: defaultValue, strict = false } = options;\n\n  if (/[[\\]]/.test(path)) {\n    if (!bracketNotation) {\n      throw new ArsenalValidationError(\n        `getPath: bracket notation is not supported. Use dot notation: '${path.replace(/\\[(\\d+)\\]/g, '.$1').replace(/^\\.|\\.$/g, '')}' or pass { bracketNotation: true }.`,\n      );\n    }\n\n    path = path.replace(/\\[(\\d+)\\]/g, '.$1').replace(/^\\.|\\.$/g, '') as P;\n  }\n\n  const fragments = path.split('.').filter(Boolean);\n  let current: unknown = item;\n\n  for (const fragment of fragments) {\n    if (UNSAFE_PATH_SEGMENTS.has(fragment)) return defaultValue as PathValue<T, P>;\n\n    if (current == null || typeof current !== 'object') {\n      if (strict) throw new ArsenalValidationError(`Cannot read property '${fragment}' of ${current}`);\n\n      return defaultValue as PathValue<T, P>;\n    }\n\n    current = (current as Record<string, unknown>)[fragment];\n\n    if (current === undefined) {\n      if (strict) throw new ArsenalValidationError(`Property '${fragment}' does not exist`);\n\n      return defaultValue as PathValue<T, P>;\n    }\n  }\n\n  return current as PathValue<T, P>;\n}\n"],"mappings":";;;AAyDA,SAAgB,EACd,GACA,GACA,IAA0B,CAAC,GACE;CAC7B,IAAM,EAAE,qBAAkB,IAAM,UAAU,GAAc,YAAS,OAAU;CAE3E,IAAI,QAAQ,KAAK,CAAI,GAAG;EACtB,IAAI,CAAC,GACH,MAAM,IAAI,EACR,kEAAkE,EAAK,QAAQ,cAAc,KAAK,CAAC,CAAC,QAAQ,YAAY,EAAE,EAAE,qCAC9H;EAGF,IAAO,EAAK,QAAQ,cAAc,KAAK,CAAC,CAAC,QAAQ,YAAY,EAAE;CACjE;CAEA,IAAM,IAAY,EAAK,MAAM,GAAG,CAAC,CAAC,OAAO,OAAO,GAC5C,IAAmB;CAEvB,KAAK,IAAM,KAAY,GAAW;EAChC,IAAI,EAAqB,IAAI,CAAQ,GAAG,OAAO;EAE/C,IAAuB,OAAO,KAAY,aAAtC,GAAgD;GAClD,IAAI,GAAQ,MAAM,IAAI,EAAuB,yBAAyB,EAAS,OAAO,GAAS;GAE/F,OAAO;EACT;EAIA,IAFA,IAAW,EAAoC,IAE3C,MAAY,KAAA,GAAW;GACzB,IAAI,GAAQ,MAAM,IAAI,EAAuB,aAAa,EAAS,iBAAiB;GAEpF,OAAO;EACT;CACF;CAEA,OAAO;AACT"}
+{"version":3,"file":"getPath.js","names":[],"sources":["../../src/object/getPath.ts"],"sourcesContent":["import type { Obj } from '../types';\n\nimport { UNSAFE_PATH_SEGMENTS } from '../_common/unsafePaths';\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":";;AAYA,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"}

package/dist/object/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./getPath.cjs"),t=require("./hash.cjs"),n=require("./omit.cjs"),r=require("./pick.cjs"),i=require("./defaults.cjs"),a=require("./diff.cjs"),o=require("./filterValues.cjs"),s=require("./flattenPaths.cjs"),c=require("./invert.cjs"),l=require("./mapKeys.cjs"),u=require("./mapValues.cjs"),d=require("./merge.cjs"),f=require("./prune.cjs"),p=require("./tryParseJson.cjs");exports.deepMerge=d.deepMerge,exports.defaults=i.defaults,exports.diff=a.diff,exports.diffArrays=a.diffArrays,exports.filterValues=o.filterValues,exports.flattenPaths=s.flattenPaths,exports.getPath=e.getPath,exports.getPathOr=e.getPathOr,exports.hash=t.hash,exports.invert=c.invert,exports.mapKeys=l.mapKeys,exports.mapValues=u.mapValues,exports.omit=n.omit,exports.pick=r.pick,exports.prune=f.prune,exports.requirePath=e.requirePath,exports.shallowMerge=d.shallowMerge,exports.tryParseJson=p.tryParseJson,exports.unflattenPaths=s.unflattenPaths;

package/dist/object/index.d.ts

@@ -9,7 +9,7 @@ export * from './mapKeys';
 export * from './mapValues';
 export * from './merge';
 export * from './omit';
-export * from './parseJSON';
 export * from './pick';
 export * from './prune';
+export * from './tryParseJson';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/object/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/object/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC"}

package/dist/object/index.js

@@ -0,0 +1,15 @@
+import { getPath as e, getPathOr as t, requirePath as n } from "./getPath.js";
+import { hash as r } from "./hash.js";
+import { omit as i } from "./omit.js";
+import { pick as a } from "./pick.js";
+import { defaults as o } from "./defaults.js";
+import { diff as s, diffArrays as c } from "./diff.js";
+import { filterValues as l } from "./filterValues.js";
+import { flattenPaths as u, unflattenPaths as d } from "./flattenPaths.js";
+import { invert as f } from "./invert.js";
+import { mapKeys as p } from "./mapKeys.js";
+import { mapValues as m } from "./mapValues.js";
+import { deepMerge as h, shallowMerge as g } from "./merge.js";
+import { prune as _ } from "./prune.js";
+import { tryParseJson as v } from "./tryParseJson.js";
+export { h as deepMerge, o as defaults, s as diff, c as diffArrays, l as filterValues, u as flattenPaths, e as getPath, t as getPathOr, r as hash, f as invert, p as mapKeys, m as mapValues, i as omit, a as pick, _ as prune, n as requirePath, g as shallowMerge, v as tryParseJson, d as unflattenPaths };

package/dist/object/merge.cjs

@@ -1,2 +1,2 @@
-const e=require("../_common/unsafePaths.cjs"),t=require("../guards/isPlainObject.cjs");function n(r,i,a){if(!t.isPlainObject(i))return i;let o={...r};for(let r of Object.keys(i)){if(e.isUnsafeKey(r))continue;let s=i[r],c=o[r];o[r]=Array.isArray(s)&&Array.isArray(c)?a.arrayStrategy===`concat`?[...c,...s]:s:t.isPlainObject(s)&&t.isPlainObject(c)?n(c,s,a):s}return o}function r(...e){let t=e[e.length-1],r=e.length>0&&typeof t==`object`&&!!t&&!Array.isArray(t)&&`arrayStrategy`in t&&Object.keys(t).length===1&&(t.arrayStrategy===`concat`||t.arrayStrategy===`replace`),i=r?t:{},a=r?e.slice(0,-1):e;return a.length===0?{}:a.reduce((e,t)=>n(e,t,i),{})}function i(...t){if(t.length===0)return{};let n={};for(let r of t)for(let t of Object.keys(r))e.isUnsafeKey(t)||(n[t]=r[t]);return n}exports.deepMerge=r,exports.shallowMerge=i;
+const e=require("../_common/unsafePaths.cjs"),t=require("../guards/isPlainObject.cjs");function n(r,i,a){if(!t.isPlainObject(i))return i;let o={...r};for(let r of Object.keys(i)){if(e.isUnsafeKey(r))continue;let s=i[r],c=o[r];o[r]=Array.isArray(s)&&Array.isArray(c)?a.arrayStrategy===`concat`?[...c,...s]:s:t.isPlainObject(s)&&t.isPlainObject(c)?n(c,s,a):s}return o}function r(e,t={}){return e.reduce((e,r)=>n(e,r,t),{})}function i(...t){if(t.length===0)return{};let n={};for(let r of t)for(let t of Object.keys(r))e.isUnsafeKey(t)||(n[t]=r[t]);return n}exports.deepMerge=r,exports.shallowMerge=i;
 //# sourceMappingURL=merge.cjs.map

package/dist/object/merge.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"merge.cjs","names":[],"sources":["../../src/object/merge.ts"],"sourcesContent":["import type { Obj } from '../types';\n\nimport { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\n\nexport type DeepMergeOptions = {\n  /** How to handle arrays when both source and target contain one. Default: `'replace'`. */\n  arrayStrategy?: 'concat' | 'replace';\n};\n\ntype DeepMerge<T, U> = T extends Obj\n  ? U extends Obj\n    ? {\n        [K in keyof T | keyof U]: K extends keyof T\n          ? K extends keyof U\n            ? DeepMerge<T[K], U[K]>\n            : T[K]\n          : K extends keyof U\n            ? U[K]\n            : never;\n      }\n    : U\n  : U;\n\ntype Merge<T extends Obj[]> = T extends [infer First, ...infer Rest]\n  ? First extends Obj\n    ? Rest extends Obj[]\n      ? DeepMerge<First, Merge<Rest>>\n      : First\n    : Obj\n  : Obj;\n\nfunction mergeObjects<T extends Obj, U extends Obj>(target: T, source: U, options: DeepMergeOptions): DeepMerge<T, U> {\n  if (!isPlainObject(source)) return source as DeepMerge<T, U>;\n\n  const result = { ...target } as DeepMerge<T, U>;\n\n  for (const key of Object.keys(source)) {\n    // Guard against prototype pollution: skip dangerous keys\n    if (isUnsafeKey(key)) {\n      continue;\n    }\n\n    const sourceValue = source[key];\n    const targetValue = result[key];\n\n    (result as Record<string, unknown>)[key] =\n      Array.isArray(sourceValue) && Array.isArray(targetValue)\n        ? options.arrayStrategy === 'concat'\n          ? [...targetValue, ...sourceValue]\n          : sourceValue\n        : isPlainObject(sourceValue) && isPlainObject(targetValue)\n          ? mergeObjects(targetValue as Obj, sourceValue as Obj, options)\n          : sourceValue;\n  }\n\n  return result;\n}\n\n/**\n * Deeply merges two or more objects. Arrays in source objects **replace** the target array by default.\n * Pass `{ arrayStrategy: 'concat' }` as the last argument to concatenate arrays instead.\n *\n * @example\n * ```ts\n * deepMerge({ a: 1, b: { x: 1 } }, { b: { y: 2 }, c: 3 });\n * // { a: 1, b: { x: 1, y: 2 }, c: 3 }\n *\n * deepMerge({ tags: ['a'] }, { tags: ['b'] });\n * // { tags: ['b'] }  ← arrays replaced\n *\n * deepMerge({ tags: ['a'] }, { tags: ['b'] }, { arrayStrategy: 'concat' });\n * // { tags: ['a', 'b'] }\n * ```\n */\nexport function deepMerge<T extends Obj[]>(...args: [...T] | [...T, DeepMergeOptions]): Merge<T> {\n  const lastArg = args[args.length - 1];\n  const hasOptions =\n    args.length > 0 &&\n    typeof lastArg === 'object' &&\n    lastArg !== null &&\n    !Array.isArray(lastArg) &&\n    'arrayStrategy' in lastArg &&\n    Object.keys(lastArg).length === 1 &&\n    ((lastArg as DeepMergeOptions).arrayStrategy === 'concat' ||\n      (lastArg as DeepMergeOptions).arrayStrategy === 'replace');\n\n  const options: DeepMergeOptions = hasOptions ? (lastArg as DeepMergeOptions) : {};\n  const items = (hasOptions ? args.slice(0, -1) : args) as Obj[];\n\n  if (items.length === 0) return {} as Merge<T>;\n\n  return items.reduce((acc: Obj, obj: Obj) => mergeObjects(acc, obj, options) as Obj, {} as Obj) as unknown as Merge<T>;\n}\n\n/**\n * Shallowly merges two or more objects. Later sources win for duplicate keys.\n * Dangerous keys (`__proto__`, `constructor`, `prototype`) are always skipped.\n *\n * @example\n * ```ts\n * shallowMerge({ a: 1, b: { x: 1 } }, { b: { y: 2 } });\n * // { a: 1, b: { y: 2 } }  ← nested object replaced, not merged\n *\n * shallowMerge(defaults, overrides, extras);\n * ```\n */\nexport function shallowMerge<T extends Obj[]>(...items: [...T]): Merge<T> {\n  if (items.length === 0) return {} as Merge<T>;\n\n  const result: Obj = {};\n\n  for (const item of items) {\n    for (const key of Object.keys(item)) {\n      if (isUnsafeKey(key)) continue;\n\n      result[key] = item[key];\n    }\n  }\n\n  return result as Merge<T>;\n}\n"],"mappings":"uFAgCA,SAAS,EAA2C,EAAW,EAAW,EAA4C,CACpH,GAAI,CAAC,EAAA,cAAc,CAAM,EAAG,OAAO,EAEnC,IAAM,EAAS,CAAE,GAAG,CAAO,EAE3B,IAAK,IAAM,KAAO,OAAO,KAAK,CAAM,EAAG,CAErC,GAAI,EAAA,YAAY,CAAG,EACjB,SAGF,IAAM,EAAc,EAAO,GACrB,EAAc,EAAO,GAE3B,EAAoC,GAClC,MAAM,QAAQ,CAAW,GAAK,MAAM,QAAQ,CAAW,EACnD,EAAQ,gBAAkB,SACxB,CAAC,GAAG,EAAa,GAAG,CAAW,EAC/B,EACF,EAAA,cAAc,CAAW,GAAK,EAAA,cAAc,CAAW,EACrD,EAAa,EAAoB,EAAoB,CAAO,EAC5D,CACV,CAEA,OAAO,CACT,CAkBA,SAAgB,EAA2B,GAAG,EAAmD,CAC/F,IAAM,EAAU,EAAK,EAAK,OAAS,GAC7B,EACJ,EAAK,OAAS,GACd,OAAO,GAAY,YACnB,GACA,CAAC,MAAM,QAAQ,CAAO,GACtB,kBAAmB,GACnB,OAAO,KAAK,CAAO,CAAC,CAAC,SAAW,IAC9B,EAA6B,gBAAkB,UAC9C,EAA6B,gBAAkB,WAE9C,EAA4B,EAAc,EAA+B,CAAC,EAC1E,EAAS,EAAa,EAAK,MAAM,EAAG,EAAE,EAAI,EAIhD,OAFI,EAAM,SAAW,EAAU,CAAC,EAEzB,EAAM,QAAQ,EAAU,IAAa,EAAa,EAAK,EAAK,CAAO,EAAU,CAAC,CAAQ,CAC/F,CAcA,SAAgB,EAA8B,GAAG,EAAyB,CACxE,GAAI,EAAM,SAAW,EAAG,MAAO,CAAC,EAEhC,IAAM,EAAc,CAAC,EAErB,IAAK,IAAM,KAAQ,EACjB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAI,EAC5B,EAAA,YAAY,CAAG,IAEnB,EAAO,GAAO,EAAK,IAIvB,OAAO,CACT"}
+{"version":3,"file":"merge.cjs","names":[],"sources":["../../src/object/merge.ts"],"sourcesContent":["import type { Obj } from '../types';\n\nimport { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\n\nexport type DeepMergeOptions = {\n  /** How to handle arrays when both source and target contain one. Default: `'replace'`. */\n  arrayStrategy?: 'concat' | 'replace';\n};\n\ntype DeepMerge<T, U> = T extends Obj\n  ? U extends Obj\n    ? {\n        [K in keyof T | keyof U]: K extends keyof T\n          ? K extends keyof U\n            ? DeepMerge<T[K], U[K]>\n            : T[K]\n          : K extends keyof U\n            ? U[K]\n            : never;\n      }\n    : U\n  : U;\n\ntype Merge<T extends Obj[]> = T extends [infer First, ...infer Rest]\n  ? First extends Obj\n    ? Rest extends Obj[]\n      ? DeepMerge<First, Merge<Rest>>\n      : First\n    : Obj\n  : Obj;\n\nfunction mergeObjects<T extends Obj, U extends Obj>(target: T, source: U, options: DeepMergeOptions): DeepMerge<T, U> {\n  if (!isPlainObject(source)) return source as DeepMerge<T, U>;\n\n  const result = { ...target } as DeepMerge<T, U>;\n\n  for (const key of Object.keys(source)) {\n    // Guard against prototype pollution: skip dangerous keys\n    if (isUnsafeKey(key)) {\n      continue;\n    }\n\n    const sourceValue = source[key];\n    const targetValue = result[key];\n\n    (result as Record<string, unknown>)[key] =\n      Array.isArray(sourceValue) && Array.isArray(targetValue)\n        ? options.arrayStrategy === 'concat'\n          ? [...targetValue, ...sourceValue]\n          : sourceValue\n        : isPlainObject(sourceValue) && isPlainObject(targetValue)\n          ? mergeObjects(targetValue as Obj, sourceValue as Obj, options)\n          : sourceValue;\n  }\n\n  return result;\n}\n\n/**\n * Deeply merges two or more objects. Arrays in source objects **replace** the target array by default.\n * Pass `{ arrayStrategy: 'concat' }` as the last argument to concatenate arrays instead.\n *\n * @example\n * ```ts\n * deepMerge({ a: 1, b: { x: 1 } }, { b: { y: 2 }, c: 3 });\n * // { a: 1, b: { x: 1, y: 2 }, c: 3 }\n *\n * deepMerge({ tags: ['a'] }, { tags: ['b'] });\n * // { tags: ['b'] }  ← arrays replaced\n *\n * deepMerge({ tags: ['a'] }, { tags: ['b'] }, { arrayStrategy: 'concat' });\n * // { tags: ['a', 'b'] }\n * ```\n */\nexport function deepMerge<T extends Obj[]>(items: readonly [...T], options: DeepMergeOptions = {}): Merge<T> {\n  return items.reduce((acc: Obj, item) => mergeObjects(acc, item, options) as Obj, {} as Obj) as Merge<T>;\n}\n\n/**\n * Shallowly merges two or more objects. Later sources win for duplicate keys.\n * Dangerous keys (`__proto__`, `constructor`, `prototype`) are always skipped.\n *\n * @example\n * ```ts\n * shallowMerge({ a: 1, b: { x: 1 } }, { b: { y: 2 } });\n * // { a: 1, b: { y: 2 } }  ← nested object replaced, not merged\n *\n * shallowMerge(defaults, overrides, extras);\n * ```\n */\nexport function shallowMerge<T extends Obj[]>(...items: [...T]): Merge<T> {\n  if (items.length === 0) return {} as Merge<T>;\n\n  const result: Obj = {};\n\n  for (const item of items) {\n    for (const key of Object.keys(item)) {\n      if (isUnsafeKey(key)) continue;\n\n      result[key] = item[key];\n    }\n  }\n\n  return result as Merge<T>;\n}\n"],"mappings":"uFAgCA,SAAS,EAA2C,EAAW,EAAW,EAA4C,CACpH,GAAI,CAAC,EAAA,cAAc,CAAM,EAAG,OAAO,EAEnC,IAAM,EAAS,CAAE,GAAG,CAAO,EAE3B,IAAK,IAAM,KAAO,OAAO,KAAK,CAAM,EAAG,CAErC,GAAI,EAAA,YAAY,CAAG,EACjB,SAGF,IAAM,EAAc,EAAO,GACrB,EAAc,EAAO,GAE3B,EAAoC,GAClC,MAAM,QAAQ,CAAW,GAAK,MAAM,QAAQ,CAAW,EACnD,EAAQ,gBAAkB,SACxB,CAAC,GAAG,EAAa,GAAG,CAAW,EAC/B,EACF,EAAA,cAAc,CAAW,GAAK,EAAA,cAAc,CAAW,EACrD,EAAa,EAAoB,EAAoB,CAAO,EAC5D,CACV,CAEA,OAAO,CACT,CAkBA,SAAgB,EAA2B,EAAwB,EAA4B,CAAC,EAAa,CAC3G,OAAO,EAAM,QAAQ,EAAU,IAAS,EAAa,EAAK,EAAM,CAAO,EAAU,CAAC,CAAQ,CAC5F,CAcA,SAAgB,EAA8B,GAAG,EAAyB,CACxE,GAAI,EAAM,SAAW,EAAG,MAAO,CAAC,EAEhC,IAAM,EAAc,CAAC,EAErB,IAAK,IAAM,KAAQ,EACjB,IAAK,IAAM,KAAO,OAAO,KAAK,CAAI,EAC5B,EAAA,YAAY,CAAG,IAEnB,EAAO,GAAO,EAAK,IAIvB,OAAO,CACT"}

package/dist/object/merge.d.ts

@@ -23,7 +23,7 @@ type Merge<T extends Obj[]> = T extends [infer First, ...infer Rest] ? First ext
  * // { tags: ['a', 'b'] }
  * ```
  */
-export declare function deepMerge<T extends Obj[]>(...args: [...T] | [...T, DeepMergeOptions]): Merge<T>;
+export declare function deepMerge<T extends Obj[]>(items: readonly [...T], options?: DeepMergeOptions): Merge<T>;
 /**
  * Shallowly merges two or more objects. Later sources win for duplicate keys.
  * Dangerous keys (`__proto__`, `constructor`, `prototype`) are always skipped.

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

@@ -1 +1 @@
-{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/object/merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAKpC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,0FAA0F;IAC1F,aAAa,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,GAAG,GAChC,CAAC,SAAS,GAAG,GACX;KACG,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,GACvC,CAAC,SAAS,MAAM,CAAC,GACf,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GACrB,CAAC,CAAC,CAAC,CAAC,GACN,CAAC,SAAS,MAAM,CAAC,GACf,CAAC,CAAC,CAAC,CAAC,GACJ,KAAK;CACZ,GACD,CAAC,GACH,CAAC,CAAC;AAEN,KAAK,KAAK,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAChE,KAAK,SAAS,GAAG,GACf,IAAI,SAAS,GAAG,EAAE,GAChB,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,GAC7B,KAAK,GACP,GAAG,GACL,GAAG,CAAC;AA6BR;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,GAAG,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,gBAAgB,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAkB/F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,GAAG,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAcxE"}
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/object/merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAKpC,MAAM,MAAM,gBAAgB,GAAG;IAC7B,0FAA0F;IAC1F,aAAa,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF,KAAK,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,GAAG,GAChC,CAAC,SAAS,GAAG,GACX;KACG,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,GACvC,CAAC,SAAS,MAAM,CAAC,GACf,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GACrB,CAAC,CAAC,CAAC,CAAC,GACN,CAAC,SAAS,MAAM,CAAC,GACf,CAAC,CAAC,CAAC,CAAC,GACJ,KAAK;CACZ,GACD,CAAC,GACH,CAAC,CAAC;AAEN,KAAK,KAAK,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAChE,KAAK,SAAS,GAAG,GACf,IAAI,SAAS,GAAG,EAAE,GAChB,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,GAC7B,KAAK,GACP,GAAG,GACL,GAAG,CAAC;AA6BR;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,GAAE,gBAAqB,GAAG,KAAK,CAAC,CAAC,CAAC,CAE3G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,GAAG,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAcxE"}

package/dist/object/merge.js

@@ -11,9 +11,8 @@ function n(r, i, a) {
 	}
 	return o;
 }
-function r(...e) {
-	let t = e[e.length - 1], r = e.length > 0 && typeof t == "object" && !!t && !Array.isArray(t) && "arrayStrategy" in t && Object.keys(t).length === 1 && (t.arrayStrategy === "concat" || t.arrayStrategy === "replace"), i = r ? t : {}, a = r ? e.slice(0, -1) : e;
-	return a.length === 0 ? {} : a.reduce((e, t) => n(e, t, i), {});
+function r(e, t = {}) {
+	return e.reduce((e, r) => n(e, r, t), {});
 }
 function i(...t) {
 	if (t.length === 0) return {};

package/dist/object/merge.js.map

@@ -1 +1 @@
-{"version":3,"file":"merge.js","names":[],"sources":["../../src/object/merge.ts"],"sourcesContent":["import type { Obj } from '../types';\n\nimport { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\n\nexport type DeepMergeOptions = {\n  /** How to handle arrays when both source and target contain one. Default: `'replace'`. */\n  arrayStrategy?: 'concat' | 'replace';\n};\n\ntype DeepMerge<T, U> = T extends Obj\n  ? U extends Obj\n    ? {\n        [K in keyof T | keyof U]: K extends keyof T\n          ? K extends keyof U\n            ? DeepMerge<T[K], U[K]>\n            : T[K]\n          : K extends keyof U\n            ? U[K]\n            : never;\n      }\n    : U\n  : U;\n\ntype Merge<T extends Obj[]> = T extends [infer First, ...infer Rest]\n  ? First extends Obj\n    ? Rest extends Obj[]\n      ? DeepMerge<First, Merge<Rest>>\n      : First\n    : Obj\n  : Obj;\n\nfunction mergeObjects<T extends Obj, U extends Obj>(target: T, source: U, options: DeepMergeOptions): DeepMerge<T, U> {\n  if (!isPlainObject(source)) return source as DeepMerge<T, U>;\n\n  const result = { ...target } as DeepMerge<T, U>;\n\n  for (const key of Object.keys(source)) {\n    // Guard against prototype pollution: skip dangerous keys\n    if (isUnsafeKey(key)) {\n      continue;\n    }\n\n    const sourceValue = source[key];\n    const targetValue = result[key];\n\n    (result as Record<string, unknown>)[key] =\n      Array.isArray(sourceValue) && Array.isArray(targetValue)\n        ? options.arrayStrategy === 'concat'\n          ? [...targetValue, ...sourceValue]\n          : sourceValue\n        : isPlainObject(sourceValue) && isPlainObject(targetValue)\n          ? mergeObjects(targetValue as Obj, sourceValue as Obj, options)\n          : sourceValue;\n  }\n\n  return result;\n}\n\n/**\n * Deeply merges two or more objects. Arrays in source objects **replace** the target array by default.\n * Pass `{ arrayStrategy: 'concat' }` as the last argument to concatenate arrays instead.\n *\n * @example\n * ```ts\n * deepMerge({ a: 1, b: { x: 1 } }, { b: { y: 2 }, c: 3 });\n * // { a: 1, b: { x: 1, y: 2 }, c: 3 }\n *\n * deepMerge({ tags: ['a'] }, { tags: ['b'] });\n * // { tags: ['b'] }  ← arrays replaced\n *\n * deepMerge({ tags: ['a'] }, { tags: ['b'] }, { arrayStrategy: 'concat' });\n * // { tags: ['a', 'b'] }\n * ```\n */\nexport function deepMerge<T extends Obj[]>(...args: [...T] | [...T, DeepMergeOptions]): Merge<T> {\n  const lastArg = args[args.length - 1];\n  const hasOptions =\n    args.length > 0 &&\n    typeof lastArg === 'object' &&\n    lastArg !== null &&\n    !Array.isArray(lastArg) &&\n    'arrayStrategy' in lastArg &&\n    Object.keys(lastArg).length === 1 &&\n    ((lastArg as DeepMergeOptions).arrayStrategy === 'concat' ||\n      (lastArg as DeepMergeOptions).arrayStrategy === 'replace');\n\n  const options: DeepMergeOptions = hasOptions ? (lastArg as DeepMergeOptions) : {};\n  const items = (hasOptions ? args.slice(0, -1) : args) as Obj[];\n\n  if (items.length === 0) return {} as Merge<T>;\n\n  return items.reduce((acc: Obj, obj: Obj) => mergeObjects(acc, obj, options) as Obj, {} as Obj) as unknown as Merge<T>;\n}\n\n/**\n * Shallowly merges two or more objects. Later sources win for duplicate keys.\n * Dangerous keys (`__proto__`, `constructor`, `prototype`) are always skipped.\n *\n * @example\n * ```ts\n * shallowMerge({ a: 1, b: { x: 1 } }, { b: { y: 2 } });\n * // { a: 1, b: { y: 2 } }  ← nested object replaced, not merged\n *\n * shallowMerge(defaults, overrides, extras);\n * ```\n */\nexport function shallowMerge<T extends Obj[]>(...items: [...T]): Merge<T> {\n  if (items.length === 0) return {} as Merge<T>;\n\n  const result: Obj = {};\n\n  for (const item of items) {\n    for (const key of Object.keys(item)) {\n      if (isUnsafeKey(key)) continue;\n\n      result[key] = item[key];\n    }\n  }\n\n  return result as Merge<T>;\n}\n"],"mappings":";;;AAgCA,SAAS,EAA2C,GAAW,GAAW,GAA4C;CACpH,IAAI,CAAC,EAAc,CAAM,GAAG,OAAO;CAEnC,IAAM,IAAS,EAAE,GAAG,EAAO;CAE3B,KAAK,IAAM,KAAO,OAAO,KAAK,CAAM,GAAG;EAErC,IAAI,EAAY,CAAG,GACjB;EAGF,IAAM,IAAc,EAAO,IACrB,IAAc,EAAO;EAE3B,EAAoC,KAClC,MAAM,QAAQ,CAAW,KAAK,MAAM,QAAQ,CAAW,IACnD,EAAQ,kBAAkB,WACxB,CAAC,GAAG,GAAa,GAAG,CAAW,IAC/B,IACF,EAAc,CAAW,KAAK,EAAc,CAAW,IACrD,EAAa,GAAoB,GAAoB,CAAO,IAC5D;CACV;CAEA,OAAO;AACT;AAkBA,SAAgB,EAA2B,GAAG,GAAmD;CAC/F,IAAM,IAAU,EAAK,EAAK,SAAS,IAC7B,IACJ,EAAK,SAAS,KACd,OAAO,KAAY,cACnB,KACA,CAAC,MAAM,QAAQ,CAAO,KACtB,mBAAmB,KACnB,OAAO,KAAK,CAAO,CAAC,CAAC,WAAW,MAC9B,EAA6B,kBAAkB,YAC9C,EAA6B,kBAAkB,YAE9C,IAA4B,IAAc,IAA+B,CAAC,GAC1E,IAAS,IAAa,EAAK,MAAM,GAAG,EAAE,IAAI;CAIhD,OAFI,EAAM,WAAW,IAAU,CAAC,IAEzB,EAAM,QAAQ,GAAU,MAAa,EAAa,GAAK,GAAK,CAAO,GAAU,CAAC,CAAQ;AAC/F;AAcA,SAAgB,EAA8B,GAAG,GAAyB;CACxE,IAAI,EAAM,WAAW,GAAG,OAAO,CAAC;CAEhC,IAAM,IAAc,CAAC;CAErB,KAAK,IAAM,KAAQ,GACjB,KAAK,IAAM,KAAO,OAAO,KAAK,CAAI,GAC5B,EAAY,CAAG,MAEnB,EAAO,KAAO,EAAK;CAIvB,OAAO;AACT"}
+{"version":3,"file":"merge.js","names":[],"sources":["../../src/object/merge.ts"],"sourcesContent":["import type { Obj } from '../types';\n\nimport { isUnsafeKey } from '../_common/unsafePaths';\nimport { isPlainObject } from '../guards/isPlainObject';\n\nexport type DeepMergeOptions = {\n  /** How to handle arrays when both source and target contain one. Default: `'replace'`. */\n  arrayStrategy?: 'concat' | 'replace';\n};\n\ntype DeepMerge<T, U> = T extends Obj\n  ? U extends Obj\n    ? {\n        [K in keyof T | keyof U]: K extends keyof T\n          ? K extends keyof U\n            ? DeepMerge<T[K], U[K]>\n            : T[K]\n          : K extends keyof U\n            ? U[K]\n            : never;\n      }\n    : U\n  : U;\n\ntype Merge<T extends Obj[]> = T extends [infer First, ...infer Rest]\n  ? First extends Obj\n    ? Rest extends Obj[]\n      ? DeepMerge<First, Merge<Rest>>\n      : First\n    : Obj\n  : Obj;\n\nfunction mergeObjects<T extends Obj, U extends Obj>(target: T, source: U, options: DeepMergeOptions): DeepMerge<T, U> {\n  if (!isPlainObject(source)) return source as DeepMerge<T, U>;\n\n  const result = { ...target } as DeepMerge<T, U>;\n\n  for (const key of Object.keys(source)) {\n    // Guard against prototype pollution: skip dangerous keys\n    if (isUnsafeKey(key)) {\n      continue;\n    }\n\n    const sourceValue = source[key];\n    const targetValue = result[key];\n\n    (result as Record<string, unknown>)[key] =\n      Array.isArray(sourceValue) && Array.isArray(targetValue)\n        ? options.arrayStrategy === 'concat'\n          ? [...targetValue, ...sourceValue]\n          : sourceValue\n        : isPlainObject(sourceValue) && isPlainObject(targetValue)\n          ? mergeObjects(targetValue as Obj, sourceValue as Obj, options)\n          : sourceValue;\n  }\n\n  return result;\n}\n\n/**\n * Deeply merges two or more objects. Arrays in source objects **replace** the target array by default.\n * Pass `{ arrayStrategy: 'concat' }` as the last argument to concatenate arrays instead.\n *\n * @example\n * ```ts\n * deepMerge({ a: 1, b: { x: 1 } }, { b: { y: 2 }, c: 3 });\n * // { a: 1, b: { x: 1, y: 2 }, c: 3 }\n *\n * deepMerge({ tags: ['a'] }, { tags: ['b'] });\n * // { tags: ['b'] }  ← arrays replaced\n *\n * deepMerge({ tags: ['a'] }, { tags: ['b'] }, { arrayStrategy: 'concat' });\n * // { tags: ['a', 'b'] }\n * ```\n */\nexport function deepMerge<T extends Obj[]>(items: readonly [...T], options: DeepMergeOptions = {}): Merge<T> {\n  return items.reduce((acc: Obj, item) => mergeObjects(acc, item, options) as Obj, {} as Obj) as Merge<T>;\n}\n\n/**\n * Shallowly merges two or more objects. Later sources win for duplicate keys.\n * Dangerous keys (`__proto__`, `constructor`, `prototype`) are always skipped.\n *\n * @example\n * ```ts\n * shallowMerge({ a: 1, b: { x: 1 } }, { b: { y: 2 } });\n * // { a: 1, b: { y: 2 } }  ← nested object replaced, not merged\n *\n * shallowMerge(defaults, overrides, extras);\n * ```\n */\nexport function shallowMerge<T extends Obj[]>(...items: [...T]): Merge<T> {\n  if (items.length === 0) return {} as Merge<T>;\n\n  const result: Obj = {};\n\n  for (const item of items) {\n    for (const key of Object.keys(item)) {\n      if (isUnsafeKey(key)) continue;\n\n      result[key] = item[key];\n    }\n  }\n\n  return result as Merge<T>;\n}\n"],"mappings":";;;AAgCA,SAAS,EAA2C,GAAW,GAAW,GAA4C;CACpH,IAAI,CAAC,EAAc,CAAM,GAAG,OAAO;CAEnC,IAAM,IAAS,EAAE,GAAG,EAAO;CAE3B,KAAK,IAAM,KAAO,OAAO,KAAK,CAAM,GAAG;EAErC,IAAI,EAAY,CAAG,GACjB;EAGF,IAAM,IAAc,EAAO,IACrB,IAAc,EAAO;EAE3B,EAAoC,KAClC,MAAM,QAAQ,CAAW,KAAK,MAAM,QAAQ,CAAW,IACnD,EAAQ,kBAAkB,WACxB,CAAC,GAAG,GAAa,GAAG,CAAW,IAC/B,IACF,EAAc,CAAW,KAAK,EAAc,CAAW,IACrD,EAAa,GAAoB,GAAoB,CAAO,IAC5D;CACV;CAEA,OAAO;AACT;AAkBA,SAAgB,EAA2B,GAAwB,IAA4B,CAAC,GAAa;CAC3G,OAAO,EAAM,QAAQ,GAAU,MAAS,EAAa,GAAK,GAAM,CAAO,GAAU,CAAC,CAAQ;AAC5F;AAcA,SAAgB,EAA8B,GAAG,GAAyB;CACxE,IAAI,EAAM,WAAW,GAAG,OAAO,CAAC;CAEhC,IAAM,IAAc,CAAC;CAErB,KAAK,IAAM,KAAQ,GACjB,KAAK,IAAM,KAAO,OAAO,KAAK,CAAI,GAC5B,EAAY,CAAG,MAEnB,EAAO,KAAO,EAAK;CAIvB,OAAO;AACT"}

package/dist/object/prune.cjs

@@ -1,2 +1,2 @@
-const e=require("../guards/isString.cjs"),t=require("../_common/unsafePaths.cjs"),n=require("../array/filterMap.cjs"),r=require("../guards/isNil.cjs"),i=require("../guards/isPlainObject.cjs"),a=require("../guards/isEmpty.cjs");function o(s){if(!r.isNil(s)){if(e.isString(s)){let e=s.trim();return e===``?void 0:e}if(Array.isArray(s)){let e=n.filterMap(s,e=>{let t=o(e);return a.isEmpty(t)?void 0:t});return e.length===0?void 0:e}if(i.isPlainObject(s)){let e={};for(let[n,r]of Object.entries(s)){if(t.isUnsafeKey(n))continue;let i=o(r);a.isEmpty(i)||(e[n]=i)}return Object.keys(e).length===0?void 0:e}return s}}exports.prune=o;
+const e=require("../_common/unsafePaths.cjs"),t=require("../array/filterMap.cjs"),n=require("../guards/isNil.cjs"),r=require("../guards/isPlainObject.cjs"),i=require("../guards/isEmpty.cjs");function a(o){if(!n.isNil(o)){if(typeof o==`string`){let e=o.trim();return e===``?void 0:e}if(Array.isArray(o)){let e=t.filterMap(o,e=>{let t=a(e);return i.isEmpty(t)?void 0:t});return e.length===0?void 0:e}if(r.isPlainObject(o)){let t={};for(let[n,r]of Object.entries(o)){if(e.isUnsafeKey(n))continue;let o=a(r);i.isEmpty(o)||(t[n]=o)}return Object.keys(t).length===0?void 0:t}return o}}exports.prune=a;
 //# sourceMappingURL=prune.cjs.map

package/dist/object/prune.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"prune.cjs","names":[],"sources":["../../src/object/prune.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { filterMap } from '../array/filterMap';\nimport { isEmpty } from '../guards/isEmpty';\nimport { isNil } from '../guards/isNil';\nimport { isPlainObject } from '../guards/isPlainObject';\nimport { isString } from '../guards/isString';\n\n/**\n * Removes all nullable and empty values from strings, arrays, or objects.\n *\n * - For strings: trims whitespace and returns `undefined` if the result is empty.\n * - For arrays: recursively removes `null`, `undefined`, empty strings, and empty objects/arrays.\n * - For objects: recursively removes properties whose pruned value is empty. Dangerous keys\n *   (`__proto__`, `constructor`, `prototype`) are always skipped.\n * - For any other type: returns the value unchanged.\n *\n * @example\n * ```ts\n * prune('  hello  '); // 'hello'\n * prune('   ');       // undefined\n * prune([1, null, '', 2, undefined, 3]); // [1, 2, 3]\n * prune({ a: 1, b: null, c: '', d: 2 }); // { a: 1, d: 2 }\n * prune({ a: { b: null, c: '' }, d: 1 }); // { d: 1 }\n * ```\n *\n * @param value - The value to prune.\n * @returns The pruned value, or `undefined` if the result would be empty.\n */\nexport function prune(value: string): string | undefined;\nexport function prune<T>(value: T[]): Array<NonNullable<T>> | undefined;\nexport function prune<T extends Record<string, unknown>>(value: T): Partial<T> | undefined;\nexport function prune<T>(value: T): T | undefined;\nexport function prune<T>(value: T): T | undefined {\n  if (isNil(value)) return undefined;\n\n  if (isString(value)) {\n    const trimmed = value.trim();\n\n    return (trimmed === '' ? undefined : trimmed) as T | undefined;\n  }\n\n  if (Array.isArray(value)) {\n    const cleaned = filterMap(value as unknown[], (item) => {\n      const pruned = prune(item);\n\n      return isEmpty(pruned) ? undefined : (pruned as unknown);\n    });\n\n    return (cleaned.length === 0 ? undefined : cleaned) as T | undefined;\n  }\n\n  if (isPlainObject(value)) {\n    const cleaned: Record<string, unknown> = {};\n\n    for (const [key, val] of Object.entries(value)) {\n      if (isUnsafeKey(key)) continue;\n\n      const cleanedValue = prune(val);\n\n      if (!isEmpty(cleanedValue)) {\n        cleaned[key] = cleanedValue;\n      }\n    }\n\n    return (Object.keys(cleaned).length === 0 ? undefined : cleaned) as T | undefined;\n  }\n\n  return value;\n}\n"],"mappings":"mOAgCA,SAAgB,EAAS,EAAyB,CAC5C,MAAA,MAAM,CAAK,EAEf,IAAI,EAAA,SAAS,CAAK,EAAG,CACnB,IAAM,EAAU,EAAM,KAAK,EAE3B,OAAQ,IAAY,GAAK,IAAA,GAAY,CACvC,CAEA,GAAI,MAAM,QAAQ,CAAK,EAAG,CACxB,IAAM,EAAU,EAAA,UAAU,EAAqB,GAAS,CACtD,IAAM,EAAS,EAAM,CAAI,EAEzB,OAAO,EAAA,QAAQ,CAAM,EAAI,IAAA,GAAa,CACxC,CAAC,EAED,OAAQ,EAAQ,SAAW,EAAI,IAAA,GAAY,CAC7C,CAEA,GAAI,EAAA,cAAc,CAAK,EAAG,CACxB,IAAM,EAAmC,CAAC,EAE1C,IAAK,GAAM,CAAC,EAAK,KAAQ,OAAO,QAAQ,CAAK,EAAG,CAC9C,GAAI,EAAA,YAAY,CAAG,EAAG,SAEtB,IAAM,EAAe,EAAM,CAAG,EAEzB,EAAA,QAAQ,CAAY,IACvB,EAAQ,GAAO,EAEnB,CAEA,OAAQ,OAAO,KAAK,CAAO,CAAC,CAAC,SAAW,EAAI,IAAA,GAAY,CAC1D,CAEA,OAAO,CA5BP,CA6BF"}
+{"version":3,"file":"prune.cjs","names":[],"sources":["../../src/object/prune.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { filterMap } from '../array/filterMap';\nimport { isEmpty } from '../guards/isEmpty';\nimport { isNil } from '../guards/isNil';\nimport { isPlainObject } from '../guards/isPlainObject';\n\n/**\n * Removes all nullable and empty values from strings, arrays, or objects.\n *\n * - For strings: trims whitespace and returns `undefined` if the result is empty.\n * - For arrays: recursively removes `null`, `undefined`, empty strings, and empty objects/arrays.\n * - For objects: recursively removes properties whose pruned value is empty. Dangerous keys\n *   (`__proto__`, `constructor`, `prototype`) are always skipped.\n * - For any other type: returns the value unchanged.\n *\n * @example\n * ```ts\n * prune('  hello  '); // 'hello'\n * prune('   ');       // undefined\n * prune([1, null, '', 2, undefined, 3]); // [1, 2, 3]\n * prune({ a: 1, b: null, c: '', d: 2 }); // { a: 1, d: 2 }\n * prune({ a: { b: null, c: '' }, d: 1 }); // { d: 1 }\n * ```\n *\n * @param value - The value to prune.\n * @returns The pruned value, or `undefined` if the result would be empty.\n */\nexport function prune(value: string): string | undefined;\nexport function prune<T>(value: T[]): Array<NonNullable<T>> | undefined;\nexport function prune<T extends Record<string, unknown>>(value: T): Partial<T> | undefined;\nexport function prune<T>(value: T): T | undefined;\nexport function prune<T>(value: T): T | undefined {\n  if (isNil(value)) return undefined;\n\n  if (typeof value === 'string') {\n    const trimmed = value.trim();\n\n    return (trimmed === '' ? undefined : trimmed) as T | undefined;\n  }\n\n  if (Array.isArray(value)) {\n    const cleaned = filterMap(value as unknown[], (item) => {\n      const pruned = prune(item);\n\n      return isEmpty(pruned) ? undefined : (pruned as unknown);\n    });\n\n    return (cleaned.length === 0 ? undefined : cleaned) as T | undefined;\n  }\n\n  if (isPlainObject(value)) {\n    const cleaned: Record<string, unknown> = {};\n\n    for (const [key, val] of Object.entries(value)) {\n      if (isUnsafeKey(key)) continue;\n\n      const cleanedValue = prune(val);\n\n      if (!isEmpty(cleanedValue)) {\n        cleaned[key] = cleanedValue;\n      }\n    }\n\n    return (Object.keys(cleaned).length === 0 ? undefined : cleaned) as T | undefined;\n  }\n\n  return value;\n}\n"],"mappings":"+LA+BA,SAAgB,EAAS,EAAyB,CAC5C,MAAA,MAAM,CAAK,EAEf,IAAI,OAAO,GAAU,SAAU,CAC7B,IAAM,EAAU,EAAM,KAAK,EAE3B,OAAQ,IAAY,GAAK,IAAA,GAAY,CACvC,CAEA,GAAI,MAAM,QAAQ,CAAK,EAAG,CACxB,IAAM,EAAU,EAAA,UAAU,EAAqB,GAAS,CACtD,IAAM,EAAS,EAAM,CAAI,EAEzB,OAAO,EAAA,QAAQ,CAAM,EAAI,IAAA,GAAa,CACxC,CAAC,EAED,OAAQ,EAAQ,SAAW,EAAI,IAAA,GAAY,CAC7C,CAEA,GAAI,EAAA,cAAc,CAAK,EAAG,CACxB,IAAM,EAAmC,CAAC,EAE1C,IAAK,GAAM,CAAC,EAAK,KAAQ,OAAO,QAAQ,CAAK,EAAG,CAC9C,GAAI,EAAA,YAAY,CAAG,EAAG,SAEtB,IAAM,EAAe,EAAM,CAAG,EAEzB,EAAA,QAAQ,CAAY,IACvB,EAAQ,GAAO,EAEnB,CAEA,OAAQ,OAAO,KAAK,CAAO,CAAC,CAAC,SAAW,EAAI,IAAA,GAAY,CAC1D,CAEA,OAAO,CA5BP,CA6BF"}

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

@@ -1 +1 @@
-{"version":3,"file":"prune.d.ts","sourceRoot":"","sources":["../../src/object/prune.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AACzD,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;AACxE,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;AAC3F,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC"}
+{"version":3,"file":"prune.d.ts","sourceRoot":"","sources":["../../src/object/prune.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AACzD,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;AACxE,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;AAC3F,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC"}

package/dist/object/prune.js

@@ -1,36 +1,35 @@
-import { isString as e } from "../guards/isString.js";
-import { isUnsafeKey as t } from "../_common/unsafePaths.js";
-import { filterMap as n } from "../array/filterMap.js";
-import { isNil as r } from "../guards/isNil.js";
-import { isPlainObject as i } from "../guards/isPlainObject.js";
-import { isEmpty as a } from "../guards/isEmpty.js";
+import { isUnsafeKey as e } from "../_common/unsafePaths.js";
+import { filterMap as t } from "../array/filterMap.js";
+import { isNil as n } from "../guards/isNil.js";
+import { isPlainObject as r } from "../guards/isPlainObject.js";
+import { isEmpty as i } from "../guards/isEmpty.js";
 //#region src/object/prune.ts
-function o(s) {
-	if (!r(s)) {
-		if (e(s)) {
-			let e = s.trim();
+function a(o) {
+	if (!n(o)) {
+		if (typeof o == "string") {
+			let e = o.trim();
 			return e === "" ? void 0 : e;
 		}
-		if (Array.isArray(s)) {
-			let e = n(s, (e) => {
-				let t = o(e);
-				return a(t) ? void 0 : t;
+		if (Array.isArray(o)) {
+			let e = t(o, (e) => {
+				let t = a(e);
+				return i(t) ? void 0 : t;
 			});
 			return e.length === 0 ? void 0 : e;
 		}
-		if (i(s)) {
-			let e = {};
-			for (let [n, r] of Object.entries(s)) {
-				if (t(n)) continue;
-				let i = o(r);
-				a(i) || (e[n] = i);
+		if (r(o)) {
+			let t = {};
+			for (let [n, r] of Object.entries(o)) {
+				if (e(n)) continue;
+				let o = a(r);
+				i(o) || (t[n] = o);
 			}
-			return Object.keys(e).length === 0 ? void 0 : e;
+			return Object.keys(t).length === 0 ? void 0 : t;
 		}
-		return s;
+		return o;
 	}
 }
 //#endregion
-export { o as prune };
+export { a as prune };
 
 //# sourceMappingURL=prune.js.map

package/dist/object/prune.js.map

@@ -1 +1 @@
-{"version":3,"file":"prune.js","names":[],"sources":["../../src/object/prune.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { filterMap } from '../array/filterMap';\nimport { isEmpty } from '../guards/isEmpty';\nimport { isNil } from '../guards/isNil';\nimport { isPlainObject } from '../guards/isPlainObject';\nimport { isString } from '../guards/isString';\n\n/**\n * Removes all nullable and empty values from strings, arrays, or objects.\n *\n * - For strings: trims whitespace and returns `undefined` if the result is empty.\n * - For arrays: recursively removes `null`, `undefined`, empty strings, and empty objects/arrays.\n * - For objects: recursively removes properties whose pruned value is empty. Dangerous keys\n *   (`__proto__`, `constructor`, `prototype`) are always skipped.\n * - For any other type: returns the value unchanged.\n *\n * @example\n * ```ts\n * prune('  hello  '); // 'hello'\n * prune('   ');       // undefined\n * prune([1, null, '', 2, undefined, 3]); // [1, 2, 3]\n * prune({ a: 1, b: null, c: '', d: 2 }); // { a: 1, d: 2 }\n * prune({ a: { b: null, c: '' }, d: 1 }); // { d: 1 }\n * ```\n *\n * @param value - The value to prune.\n * @returns The pruned value, or `undefined` if the result would be empty.\n */\nexport function prune(value: string): string | undefined;\nexport function prune<T>(value: T[]): Array<NonNullable<T>> | undefined;\nexport function prune<T extends Record<string, unknown>>(value: T): Partial<T> | undefined;\nexport function prune<T>(value: T): T | undefined;\nexport function prune<T>(value: T): T | undefined {\n  if (isNil(value)) return undefined;\n\n  if (isString(value)) {\n    const trimmed = value.trim();\n\n    return (trimmed === '' ? undefined : trimmed) as T | undefined;\n  }\n\n  if (Array.isArray(value)) {\n    const cleaned = filterMap(value as unknown[], (item) => {\n      const pruned = prune(item);\n\n      return isEmpty(pruned) ? undefined : (pruned as unknown);\n    });\n\n    return (cleaned.length === 0 ? undefined : cleaned) as T | undefined;\n  }\n\n  if (isPlainObject(value)) {\n    const cleaned: Record<string, unknown> = {};\n\n    for (const [key, val] of Object.entries(value)) {\n      if (isUnsafeKey(key)) continue;\n\n      const cleanedValue = prune(val);\n\n      if (!isEmpty(cleanedValue)) {\n        cleaned[key] = cleanedValue;\n      }\n    }\n\n    return (Object.keys(cleaned).length === 0 ? undefined : cleaned) as T | undefined;\n  }\n\n  return value;\n}\n"],"mappings":";;;;;;;AAgCA,SAAgB,EAAS,GAAyB;CAC5C,OAAM,CAAK,GAEf;MAAI,EAAS,CAAK,GAAG;GACnB,IAAM,IAAU,EAAM,KAAK;GAE3B,OAAQ,MAAY,KAAK,KAAA,IAAY;EACvC;EAEA,IAAI,MAAM,QAAQ,CAAK,GAAG;GACxB,IAAM,IAAU,EAAU,IAAqB,MAAS;IACtD,IAAM,IAAS,EAAM,CAAI;IAEzB,OAAO,EAAQ,CAAM,IAAI,KAAA,IAAa;GACxC,CAAC;GAED,OAAQ,EAAQ,WAAW,IAAI,KAAA,IAAY;EAC7C;EAEA,IAAI,EAAc,CAAK,GAAG;GACxB,IAAM,IAAmC,CAAC;GAE1C,KAAK,IAAM,CAAC,GAAK,MAAQ,OAAO,QAAQ,CAAK,GAAG;IAC9C,IAAI,EAAY,CAAG,GAAG;IAEtB,IAAM,IAAe,EAAM,CAAG;IAE9B,AAAK,EAAQ,CAAY,MACvB,EAAQ,KAAO;GAEnB;GAEA,OAAQ,OAAO,KAAK,CAAO,CAAC,CAAC,WAAW,IAAI,KAAA,IAAY;EAC1D;EAEA,OAAO;CA5BP;AA6BF"}
+{"version":3,"file":"prune.js","names":[],"sources":["../../src/object/prune.ts"],"sourcesContent":["import { isUnsafeKey } from '../_common/unsafePaths';\nimport { filterMap } from '../array/filterMap';\nimport { isEmpty } from '../guards/isEmpty';\nimport { isNil } from '../guards/isNil';\nimport { isPlainObject } from '../guards/isPlainObject';\n\n/**\n * Removes all nullable and empty values from strings, arrays, or objects.\n *\n * - For strings: trims whitespace and returns `undefined` if the result is empty.\n * - For arrays: recursively removes `null`, `undefined`, empty strings, and empty objects/arrays.\n * - For objects: recursively removes properties whose pruned value is empty. Dangerous keys\n *   (`__proto__`, `constructor`, `prototype`) are always skipped.\n * - For any other type: returns the value unchanged.\n *\n * @example\n * ```ts\n * prune('  hello  '); // 'hello'\n * prune('   ');       // undefined\n * prune([1, null, '', 2, undefined, 3]); // [1, 2, 3]\n * prune({ a: 1, b: null, c: '', d: 2 }); // { a: 1, d: 2 }\n * prune({ a: { b: null, c: '' }, d: 1 }); // { d: 1 }\n * ```\n *\n * @param value - The value to prune.\n * @returns The pruned value, or `undefined` if the result would be empty.\n */\nexport function prune(value: string): string | undefined;\nexport function prune<T>(value: T[]): Array<NonNullable<T>> | undefined;\nexport function prune<T extends Record<string, unknown>>(value: T): Partial<T> | undefined;\nexport function prune<T>(value: T): T | undefined;\nexport function prune<T>(value: T): T | undefined {\n  if (isNil(value)) return undefined;\n\n  if (typeof value === 'string') {\n    const trimmed = value.trim();\n\n    return (trimmed === '' ? undefined : trimmed) as T | undefined;\n  }\n\n  if (Array.isArray(value)) {\n    const cleaned = filterMap(value as unknown[], (item) => {\n      const pruned = prune(item);\n\n      return isEmpty(pruned) ? undefined : (pruned as unknown);\n    });\n\n    return (cleaned.length === 0 ? undefined : cleaned) as T | undefined;\n  }\n\n  if (isPlainObject(value)) {\n    const cleaned: Record<string, unknown> = {};\n\n    for (const [key, val] of Object.entries(value)) {\n      if (isUnsafeKey(key)) continue;\n\n      const cleanedValue = prune(val);\n\n      if (!isEmpty(cleanedValue)) {\n        cleaned[key] = cleanedValue;\n      }\n    }\n\n    return (Object.keys(cleaned).length === 0 ? undefined : cleaned) as T | undefined;\n  }\n\n  return value;\n}\n"],"mappings":";;;;;;AA+BA,SAAgB,EAAS,GAAyB;CAC5C,OAAM,CAAK,GAEf;MAAI,OAAO,KAAU,UAAU;GAC7B,IAAM,IAAU,EAAM,KAAK;GAE3B,OAAQ,MAAY,KAAK,KAAA,IAAY;EACvC;EAEA,IAAI,MAAM,QAAQ,CAAK,GAAG;GACxB,IAAM,IAAU,EAAU,IAAqB,MAAS;IACtD,IAAM,IAAS,EAAM,CAAI;IAEzB,OAAO,EAAQ,CAAM,IAAI,KAAA,IAAa;GACxC,CAAC;GAED,OAAQ,EAAQ,WAAW,IAAI,KAAA,IAAY;EAC7C;EAEA,IAAI,EAAc,CAAK,GAAG;GACxB,IAAM,IAAmC,CAAC;GAE1C,KAAK,IAAM,CAAC,GAAK,MAAQ,OAAO,QAAQ,CAAK,GAAG;IAC9C,IAAI,EAAY,CAAG,GAAG;IAEtB,IAAM,IAAe,EAAM,CAAG;IAE9B,AAAK,EAAQ,CAAY,MACvB,EAAQ,KAAO;GAEnB;GAEA,OAAQ,OAAO,KAAK,CAAO,CAAC,CAAC,WAAW,IAAI,KAAA,IAAY;EAC1D;EAEA,OAAO;CA5BP;AA6BF"}

package/dist/object/tryParseJson.cjs

@@ -0,0 +1,2 @@
+function e(e){try{return{ok:!0,value:JSON.parse(e)}}catch(e){return{error:e,ok:!1}}}exports.tryParseJson=e;
+//# sourceMappingURL=tryParseJson.cjs.map

package/dist/object/tryParseJson.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tryParseJson.cjs","names":[],"sources":["../../src/object/tryParseJson.ts"],"sourcesContent":["export type JsonParseResult = { ok: true; value: unknown } | { error: SyntaxError; ok: false };\n\nexport function tryParseJson(text: string): JsonParseResult {\n  try {\n    return { ok: true, value: JSON.parse(text) as unknown };\n  } catch (error) {\n    return { error: error as SyntaxError, ok: false };\n  }\n}\n"],"mappings":"AAEA,SAAgB,EAAa,EAA+B,CAC1D,GAAI,CACF,MAAO,CAAE,GAAI,GAAM,MAAO,KAAK,MAAM,CAAI,CAAa,CACxD,OAAS,EAAO,CACd,MAAO,CAAS,QAAsB,GAAI,EAAM,CAClD,CACF"}

package/dist/object/tryParseJson.d.ts

@@ -0,0 +1,9 @@
+export type JsonParseResult = {
+    ok: true;
+    value: unknown;
+} | {
+    error: SyntaxError;
+    ok: false;
+};
+export declare function tryParseJson(text: string): JsonParseResult;
+//# sourceMappingURL=tryParseJson.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tryParseJson.d.ts","sourceRoot":"","sources":["../../src/object/tryParseJson.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,WAAW,CAAC;IAAC,EAAE,EAAE,KAAK,CAAA;CAAE,CAAC;AAE/F,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAM1D"}

package/dist/object/tryParseJson.js

@@ -0,0 +1,18 @@
+//#region src/object/tryParseJson.ts
+function e(e) {
+	try {
+		return {
+			ok: !0,
+			value: JSON.parse(e)
+		};
+	} catch (e) {
+		return {
+			error: e,
+			ok: !1
+		};
+	}
+}
+//#endregion
+export { e as tryParseJson };
+
+//# sourceMappingURL=tryParseJson.js.map

package/dist/object/tryParseJson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tryParseJson.js","names":[],"sources":["../../src/object/tryParseJson.ts"],"sourcesContent":["export type JsonParseResult = { ok: true; value: unknown } | { error: SyntaxError; ok: false };\n\nexport function tryParseJson(text: string): JsonParseResult {\n  try {\n    return { ok: true, value: JSON.parse(text) as unknown };\n  } catch (error) {\n    return { error: error as SyntaxError, ok: false };\n  }\n}\n"],"mappings":";AAEA,SAAgB,EAAa,GAA+B;CAC1D,IAAI;EACF,OAAO;GAAE,IAAI;GAAM,OAAO,KAAK,MAAM,CAAI;EAAa;CACxD,SAAS,GAAO;EACd,OAAO;GAAS;GAAsB,IAAI;EAAM;CAClD;AACF"}

package/dist/random/_index.cjs

@@ -0,0 +1,2 @@
+function e(e,t){let n=t?.next()??crypto.getRandomValues(new Uint32Array(1))[0]/4294967296;if(!Number.isFinite(n)||n<0||n>=1)throw RangeError(`random source must return a finite number in [0, 1)`);return Math.floor(n*e)}exports.randomIndex=e;
+//# sourceMappingURL=_index.cjs.map

package/dist/random/_index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_index.cjs","names":[],"sources":["../../src/random/_index.ts"],"sourcesContent":["import type { RandomSource } from './source';\n\nexport function randomIndex(exclusiveMax: number, source?: RandomSource): number {\n  const value = source?.next() ?? crypto.getRandomValues(new Uint32Array(1))[0]! / 0x100000000;\n\n  if (!Number.isFinite(value) || value < 0 || value >= 1) {\n    throw new RangeError('random source must return a finite number in [0, 1)');\n  }\n\n  return Math.floor(value * exclusiveMax);\n}\n"],"mappings":"AAEA,SAAgB,EAAY,EAAsB,EAA+B,CAC/E,IAAM,EAAQ,GAAQ,KAAK,GAAK,OAAO,gBAAgB,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,GAAM,WAEjF,GAAI,CAAC,OAAO,SAAS,CAAK,GAAK,EAAQ,GAAK,GAAS,EACnD,MAAU,WAAW,qDAAqD,EAG5E,OAAO,KAAK,MAAM,EAAQ,CAAY,CACxC"}

package/dist/random/_index.d.ts

@@ -0,0 +1,3 @@
+import type { RandomSource } from './source';
+export declare function randomIndex(exclusiveMax: number, source?: RandomSource): number;
+//# sourceMappingURL=_index.d.ts.map

package/dist/random/_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_index.d.ts","sourceRoot":"","sources":["../../src/random/_index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAQ/E"}

package/dist/random/_index.js

@@ -0,0 +1,10 @@
+//#region src/random/_index.ts
+function e(e, t) {
+	let n = t?.next() ?? crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(1))[0] / 4294967296;
+	if (!Number.isFinite(n) || n < 0 || n >= 1) throw RangeError("random source must return a finite number in [0, 1)");
+	return Math.floor(n * e);
+}
+//#endregion
+export { e as randomIndex };
+
+//# sourceMappingURL=_index.js.map