@homer0/object-utils 6.0.7 → 7.0.0

package/dist/index.d.ts

@@ -5,7 +5,7 @@
  * @template T The type of the input object, which will be the same as the one returned.
  * @param target The object to copy.
  */
-declare const copy: <T>(target: T) => T;
+export declare const copy: <T>(target: T) => T;
 //#endregion
 //#region src/fns/formatKeys.d.ts
 /**
@@ -14,8 +14,8 @@ declare const copy: <T>(target: T) => T;
  * @param substring The captured string to replace.
  * @param args The list of groups captured by the expression.
  */
-type FormatKeysReplaceFn = (substring: string, ...args: string[]) => string;
-type FormatKeysOptions = {
+export type FormatKeysReplaceFn = (substring: string, ...args: string[]) => string;
+export type FormatKeysOptions = {
   /** The object to transform. */
   target: unknown;
   /** A regular expression to match the keys to transform. */
@@ -38,7 +38,7 @@ type FormatKeysOptions = {
    */
   pathDelimiter?: string;
 };
-type FormatKeysExtensionOptions = Omit<FormatKeysOptions, 'search' | 'replace'>;
+export type FormatKeysExtensionOptions = Omit<FormatKeysOptions, 'search' | 'replace'>;
 /**
  * Formats all the keys on an object using a way similar to `.replace(regexp, ...)` but
  * that also works recursively and with _"object paths"_.
@@ -64,7 +64,7 @@ type FormatKeysExtensionOptions = Omit<FormatKeysOptions, 'search' | 'replace'>;
  *   @template T The type of the returned object.
  *   @param options The set of options to customize the transformation.
  */
-declare const formatKeys: <T = Record<string, unknown>>(options: FormatKeysOptions) => T;
+export declare const formatKeys: <T = Record<string, unknown>>(options: FormatKeysOptions) => T;
 //#endregion
 //#region src/fns/dashToLowerCamelKeys.d.ts
 /**
@@ -74,7 +74,7 @@ declare const formatKeys: <T = Record<string, unknown>>(options: FormatKeysOptio
  * @template T The type of the returned object.
  * @param options The options to use.
  */
-declare const dashToLowerCamelKeys: <T>(options: FormatKeysExtensionOptions) => T;
+export declare const dashToLowerCamelKeys: <T>(options: FormatKeysExtensionOptions) => T;
 //#endregion
 //#region src/fns/dashToSnakeKeys.d.ts
 /**
@@ -84,15 +84,15 @@ declare const dashToLowerCamelKeys: <T>(options: FormatKeysExtensionOptions) =>
  * @template T The type of the returned object.
  * @param options The options to use.
  */
-declare const dashToSnakeKeys: <T>(options: FormatKeysExtensionOptions) => T;
+export declare const dashToSnakeKeys: <T>(options: FormatKeysExtensionOptions) => T;
 //#endregion
 //#region src/fns/extract.d.ts
 /**
  * Used in the {@link extract} function to specify a path for a property, or an "origin
  * path" and an "extraction path".
  */
-type extractionPath = string | Record<string, string>;
-type ExtractOptions = {
+export type extractionPath = string | Record<string, string>;
+export type ExtractOptions = {
   /** The object from where the property/properties will be extracted. */
   target: unknown;
   /**
@@ -134,7 +134,7 @@ type ExtractOptions = {
  * @template T The type of the returned object.
  * @param options The options to use.
  */
-declare const extract: <T = Record<string, unknown>>(options: ExtractOptions) => T | undefined;
+export declare const extract: <T = Record<string, unknown>>(options: ExtractOptions) => T | undefined;
 //#endregion
 //#region src/fns/flat.d.ts
 /**
@@ -143,8 +143,8 @@ declare const extract: <T = Record<string, unknown>>(options: ExtractOptions) =>
  * @param key The key to check inside its parent.
  * @param value The value of the key.
  */
-type ShouldFlattenFn = (key: string, value: unknown) => boolean;
-type FlatOptions = {
+export type ShouldFlattenFn = (key: string, value: unknown) => boolean;
+export type FlatOptions = {
   /** The object to transform. */
   target: unknown;
   /**
@@ -177,10 +177,10 @@ type FlatOptions = {
  * @template T The type of the returned object.
  * @param options The options to use.
  */
-declare const flat: <T = Record<string, unknown>>(options: FlatOptions) => T;
+export declare const flat: <T = Record<string, unknown>>(options: FlatOptions) => T;
 //#endregion
 //#region src/fns/get.d.ts
-type GetOptions = {
+export type GetOptions = {
   /** The object from where the property will be read. */
   target: unknown;
   /** The path to the property. */
@@ -221,7 +221,7 @@ declare function get<T>(options: unknown, path: string): T | undefined;
  * @template T The type of the returned object.
  * @param options The options to use.
  */
-declare const lowerCamelToDashKeys: <T>(options: FormatKeysExtensionOptions) => T;
+export declare const lowerCamelToDashKeys: <T>(options: FormatKeysExtensionOptions) => T;
 //#endregion
 //#region src/fns/lowerCamelToSnakeKeys.d.ts
 /**
@@ -231,7 +231,7 @@ declare const lowerCamelToDashKeys: <T>(options: FormatKeysExtensionOptions) =>
  * @template T The type of the returned object.
  * @param options The options to use.
  */
-declare const lowerCamelToSnakeKeys: <T>(options: FormatKeysExtensionOptions) => T;
+export declare const lowerCamelToSnakeKeys: <T>(options: FormatKeysExtensionOptions) => T;
 //#endregion
 //#region src/fns/merge.d.ts
 /**
@@ -254,10 +254,10 @@ declare const lowerCamelToSnakeKeys: <T>(options: FormatKeysExtensionOptions) =>
  * @template T The type of the merged object that will be returned.
  * @param targets The list of objects to merge.
  */
-declare const merge: <T = unknown>(...targets: unknown[]) => T;
+export declare const merge: <T = unknown>(...targets: unknown[]) => T;
 //#endregion
 //#region src/fns/remove.d.ts
-type RemoveOptions = {
+export type RemoveOptions = {
   /** The object from where the property will be removed. */
   target: unknown;
   /** The path to the property. */
@@ -295,7 +295,7 @@ declare function remove<T = unknown>(options: RemoveOptions): T | undefined;
 declare function remove<T = unknown>(options: unknown, path: string): T | undefined;
 //#endregion
 //#region src/fns/set.d.ts
-type SetOptions = {
+export type SetOptions = {
   /** The object where the property will be set. */
   target: unknown;
   /** The path for the property. */
@@ -335,7 +335,7 @@ declare function set<T = Record<string, unknown>>(options: SetOptions | unknown,
  * @template T The type of the returned object.
  * @param options The options to use.
  */
-declare const snakeToDashKeys: <T>(options: FormatKeysExtensionOptions) => T;
+export declare const snakeToDashKeys: <T>(options: FormatKeysExtensionOptions) => T;
 //#endregion
 //#region src/fns/snakeToLowerCamelKeys.d.ts
 /**
@@ -345,10 +345,10 @@ declare const snakeToDashKeys: <T>(options: FormatKeysExtensionOptions) => T;
  * @template T The type of the returned object.
  * @param options The options to use.
  */
-declare const snakeToLowerCamelKeys: <T>(options: FormatKeysExtensionOptions) => T;
+export declare const snakeToLowerCamelKeys: <T>(options: FormatKeysExtensionOptions) => T;
 //#endregion
 //#region src/fns/unflat.d.ts
-type UnflatOptions = {
+export type UnflatOptions = {
   /** The object to transform. */
   target: unknown;
   /** The delimiter that will separate the path components. */
@@ -369,7 +369,7 @@ type UnflatOptions = {
  * @template T The type of the returned object.
  * @param options The options to use.
  */
-declare const unflat: <T = Record<string, unknown>>(options: UnflatOptions) => T;
+export declare const unflat: <T = Record<string, unknown>>(options: UnflatOptions) => T;
 //#endregion
-export { ExtractOptions, FlatOptions, FormatKeysExtensionOptions, FormatKeysOptions, FormatKeysReplaceFn, GetOptions, RemoveOptions, SetOptions, ShouldFlattenFn, UnflatOptions, copy, dashToLowerCamelKeys, dashToSnakeKeys, extract, extractionPath, flat, formatKeys, get, lowerCamelToDashKeys, lowerCamelToSnakeKeys, merge, remove, set, snakeToDashKeys, snakeToLowerCamelKeys, unflat };
+export { get, remove, set };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,2 +1,2 @@
-import e from"extend";const t=(...t)=>{let[n]=t;return e(!0,Array.isArray(n)?[]:{},...t)},n=e=>t(e),r=e=>{let{target:t,search:n,replace:i,include:a=[],exclude:o=[],pathDelimiter:s=`.`}=e,c=t,l=Object.keys(t),u={};l.forEach(e=>{let t=c[e];u[e]=!!(t&&typeof t==`object`&&t&&!Array.isArray(t)&&Object.keys(t))});let d=s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g,`\\$&`),f=RegExp(`^${d}`,`i`),p=RegExp(`${d}$`,`i`),m={},h;h=a.length?a.map(e=>{let t=e.replace(f,``).replace(p,``),n;if(t.includes(s)){let e=t.split(s),r=e.shift();n=``,m[r]||(m[r]=[]),m[r].push(e.join(s))}else n=t;return n}).filter(e=>e):l;let g={};if(o.length){let e=[];o.forEach(t=>{let n=t.replace(f,``).replace(p,``);if(n.includes(s)){let e=n.split(s),t=e.shift();g[t]||(g[t]=[]),g[t].push(e.join(s))}else u[n]=!1,e.push(n)}),h=h.filter(t=>t&&!e.includes(t))}return l.reduce((e,t)=>{let a,o,l=c[t];return a=h.includes(t)?t.replace(n,i):t,o=u[t]?r({target:l,search:n,replace:i,include:m[t]||[],exclude:g[t]||[],pathDelimiter:s}):l,{...e,[a]:o}},{})},i=e=>r({...e,search:/([a-z])-([a-z])/g,replace:(e,t,n)=>`${t}${n.toUpperCase()}`}),a=e=>r({...e,search:/([a-z])-([a-z])/g,replace:(e,t,n)=>`${t}_${n}`});function o(e,t){let n;n=typeof t==`string`?{target:e,path:t}:e;let{target:r,path:i,pathDelimiter:a=`.`,failWithError:o=!1}=n,s=r,c=i.split(a),l=c.shift(),u=s[l];if(u===void 0){if(o)throw Error(`There's nothing on '${i}'`);return}if(!c.length)return u;let d=l;return c.some(e=>{let t=!1;if(d+=`${a}${e}`,u=u[e],u===void 0){if(o)throw Error(`There's nothing on '${d}'`);t=!0}return t}),u}const s=[`__proto__`,`prototype`,`constructor`];function c(e,t,r){let i;i=typeof t==`string`?{target:e,path:t,value:r}:e;let{target:a,path:o,value:c,pathDelimiter:l=`.`,failWithError:u=!1}=i,d=n(a);if(!o.includes(l))return!o||s.includes(o.toLowerCase())?void 0:(d[o]=c,d);let f=o.split(l);if(f.some(e=>!e||s.includes(e.toLowerCase())))return;let p=f.pop(),m=d,h=``,g=!1;if(f.forEach(e=>{h+=`${l}${e}`;let t=typeof m[e];if(t===`undefined`)m[e]={},m=m[e];else if(t===`object`)m=m[e];else{let e=h.substring(l.length);if(u)throw Error(`There's already an element of type '${t}' on '${e}'`);g=!0}}),!g)return m[p]=c,d}const l=e=>{let{target:t,paths:r,pathDelimiter:i=`.`,failWithError:a=!1}=e,s=n(t),l={},u=!1;if((Array.isArray(r)?r:[r]).reduce((e,t)=>{let n,r;if(typeof t==`string`)n=t,r=t;else{let[e]=Object.keys(t);n=e,r=t[n]}return e.push({origin:r,customDest:n.includes(i),dest:n}),e},[]).some(e=>{let t=!1,n=o({target:s,path:e.origin,pathDelimiter:i,failWithError:a});if(n!==void 0)if(e.customDest){let r=c({target:l,path:e.dest,value:n,pathDelimiter:i,failWithError:a});r===void 0?(t=!0,u=!0):l=r}else l[e.dest]=n;return t}),!u)return l},u=e=>{let{target:r,shouldFlatten:i,pathDelimiter:a=`.`,prefix:o=``}=e,s=r,c={},l=o?`${o}${a}`:``;return Object.keys(s).forEach(e=>{let r=`${l}${e}`,o=s[e],d=typeof o==`object`&&!!o;d&&(!i||i(e,o))?c=t(c,u({target:o,pathDelimiter:a,prefix:r,shouldFlatten:i})):c[r]=d?n(o):o}),c},d=e=>r({...e,search:/([a-z])([A-Z])/g,replace:(e,t,n)=>`${t}-${n.toLowerCase()}`}),f=e=>r({...e,search:/([a-z])([A-Z])/g,replace:(e,t,n)=>`${t}_${n.toLowerCase()}`});function p(e,t){let r;r=typeof t==`string`?{target:e,path:t}:e;let{target:i,path:a,pathDelimiter:s=`.`,cleanEmptyProperties:c=!0,failWithError:l=!1}=r,u=a.split(s),d=u.pop(),f=n(i);if(!u.length)return delete f[d],f;let m=u.join(s),h=o({target:f,path:m,pathDelimiter:s,failWithError:l});if(h!==void 0)return delete h[d],c&&!Object.keys(h).length?p({target:f,path:m,pathDelimiter:s,failWithError:l,cleanEmptyProperties:c}):f}const m=e=>r({...e,search:/([a-z])_([a-z])/g,replace:(e,t,n)=>`${t}-${n}`}),h=e=>r({...e,search:/([a-z])_([a-z])/g,replace:(e,t,n)=>`${t}${n.toUpperCase()}`}),g=e=>{let{target:t,pathDelimiter:n=`.`}=e,r=t;return Object.keys(r).reduce((e,t)=>c({target:e,path:t,value:r[t],pathDelimiter:n}),{})};export{n as copy,i as dashToLowerCamelKeys,a as dashToSnakeKeys,l as extract,u as flat,r as formatKeys,o as get,d as lowerCamelToDashKeys,f as lowerCamelToSnakeKeys,t as merge,p as remove,c as set,m as snakeToDashKeys,h as snakeToLowerCamelKeys,g as unflat};
+import e from"extend";const t=(...t)=>{let[n]=t;return e(!0,Array.isArray(n)?[]:{},...t)},n=e=>t(e),r=e=>{let{target:t,search:n,replace:i,include:a=[],exclude:o=[],pathDelimiter:s=`.`}=e,c=t,l=Object.keys(t),u={};l.forEach(e=>{let t=c[e];u[e]=!!(t&&typeof t==`object`&&t&&!Array.isArray(t)&&Object.keys(t))});let d=s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g,`\\$&`),f=RegExp(`^${d}`,`i`),p=RegExp(`${d}$`,`i`),m={},h;h=a.length?a.map(e=>{let t=e.replace(f,``).replace(p,``),n;if(t.includes(s)){let e=t.split(s),r=e.shift();n=``,m[r]||(m[r]=[]),m[r].push(e.join(s))}else n=t;return n}).filter(e=>e):l;let g={};if(o.length){let e=[];o.forEach(t=>{let n=t.replace(f,``).replace(p,``);if(n.includes(s)){let e=n.split(s),t=e.shift();g[t]||(g[t]=[]),g[t].push(e.join(s))}else u[n]=!1,e.push(n)}),h=h.filter(t=>t&&!e.includes(t))}return l.reduce((e,t)=>{let a,o,l=c[t];return a=h.includes(t)?t.replace(n,i):t,o=u[t]?r({target:l,search:n,replace:i,include:m[t]||[],exclude:g[t]||[],pathDelimiter:s}):l,{...e,[a]:o}},{})},i=e=>r({...e,search:/([a-z])-([a-z])/g,replace:(e,t,n)=>`${t}${n.toUpperCase()}`}),a=e=>r({...e,search:/([a-z])-([a-z])/g,replace:(e,t,n)=>`${t}_${n}`});function o(e,t){let n;n=typeof t==`string`?{target:e,path:t}:e;let{target:r,path:i,pathDelimiter:a=`.`,failWithError:o=!1}=n,s=r,c=i.split(a),l=c.shift(),u=s[l];if(u===void 0){if(o)throw Error(`There's nothing on '${i}'`);return}if(!c.length)return u;let d=l;return c.some(e=>{let t=!1;if(d+=`${a}${e}`,u=u[e],u===void 0){if(o)throw Error(`There's nothing on '${d}'`);t=!0}return t}),u}const s=[`__proto__`,`prototype`,`constructor`];function c(e,t,r){let i;i=typeof t==`string`?{target:e,path:t,value:r}:e;let{target:a,path:o,value:c,pathDelimiter:l=`.`,failWithError:u=!1}=i,d=n(a);if(!o.includes(l))return!o||s.includes(o.toLowerCase())?void 0:(d[o]=c,d);let f=o.split(l);if(f.some(e=>!e||s.includes(e.toLowerCase())))return;let p=f.pop(),m=d,h=``,g=!1;if(f.forEach(e=>{h+=`${l}${e}`;let t=typeof m[e];if(t===`undefined`)m[e]={},m=m[e];else if(t===`object`)m=m[e];else{let e=h.substring(l.length);if(u)throw Error(`There's already an element of type '${t}' on '${e}'`);g=!0}}),!g)return m[p]=c,d}const l=e=>{let{target:t,paths:r,pathDelimiter:i=`.`,failWithError:a=!1}=e,s=n(t),l={},u=!1;if((Array.isArray(r)?r:[r]).reduce((e,t)=>{let n,r;if(typeof t==`string`)n=t,r=t;else{let[e]=Object.keys(t);n=e,r=t[n]}return e.push({origin:r,customDest:n.includes(i),dest:n}),e},[]).some(e=>{let t=!1,n=o({target:s,path:e.origin,pathDelimiter:i,failWithError:a});if(n!==void 0){if(e.customDest){let r=c({target:l,path:e.dest,value:n,pathDelimiter:i,failWithError:a});r===void 0?(t=!0,u=!0):l=r}else l[e.dest]=n}return t}),!u)return l},u=e=>{let{target:r,shouldFlatten:i,pathDelimiter:a=`.`,prefix:o=``}=e,s=r,c={},l=o?`${o}${a}`:``;return Object.keys(s).forEach(e=>{let r=`${l}${e}`,o=s[e],d=typeof o==`object`&&!!o;d&&(!i||i(e,o))?c=t(c,u({target:o,pathDelimiter:a,prefix:r,shouldFlatten:i})):c[r]=d?n(o):o}),c},d=e=>r({...e,search:/([a-z])([A-Z])/g,replace:(e,t,n)=>`${t}-${n.toLowerCase()}`}),f=e=>r({...e,search:/([a-z])([A-Z])/g,replace:(e,t,n)=>`${t}_${n.toLowerCase()}`});function p(e,t){let r;r=typeof t==`string`?{target:e,path:t}:e;let{target:i,path:a,pathDelimiter:s=`.`,cleanEmptyProperties:c=!0,failWithError:l=!1}=r,u=a.split(s),d=u.pop(),f=n(i);if(!u.length)return delete f[d],f;let m=u.join(s),h=o({target:f,path:m,pathDelimiter:s,failWithError:l});if(h!==void 0)return delete h[d],c&&!Object.keys(h).length?p({target:f,path:m,pathDelimiter:s,failWithError:l,cleanEmptyProperties:c}):f}const m=e=>r({...e,search:/([a-z])_([a-z])/g,replace:(e,t,n)=>`${t}-${n}`}),h=e=>r({...e,search:/([a-z])_([a-z])/g,replace:(e,t,n)=>`${t}${n.toUpperCase()}`}),g=e=>{let{target:t,pathDelimiter:n=`.`}=e,r=t;return Object.keys(r).reduce((e,t)=>c({target:e,path:t,value:r[t],pathDelimiter:n}),{})};export{n as copy,i as dashToLowerCamelKeys,a as dashToSnakeKeys,l as extract,u as flat,r as formatKeys,o as get,d as lowerCamelToDashKeys,f as lowerCamelToSnakeKeys,t as merge,p as remove,c as set,m as snakeToDashKeys,h as snakeToLowerCamelKeys,g as unflat};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/fns/merge.ts","../src/fns/copy.ts","../src/fns/formatKeys.ts","../src/fns/dashToLowerCamelKeys.ts","../src/fns/dashToSnakeKeys.ts","../src/fns/get.ts","../src/fns/set.ts","../src/fns/extract.ts","../src/fns/flat.ts","../src/fns/lowerCamelToDashKeys.ts","../src/fns/lowerCamelToSnakeKeys.ts","../src/fns/remove.ts","../src/fns/snakeToDashKeys.ts","../src/fns/snakeToLowerCamelKeys.ts","../src/fns/unflat.ts"],"sourcesContent":["import extend from 'extend';\n\n/**\n * This method makes a deep merge of a list of objects into a new one. The method also\n * supports arrays: if the first element is an array, it will be merged into an array,\n * otherwise, it will be an object.\n *\n * @example\n *   const objA = { a: 'first' };\n *   const objB = { b: 'second' };\n *   console.log(merge(objA, objB));\n *   // Will output { a: 'first', b: 'second' }\n *\n * @example\n *   const arrA = [{ a: 'first' }];\n *   const arrB = [{ b: 'second' }];\n *   console.log(merge(objA, objB));\n *   // Will output [{ a: 'first', b: 'second' }]\n *\n * @template T The type of the merged object that will be returned.\n * @param targets The list of objects to merge.\n */\nexport const merge = <T = unknown>(...targets: unknown[]): T => {\n  const [firstTarget] = targets;\n  const base = Array.isArray(firstTarget) ? [] : {};\n  return extend(true, base, ...targets) as T;\n};\n","import { merge } from './merge.js';\n\n/**\n * Creates a deep copy of a given object.\n *\n * @template T The type of the input object, which will be the same as the one returned.\n * @param target The object to copy.\n */\nexport const copy = <T>(target: T): T => merge(target);\n","/**\n * The callback that will be used to replace a key.\n *\n * @param substring The captured string to replace.\n * @param args The list of groups captured by the expression.\n */\nexport type FormatKeysReplaceFn = (substring: string, ...args: string[]) => string;\n\nexport type FormatKeysOptions = {\n  /** The object to transform. */\n  target: unknown;\n  /** A regular expression to match the keys to transform. */\n  search: RegExp;\n  /**\n   * The callback that will be used to replace the matched substring. Think of `search`\n   * and `replace` as the parameters of `String.replace`.\n   */\n  replace: FormatKeysReplaceFn;\n  /**\n   * A list of keys or paths where the transformation will be made. If not specified, the\n   * function will use all the keys from the object.\n   */\n  include?: string[];\n  /** A list of keys or paths where the transformation won't be made. */\n  exclude?: string[];\n  /**\n   * The delimiter that will separate the path components for both `include` and\n   * `exclude`.\n   */\n  pathDelimiter?: string;\n};\n\nexport type FormatKeysExtensionOptions = Omit<FormatKeysOptions, 'search' | 'replace'>;\n\n/**\n * Formats all the keys on an object using a way similar to `.replace(regexp, ...)` but\n * that also works recursively and with _\"object paths\"_.\n *\n * @example\n *   const target = {\n *   prop_one: 'Charito!',\n *   };\n *   console.log(\n *   formatKeys({\n *   target,\n *   // Find all the keys with snake case.\n *   search: /([a-z])_([a-z])/g,\n *   // Using the same .replace style callback, replace it with lower camel case.\n *   replace: (_, firstLetter, secondLetter) => {\n *   const newSecondLetter = secondLetter.toUpperCase();\n *   return `${firstLetter}${newSecondLetter}`;\n *   },\n *   }),\n *   );\n *   // Will output { propOne: 'Charito!}.\n *\n *   @template T The type of the returned object.\n *   @param options The set of options to customize the transformation.\n */\nexport const formatKeys = <T = Record<string, unknown>>(\n  options: FormatKeysOptions,\n): T => {\n  const {\n    target,\n    search,\n    replace,\n    include = [],\n    exclude = [],\n    pathDelimiter = '.',\n  } = options;\n  // Re-case target.\n  const useTarget = target as Record<string, unknown>;\n  // First of all, get all the keys from the target.\n  const keys = Object.keys(target as Record<string, unknown>);\n  /**\n   * Then, check which keys are parent to other objects. This is saved on a dictionary not\n   * only because it makes it easier to check if the method should make a recursive call\n   * for a key, but also because when parsing the `exclude` parameter, if one of items is\n   * a key (and not an specific path), the method won't make the recursive call.\n   *\n   * @ignore\n   */\n  const hasChildrenByKey: Record<string, unknown> = {};\n  keys.forEach((key) => {\n    const value = useTarget[key];\n    hasChildrenByKey[key] = !!(\n      value &&\n      typeof value === 'object' &&\n      value !== null &&\n      !Array.isArray(value) &&\n      Object.keys(value)\n    );\n  });\n  /**\n   * Escape the path delimiter and create two regular expression: One that removes the\n   * path delimiter from the start of a path and one that removes it from the end. They\n   * are later used to normalize paths in order to avoid \"incomplete paths\" (paths that\n   * end or start with the delimiter).\n   */\n  const escapedPathDelimiter = pathDelimiter.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n  const cleanPathStartExpression = new RegExp(`^${escapedPathDelimiter}`, 'i');\n  const cleanPathEndExpression = new RegExp(`${escapedPathDelimiter}$`, 'i');\n  /**\n   * This dictionary will be used to save the `include` parameter that will be sent for\n   * specific keys on recursive calls. If `include` has a path like `myKey.mySubKey`,\n   * `myKey` is not transformed, but `mySubKey` is saved on this dictionary (`{ myKey:\n   * ['mySubKey']}`) and when the method applies the formatting to the object, if `myKey`\n   * has an object, it will make a recursive all and send `['mySubKey]` as its `include`\n   * parameter.\n   */\n  const subIncludeByKey: Record<string, string[]> = {};\n  /**\n   * This will be an array containing the final list of `keys` that should be tranformed.\n   * To be clear, these keys will be from the top level, so, they won't be paths. Thd\n   * following blocks will parse `include` and `exclude` in order to extract the real\n   * keys, prepare the `include` and `exclude` for recursive calls, and save the actual\n   * keys from the object \"at the current level of this call\" (no, it's not thinking about\n   * the children :P).\n   */\n  let keysToFormat: string[];\n  // If the `include` parameter has paths/keys...\n  if (include.length) {\n    keysToFormat = include\n      .map((includePath) => {\n        // Normalize the path/key.\n        const useIncludePath = includePath\n          .replace(cleanPathStartExpression, '')\n          .replace(cleanPathEndExpression, '');\n        // Define the variable that will, eventually, have the real key.\n        let key;\n        // If the value is a path...\n        if (useIncludePath.includes(pathDelimiter)) {\n          // Split all its components.\n          const pathParts = useIncludePath.split(pathDelimiter);\n          // Get the first component, a.k.a. the real key.\n          const pathKey = pathParts.shift()!;\n          /**\n           * This is very important: Since the path was specified with sub components\n           * (like `myProp.mySubProp`), the method won't format the key, but the sub\n           * key(s) (`mySubProp`). The `key` is set to `''` so it will be later removed\n           * using `.filter`.\n           *\n           * @ignore\n           */\n          key = '';\n          /**\n           * If there's no array for the key on the \"`include` dictionary for recursive\n           * calls\", create an empty one.\n           */\n          if (!subIncludeByKey[pathKey]) {\n            subIncludeByKey[pathKey] = [];\n          }\n          // Save the rest of the path to be sent on the recursive call as `include`.\n          subIncludeByKey[pathKey]!.push(pathParts.join(pathDelimiter));\n        } else {\n          // If the value wasn't a path, assume it's a key, and set it to be returned.\n          key = useIncludePath;\n        }\n\n        return key;\n      })\n      // Remove any _empty keys_.\n      .filter((key) => key);\n  } else {\n    // There's nothing on the `include` parameter, so use all the keys.\n    keysToFormat = keys;\n  }\n  /**\n   * Similar to `subIncludeByKey`, this dictionary will be used to save the `exclude`\n   * parameter that will be sent for specific keys on recursive calls. If `exclude` has a\n   * path like `myKey.mySubKey`, `myKey` will be transformed, but `mySubKey` is saved on\n   * this dictionary (`{ myKey: ['mySubKey']}`) and when the method applies the formatting\n   * to the object, if `myKey` has an object, it will make a recursive all and send\n   * `['mySubKey]` as its `exclude` parameter.\n   */\n  const subExcludeByKey: Record<string, string[]> = {};\n  // If the `include` parameter has paths/keys...\n  if (exclude.length) {\n    /**\n     * Create a dictionary of keys that should be removed from `keysToFormat`. It's easier\n     * to have them on a list and use `.filter` than actually call `.splice` for every key\n     * that should be removed.\n     */\n    const keysToRemove: string[] = [];\n    exclude.forEach((excludePath) => {\n      // Normalize the path/key.\n      const useExcludePath = excludePath\n        .replace(cleanPathStartExpression, '')\n        .replace(cleanPathEndExpression, '');\n      // If the value is a path...\n      if (useExcludePath.includes(pathDelimiter)) {\n        // Split all its components.\n        const pathParts = useExcludePath.split(pathDelimiter);\n        // Get the first component, a.k.a. the real key.\n        const pathKey = pathParts.shift()!;\n        /**\n         * If there's no array for the key on the \"`exclude` dictionary for recursive\n         * calls\", create an empty one.\n         */\n        if (!subExcludeByKey[pathKey]) {\n          subExcludeByKey[pathKey] = [];\n        }\n        // Save the rest of the path to be sent on the recursive call as `exclude`.\n        subExcludeByKey[pathKey]!.push(pathParts.join(pathDelimiter));\n      } else {\n        /**\n         * If the value wasn't a path, assume it's a key, turn the flag on the \"children\n         * dictionary\" to `false`, to prevent recursive calls, and add the key to the list\n         * of keys that will be removed from `keysToFormat`. Basically: If it's a key,\n         * don't format it and don't make recursive calls for it.\n         *\n         * @ignore\n         */\n        hasChildrenByKey[useExcludePath] = false;\n        keysToRemove.push(useExcludePath);\n      }\n    });\n    // Remove keys that should be excluded.\n    keysToFormat = keysToFormat.filter((key) => key && !keysToRemove.includes(key));\n  }\n  // \"Finally\", reduce all the keys from the object and create the new one...\n  return keys.reduce<Record<string, unknown>>((newObj, key) => {\n    /**\n     * Define the new key and value for the object property. Depending on the validations,\n     * they may be replaced with formatted ones.\n     */\n    let newKey;\n    let newValue;\n    /**\n     * Get the current value for the key, in case it's needed for a recursive call or just\n     * to send it back because it didn't need any change.\n     */\n    const value = useTarget[key];\n    // If the key should be formatted, apply the formatting; otherwise, keep the original.\n    if (keysToFormat.includes(key)) {\n      newKey = key.replace(search, replace);\n    } else {\n      newKey = key;\n    }\n    /**\n     * If the paths/keys on `exclude` didn't modify the \"children dictionary\" for the key\n     * and the value is another object, make a recursive call; otherwise, just use the\n     * original value.\n     */\n    if (hasChildrenByKey[key]) {\n      newValue = formatKeys({\n        target: value,\n        search,\n        replace,\n        include: subIncludeByKey[key] || [],\n        exclude: subExcludeByKey[key] || [],\n        pathDelimiter,\n      });\n    } else {\n      newValue = value;\n    }\n    // \"Done\", return the new object with the \"new key\" and the \"new value\".\n    return { ...newObj, [newKey]: newValue };\n  }, {}) as T;\n};\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case` to\n * `lowerCamelCase`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const dashToLowerCamelKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])-([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toUpperCase();\n      return `${firstLetter}${newSecondLetter}`;\n    },\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case` to\n * `snake_case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const dashToSnakeKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])-([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => `${firstLetter}_${secondLetter}`,\n  });\n","export type GetOptions = {\n  /** The object from where the property will be read. */\n  target: unknown;\n  /** The path to the property. */\n  path: string;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * method will silently fail and return `undefined`.\n   */\n  failWithError?: boolean;\n};\n\n/**\n * Returns the value of an object property using a path.\n *\n * @example\n *   const obj = {\n *     propOne: {\n *       propOneSub: 'Charito!',\n *     },\n *     propTwo: '!!!',\n *   };\n *   console.log(get({ target: obj, path: 'propOne.propOneSub' }));\n *   // Will output 'Charito!'\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n * @throws {Error} If the path is invalid and `failWithError` is set to `true`.\n */\nfunction get<T>(options: GetOptions): T | undefined;\nfunction get<T>(options: unknown, path: string): T | undefined;\nfunction get<T>(options: GetOptions | unknown, path?: string): T | undefined {\n  let useOptions: GetOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n    };\n  } else {\n    useOptions = options as GetOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    pathDelimiter = '.',\n    failWithError = false,\n  } = useOptions;\n  const useTarget = target as Record<string, unknown>;\n  const parts = usePath.split(pathDelimiter);\n  const first = parts.shift()!;\n  let currentElement = useTarget[first] as Record<string, unknown>;\n  if (typeof currentElement === 'undefined') {\n    if (failWithError) {\n      throw new Error(`There's nothing on '${usePath}'`);\n    }\n\n    return undefined;\n  }\n\n  if (!parts.length) {\n    return currentElement as T;\n  }\n\n  let currentPath = first;\n  parts.some((currentPart) => {\n    let breakLoop = false;\n    currentPath += `${pathDelimiter}${currentPart}`;\n    currentElement = currentElement[currentPart] as Record<string, unknown>;\n    if (typeof currentElement === 'undefined') {\n      if (failWithError) {\n        throw new Error(`There's nothing on '${currentPath}'`);\n      } else {\n        breakLoop = true;\n      }\n    }\n\n    return breakLoop;\n  });\n\n  return currentElement as T;\n}\n\nexport { get };\n","import { copy } from './copy.js';\n\n/**\n * List of paths that are forbidden to use on the `set` function, as they could lead to\n * security issues.\n *\n * @access protected\n */\nconst FORBIDDEN_PATHS = ['__proto__', 'prototype', 'constructor'];\n\nexport type SetOptions = {\n  /** The object where the property will be set. */\n  target: unknown;\n  /** The path for the property. */\n  path: string;\n  /** The value to set on the property. */\n  value: unknown;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * method will silently fail and return `undefined`.\n   */\n  failWithError?: boolean;\n};\n/**\n * Sets a property on an object using a path. If the path doesn't exist, it will be\n * created.\n *\n * @example\n *   const target = {};\n *   console.log(set({ target, path: 'some.prop.path', value: 'some-value' }));\n *   // Will output { some: { prop: { path: 'some-value' } } }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n * @throws {Error} If one of the path components is for a non-object property and\n *   `failWithError` is set to `true`.\n */\nfunction set<T = Record<string, unknown>>(options: SetOptions): T | undefined;\nfunction set<T = Record<string, unknown>>(\n  options: SetOptions | unknown,\n  path: string,\n  value: unknown,\n): T | undefined;\nfunction set<T = Record<string, unknown>>(\n  options: SetOptions | unknown,\n  path?: string,\n  value?: unknown,\n): T | undefined {\n  let useOptions: SetOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n      value,\n    };\n  } else {\n    useOptions = options as SetOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    value: useValue,\n    pathDelimiter = '.',\n    failWithError = false,\n  } = useOptions;\n  const result = copy(target) as Record<string, unknown>;\n  if (!usePath.includes(pathDelimiter)) {\n    if (!usePath || FORBIDDEN_PATHS.includes(usePath.toLowerCase())) {\n      return undefined;\n    }\n\n    result[usePath] = useValue;\n    return result as T;\n  }\n\n  const parts = usePath.split(pathDelimiter);\n  const isInvalid = parts.some(\n    (part) => !part || FORBIDDEN_PATHS.includes(part.toLowerCase()),\n  );\n\n  if (isInvalid) {\n    return undefined;\n  }\n\n  // Path validation ensures that every component is defined and non-empty.\n  const last = parts.pop()!;\n  let currentElement = result;\n  let currentPath = '';\n  let foundInvalid = false;\n  parts.forEach((part) => {\n    currentPath += `${pathDelimiter}${part}`;\n    const element = currentElement[part];\n    const elementType = typeof element;\n    if (elementType === 'undefined') {\n      currentElement[part] = {};\n      currentElement = currentElement[part] as Record<string, unknown>;\n    } else if (elementType === 'object') {\n      currentElement = currentElement[part] as Record<string, unknown>;\n    } else {\n      const errorPath = currentPath.substring(pathDelimiter.length);\n      if (failWithError) {\n        throw new Error(\n          `There's already an element of type '${elementType}' on '${errorPath}'`,\n        );\n      } else {\n        foundInvalid = true;\n      }\n    }\n  });\n\n  if (foundInvalid) return undefined;\n\n  currentElement[last] = useValue;\n\n  return result as T | undefined;\n}\n\nexport { set };\n","import { copy } from './copy.js';\nimport { get } from './get.js';\nimport { set } from './set.js';\n/**\n * Used in the {@link extract} function to specify a path for a property, or an \"origin\n * path\" and an \"extraction path\".\n */\nexport type extractionPath = string | Record<string, string>;\n\nexport type ExtractOptions = {\n  /** The object from where the property/properties will be extracted. */\n  target: unknown;\n  /**\n   * This can be a single path or a list of them. And for this method, the paths are not\n   * only strings but can also be an object with a single key, that would be the path to\n   * where to \"do the extraction\", and the value the path on the target object.\n   */\n  paths: extractionPath | extractionPath[];\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * method will silently fail an empty object.\n   */\n  failWithError?: boolean;\n};\n/**\n * Extracts a property or properties from an object in order to create a new one.\n *\n * @example\n *   const target = {\n *     name: {\n *       first: 'Pilar',\n *     },\n *     age: 3,\n *     address: {\n *       planet: 'earth',\n *       something: 'else',\n *     },\n *   };\n *   console.log(\n *     extract({\n *       target: obj,\n *       paths: [{ name: 'name.first' }, 'age', 'address.planet'],\n *     }),\n *   );\n *   // Will output { name: 'Pilar', age: 3, address: { planet: 'earth' } }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const extract = <T = Record<string, unknown>>(\n  options: ExtractOptions,\n): T | undefined => {\n  const { target, paths, pathDelimiter = '.', failWithError = false } = options;\n  const copied = copy(target) as Record<string, unknown>;\n  let result: Record<string, unknown> = {};\n  let failed = false;\n  (Array.isArray(paths) ? paths : [paths])\n    .reduce<Array<{ origin: string; customDest: boolean; dest: string }>>(\n      (acc, objPath) => {\n        let destPath: string;\n        let originPath: string;\n        if (typeof objPath === 'string') {\n          destPath = objPath;\n          originPath = objPath;\n        } else {\n          const [firstKey] = Object.keys(objPath);\n          destPath = firstKey!;\n          originPath = objPath[destPath]!;\n        }\n\n        acc.push({\n          origin: originPath,\n          customDest: destPath.includes(pathDelimiter),\n          dest: destPath,\n        });\n        return acc;\n      },\n      [],\n    )\n    .some((pathInfo) => {\n      let breakLoop = false;\n      const value = get({\n        target: copied,\n        path: pathInfo.origin,\n        pathDelimiter,\n        failWithError,\n      });\n      if (typeof value !== 'undefined') {\n        if (pathInfo.customDest) {\n          const withCustomProp = set({\n            target: result,\n            path: pathInfo.dest,\n            value,\n            pathDelimiter,\n            failWithError,\n          });\n          if (typeof withCustomProp === 'undefined') {\n            breakLoop = true;\n            failed = true;\n          } else {\n            result = withCustomProp;\n          }\n        } else {\n          result[pathInfo.dest] = value;\n        }\n      }\n\n      return breakLoop;\n    });\n\n  if (failed) return undefined;\n  return result as T;\n};\n","import { copy } from './copy.js';\nimport { merge } from './merge.js';\n\n/**\n * Checks whether a key for an array or an Object should be flattened.\n *\n * @param key The key to check inside its parent.\n * @param value The value of the key.\n */\nexport type ShouldFlattenFn = (key: string, value: unknown) => boolean;\n\nexport type FlatOptions = {\n  /** The object to transform. */\n  target: unknown;\n  /**\n   * A custom prefix to be added before the name of the properties. This can be used on\n   * custom cases and it's also used when the method calls itself in order to flatten a\n   * sub object.\n   */\n  prefix?: string;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * A custom function that can be used in order to tell the function whether an Object or\n   * an Array property should be flatten or not.\n   */\n  shouldFlatten?: ShouldFlattenFn;\n};\n/**\n * Flattens an object properties into a single level dictionary.\n *\n * @example\n *   const target = {\n *   propOne: {\n *   propOneSub: 'Charito!',\n *   },\n *   propTwo: '!!!',\n *   };\n *   console.log(flat({ target });\n *   // Will output { 'propOne.propOneSub': 'Charito!', propTwo: '!!!' }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const flat = <T = Record<string, unknown>>(options: FlatOptions): T => {\n  const { target, shouldFlatten, pathDelimiter = '.', prefix = '' } = options;\n  const useTarget = target as Record<string, unknown>;\n  let result: Record<string, unknown> = {};\n  const namePrefix = prefix ? `${prefix}${pathDelimiter}` : '';\n  Object.keys(useTarget).forEach((key) => {\n    const name = `${namePrefix}${key}`;\n    const value = useTarget[key] as unknown;\n    const valueType = typeof value;\n    const isObject = valueType === 'object' && value !== null;\n    if (isObject && (!shouldFlatten || shouldFlatten(key, value))) {\n      result = merge(\n        result,\n        flat({ target: value, pathDelimiter, prefix: name, shouldFlatten }),\n      );\n    } else {\n      result[name] = isObject ? copy(value) : value;\n    }\n  });\n\n  return result as T;\n};\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `lowerCamelCase`\n * to `dash-case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const lowerCamelToDashKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])([A-Z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toLowerCase();\n      return `${firstLetter}-${newSecondLetter}`;\n    },\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from\n * `lowerCamelCase` to `snake_case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const lowerCamelToSnakeKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])([A-Z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toLowerCase();\n      return `${firstLetter}_${newSecondLetter}`;\n    },\n  });\n","import { copy } from './copy.js';\nimport { get } from './get.js';\n\nexport type RemoveOptions = {\n  /** The object from where the property will be removed. */\n  target: unknown;\n  /** The path to the property. */\n  path: string;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * function will silently fail.\n   */\n  failWithError?: boolean;\n  /**\n   * If this flag is `true` and after removing the property the parent object is empty, it\n   * will remove it recursively until a non empty parent object is found.\n   */\n  cleanEmptyProperties?: boolean;\n};\n/**\n * Deletes a property of an object using a path.\n *\n * @example\n *   const target = {\n *     propOne: {\n *       propOneSub: 'Charito!',\n *     },\n *     propTwo: '!!!',\n *   };\n *   console.log(remove({ target, path: 'propOne.propOneSub' }));\n *   // Will output { propTwo: '!!!' }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nfunction remove<T = unknown>(options: RemoveOptions): T | undefined;\nfunction remove<T = unknown>(options: unknown, path: string): T | undefined;\nfunction remove<T = unknown>(\n  options: RemoveOptions | unknown,\n  path?: string,\n): T | undefined {\n  let useOptions: RemoveOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n    };\n  } else {\n    useOptions = options as RemoveOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    pathDelimiter = '.',\n    cleanEmptyProperties = true,\n    failWithError = false,\n  } = useOptions;\n\n  const parts = usePath.split(pathDelimiter);\n  const last = parts.pop()!;\n  const result = copy(target) as Record<string, unknown>;\n  if (!parts.length) {\n    delete result[last];\n    return result as T;\n  }\n  const parentPath = parts.join(pathDelimiter);\n  const parentObj = get<Record<string, unknown>>({\n    target: result,\n    path: parentPath,\n    pathDelimiter,\n    failWithError,\n  });\n\n  if (typeof parentObj === 'undefined') {\n    return undefined;\n  }\n\n  delete parentObj[last];\n  if (cleanEmptyProperties && !Object.keys(parentObj).length) {\n    return remove({\n      target: result,\n      path: parentPath,\n      pathDelimiter,\n      failWithError,\n      cleanEmptyProperties,\n    }) as T;\n  }\n\n  return result as T;\n}\n\nexport { remove };\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to\n * `dash-case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const snakeToDashKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])_([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => `${firstLetter}-${secondLetter}`,\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to\n * `lowerCamelCase`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const snakeToLowerCamelKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])_([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toUpperCase();\n      return `${firstLetter}${newSecondLetter}`;\n    },\n  });\n","import { set } from './set.js';\n\nexport type UnflatOptions = {\n  /** The object to transform. */\n  target: unknown;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n};\n/**\n * This method does the exact opposite from `flat`: It takes an already flatten object and\n * restores it structure.\n *\n * @example\n *   const target = {\n *     'propOne.propOneSub': 'Charito!',\n *     propTwo: '!!!',\n *   };\n *   console.log(unflat({ target }));\n *   // Will output { propOne: { propOneSub: 'Charito!' }, 'propTwo': '!!!' }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const unflat = <T = Record<string, unknown>>(options: UnflatOptions): T => {\n  const { target, pathDelimiter = '.' } = options;\n  const useTarget = target as Record<string, unknown>;\n  return Object.keys(useTarget).reduce<Record<string, unknown>>(\n    (current, key) =>\n      set({ target: current, path: key, value: useTarget[key], pathDelimiter })!,\n    {},\n  ) as T;\n};\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["extend","merge","targets","firstTarget","copy","target","formatKeys","options","useTarget","keys","hasChildrenByKey","value","key","escapedPathDelimiter","pathDelimiter","cleanPathStartExpression","cleanPathEndExpression","subIncludeByKey","keysToFormat","include","useIncludePath","includePath","pathParts","pathKey","subExcludeByKey","exclude","keysToRemove","useExcludePath","excludePath","newKey","newValue","search","replace","newObj","dashToLowerCamelKeys","firstLetter","secondLetter","dashToSnakeKeys","get","useOptions","path","usePath","parts","first","currentElement","failWithError","currentPath","breakLoop","currentPart","FORBIDDEN_PATHS","set","useValue","result","part","last","foundInvalid","elementType","errorPath","extract","copied","failed","paths","destPath","originPath","objPath","firstKey","acc","pathInfo","withCustomProp","flat","namePrefix","prefix","name","isObject","shouldFlatten","lowerCamelToDashKeys","lowerCamelToSnakeKeys","remove","parentPath","parentObj","cleanEmptyProperties","snakeToDashKeys","snakeToLowerCamelKeys","unflat","current"],"sources":["../src/fns/merge.ts","../src/fns/copy.ts","../src/fns/formatKeys.ts","../src/fns/dashToLowerCamelKeys.ts","../src/fns/dashToSnakeKeys.ts","../src/fns/get.ts","../src/fns/set.ts","../src/fns/extract.ts","../src/fns/flat.ts","../src/fns/lowerCamelToDashKeys.ts","../src/fns/lowerCamelToSnakeKeys.ts","../src/fns/remove.ts","../src/fns/snakeToDashKeys.ts","../src/fns/snakeToLowerCamelKeys.ts","../src/fns/unflat.ts"],"sourcesContent":["import extend from 'extend';\n\n/**\n * This method makes a deep merge of a list of objects into a new one. The method also\n * supports arrays: if the first element is an array, it will be merged into an array,\n * otherwise, it will be an object.\n *\n * @example\n *   const objA = { a: 'first' };\n *   const objB = { b: 'second' };\n *   console.log(merge(objA, objB));\n *   // Will output { a: 'first', b: 'second' }\n *\n * @example\n *   const arrA = [{ a: 'first' }];\n *   const arrB = [{ b: 'second' }];\n *   console.log(merge(objA, objB));\n *   // Will output [{ a: 'first', b: 'second' }]\n *\n * @template T The type of the merged object that will be returned.\n * @param targets The list of objects to merge.\n */\nexport const merge = <T = unknown>(...targets: unknown[]): T => {\n  const [firstTarget] = targets;\n  const base = Array.isArray(firstTarget) ? [] : {};\n  return extend(true, base, ...targets) as T;\n};\n","import { merge } from './merge.js';\n\n/**\n * Creates a deep copy of a given object.\n *\n * @template T The type of the input object, which will be the same as the one returned.\n * @param target The object to copy.\n */\nexport const copy = <T>(target: T): T => merge(target);\n","/**\n * The callback that will be used to replace a key.\n *\n * @param substring The captured string to replace.\n * @param args The list of groups captured by the expression.\n */\nexport type FormatKeysReplaceFn = (substring: string, ...args: string[]) => string;\n\nexport type FormatKeysOptions = {\n  /** The object to transform. */\n  target: unknown;\n  /** A regular expression to match the keys to transform. */\n  search: RegExp;\n  /**\n   * The callback that will be used to replace the matched substring. Think of `search`\n   * and `replace` as the parameters of `String.replace`.\n   */\n  replace: FormatKeysReplaceFn;\n  /**\n   * A list of keys or paths where the transformation will be made. If not specified, the\n   * function will use all the keys from the object.\n   */\n  include?: string[];\n  /** A list of keys or paths where the transformation won't be made. */\n  exclude?: string[];\n  /**\n   * The delimiter that will separate the path components for both `include` and\n   * `exclude`.\n   */\n  pathDelimiter?: string;\n};\n\nexport type FormatKeysExtensionOptions = Omit<FormatKeysOptions, 'search' | 'replace'>;\n\n/**\n * Formats all the keys on an object using a way similar to `.replace(regexp, ...)` but\n * that also works recursively and with _\"object paths\"_.\n *\n * @example\n *   const target = {\n *   prop_one: 'Charito!',\n *   };\n *   console.log(\n *   formatKeys({\n *   target,\n *   // Find all the keys with snake case.\n *   search: /([a-z])_([a-z])/g,\n *   // Using the same .replace style callback, replace it with lower camel case.\n *   replace: (_, firstLetter, secondLetter) => {\n *   const newSecondLetter = secondLetter.toUpperCase();\n *   return `${firstLetter}${newSecondLetter}`;\n *   },\n *   }),\n *   );\n *   // Will output { propOne: 'Charito!}.\n *\n *   @template T The type of the returned object.\n *   @param options The set of options to customize the transformation.\n */\nexport const formatKeys = <T = Record<string, unknown>>(\n  options: FormatKeysOptions,\n): T => {\n  const {\n    target,\n    search,\n    replace,\n    include = [],\n    exclude = [],\n    pathDelimiter = '.',\n  } = options;\n  // Re-case target.\n  const useTarget = target as Record<string, unknown>;\n  // First of all, get all the keys from the target.\n  const keys = Object.keys(target as Record<string, unknown>);\n  /**\n   * Then, check which keys are parent to other objects. This is saved on a dictionary not\n   * only because it makes it easier to check if the method should make a recursive call\n   * for a key, but also because when parsing the `exclude` parameter, if one of items is\n   * a key (and not an specific path), the method won't make the recursive call.\n   *\n   * @ignore\n   */\n  const hasChildrenByKey: Record<string, unknown> = {};\n  keys.forEach((key) => {\n    const value = useTarget[key];\n    hasChildrenByKey[key] = !!(\n      value &&\n      typeof value === 'object' &&\n      value !== null &&\n      !Array.isArray(value) &&\n      Object.keys(value)\n    );\n  });\n  /**\n   * Escape the path delimiter and create two regular expression: One that removes the\n   * path delimiter from the start of a path and one that removes it from the end. They\n   * are later used to normalize paths in order to avoid \"incomplete paths\" (paths that\n   * end or start with the delimiter).\n   */\n  const escapedPathDelimiter = pathDelimiter.replace(/[-[\\]{}()*+?.,\\\\^$|#\\s]/g, '\\\\$&');\n  const cleanPathStartExpression = new RegExp(`^${escapedPathDelimiter}`, 'i');\n  const cleanPathEndExpression = new RegExp(`${escapedPathDelimiter}$`, 'i');\n  /**\n   * This dictionary will be used to save the `include` parameter that will be sent for\n   * specific keys on recursive calls. If `include` has a path like `myKey.mySubKey`,\n   * `myKey` is not transformed, but `mySubKey` is saved on this dictionary (`{ myKey:\n   * ['mySubKey']}`) and when the method applies the formatting to the object, if `myKey`\n   * has an object, it will make a recursive all and send `['mySubKey]` as its `include`\n   * parameter.\n   */\n  const subIncludeByKey: Record<string, string[]> = {};\n  /**\n   * This will be an array containing the final list of `keys` that should be tranformed.\n   * To be clear, these keys will be from the top level, so, they won't be paths. Thd\n   * following blocks will parse `include` and `exclude` in order to extract the real\n   * keys, prepare the `include` and `exclude` for recursive calls, and save the actual\n   * keys from the object \"at the current level of this call\" (no, it's not thinking about\n   * the children :P).\n   */\n  let keysToFormat: string[];\n  // If the `include` parameter has paths/keys...\n  if (include.length) {\n    keysToFormat = include\n      .map((includePath) => {\n        // Normalize the path/key.\n        const useIncludePath = includePath\n          .replace(cleanPathStartExpression, '')\n          .replace(cleanPathEndExpression, '');\n        // Define the variable that will, eventually, have the real key.\n        let key;\n        // If the value is a path...\n        if (useIncludePath.includes(pathDelimiter)) {\n          // Split all its components.\n          const pathParts = useIncludePath.split(pathDelimiter);\n          // Get the first component, a.k.a. the real key.\n          const pathKey = pathParts.shift()!;\n          /**\n           * This is very important: Since the path was specified with sub components\n           * (like `myProp.mySubProp`), the method won't format the key, but the sub\n           * key(s) (`mySubProp`). The `key` is set to `''` so it will be later removed\n           * using `.filter`.\n           *\n           * @ignore\n           */\n          key = '';\n          /**\n           * If there's no array for the key on the \"`include` dictionary for recursive\n           * calls\", create an empty one.\n           */\n          if (!subIncludeByKey[pathKey]) {\n            subIncludeByKey[pathKey] = [];\n          }\n          // Save the rest of the path to be sent on the recursive call as `include`.\n          subIncludeByKey[pathKey]!.push(pathParts.join(pathDelimiter));\n        } else {\n          // If the value wasn't a path, assume it's a key, and set it to be returned.\n          key = useIncludePath;\n        }\n\n        return key;\n      })\n      // Remove any _empty keys_.\n      .filter((key) => key);\n  } else {\n    // There's nothing on the `include` parameter, so use all the keys.\n    keysToFormat = keys;\n  }\n  /**\n   * Similar to `subIncludeByKey`, this dictionary will be used to save the `exclude`\n   * parameter that will be sent for specific keys on recursive calls. If `exclude` has a\n   * path like `myKey.mySubKey`, `myKey` will be transformed, but `mySubKey` is saved on\n   * this dictionary (`{ myKey: ['mySubKey']}`) and when the method applies the formatting\n   * to the object, if `myKey` has an object, it will make a recursive all and send\n   * `['mySubKey]` as its `exclude` parameter.\n   */\n  const subExcludeByKey: Record<string, string[]> = {};\n  // If the `include` parameter has paths/keys...\n  if (exclude.length) {\n    /**\n     * Create a dictionary of keys that should be removed from `keysToFormat`. It's easier\n     * to have them on a list and use `.filter` than actually call `.splice` for every key\n     * that should be removed.\n     */\n    const keysToRemove: string[] = [];\n    exclude.forEach((excludePath) => {\n      // Normalize the path/key.\n      const useExcludePath = excludePath\n        .replace(cleanPathStartExpression, '')\n        .replace(cleanPathEndExpression, '');\n      // If the value is a path...\n      if (useExcludePath.includes(pathDelimiter)) {\n        // Split all its components.\n        const pathParts = useExcludePath.split(pathDelimiter);\n        // Get the first component, a.k.a. the real key.\n        const pathKey = pathParts.shift()!;\n        /**\n         * If there's no array for the key on the \"`exclude` dictionary for recursive\n         * calls\", create an empty one.\n         */\n        if (!subExcludeByKey[pathKey]) {\n          subExcludeByKey[pathKey] = [];\n        }\n        // Save the rest of the path to be sent on the recursive call as `exclude`.\n        subExcludeByKey[pathKey]!.push(pathParts.join(pathDelimiter));\n      } else {\n        /**\n         * If the value wasn't a path, assume it's a key, turn the flag on the \"children\n         * dictionary\" to `false`, to prevent recursive calls, and add the key to the list\n         * of keys that will be removed from `keysToFormat`. Basically: If it's a key,\n         * don't format it and don't make recursive calls for it.\n         *\n         * @ignore\n         */\n        hasChildrenByKey[useExcludePath] = false;\n        keysToRemove.push(useExcludePath);\n      }\n    });\n    // Remove keys that should be excluded.\n    keysToFormat = keysToFormat.filter((key) => key && !keysToRemove.includes(key));\n  }\n  // \"Finally\", reduce all the keys from the object and create the new one...\n  return keys.reduce<Record<string, unknown>>((newObj, key) => {\n    /**\n     * Define the new key and value for the object property. Depending on the validations,\n     * they may be replaced with formatted ones.\n     */\n    let newKey;\n    let newValue;\n    /**\n     * Get the current value for the key, in case it's needed for a recursive call or just\n     * to send it back because it didn't need any change.\n     */\n    const value = useTarget[key];\n    // If the key should be formatted, apply the formatting; otherwise, keep the original.\n    if (keysToFormat.includes(key)) {\n      newKey = key.replace(search, replace);\n    } else {\n      newKey = key;\n    }\n    /**\n     * If the paths/keys on `exclude` didn't modify the \"children dictionary\" for the key\n     * and the value is another object, make a recursive call; otherwise, just use the\n     * original value.\n     */\n    if (hasChildrenByKey[key]) {\n      newValue = formatKeys({\n        target: value,\n        search,\n        replace,\n        include: subIncludeByKey[key] || [],\n        exclude: subExcludeByKey[key] || [],\n        pathDelimiter,\n      });\n    } else {\n      newValue = value;\n    }\n    // \"Done\", return the new object with the \"new key\" and the \"new value\".\n    return { ...newObj, [newKey]: newValue };\n  }, {}) as T;\n};\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case` to\n * `lowerCamelCase`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const dashToLowerCamelKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])-([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toUpperCase();\n      return `${firstLetter}${newSecondLetter}`;\n    },\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case` to\n * `snake_case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const dashToSnakeKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])-([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => `${firstLetter}_${secondLetter}`,\n  });\n","export type GetOptions = {\n  /** The object from where the property will be read. */\n  target: unknown;\n  /** The path to the property. */\n  path: string;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * method will silently fail and return `undefined`.\n   */\n  failWithError?: boolean;\n};\n\n/**\n * Returns the value of an object property using a path.\n *\n * @example\n *   const obj = {\n *     propOne: {\n *       propOneSub: 'Charito!',\n *     },\n *     propTwo: '!!!',\n *   };\n *   console.log(get({ target: obj, path: 'propOne.propOneSub' }));\n *   // Will output 'Charito!'\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n * @throws {Error} If the path is invalid and `failWithError` is set to `true`.\n */\nfunction get<T>(options: GetOptions): T | undefined;\nfunction get<T>(options: unknown, path: string): T | undefined;\nfunction get<T>(options: GetOptions | unknown, path?: string): T | undefined {\n  let useOptions: GetOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n    };\n  } else {\n    useOptions = options as GetOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    pathDelimiter = '.',\n    failWithError = false,\n  } = useOptions;\n  const useTarget = target as Record<string, unknown>;\n  const parts = usePath.split(pathDelimiter);\n  const first = parts.shift()!;\n  let currentElement = useTarget[first] as Record<string, unknown>;\n  if (typeof currentElement === 'undefined') {\n    if (failWithError) {\n      throw new Error(`There's nothing on '${usePath}'`);\n    }\n\n    return undefined;\n  }\n\n  if (!parts.length) {\n    return currentElement as T;\n  }\n\n  let currentPath = first;\n  parts.some((currentPart) => {\n    let breakLoop = false;\n    currentPath += `${pathDelimiter}${currentPart}`;\n    currentElement = currentElement[currentPart] as Record<string, unknown>;\n    if (typeof currentElement === 'undefined') {\n      if (failWithError) {\n        throw new Error(`There's nothing on '${currentPath}'`);\n      } else {\n        breakLoop = true;\n      }\n    }\n\n    return breakLoop;\n  });\n\n  return currentElement as T;\n}\n\nexport { get };\n","import { copy } from './copy.js';\n\n/**\n * List of paths that are forbidden to use on the `set` function, as they could lead to\n * security issues.\n *\n * @access protected\n */\nconst FORBIDDEN_PATHS = ['__proto__', 'prototype', 'constructor'];\n\nexport type SetOptions = {\n  /** The object where the property will be set. */\n  target: unknown;\n  /** The path for the property. */\n  path: string;\n  /** The value to set on the property. */\n  value: unknown;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * method will silently fail and return `undefined`.\n   */\n  failWithError?: boolean;\n};\n/**\n * Sets a property on an object using a path. If the path doesn't exist, it will be\n * created.\n *\n * @example\n *   const target = {};\n *   console.log(set({ target, path: 'some.prop.path', value: 'some-value' }));\n *   // Will output { some: { prop: { path: 'some-value' } } }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n * @throws {Error} If one of the path components is for a non-object property and\n *   `failWithError` is set to `true`.\n */\nfunction set<T = Record<string, unknown>>(options: SetOptions): T | undefined;\nfunction set<T = Record<string, unknown>>(\n  options: SetOptions | unknown,\n  path: string,\n  value: unknown,\n): T | undefined;\nfunction set<T = Record<string, unknown>>(\n  options: SetOptions | unknown,\n  path?: string,\n  value?: unknown,\n): T | undefined {\n  let useOptions: SetOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n      value,\n    };\n  } else {\n    useOptions = options as SetOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    value: useValue,\n    pathDelimiter = '.',\n    failWithError = false,\n  } = useOptions;\n  const result = copy(target) as Record<string, unknown>;\n  if (!usePath.includes(pathDelimiter)) {\n    if (!usePath || FORBIDDEN_PATHS.includes(usePath.toLowerCase())) {\n      return undefined;\n    }\n\n    result[usePath] = useValue;\n    return result as T;\n  }\n\n  const parts = usePath.split(pathDelimiter);\n  const isInvalid = parts.some(\n    (part) => !part || FORBIDDEN_PATHS.includes(part.toLowerCase()),\n  );\n\n  if (isInvalid) {\n    return undefined;\n  }\n\n  // Path validation ensures that every component is defined and non-empty.\n  const last = parts.pop()!;\n  let currentElement = result;\n  let currentPath = '';\n  let foundInvalid = false;\n  parts.forEach((part) => {\n    currentPath += `${pathDelimiter}${part}`;\n    const element = currentElement[part];\n    const elementType = typeof element;\n    if (elementType === 'undefined') {\n      currentElement[part] = {};\n      currentElement = currentElement[part] as Record<string, unknown>;\n    } else if (elementType === 'object') {\n      currentElement = currentElement[part] as Record<string, unknown>;\n    } else {\n      const errorPath = currentPath.substring(pathDelimiter.length);\n      if (failWithError) {\n        throw new Error(\n          `There's already an element of type '${elementType}' on '${errorPath}'`,\n        );\n      } else {\n        foundInvalid = true;\n      }\n    }\n  });\n\n  if (foundInvalid) return undefined;\n\n  currentElement[last] = useValue;\n\n  return result as T | undefined;\n}\n\nexport { set };\n","import { copy } from './copy.js';\nimport { get } from './get.js';\nimport { set } from './set.js';\n/**\n * Used in the {@link extract} function to specify a path for a property, or an \"origin\n * path\" and an \"extraction path\".\n */\nexport type extractionPath = string | Record<string, string>;\n\nexport type ExtractOptions = {\n  /** The object from where the property/properties will be extracted. */\n  target: unknown;\n  /**\n   * This can be a single path or a list of them. And for this method, the paths are not\n   * only strings but can also be an object with a single key, that would be the path to\n   * where to \"do the extraction\", and the value the path on the target object.\n   */\n  paths: extractionPath | extractionPath[];\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * method will silently fail an empty object.\n   */\n  failWithError?: boolean;\n};\n/**\n * Extracts a property or properties from an object in order to create a new one.\n *\n * @example\n *   const target = {\n *     name: {\n *       first: 'Pilar',\n *     },\n *     age: 3,\n *     address: {\n *       planet: 'earth',\n *       something: 'else',\n *     },\n *   };\n *   console.log(\n *     extract({\n *       target: obj,\n *       paths: [{ name: 'name.first' }, 'age', 'address.planet'],\n *     }),\n *   );\n *   // Will output { name: 'Pilar', age: 3, address: { planet: 'earth' } }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const extract = <T = Record<string, unknown>>(\n  options: ExtractOptions,\n): T | undefined => {\n  const { target, paths, pathDelimiter = '.', failWithError = false } = options;\n  const copied = copy(target) as Record<string, unknown>;\n  let result: Record<string, unknown> = {};\n  let failed = false;\n  (Array.isArray(paths) ? paths : [paths])\n    .reduce<Array<{ origin: string; customDest: boolean; dest: string }>>(\n      (acc, objPath) => {\n        let destPath: string;\n        let originPath: string;\n        if (typeof objPath === 'string') {\n          destPath = objPath;\n          originPath = objPath;\n        } else {\n          const [firstKey] = Object.keys(objPath);\n          destPath = firstKey!;\n          originPath = objPath[destPath]!;\n        }\n\n        acc.push({\n          origin: originPath,\n          customDest: destPath.includes(pathDelimiter),\n          dest: destPath,\n        });\n        return acc;\n      },\n      [],\n    )\n    .some((pathInfo) => {\n      let breakLoop = false;\n      const value = get({\n        target: copied,\n        path: pathInfo.origin,\n        pathDelimiter,\n        failWithError,\n      });\n      if (typeof value !== 'undefined') {\n        if (pathInfo.customDest) {\n          const withCustomProp = set({\n            target: result,\n            path: pathInfo.dest,\n            value,\n            pathDelimiter,\n            failWithError,\n          });\n          if (typeof withCustomProp === 'undefined') {\n            breakLoop = true;\n            failed = true;\n          } else {\n            result = withCustomProp;\n          }\n        } else {\n          result[pathInfo.dest] = value;\n        }\n      }\n\n      return breakLoop;\n    });\n\n  if (failed) return undefined;\n  return result as T;\n};\n","import { copy } from './copy.js';\nimport { merge } from './merge.js';\n\n/**\n * Checks whether a key for an array or an Object should be flattened.\n *\n * @param key The key to check inside its parent.\n * @param value The value of the key.\n */\nexport type ShouldFlattenFn = (key: string, value: unknown) => boolean;\n\nexport type FlatOptions = {\n  /** The object to transform. */\n  target: unknown;\n  /**\n   * A custom prefix to be added before the name of the properties. This can be used on\n   * custom cases and it's also used when the method calls itself in order to flatten a\n   * sub object.\n   */\n  prefix?: string;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * A custom function that can be used in order to tell the function whether an Object or\n   * an Array property should be flatten or not.\n   */\n  shouldFlatten?: ShouldFlattenFn;\n};\n/**\n * Flattens an object properties into a single level dictionary.\n *\n * @example\n *   const target = {\n *   propOne: {\n *   propOneSub: 'Charito!',\n *   },\n *   propTwo: '!!!',\n *   };\n *   console.log(flat({ target });\n *   // Will output { 'propOne.propOneSub': 'Charito!', propTwo: '!!!' }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const flat = <T = Record<string, unknown>>(options: FlatOptions): T => {\n  const { target, shouldFlatten, pathDelimiter = '.', prefix = '' } = options;\n  const useTarget = target as Record<string, unknown>;\n  let result: Record<string, unknown> = {};\n  const namePrefix = prefix ? `${prefix}${pathDelimiter}` : '';\n  Object.keys(useTarget).forEach((key) => {\n    const name = `${namePrefix}${key}`;\n    const value = useTarget[key] as unknown;\n    const valueType = typeof value;\n    const isObject = valueType === 'object' && value !== null;\n    if (isObject && (!shouldFlatten || shouldFlatten(key, value))) {\n      result = merge(\n        result,\n        flat({ target: value, pathDelimiter, prefix: name, shouldFlatten }),\n      );\n    } else {\n      result[name] = isObject ? copy(value) : value;\n    }\n  });\n\n  return result as T;\n};\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `lowerCamelCase`\n * to `dash-case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const lowerCamelToDashKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])([A-Z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toLowerCase();\n      return `${firstLetter}-${newSecondLetter}`;\n    },\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from\n * `lowerCamelCase` to `snake_case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const lowerCamelToSnakeKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])([A-Z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toLowerCase();\n      return `${firstLetter}_${newSecondLetter}`;\n    },\n  });\n","import { copy } from './copy.js';\nimport { get } from './get.js';\n\nexport type RemoveOptions = {\n  /** The object from where the property will be removed. */\n  target: unknown;\n  /** The path to the property. */\n  path: string;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the\n   * function will silently fail.\n   */\n  failWithError?: boolean;\n  /**\n   * If this flag is `true` and after removing the property the parent object is empty, it\n   * will remove it recursively until a non empty parent object is found.\n   */\n  cleanEmptyProperties?: boolean;\n};\n/**\n * Deletes a property of an object using a path.\n *\n * @example\n *   const target = {\n *     propOne: {\n *       propOneSub: 'Charito!',\n *     },\n *     propTwo: '!!!',\n *   };\n *   console.log(remove({ target, path: 'propOne.propOneSub' }));\n *   // Will output { propTwo: '!!!' }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nfunction remove<T = unknown>(options: RemoveOptions): T | undefined;\nfunction remove<T = unknown>(options: unknown, path: string): T | undefined;\nfunction remove<T = unknown>(\n  options: RemoveOptions | unknown,\n  path?: string,\n): T | undefined {\n  let useOptions: RemoveOptions;\n  if (typeof path === 'string') {\n    useOptions = {\n      target: options,\n      path,\n    };\n  } else {\n    useOptions = options as RemoveOptions;\n  }\n\n  const {\n    target,\n    path: usePath,\n    pathDelimiter = '.',\n    cleanEmptyProperties = true,\n    failWithError = false,\n  } = useOptions;\n\n  const parts = usePath.split(pathDelimiter);\n  const last = parts.pop()!;\n  const result = copy(target) as Record<string, unknown>;\n  if (!parts.length) {\n    delete result[last];\n    return result as T;\n  }\n  const parentPath = parts.join(pathDelimiter);\n  const parentObj = get<Record<string, unknown>>({\n    target: result,\n    path: parentPath,\n    pathDelimiter,\n    failWithError,\n  });\n\n  if (typeof parentObj === 'undefined') {\n    return undefined;\n  }\n\n  delete parentObj[last];\n  if (cleanEmptyProperties && !Object.keys(parentObj).length) {\n    return remove({\n      target: result,\n      path: parentPath,\n      pathDelimiter,\n      failWithError,\n      cleanEmptyProperties,\n    }) as T;\n  }\n\n  return result as T;\n}\n\nexport { remove };\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to\n * `dash-case`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const snakeToDashKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])_([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => `${firstLetter}-${secondLetter}`,\n  });\n","import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to\n * `lowerCamelCase`.\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const snakeToLowerCamelKeys = <T>(options: FormatKeysExtensionOptions): T =>\n  formatKeys<T>({\n    ...options,\n    search: /([a-z])_([a-z])/g,\n    replace: (_, firstLetter, secondLetter) => {\n      const newSecondLetter = secondLetter.toUpperCase();\n      return `${firstLetter}${newSecondLetter}`;\n    },\n  });\n","import { set } from './set.js';\n\nexport type UnflatOptions = {\n  /** The object to transform. */\n  target: unknown;\n  /** The delimiter that will separate the path components. */\n  pathDelimiter?: string;\n};\n/**\n * This method does the exact opposite from `flat`: It takes an already flatten object and\n * restores it structure.\n *\n * @example\n *   const target = {\n *     'propOne.propOneSub': 'Charito!',\n *     propTwo: '!!!',\n *   };\n *   console.log(unflat({ target }));\n *   // Will output { propOne: { propOneSub: 'Charito!' }, 'propTwo': '!!!' }\n *\n * @template T The type of the returned object.\n * @param options The options to use.\n */\nexport const unflat = <T = Record<string, unknown>>(options: UnflatOptions): T => {\n  const { target, pathDelimiter = '.' } = options;\n  const useTarget = target as Record<string, unknown>;\n  return Object.keys(useTarget).reduce<Record<string, unknown>>(\n    (current, key) =>\n      set({ target: current, path: key, value: useTarget[key], pathDelimiter })!,\n    {},\n  ) as T;\n};\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@homer0/object-utils",
   "description": "A small collection of utility methods to work with objects.",
-  "version": "6.0.7",
+  "version": "7.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/homer0/packages.git",
@@ -37,8 +37,8 @@
     "extend": "^3.0.2"
   },
   "devDependencies": {
-    "@homer0/oxlint-config": "2.0.0",
-    "@homer0/tsconfig": "5.0.1",
+    "@homer0/oxlint-config": "3.0.0",
+    "@homer0/tsconfig": "6.0.0",
     "@types/extend": "^3.0.4",
     "@vitest/coverage-v8": "catalog:",
     "oxlint": "catalog:",
@@ -49,7 +49,7 @@
   },
   "engine-strict": true,
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "scripts": {
     "lint": "oxlint .",
@@ -59,5 +59,5 @@
     "build": "tsdown",
     "prepublishOnly": "pnpm run build"
   },
-  "gitHead": "7d849b3b0b5d9cc54557f3132bb50b1acc67f9f5"
+  "gitHead": "cc45fa7b2a70d060ac154c13d4dcaed6ca69334f"
 }