@homer0/object-utils 4.0.0 → 5.0.0

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../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":["export * from './fns/copy';\nexport * from './fns/dashToLowerCamelKeys';\nexport * from './fns/dashToSnakeKeys';\nexport * from './fns/extract';\nexport * from './fns/flat';\nexport * from './fns/formatKeys';\nexport * from './fns/get';\nexport * from './fns/lowerCamelToDashKeys';\nexport * from './fns/lowerCamelToSnakeKeys';\nexport * from './fns/merge';\nexport * from './fns/remove';\nexport * from './fns/set';\nexport * from './fns/snakeToDashKeys';\nexport * from './fns/snakeToLowerCamelKeys';\nexport * from './fns/unflat';\n","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 * @param targets  The list of objects to merge.\n * @template T  The type of the merged object that will be returned.\n * @example\n *\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 *\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 */\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';\n\n/**\n * Creates a deep copy of a given object.\n *\n * @param target  The object to copy.\n * @template T  The type of the input object, which will be the same as the one\n *              returned.\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  /**\n   * The object to transform.\n   */\n  target: unknown;\n  /**\n   * A regular expression to match the keys to transform.\n   */\n  search: RegExp;\n  /**\n   * The callback that will be used to replace the matched substring. Think of `search` and\n   * `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  /**\n   * A list of keys or paths where the transformation won't be made.\n   */\n  exclude?: string[];\n  /**\n   * The delimiter that will separate the path components for both `include` and `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 * @param options  The set of options to customize the transformation.\n * @template T  The type of the returned object.\n * @example\n *\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 */\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.\n   * This is saved on a dictionary not only because it makes it easier to check if the\n   * method should make a recursive call for a key, but also because when parsing the\n   * `exclude`\n   * parameter, if one of items is a key (and not an specific path), the method won't make\n   * 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 path\n   * delimiter from the start of a path and one that removes it from the end.\n   * They 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 specific\n   * keys on recursive calls.\n   * If `include` has a path like `myKey.mySubKey`, `myKey` is not transformed, but `mySubKey`\n   * is saved on this dictionary (`{ myKey: ['mySubKey']}`) and when the method applies the\n   * formatting to the object, if `myKey` has an object, it will make a recursive all and\n   * send `['mySubKey]` as its `include` 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.\n   * Thd following blocks will parse `include` and `exclude` in order to extract the real keys,\n   * prepare the `include` and `exclude` for recursive calls, and save the actual keys\n   * from the object \"at the current level of this call\" (no, it's not thinking about the\n   * 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)\n           * (`mySubProp`).\n           * The `key` is set to `''` so it will be later removed using `.filter`.\n           *\n           * @ignore\n           */\n          key = '';\n          /**\n           * If there's no array for the key on the \"`include` dictionary for recursive calls\",\n           * 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` parameter\n   * that will be sent for specific keys on recursive calls.\n   * If `exclude` has a path like `myKey.mySubKey`, `myKey` will be transformed, but `mySubKey`\n   * is saved on this dictionary (`{ myKey: ['mySubKey']}`) and when the method applies the\n   * formatting to the object, if `myKey` has an object, it will make a recursive all and\n   * send `['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`.\n     * It's easier to have them on a list and use `.filter` than actually call `.splice` for\n     * every key 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 calls\",\n         * 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`.\n         * Basically: If it's a key, don't format it and don't make recursive calls for\n         * 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 and\n     * the value is another object, make a recursive call; otherwise, just use the original\n     * 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';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case`\n * to `lowerCamelCase`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\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';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case`\n * to `snake_case`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\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  /**\n   * The object from where the property will be read.\n   */\n  target: unknown;\n  /**\n   * The path to the property.\n   */\n  path: string;\n  /**\n   * The delimiter that will separate the path components.\n   */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`,\n   *  the 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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @throws {Error} If the path is invalid and `failWithError` is set to `true`.\n * @example\n *\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 */\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';\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  /**\n   * The object where the property will be set.\n   */\n  target: unknown;\n  /**\n   * The path for the property.\n   */\n  path: string;\n  /**\n   * The value to set on the property.\n   */\n  value: unknown;\n  /**\n   * The delimiter that will separate the path components.\n   */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the method\n   * 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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @throws {Error} If one of the path components is for a non-object property and\n *                 `failWithError` is set to `true`.\n * @example\n *\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 */\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  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  if (result && last) {\n    currentElement[last] = useValue;\n  }\n\n  return result as T | undefined;\n}\n\nexport { set };\n","import { get } from './get';\nimport { set } from './set';\nimport { copy } from './copy';\n/**\n * Used in the {@link extract} function to specify a path for a property, or an \"origin path\"\n * and an \"extraction path\".\n */\nexport type extractionPath = string | Record<string, string>;\n\nexport type ExtractOptions = {\n  /**\n   * The object from where the property/properties will be extracted.\n   */\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  /**\n   * The delimiter that will separate the path components.\n   */\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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\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 */\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';\nimport { merge } from './merge';\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  /**\n   * The object to transform.\n   */\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  /**\n   * The delimiter that will separate the path components.\n   */\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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\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 */\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';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from\n * `lowerCamelCase` to `dash-case`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\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';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from\n * `lowerCamelCase` to `snake_case`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\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';\nimport { get } from './get';\n\nexport type RemoveOptions = {\n  /**\n   * The object from where the property will be removed.\n   */\n  target: unknown;\n  /**\n   * The path to the property.\n   */\n  path: string;\n  /**\n   * The delimiter that will separate the path components.\n   */\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,\n   * it 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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\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 */\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';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to\n * `dash-case`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\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';\n\n/**\n * A shorthand method for {@link formatKeys} that transforms the keys from `snake_case` to\n * `lowerCamelCase`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\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';\n\nexport type UnflatOptions = {\n  /**\n   * The object to transform.\n   */\n  target: unknown;\n  /**\n   * The delimiter that will separate the path components.\n   */\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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\n *   const target = {\n *     'propOne.propOneSub': 'Charito!',\n *     propTwo: '!!!',\n *   };\n *   console.log(unflat({ target }));\n *   // Will output { propOne: { propOneSub: 'Charito!' }, 'propTwo': '!!!' }\n *\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,oBAAmB;AAwBZ,IAAM,QAAQ,IAAiB,YAA0B;AAC9D,QAAM,CAAC,WAAW,IAAI;AACtB,QAAM,OAAO,MAAM,QAAQ,WAAW,IAAI,CAAC,IAAI,CAAC;AAChD,aAAO,cAAAA,SAAO,MAAM,MAAM,GAAG,OAAO;AACtC;;;ACnBO,IAAM,OAAO,CAAI,WAAiB,MAAM,MAAM;;;ACwD9C,IAAM,aAAa,CACxB,YACM;AACN,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA,UAAU,CAAC;AAAA,IACX,UAAU,CAAC;AAAA,IACX,gBAAgB;AAAA,EAClB,IAAI;AAEJ,QAAM,YAAY;AAElB,QAAM,OAAO,OAAO,KAAK,MAAiC;AAW1D,QAAM,mBAA4C,CAAC;AACnD,OAAK,QAAQ,CAAC,QAAQ;AACpB,UAAM,QAAQ,UAAU,GAAG;AAC3B,qBAAiB,GAAG,IAAI,CAAC,EACvB,SACA,OAAO,UAAU,YACjB,UAAU,QACV,CAAC,MAAM,QAAQ,KAAK,KACpB,OAAO,KAAK,KAAK;AAAA,EAErB,CAAC;AAOD,QAAM,uBAAuB,cAAc,QAAQ,4BAA4B,MAAM;AACrF,QAAM,2BAA2B,IAAI,OAAO,IAAI,oBAAoB,IAAI,GAAG;AAC3E,QAAM,yBAAyB,IAAI,OAAO,GAAG,oBAAoB,KAAK,GAAG;AASzE,QAAM,kBAA4C,CAAC;AASnD,MAAI;AAEJ,MAAI,QAAQ,QAAQ;AAClB,mBAAe,QACZ,IAAI,CAAC,gBAAgB;AAEpB,YAAM,iBAAiB,YACpB,QAAQ,0BAA0B,EAAE,EACpC,QAAQ,wBAAwB,EAAE;AAErC,UAAI;AAEJ,UAAI,eAAe,SAAS,aAAa,GAAG;AAE1C,cAAM,YAAY,eAAe,MAAM,aAAa;AAEpD,cAAM,UAAU,UAAU,MAAM;AAUhC,cAAM;AAKN,YAAI,CAAC,gBAAgB,OAAO,GAAG;AAC7B,0BAAgB,OAAO,IAAI,CAAC;AAAA,QAC9B;AAEA,wBAAgB,OAAO,EAAG,KAAK,UAAU,KAAK,aAAa,CAAC;AAAA,MAC9D,OAAO;AAEL,cAAM;AAAA,MACR;AAEA,aAAO;AAAA,IACT,CAAC,EAEA,OAAO,CAAC,QAAQ,GAAG;AAAA,EACxB,OAAO;AAEL,mBAAe;AAAA,EACjB;AASA,QAAM,kBAA4C,CAAC;AAEnD,MAAI,QAAQ,QAAQ;AAMlB,UAAM,eAAyB,CAAC;AAChC,YAAQ,QAAQ,CAAC,gBAAgB;AAE/B,YAAM,iBAAiB,YACpB,QAAQ,0BAA0B,EAAE,EACpC,QAAQ,wBAAwB,EAAE;AAErC,UAAI,eAAe,SAAS,aAAa,GAAG;AAE1C,cAAM,YAAY,eAAe,MAAM,aAAa;AAEpD,cAAM,UAAU,UAAU,MAAM;AAKhC,YAAI,CAAC,gBAAgB,OAAO,GAAG;AAC7B,0BAAgB,OAAO,IAAI,CAAC;AAAA,QAC9B;AAEA,wBAAgB,OAAO,EAAG,KAAK,UAAU,KAAK,aAAa,CAAC;AAAA,MAC9D,OAAO;AAUL,yBAAiB,cAAc,IAAI;AACnC,qBAAa,KAAK,cAAc;AAAA,MAClC;AAAA,IACF,CAAC;AAED,mBAAe,aAAa,OAAO,CAAC,QAAQ,OAAO,CAAC,aAAa,SAAS,GAAG,CAAC;AAAA,EAChF;AAEA,SAAO,KAAK,OAAgC,CAAC,QAAQ,QAAQ;AAK3D,QAAI;AACJ,QAAI;AAKJ,UAAM,QAAQ,UAAU,GAAG;AAE3B,QAAI,aAAa,SAAS,GAAG,GAAG;AAC9B,eAAS,IAAI,QAAQ,QAAQ,OAAO;AAAA,IACtC,OAAO;AACL,eAAS;AAAA,IACX;AAMA,QAAI,iBAAiB,GAAG,GAAG;AACzB,iBAAW,WAAW;AAAA,QACpB,QAAQ;AAAA,QACR;AAAA,QACA;AAAA,QACA,SAAS,gBAAgB,GAAG,KAAK,CAAC;AAAA,QAClC,SAAS,gBAAgB,GAAG,KAAK,CAAC;AAAA,QAClC;AAAA,MACF,CAAC;AAAA,IACH,OAAO;AACL,iBAAW;AAAA,IACb;AAEA,WAAO,EAAE,GAAG,QAAQ,CAAC,MAAM,GAAG,SAAS;AAAA,EACzC,GAAG,CAAC,CAAC;AACP;;;ACpQO,IAAM,uBAAuB,CAAI,YACtC,WAAc;AAAA,EACZ,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,SAAS,CAAC,GAAG,aAAa,iBAAiB;AACzC,UAAM,kBAAkB,aAAa,YAAY;AACjD,WAAO,GAAG,WAAW,GAAG,eAAe;AAAA,EACzC;AACF,CAAC;;;ACRI,IAAM,kBAAkB,CAAI,YACjC,WAAc;AAAA,EACZ,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,SAAS,CAAC,GAAG,aAAa,iBAAiB,GAAG,WAAW,IAAI,YAAY;AAC3E,CAAC;;;AC0BH,SAAS,IAAO,SAA+B,MAA8B;AAC3E,MAAI;AACJ,MAAI,OAAO,SAAS,UAAU;AAC5B,iBAAa;AAAA,MACX,QAAQ;AAAA,MACR;AAAA,IACF;AAAA,EACF,OAAO;AACL,iBAAa;AAAA,EACf;AAEA,QAAM;AAAA,IACJ;AAAA,IACA,MAAM;AAAA,IACN,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,EAClB,IAAI;AACJ,QAAM,YAAY;AAClB,QAAM,QAAQ,QAAQ,MAAM,aAAa;AACzC,QAAM,QAAQ,MAAM,MAAM;AAC1B,MAAI,iBAAiB,UAAU,KAAK;AACpC,MAAI,OAAO,mBAAmB,aAAa;AACzC,QAAI,eAAe;AACjB,YAAM,IAAI,MAAM,uBAAuB,OAAO,GAAG;AAAA,IACnD;AAEA,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,MAAM,QAAQ;AACjB,WAAO;AAAA,EACT;AAEA,MAAI,cAAc;AAClB,QAAM,KAAK,CAAC,gBAAgB;AAC1B,QAAI,YAAY;AAChB,mBAAe,GAAG,aAAa,GAAG,WAAW;AAC7C,qBAAiB,eAAe,WAAW;AAC3C,QAAI,OAAO,mBAAmB,aAAa;AACzC,UAAI,eAAe;AACjB,cAAM,IAAI,MAAM,uBAAuB,WAAW,GAAG;AAAA,MACvD,OAAO;AACL,oBAAY;AAAA,MACd;AAAA,IACF;AAEA,WAAO;AAAA,EACT,CAAC;AAED,SAAO;AACT;;;AClFA,IAAM,kBAAkB,CAAC,aAAa,aAAa,aAAa;AA8ChE,SAAS,IACP,SACA,MACA,OACe;AACf,MAAI;AACJ,MAAI,OAAO,SAAS,UAAU;AAC5B,iBAAa;AAAA,MACX,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACF;AAAA,EACF,OAAO;AACL,iBAAa;AAAA,EACf;AAEA,QAAM;AAAA,IACJ;AAAA,IACA,MAAM;AAAA,IACN,OAAO;AAAA,IACP,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,EAClB,IAAI;AACJ,QAAM,SAAS,KAAK,MAAM;AAC1B,MAAI,CAAC,QAAQ,SAAS,aAAa,GAAG;AACpC,QAAI,CAAC,WAAW,gBAAgB,SAAS,QAAQ,YAAY,CAAC,GAAG;AAC/D,aAAO;AAAA,IACT;AAEA,WAAO,OAAO,IAAI;AAClB,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,QAAQ,MAAM,aAAa;AACzC,QAAM,YAAY,MAAM;AAAA,IACtB,CAAC,SAAS,CAAC,QAAQ,gBAAgB,SAAS,KAAK,YAAY,CAAC;AAAA,EAChE;AAEA,MAAI,WAAW;AACb,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,MAAM,IAAI;AACvB,MAAI,iBAAiB;AACrB,MAAI,cAAc;AAClB,MAAI,eAAe;AACnB,QAAM,QAAQ,CAAC,SAAS;AACtB,mBAAe,GAAG,aAAa,GAAG,IAAI;AACtC,UAAM,UAAU,eAAe,IAAI;AACnC,UAAM,cAAc,OAAO;AAC3B,QAAI,gBAAgB,aAAa;AAC/B,qBAAe,IAAI,IAAI,CAAC;AACxB,uBAAiB,eAAe,IAAI;AAAA,IACtC,WAAW,gBAAgB,UAAU;AACnC,uBAAiB,eAAe,IAAI;AAAA,IACtC,OAAO;AACL,YAAM,YAAY,YAAY,UAAU,cAAc,MAAM;AAC5D,UAAI,eAAe;AACjB,cAAM,IAAI;AAAA,UACR,uCAAuC,WAAW,SAAS,SAAS;AAAA,QACtE;AAAA,MACF,OAAO;AACL,uBAAe;AAAA,MACjB;AAAA,IACF;AAAA,EACF,CAAC;AAED,MAAI,aAAc,QAAO;AAEzB,MAAI,UAAU,MAAM;AAClB,mBAAe,IAAI,IAAI;AAAA,EACzB;AAEA,SAAO;AACT;;;ACxEO,IAAM,UAAU,CACrB,YACkB;AAClB,QAAM,EAAE,QAAQ,OAAO,gBAAgB,KAAK,gBAAgB,MAAM,IAAI;AACtE,QAAM,SAAS,KAAK,MAAM;AAC1B,MAAI,SAAkC,CAAC;AACvC,MAAI,SAAS;AACb,GAAC,MAAM,QAAQ,KAAK,IAAI,QAAQ,CAAC,KAAK,GACnC;AAAA,IACC,CAAC,KAAK,YAAY;AAChB,UAAI;AACJ,UAAI;AACJ,UAAI,OAAO,YAAY,UAAU;AAC/B,mBAAW;AACX,qBAAa;AAAA,MACf,OAAO;AACL,cAAM,CAAC,QAAQ,IAAI,OAAO,KAAK,OAAO;AACtC,mBAAW;AACX,qBAAa,QAAQ,QAAQ;AAAA,MAC/B;AAEA,UAAI,KAAK;AAAA,QACP,QAAQ;AAAA,QACR,YAAY,SAAS,SAAS,aAAa;AAAA,QAC3C,MAAM;AAAA,MACR,CAAC;AACD,aAAO;AAAA,IACT;AAAA,IACA,CAAC;AAAA,EACH,EACC,KAAK,CAAC,aAAa;AAClB,QAAI,YAAY;AAChB,UAAM,QAAQ,IAAI;AAAA,MAChB,QAAQ;AAAA,MACR,MAAM,SAAS;AAAA,MACf;AAAA,MACA;AAAA,IACF,CAAC;AACD,QAAI,OAAO,UAAU,aAAa;AAChC,UAAI,SAAS,YAAY;AACvB,cAAM,iBAAiB,IAAI;AAAA,UACzB,QAAQ;AAAA,UACR,MAAM,SAAS;AAAA,UACf;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AACD,YAAI,OAAO,mBAAmB,aAAa;AACzC,sBAAY;AACZ,mBAAS;AAAA,QACX,OAAO;AACL,mBAAS;AAAA,QACX;AAAA,MACF,OAAO;AACL,eAAO,SAAS,IAAI,IAAI;AAAA,MAC1B;AAAA,IACF;AAEA,WAAO;AAAA,EACT,CAAC;AAEH,MAAI,OAAQ,QAAO;AACnB,SAAO;AACT;;;ACtEO,IAAM,OAAO,CAA8B,YAA4B;AAC5E,QAAM,EAAE,QAAQ,eAAe,gBAAgB,KAAK,SAAS,GAAG,IAAI;AACpE,QAAM,YAAY;AAClB,MAAI,SAAkC,CAAC;AACvC,QAAM,aAAa,SAAS,GAAG,MAAM,GAAG,aAAa,KAAK;AAC1D,SAAO,KAAK,SAAS,EAAE,QAAQ,CAAC,QAAQ;AACtC,UAAM,OAAO,GAAG,UAAU,GAAG,GAAG;AAChC,UAAM,QAAQ,UAAU,GAAG;AAC3B,UAAM,YAAY,OAAO;AACzB,UAAM,WAAW,cAAc,YAAY,UAAU;AACrD,QAAI,aAAa,CAAC,iBAAiB,cAAc,KAAK,KAAK,IAAI;AAC7D,eAAS;AAAA,QACP;AAAA,QACA,KAAK,EAAE,QAAQ,OAAO,eAAe,QAAQ,MAAM,cAAc,CAAC;AAAA,MACpE;AAAA,IACF,OAAO;AACL,aAAO,IAAI,IAAI,WAAW,KAAK,KAAK,IAAI;AAAA,IAC1C;AAAA,EACF,CAAC;AAED,SAAO;AACT;;;AC7DO,IAAM,uBAAuB,CAAI,YACtC,WAAc;AAAA,EACZ,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,SAAS,CAAC,GAAG,aAAa,iBAAiB;AACzC,UAAM,kBAAkB,aAAa,YAAY;AACjD,WAAO,GAAG,WAAW,IAAI,eAAe;AAAA,EAC1C;AACF,CAAC;;;ACRI,IAAM,wBAAwB,CAAI,YACvC,WAAc;AAAA,EACZ,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,SAAS,CAAC,GAAG,aAAa,iBAAiB;AACzC,UAAM,kBAAkB,aAAa,YAAY;AACjD,WAAO,GAAG,WAAW,IAAI,eAAe;AAAA,EAC1C;AACF,CAAC;;;AC6BH,SAAS,OACP,SACA,MACe;AACf,MAAI;AACJ,MAAI,OAAO,SAAS,UAAU;AAC5B,iBAAa;AAAA,MACX,QAAQ;AAAA,MACR;AAAA,IACF;AAAA,EACF,OAAO;AACL,iBAAa;AAAA,EACf;AAEA,QAAM;AAAA,IACJ;AAAA,IACA,MAAM;AAAA,IACN,gBAAgB;AAAA,IAChB,uBAAuB;AAAA,IACvB,gBAAgB;AAAA,EAClB,IAAI;AAEJ,QAAM,QAAQ,QAAQ,MAAM,aAAa;AACzC,QAAM,OAAO,MAAM,IAAI;AACvB,QAAM,SAAS,KAAK,MAAM;AAC1B,MAAI,CAAC,MAAM,QAAQ;AACjB,WAAO,OAAO,IAAI;AAClB,WAAO;AAAA,EACT;AACA,QAAM,aAAa,MAAM,KAAK,aAAa;AAC3C,QAAM,YAAY,IAA6B;AAAA,IAC7C,QAAQ;AAAA,IACR,MAAM;AAAA,IACN;AAAA,IACA;AAAA,EACF,CAAC;AAED,MAAI,OAAO,cAAc,aAAa;AACpC,WAAO;AAAA,EACT;AAEA,SAAO,UAAU,IAAI;AACrB,MAAI,wBAAwB,CAAC,OAAO,KAAK,SAAS,EAAE,QAAQ;AAC1D,WAAO,OAAO;AAAA,MACZ,QAAQ;AAAA,MACR,MAAM;AAAA,MACN;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAEA,SAAO;AACT;;;AC1FO,IAAM,kBAAkB,CAAI,YACjC,WAAc;AAAA,EACZ,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,SAAS,CAAC,GAAG,aAAa,iBAAiB,GAAG,WAAW,IAAI,YAAY;AAC3E,CAAC;;;ACLI,IAAM,wBAAwB,CAAI,YACvC,WAAc;AAAA,EACZ,GAAG;AAAA,EACH,QAAQ;AAAA,EACR,SAAS,CAAC,GAAG,aAAa,iBAAiB;AACzC,UAAM,kBAAkB,aAAa,YAAY;AACjD,WAAO,GAAG,WAAW,GAAG,eAAe;AAAA,EACzC;AACF,CAAC;;;ACWI,IAAM,SAAS,CAA8B,YAA8B;AAChF,QAAM,EAAE,QAAQ,gBAAgB,IAAI,IAAI;AACxC,QAAM,YAAY;AAClB,SAAO,OAAO,KAAK,SAAS,EAAE;AAAA,IAC5B,CAAC,SAAS,QACR,IAAI,EAAE,QAAQ,SAAS,MAAM,KAAK,OAAO,UAAU,GAAG,GAAG,cAAc,CAAC;AAAA,IAC1E,CAAC;AAAA,EACH;AACF;","names":["extend"]}
+{"version":3,"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 * @param targets  The list of objects to merge.\n * @template T  The type of the merged object that will be returned.\n * @example\n *\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 *\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 */\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 * @param target  The object to copy.\n * @template T  The type of the input object, which will be the same as the one\n *              returned.\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  /**\n   * The object to transform.\n   */\n  target: unknown;\n  /**\n   * A regular expression to match the keys to transform.\n   */\n  search: RegExp;\n  /**\n   * The callback that will be used to replace the matched substring. Think of `search` and\n   * `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  /**\n   * A list of keys or paths where the transformation won't be made.\n   */\n  exclude?: string[];\n  /**\n   * The delimiter that will separate the path components for both `include` and `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 * @param options  The set of options to customize the transformation.\n * @template T  The type of the returned object.\n * @example\n *\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 */\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.\n   * This is saved on a dictionary not only because it makes it easier to check if the\n   * method should make a recursive call for a key, but also because when parsing the\n   * `exclude`\n   * parameter, if one of items is a key (and not an specific path), the method won't make\n   * 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 path\n   * delimiter from the start of a path and one that removes it from the end.\n   * They 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 specific\n   * keys on recursive calls.\n   * If `include` has a path like `myKey.mySubKey`, `myKey` is not transformed, but `mySubKey`\n   * is saved on this dictionary (`{ myKey: ['mySubKey']}`) and when the method applies the\n   * formatting to the object, if `myKey` has an object, it will make a recursive all and\n   * send `['mySubKey]` as its `include` 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.\n   * Thd following blocks will parse `include` and `exclude` in order to extract the real keys,\n   * prepare the `include` and `exclude` for recursive calls, and save the actual keys\n   * from the object \"at the current level of this call\" (no, it's not thinking about the\n   * 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)\n           * (`mySubProp`).\n           * The `key` is set to `''` so it will be later removed using `.filter`.\n           *\n           * @ignore\n           */\n          key = '';\n          /**\n           * If there's no array for the key on the \"`include` dictionary for recursive calls\",\n           * 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` parameter\n   * that will be sent for specific keys on recursive calls.\n   * If `exclude` has a path like `myKey.mySubKey`, `myKey` will be transformed, but `mySubKey`\n   * is saved on this dictionary (`{ myKey: ['mySubKey']}`) and when the method applies the\n   * formatting to the object, if `myKey` has an object, it will make a recursive all and\n   * send `['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`.\n     * It's easier to have them on a list and use `.filter` than actually call `.splice` for\n     * every key 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 calls\",\n         * 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`.\n         * Basically: If it's a key, don't format it and don't make recursive calls for\n         * 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 and\n     * the value is another object, make a recursive call; otherwise, just use the original\n     * 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`\n * to `lowerCamelCase`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\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`\n * to `snake_case`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\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  /**\n   * The object from where the property will be read.\n   */\n  target: unknown;\n  /**\n   * The path to the property.\n   */\n  path: string;\n  /**\n   * The delimiter that will separate the path components.\n   */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`,\n   *  the 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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @throws {Error} If the path is invalid and `failWithError` is set to `true`.\n * @example\n *\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 */\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  /**\n   * The object where the property will be set.\n   */\n  target: unknown;\n  /**\n   * The path for the property.\n   */\n  path: string;\n  /**\n   * The value to set on the property.\n   */\n  value: unknown;\n  /**\n   * The delimiter that will separate the path components.\n   */\n  pathDelimiter?: string;\n  /**\n   * Whether or not to throw an error when the path is invalid. If this is `false`, the method\n   * 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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @throws {Error} If one of the path components is for a non-object property and\n *                 `failWithError` is set to `true`.\n * @example\n *\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 */\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  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  if (result && last) {\n    currentElement[last] = useValue;\n  }\n\n  return result as T | undefined;\n}\n\nexport { set };\n","import { get } from './get.js';\nimport { set } from './set.js';\nimport { copy } from './copy.js';\n/**\n * Used in the {@link extract} function to specify a path for a property, or an \"origin path\"\n * and an \"extraction path\".\n */\nexport type extractionPath = string | Record<string, string>;\n\nexport type ExtractOptions = {\n  /**\n   * The object from where the property/properties will be extracted.\n   */\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  /**\n   * The delimiter that will separate the path components.\n   */\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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\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 */\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  /**\n   * The object to transform.\n   */\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  /**\n   * The delimiter that will separate the path components.\n   */\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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\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 */\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\n * `lowerCamelCase` to `dash-case`.\n *\n * @param options  The options to use.\n * @template T  The type of the returned object.\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 * @param options  The options to use.\n * @template T  The type of the returned object.\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  /**\n   * The object from where the property will be removed.\n   */\n  target: unknown;\n  /**\n   * The path to the property.\n   */\n  path: string;\n  /**\n   * The delimiter that will separate the path components.\n   */\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,\n   * it 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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\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 */\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 * @param options  The options to use.\n * @template T  The type of the returned object.\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 * @param options  The options to use.\n * @template T  The type of the returned object.\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  /**\n   * The object to transform.\n   */\n  target: unknown;\n  /**\n   * The delimiter that will separate the path components.\n   */\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 * @param options  The options to use.\n * @template T  The type of the returned object.\n * @example\n *\n *   const target = {\n *     'propOne.propOneSub': 'Charito!',\n *     propTwo: '!!!',\n *   };\n *   console.log(unflat({ target }));\n *   // Will output { propOne: { propOneSub: 'Charito!' }, 'propTwo': '!!!' }\n *\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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","names":["extend","merge","targets","firstTarget","base","copy","target","merge","formatKeys","options","target","search","replace","include","exclude","pathDelimiter","useTarget","keys","hasChildrenByKey","key","value","escapedPathDelimiter","cleanPathStartExpression","cleanPathEndExpression","subIncludeByKey","keysToFormat","includePath","useIncludePath","pathParts","pathKey","subExcludeByKey","keysToRemove","excludePath","useExcludePath","newObj","newKey","newValue","dashToLowerCamelKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","dashToSnakeKeys","options","formatKeys","_","firstLetter","secondLetter","get","options","path","useOptions","target","usePath","pathDelimiter","failWithError","useTarget","parts","first","currentElement","currentPath","currentPart","breakLoop","FORBIDDEN_PATHS","set","options","path","value","useOptions","target","usePath","useValue","pathDelimiter","failWithError","result","copy","parts","part","last","currentElement","currentPath","foundInvalid","elementType","errorPath","extract","options","target","paths","pathDelimiter","failWithError","copied","copy","result","failed","acc","objPath","destPath","originPath","firstKey","pathInfo","breakLoop","value","get","withCustomProp","set","flat","options","target","shouldFlatten","pathDelimiter","prefix","useTarget","result","namePrefix","key","name","value","isObject","merge","copy","lowerCamelToDashKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","lowerCamelToSnakeKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","remove","options","path","useOptions","target","usePath","pathDelimiter","cleanEmptyProperties","failWithError","parts","last","result","copy","parentPath","parentObj","get","snakeToDashKeys","options","formatKeys","_","firstLetter","secondLetter","snakeToLowerCamelKeys","options","formatKeys","_","firstLetter","secondLetter","newSecondLetter","unflat","options","target","pathDelimiter","useTarget","current","key","set"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@homer0/object-utils",
   "description": "A small collection of utility methods to work with objects.",
-  "version": "4.0.0",
+  "version": "5.0.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/homer0/packages.git",
@@ -19,34 +19,46 @@
   "publishConfig": {
     "access": "public"
   },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./src/index.ts"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
-    "dist/"
+    "dist/",
+    "src/"
   ],
   "dependencies": {
     "extend": "^3.0.2"
   },
   "devDependencies": {
-    "@homer0/eslint-plugin": "13.0.0",
-    "@homer0/tsconfig": "3.0.0",
+    "@homer0/eslint-plugin": "14.0.0",
+    "@homer0/tsconfig": "4.0.0",
     "@types/extend": "^3.0.4",
-    "jest": "catalog:",
-    "ts-jest": "catalog:",
+    "@vitest/coverage-v8": "catalog:",
+    "eslint": "catalog:",
     "tsup": "catalog:",
-    "typescript": "catalog:"
+    "typescript": "catalog:",
+    "unplugin-swc": "catalog:",
+    "vite-tsconfig-paths": "catalog:",
+    "vitest": "catalog:"
   },
   "engine-strict": true,
   "engines": {
     "node": ">=20 <23"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/index.d.ts",
   "scripts": {
     "lint": "eslint .",
-    "test": "jest -c ./.jestrc.js",
+    "lint:file": "eslint $@",
+    "test": "vitest run $@",
     "types:check": "tsc --noEmit && tsc --noEmit --project ./tests/tsconfig.json",
-    "build": "tsup src/index.ts",
+    "build": "tsup",
     "prepublishOnly": "pnpm run build"
   },
-  "gitHead": "8ebd444fb628a91cebb3cd70e22ab9f041e5ec0a"
+  "gitHead": "fece630639760a2ea3b9f191ff203ac33bb88a09"
 }

package/src/fns/copy.ts

@@ -0,0 +1,10 @@
+import { merge } from './merge.js';
+
+/**
+ * Creates a deep copy of a given object.
+ *
+ * @param target  The object to copy.
+ * @template T  The type of the input object, which will be the same as the one
+ *              returned.
+ */
+export const copy = <T>(target: T): T => merge(target);

package/src/fns/dashToLowerCamelKeys.ts

@@ -0,0 +1,18 @@
+import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';
+
+/**
+ * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case`
+ * to `lowerCamelCase`.
+ *
+ * @param options  The options to use.
+ * @template T  The type of the returned object.
+ */
+export const dashToLowerCamelKeys = <T>(options: FormatKeysExtensionOptions): T =>
+  formatKeys<T>({
+    ...options,
+    search: /([a-z])-([a-z])/g,
+    replace: (_, firstLetter, secondLetter) => {
+      const newSecondLetter = secondLetter.toUpperCase();
+      return `${firstLetter}${newSecondLetter}`;
+    },
+  });

package/src/fns/dashToSnakeKeys.ts

@@ -0,0 +1,15 @@
+import { formatKeys, type FormatKeysExtensionOptions } from './formatKeys.js';
+
+/**
+ * A shorthand method for {@link formatKeys} that transforms the keys from `dash-case`
+ * to `snake_case`.
+ *
+ * @param options  The options to use.
+ * @template T  The type of the returned object.
+ */
+export const dashToSnakeKeys = <T>(options: FormatKeysExtensionOptions): T =>
+  formatKeys<T>({
+    ...options,
+    search: /([a-z])-([a-z])/g,
+    replace: (_, firstLetter, secondLetter) => `${firstLetter}_${secondLetter}`,
+  });

package/src/fns/extract.ts

@@ -0,0 +1,120 @@
+import { get } from './get.js';
+import { set } from './set.js';
+import { copy } from './copy.js';
+/**
+ * Used in the {@link extract} function to specify a path for a property, or an "origin path"
+ * and an "extraction path".
+ */
+export type extractionPath = string | Record<string, string>;
+
+export type ExtractOptions = {
+  /**
+   * The object from where the property/properties will be extracted.
+   */
+  target: unknown;
+  /**
+   * This can be a single path or a list of them. And for this method, the paths are not
+   * only strings but can also be an object with a single key, that would be the path to
+   * where to "do the extraction", and the value the path on the target object.
+   */
+  paths: extractionPath | extractionPath[];
+  /**
+   * The delimiter that will separate the path components.
+   */
+  pathDelimiter?: string;
+  /**
+   * Whether or not to throw an error when the path is invalid. If this is `false`, the
+   * method will silently fail an empty object.
+   */
+  failWithError?: boolean;
+};
+/**
+ * Extracts a property or properties from an object in order to create a new one.
+ *
+ * @param options  The options to use.
+ * @template T  The type of the returned object.
+ * @example
+ *
+ *   const target = {
+ *     name: {
+ *       first: 'Pilar',
+ *     },
+ *     age: 3,
+ *     address: {
+ *       planet: 'earth',
+ *       something: 'else',
+ *     },
+ *   };
+ *   console.log(
+ *     extract({
+ *       target: obj,
+ *       paths: [{ name: 'name.first' }, 'age', 'address.planet'],
+ *     }),
+ *   );
+ *   // Will output { name: 'Pilar', age: 3, address: { planet: 'earth' } }
+ *
+ */
+export const extract = <T = Record<string, unknown>>(
+  options: ExtractOptions,
+): T | undefined => {
+  const { target, paths, pathDelimiter = '.', failWithError = false } = options;
+  const copied = copy(target) as Record<string, unknown>;
+  let result: Record<string, unknown> = {};
+  let failed = false;
+  (Array.isArray(paths) ? paths : [paths])
+    .reduce<Array<{ origin: string; customDest: boolean; dest: string }>>(
+      (acc, objPath) => {
+        let destPath: string;
+        let originPath: string;
+        if (typeof objPath === 'string') {
+          destPath = objPath;
+          originPath = objPath;
+        } else {
+          const [firstKey] = Object.keys(objPath);
+          destPath = firstKey!;
+          originPath = objPath[destPath]!;
+        }
+
+        acc.push({
+          origin: originPath,
+          customDest: destPath.includes(pathDelimiter),
+          dest: destPath,
+        });
+        return acc;
+      },
+      [],
+    )
+    .some((pathInfo) => {
+      let breakLoop = false;
+      const value = get({
+        target: copied,
+        path: pathInfo.origin,
+        pathDelimiter,
+        failWithError,
+      });
+      if (typeof value !== 'undefined') {
+        if (pathInfo.customDest) {
+          const withCustomProp = set({
+            target: result,
+            path: pathInfo.dest,
+            value,
+            pathDelimiter,
+            failWithError,
+          });
+          if (typeof withCustomProp === 'undefined') {
+            breakLoop = true;
+            failed = true;
+          } else {
+            result = withCustomProp;
+          }
+        } else {
+          result[pathInfo.dest] = value;
+        }
+      }
+
+      return breakLoop;
+    });
+
+  if (failed) return undefined;
+  return result as T;
+};

package/src/fns/flat.ts

@@ -0,0 +1,71 @@
+import { copy } from './copy.js';
+import { merge } from './merge.js';
+
+/**
+ * Checks whether a key for an array or an Object should be flattened.
+ *
+ * @param key    The key to check inside its parent.
+ * @param value  The value of the key.
+ */
+export type ShouldFlattenFn = (key: string, value: unknown) => boolean;
+
+export type FlatOptions = {
+  /**
+   * The object to transform.
+   */
+  target: unknown;
+  /**
+   * A custom prefix to be added before the name of the properties. This can be used on
+   * custom cases and it's also used when the method calls itself in order to flatten a
+   * sub object.
+   */
+  prefix?: string;
+  /**
+   * The delimiter that will separate the path components.
+   */
+  pathDelimiter?: string;
+  /**
+   * A custom function that can be used in order to tell the function whether an Object or
+   * an Array property should be flatten or not.
+   */
+  shouldFlatten?: ShouldFlattenFn;
+};
+/**
+ * Flattens an object properties into a single level dictionary.
+ *
+ * @param options  The options to use.
+ * @template T  The type of the returned object.
+ * @example
+ *
+ * const target = {
+ * propOne: {
+ * propOneSub: 'Charito!',
+ * },
+ * propTwo: '!!!',
+ * };
+ * console.log(flat({ target });
+ * // Will output { 'propOne.propOneSub': 'Charito!', propTwo: '!!!' }
+ *
+ */
+export const flat = <T = Record<string, unknown>>(options: FlatOptions): T => {
+  const { target, shouldFlatten, pathDelimiter = '.', prefix = '' } = options;
+  const useTarget = target as Record<string, unknown>;
+  let result: Record<string, unknown> = {};
+  const namePrefix = prefix ? `${prefix}${pathDelimiter}` : '';
+  Object.keys(useTarget).forEach((key) => {
+    const name = `${namePrefix}${key}`;
+    const value = useTarget[key] as unknown;
+    const valueType = typeof value;
+    const isObject = valueType === 'object' && value !== null;
+    if (isObject && (!shouldFlatten || shouldFlatten(key, value))) {
+      result = merge(
+        result,
+        flat({ target: value, pathDelimiter, prefix: name, shouldFlatten }),
+      );
+    } else {
+      result[name] = isObject ? copy(value) : value;
+    }
+  });
+
+  return result as T;
+};