@rzl-zone/utils-js 3.12.1-beta.0 → 3.13.0-beta.2

package/dist/formatEnvPort-DpIXzPAZ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatEnvPort-DpIXzPAZ.js","names":[],"sources":["../src/urls/_private/NormalizePathnameError.ts","../src/urls/pathname/normalizePathname.ts","../src/urls/utils/formatEnvPort.ts"],"sourcesContent":["import { isFunction } from \"@/predicates/is/isFunction\";\n\n/** ---------------------------------\n * * ***Custom Error for Pathname Normalization Failures***\n * --------------------------------- */\nexport class NormalizePathnameError extends Error {\n  /** * ***The original error that triggered this normalization failure.***\n   *\n   * **Always available for backward compatibility.**\n   */\n  public readonly originalError: Error;\n\n  constructor(message: string, originalError: Error) {\n    // Pass a `cause` option if the runtime supports it (ignored by older engines).\n    super(message, isFunction(Error) ? { cause: originalError } : undefined);\n\n    this.name = \"NormalizePathnameError\";\n    this.originalError = originalError;\n\n    // Preserve stack trace when available (Node.js & modern browsers).\n    if (isFunction(Error.captureStackTrace)) {\n      Error.captureStackTrace(this, NormalizePathnameError);\n    } else {\n      // Fallback for very old environments.\n      this.stack = new Error(message).stack;\n    }\n  }\n\n  /** * ***Safe JSON representation for logging or IPC.*** */\n  toJSON() {\n    return {\n      name: this.name,\n      message: this.message,\n      stack: this.stack,\n      originalError: {\n        name: this.originalError.name,\n        message: this.originalError.message,\n        stack: this.originalError.stack\n      }\n    };\n  }\n}\n","import type { OverrideTypes, Prettify } from \"@rzl-zone/ts-types-plus\";\n\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isNull } from \"@/predicates/is/isNull\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isError } from \"@/predicates/is/isError\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isValidDomain } from \"@/predicates/is/isValidDomain\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport { removeSpaces } from \"@/strings/sanitizations/removeSpaces\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\nimport { NormalizePathnameError } from \"../_private/NormalizePathnameError\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\n\n/** Options when `keepNullable` is false (default).\n *\n * Returns `defaultPath` if `pathname` is empty or invalid.\n */\ntype UnKeepNullableOptions = {\n  /** * ***Fallback value returned if `pathname` is empty-string or invalid.***\n   *\n   * Must be a **`non-empty string`**, defaultValue: `\"/\"`.\n   *\n   * @defaultValue `\"/\"`.\n   */\n  defaultPath?: string;\n\n  /** * ***Whether to preserve `null` or `undefined`, defaultValue: `false`.***\n   *\n   * @defaultValue `false`.\n   */\n  keepNullable?: false;\n};\n\n/** Options when `keepNullable` is true.\n *\n * Preserves `null` or `undefined` instead of returning `defaultPath`.\n */\ntype KeepNullableOptions = {\n  /** * ***Fallback path is ignored when `keepNullable` is true **(except if\n   * `pathname` is empty-string or invalid, even this `true`)**,\n   * defaultValue: `\"/\"`.***\n   *\n   * @defaultValue `\"/\"`.\n   */\n  defaultPath?: string;\n\n  /** * ***Preserve `null` or `undefined` as-is if `true` (defaultValue: `false`).***\n   *\n   * - ***⚠️ Notes:***\n   *      - Keep returning `defaultPath` if `pathname` is empty-string, even this `true`.\n   *\n   * **Must be `true` in this type.**\n   */\n  keepNullable?: true;\n};\n\ntype MainNormalizePathnameOptions = {\n  /** --------------------------------------------------------\n   * * ***Preserve trailing slash at the end of the normalized pathname, defaultValue: `false`.***\n   * --------------------------------------------------------\n   *\n   * @defaultValue `false`\n   */\n  keepTrailingSlash?: boolean;\n\n  /** --------------------------------------------------------\n   * * ***Allow special localhost domain at the beginning of the pathname.***\n   * --------------------------------------------------------\n   * @description\n   * If `true`, the first segment of the pathname that is `/localhost` or `localhost`\n   * (with or without a port, e.g., `localhost:3000`) will be treated as a special domain\n   * and **removed** from the normalized pathname.\n   *\n   * - **Examples (`localhostDomain: true`)**:\n   *    - `\"/localhost/path\"` ➔ `\"/path\"`\n   *    - `\"localhost:3000/path\"` ➔ `\"/path\"`\n   *    - `\"localhost\"` ➔ `\"/\"` (entire path removed)\n   *\n   * - Only the **first path segment** is affected. Any subsequent occurrences of `\"localhost\"`\n   *   will remain intact.\n   *\n   * @defaultValue `false`\n   */\n  localhostDomain?: boolean;\n\n  /**\n   * --------------------------------------------------------\n   * * ***Custom list of file extensions that prevent the first path segment from being treated as a domain.***\n   * --------------------------------------------------------\n   *\n   * **Description:**\n   * - The first segment of a pathname is often interpreted as a domain (e.g., `example.com`).\n   * - If this first segment ends with any of the extensions listed here, it will **not** be considered a domain,\n   *   and will instead be preserved as part of the relative path.\n   * - This is useful for cases where filenames appear at the start of a path and you want them treated as relative paths,\n   *   such as `\"image.png?version=2\"` or `\"archive.tar.gz#download\"`.\n   * - Only the **first path segment** is affected; all other segments are processed normally.\n   * - **Ignored** if:\n   *    1. The pathname starts with a full URL protocol (`http://` or `https://`), e.g., `\"https://example.com/file.png\"`.\n   *    2. The first path segment is already a valid domain, e.g., `\"example.com/image.png\"`.\n   *\n   * **Type & Validation:**\n   * - Must be a `Set<string>` or `string[]`.\n   * - Each string **must include the leading dot**, e.g., `.png`, `.tar.gz`.\n   * - Multi-part extensions (like `.tar.gz`, `.tar.bz`) are supported.\n   * - Throws a **TypeError** if:\n   *    1. The type is not a `Set<string>` or `string[]`.\n   *    2. Any string in the array/set is empty.\n   *    3. Any string does not start with a dot (`.`).\n   *\n   * **Usage Notes:**\n   * - Only applied when the first segment is otherwise domain-like **and** pathname is relative or domain-like without protocol.\n   * - Query strings (`?x=1`) and hash fragments (`#section`) are preserved.\n   *\n   * **Examples (relative paths, option active):**\n   * ```ts\n   * normalizePathname(\"image.png?version=2\", {\n   *   ignoreDomainExtensions: [\".png\", \".jpg\"]\n   * });\n   * // ➔ \"/image.png?version=2\"\n   *\n   * normalizePathname(\"archive.tar.gz#download\", {\n   *   ignoreDomainExtensions: new Set([\".tar.gz\"])\n   * });\n   * // ➔ \"/archive.tar.gz#download\"\n   *\n   * normalizePathname(\"script.js?module=true#top\", {\n   *   ignoreDomainExtensions: [\".js\"]\n   * });\n   * // ➔ \"/script.js?module=true#top\"\n   * ```\n   *\n   * **Examples (full URL or explicit domain - option ignored):**\n   * ```ts\n   * normalizePathname(\"https://example.com/image.png?version=2\", {\n   *   ignoreDomainExtensions: [\".png\"]\n   * });\n   * // ➔ \"/image.png?version=2\"  // URL is parsed normally; ignoreDomainExtensions has no effect\n   *\n   * normalizePathname(\"example.com/script.js?module=true#top\", {\n   *   ignoreDomainExtensions: [\".js\"]\n   * });\n   * // ➔ \"/script.js?module=true#top\"  // domain recognized; option ignored\n   * ```\n   *\n   * **Notes:**\n   * - Only the **first path segment** is checked.\n   * - Prevents false-positive domain stripping for filenames that look like domains.\n   * - Throws **TypeError** if invalid type or invalid string is provided.\n   *\n   * @defaultValue `undefined` (feature inactive if not provided)\n   */\n  ignoreDomainExtensions?: Set<string> | string[];\n};\n\n/** Options for main `normalizePathname`.\n *\n * Combines `UnKeepNullableOptions` or `KeepNullableOptions` with trailing slash control.\n */\ntype NormalizePathnameOptions = Prettify<\n  MainNormalizePathnameOptions & (UnKeepNullableOptions | KeepNullableOptions)\n>;\n\ntype NormalizePathnameOptionsKeepNullableTrue = MainNormalizePathnameOptions &\n  KeepNullableOptions;\ntype NormalizePathnameOptionsKeepNullableFalse = MainNormalizePathnameOptions &\n  UnKeepNullableOptions;\n\ntype ResUnKeepNullable<T> = T extends undefined\n  ? string\n  : T extends null\n    ? string\n    : T extends null | undefined\n      ? string\n      : string;\n\ntype ResKeepNullable<T> = T extends string\n  ? string\n  : T extends undefined\n    ? undefined\n    : T extends null\n      ? null\n      : T extends null | undefined\n        ? null | undefined\n        : string | null | undefined;\n\n/** --------------------------------------------------------\n * * ***Utility: `normalizePathname`.***\n * --------------------------------------------------------\n *\n * - **Description:**\n *    Normalizes any pathname or URL string to a clean, predictable format.\n *    Useful for routing, file paths, and URL handling.\n *    - Handles:\n *      - Leading/trailing spaces\n *      - Internal spaces in path segments\n *      - Redundant slashes (`//`)\n *      - Full URLs vs relative paths\n *      - Query (`?`) and hash (`#`) preservation\n *      - Unicode & emoji characters\n *      - Optional nullable preservation (`keepNullable`)\n *      - Optional trailing slash preservation (`keepTrailingSlash`)\n *      - Optional removal of localhost first segment (`localhostDomain`)\n *      - Prevention of false-positive domain stripping (`ignoreDomainExtensions`)\n *\n * - **Key Steps Internally:**\n *    1. Validate `options` (plain object, correct types)\n *    2. Validate `defaultPath` (non-empty string if `keepNullable` is false)\n *    3. Validate `ignoreDomainExtensions` (Set<string> | string[], each starts with `.`)\n *    4. Handle nullable:\n *       - Returns `null` / `undefined` if `keepNullable: true`\n *       - Otherwise uses `defaultPath`\n *    5. Trim spaces, remove internal spaces\n *    6. If full URL: parse using `URL` constructor\n *    7. If relative path or domain-like:\n *       - Remove `localhost`/`localhost:port` if `localhostDomain`\n *       - Remove first segment if domain-like and **not** in `ignoreDomainExtensions`\n *    8. Normalize slashes\n *    9. Ensure leading slash\n *    10. Handle trailing slash\n *    11. Decode Unicode safely\n *    12. Return normalized pathname + search + hash\n *\n * - **Error Handling:**\n *    - **TypeError**:\n *       - `defaultPath` invalid (non-string or empty) when `keepNullable: false`\n *       - `keepNullable`, `keepTrailingSlash`, `localhostDomain` not boolean\n *       - `ignoreDomainExtensions` invalid\n *    - **NormalizePathnameError** (extends ***Error***):\n *       - Invalid URL parsing\n *       - Unexpected normalization errors\n *\n * - **Options:**\n *    ```ts\n *    {\n *      // fallback if invalid path, default: \"/\"\n *      defaultPath?: string;\n *      // preserve null/undefined, default: false\n *      keepNullable?: boolean;\n *      // preserve trailing slash, default: false\n *      keepTrailingSlash?: boolean;\n *      // remove localhost:port first segment, default: false\n *      localhostDomain?: boolean;\n *      // prevent domain stripping, default: undefined\n *      ignoreDomainExtensions?: Set<string> | string[];\n *    }\n *    ```\n *\n * @example\n * // Basic path cleaning\n * normalizePathname(\"   /foo//bar  \");\n * // ➔ \"/foo/bar\"\n *\n * // Trailing slash control\n * normalizePathname(\"/api//v1//user//\", { keepTrailingSlash: true });\n * // ➔ \"/api/v1/user/\"\n * normalizePathname(\"/api//v1//user//\", { keepTrailingSlash: false });\n * // ➔ \"/api/v1/user\"\n *\n * // Full URL normalization\n * normalizePathname(\"https://example.com//path///to/resource?x=1#hash\");\n * // ➔ \"/path/to/resource?x=1#hash\"\n *\n * // Null/undefined preservation\n * normalizePathname(null, { keepNullable: true });\n * // ➔ null\n * normalizePathname(undefined, { keepNullable: true });\n * // ➔ undefined\n *\n * // Default fallback\n * normalizePathname(\"\", { defaultPath: \"/home\" });\n * // ➔ \"/home\"\n *\n * // Localhost removal\n * normalizePathname(\"localhost:3000/path/to/resource\", { localhostDomain: true });\n * // ➔ \"/path/to/resource\"\n *\n * // Prevent false-positive domain stripping\n * normalizePathname(\"archive.tar.gz#download\", { ignoreDomainExtensions: [\".tar.gz\"] });\n * // ➔ \"/archive.tar.gz#download\"\n * normalizePathname(\"image.png?version=2\", { ignoreDomainExtensions: [\".png\"] });\n * // ➔ \"/image.png?version=2\"\n *\n * // Emojis and Unicode\n * normalizePathname(\"🔥//deep//path///🚀\");\n * // ➔ \"/🔥/deep/path/🚀\"\n *\n * // Query-only or hash-only\n * normalizePathname(\"?page=2\");\n * // ➔ \"/?page=2\"\n * normalizePathname(\"#section3\");\n * // ➔ \"/#section3\"\n *\n * // Complex nested paths\n * normalizePathname(\"   //nested///folder//file.txt  \");\n * // ➔ \"/nested/folder/file.txt\"\n *\n * // Invalid URL triggers error\n * try {\n *   normalizePathname(\"http://\");\n * } catch (e) {\n *   // console.log(e);\n * }\n *\n * // First segment is domain but ignored due to extension\n * normalizePathname(\"example.tar.bz/file\", { ignoreDomainExtensions: [\".tar.bz\"] });\n * // ➔ \"/example.tar.bz/file\"\n */\nexport function normalizePathname<T>(\n  pathname: T,\n  options?: NormalizePathnameOptionsKeepNullableFalse\n): ResUnKeepNullable<T>;\nexport function normalizePathname<T>(\n  pathname: T,\n  options?: NormalizePathnameOptionsKeepNullableTrue\n): ResKeepNullable<T>;\nexport function normalizePathname(\n  pathname: unknown,\n  options: NormalizePathnameOptions = {\n    defaultPath: \"/\",\n    keepNullable: false\n  }\n): string | null | undefined {\n  assertIsPlainObject(options, {\n    message({ currentType, validType }) {\n      return `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n\n  const {\n    defaultPath = \"/\",\n    keepNullable = false,\n    keepTrailingSlash = false,\n    localhostDomain = false,\n    ignoreDomainExtensions = undefined\n  } = options;\n\n  // Validate defaultPath\n  if (!isNonEmptyString(defaultPath)) {\n    throw new TypeError(\n      `Parameter \\`defaultPath\\` property of the \\`options\\` (second parameter) must be of type \\`string\\` and not empty-string, but received: \\`${getPreciseType(\n        defaultPath\n      )}\\`, with value: \\`${safeStableStringify(defaultPath, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  assertIsBoolean(keepNullable, {\n    message({ currentType, validType }) {\n      return `Parameter \\`keepNullable\\` property of the \\`options\\` (second parameter)  must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n  assertIsBoolean(keepTrailingSlash, {\n    message({ currentType, validType }) {\n      return `Parameter \\`keepTrailingSlash\\` property of the \\`options\\` (second parameter)  must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n  assertIsBoolean(localhostDomain, {\n    message({ currentType, validType }) {\n      return `Parameter \\`localhostDomain\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n\n  let ignoreDomainExtsSet: Set<string> | undefined;\n\n  if (!isUndefined(ignoreDomainExtensions)) {\n    if (!isSet(ignoreDomainExtensions) && !isArray(ignoreDomainExtensions)) {\n      throw new TypeError(\n        `Parameter \\`ignoreDomainExtensions\\` must be of type a \\`Set<string>\\` or \\`string[]\\`, but received: \\`${getPreciseType(\n          ignoreDomainExtensions\n        )}\\`.`\n      );\n    }\n\n    ignoreDomainExtsSet = isSet(ignoreDomainExtensions)\n      ? ignoreDomainExtensions\n      : new Set(ignoreDomainExtensions);\n\n    // validation every ext\n    let idx = 0;\n    for (const ext of ignoreDomainExtsSet) {\n      if (!isNonEmptyString(ext)) {\n        throw new TypeError(\n          `Parameter \\`ignoreDomainExtensions[${idx}]\\` must be a \\`string\\` and \\`non-empty string\\`, but received: \\`${safeStableStringify(\n            ext,\n            { keepUndefined: true }\n          )}\\`.`\n        );\n      }\n      if (!ext.startsWith(\".\")) {\n        throw new TypeError(\n          `Parameter \\`ignoreDomainExtensions[${idx}]\\` must start with a dot (.), but received: ${safeStableStringify(\n            ext,\n            { keepUndefined: true }\n          )}`\n        );\n      }\n      idx++;\n    }\n  }\n\n  try {\n    if (keepNullable && (isNil(pathname) || !isString(pathname))) {\n      if (isNull(pathname)) return null;\n      return undefined;\n    }\n\n    // If the pathname is invalid (null, undefined, or an empty string), return the default value, only if `keepNullable` is false\n    let currentPathName: string = isNonEmptyString(pathname)\n      ? pathname\n      : defaultPath;\n\n    // Trim spaces from the string (only trim leading and trailing spaces)\n    currentPathName = removeSpaces(currentPathName, { trimOnly: true }).replace(\n      /\\s+/g,\n      \"\"\n    ); // remove all space\n\n    currentPathName = stripLeadingDomain(currentPathName, {\n      keepTrailingSlash,\n      localhostDomain,\n      ignoreDomainExtensions: ignoreDomainExtsSet\n    });\n\n    let _pathName: string = currentPathName;\n    let search = \"\";\n    let hash = \"\";\n\n    // relative path: extract search/hash manually\n    const searchIndex = currentPathName.indexOf(\"?\");\n    const hashIndex = currentPathName.indexOf(\"#\");\n\n    if (searchIndex !== -1) {\n      search = currentPathName.slice(\n        searchIndex,\n        hashIndex !== -1 ? hashIndex : undefined\n      );\n    }\n    if (hashIndex !== -1) {\n      hash = currentPathName.slice(hashIndex);\n    }\n\n    const endIndex = Math.min(\n      searchIndex !== -1 ? searchIndex : currentPathName.length,\n      hashIndex !== -1 ? hashIndex : currentPathName.length\n    );\n    _pathName = currentPathName.slice(0, endIndex);\n\n    // Normalize slashes\n    _pathName = \"/\" + _pathName.replace(/^\\/+/, \"\").replace(/\\/{2,}/g, \"/\");\n\n    // Trailing slash\n    // if (keepTrailingSlash && _pathName !== \"/\") {\n    // _pathName += \"/\"\n    // } else\n    if (!keepTrailingSlash && _pathName !== \"/\") {\n      _pathName = _pathName.replace(/\\/+$/, \"\");\n    }\n\n    // Decode Unicode safely\n    _pathName = decodeUnicodeSequences(_pathName);\n    search = decodeUnicodeSequences(search);\n    hash = decodeUnicodeSequences(hash);\n\n    return _pathName + search + hash;\n  } catch (error) {\n    // Handle any errors that occur during processing\n    throwError(error);\n  }\n}\n\n// --- Internal Helper Utils ----\n\n/** @internal */\nconst decodeUnicodeSequences = (str: string): string => {\n  return str.replace(/(?:%(?:[0-9A-F]{2})){2,}/gi, (match) => {\n    try {\n      const decoded = decodeURIComponent(match);\n      // eslint-disable-next-line no-control-regex\n      if (/^[\\u0000-\\u007F]+$/.test(decoded)) return match;\n      // eslint-enable-next-line no-control-regex\n      return decoded;\n    } catch {\n      return match;\n    }\n  });\n};\n/** @internal */\nconst stripLeadingDomain = (\n  path: string,\n  options: OverrideTypes<\n    MainNormalizePathnameOptions,\n    { ignoreDomainExtensions?: Set<string> }\n  >\n): string => {\n  let currentPath = path;\n\n  const { ignoreDomainExtensions, localhostDomain } = options;\n\n  // Full URL (protocol) -> only normalize path, ignore ignoreDomainExtensions\n  if (/^https?:\\/\\//i.test(currentPath)) {\n    try {\n      const url = new URL(currentPath);\n      currentPath =\n        url.pathname.replace(/^\\/+/, \"\").replace(/\\/{2,}/g, \"/\") +\n        url.search +\n        url.hash;\n\n      return ensureLeadingSlash(currentPath);\n    } catch (error) {\n      // fallback: keep as-is\n      // Handle any errors that occur during processing\n      throwError(error);\n    }\n  }\n\n  // relative path: remove leading slash\n  if (currentPath.startsWith(\"/\")) {\n    currentPath = currentPath.replace(/\\/{2,}/g, \"/\").slice(1);\n  }\n\n  // take first segment\n  const segments = currentPath.split(\"/\");\n  const firstPart = segments[0];\n  const domainPart = firstPart.split(\":\")[0];\n\n  const isDomain = isValidDomain(domainPart, {\n    subdomain: true,\n    allowUnicode: true,\n    wildcard: true,\n    allowLocalhost: localhostDomain,\n    allowPort: true,\n    allowProtocol: true,\n    topLevel: false\n  });\n\n  // ignoreDomainExtensions only applies for relative/non-protocol paths\n  let hasIgnoredExtension = false;\n  if (ignoreDomainExtensions) {\n    for (const ext of ignoreDomainExtensions) {\n      if (firstPart.endsWith(ext)) {\n        hasIgnoredExtension = true;\n        break;\n      }\n    }\n  }\n\n  if (isDomain && !hasIgnoredExtension) {\n    segments.shift(); // remove first segment\n  }\n\n  return ensureLeadingSlash(segments.join(\"/\"));\n};\n/** @internal */\nconst ensureLeadingSlash = (path: string): string => {\n  if (!path.startsWith(\"/\")) path = \"/\" + path;\n  return path;\n};\n/** @internal */\nconst throwError = (error: unknown): never => {\n  // Handle any errors that occur during processing\n  const err = isError(error)\n    ? error\n    : new Error(\"Unknown error from function `normalizePathname()`.\");\n  throw new NormalizePathnameError(\n    `Failed to normalize pathname in function \\`normalizePathname()\\`: ${err.message}`,\n    err\n  );\n};\n","import { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isEmptyString } from \"@/predicates/is/isEmptyString\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype FormatEnvPortOptions = {\n  /** Add prefix with a colon, defaultValue: `false`.\n   *\n   * @default false\n   */\n  prefixColon?: boolean;\n};\n\n/** -----------------------------------------------\n * * ***Utility: `formatEnvPort`.***\n * -----------------------------------------------\n * **Retrieves and formats an environment port variable.**\n * - **Behavior:**\n *    - Extracts only digits from the input.\n *    - If no digits found, returns an empty string.\n *    - By default does NOT prefix with a colon.\n *      - Use `{ prefixColon: true }` to prefix with a colon.\n * @param {string | null | undefined} envVar The environment variable string.\n * @param {FormatEnvPortOptions} [options] Optional object: `{ prefixColon?: boolean }`.\n * @returns {string} A string like `\":8080\"` or `\"8080\"`, or `\"\"` if no digits.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not an object or `prefixColon` is not boolean.\n * @example\n * formatEnvPort(\"port:8080\");\n * // ➔ \"8080\"\n * formatEnvPort(\"port:8080\", { prefixColon: true });\n * // ➔ \":8080\"\n */\nexport const formatEnvPort = (\n  envVar: string | null | undefined,\n  options: FormatEnvPortOptions = {}\n): string => {\n  if (!isNonEmptyString(envVar)) return \"\"; // Handle empty string case\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const prefixColon = hasOwnProp(options, \"prefixColon\")\n    ? options.prefixColon\n    : false;\n\n  if (!isBoolean(prefixColon)) {\n    throw new TypeError(\n      `Parameter \\`prefixColon\\` property of the \\`options\\` (second parameter) must be of type \\`boolean\\`, but received: \\`${getPreciseType(\n        prefixColon\n      )}\\`.`\n    );\n  }\n\n  const digitsOnly = envVar.replace(/\\D+/g, \"\");\n  if (isEmptyString(digitsOnly)) return \"\";\n\n  return prefixColon ? `:${digitsOnly}` : digitsOnly;\n};\n"],"mappings":"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"}

package/dist/formatEnvPort-hHNvOim-.cjs

@@ -1,171 +0,0 @@
-/*!
-* ========================================================================
-*  @rzl-zone/utils-js
-* ------------------------------------------------------------------------
-*  Version: `3.12.1-beta.0`
-*  Author: `Rizalvin Dwiky <rizalvindwiky@gmail.com>`
-*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/utils-js`
-* ========================================================================
-*/
-"use strict";
-const require_assertIsBoolean = require('./assertIsBoolean-DozdtbNi.cjs');
-const require_safeStableStringify = require('./safeStableStringify-Cc62pfRp.cjs');
-const require_isEmptyString = require('./isEmptyString-CCK3bP74.cjs');
-const require_isValidDomain = require('./isValidDomain-BSXshgkC.cjs');
-const require_removeSpaces = require('./removeSpaces-DRRxNWlb.cjs');
-var NormalizePathnameError = class NormalizePathnameError extends Error {
-	originalError;
-	constructor(message, originalError) {
-		super(message, require_assertIsBoolean.isFunction(Error) ? { cause: originalError } : void 0);
-		this.name = "NormalizePathnameError";
-		this.originalError = originalError;
-		if (require_assertIsBoolean.isFunction(Error.captureStackTrace)) Error.captureStackTrace(this, NormalizePathnameError);
-		else this.stack = new Error(message).stack;
-	}
-	toJSON() {
-		return {
-			name: this.name,
-			message: this.message,
-			stack: this.stack,
-			originalError: {
-				name: this.originalError.name,
-				message: this.originalError.message,
-				stack: this.originalError.stack
-			}
-		};
-	}
-};
-function normalizePathname(pathname, options = {
-	defaultPath: "/",
-	keepNullable: false
-}) {
-	require_assertIsBoolean.assertIsPlainObject(options, { message({ currentType, validType }) {
-		return `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.`;
-	} });
-	const { defaultPath = "/", keepNullable = false, keepTrailingSlash = false, localhostDomain = false, ignoreDomainExtensions = void 0 } = options;
-	if (!require_assertIsBoolean.isNonEmptyString(defaultPath)) throw new TypeError(`Parameter \`defaultPath\` property of the \`options\` (second parameter) must be of type \`string\` and not empty-string, but received: \`${require_assertIsBoolean.getPreciseType(defaultPath)}\`, with value: \`${require_safeStableStringify.safeStableStringify(defaultPath, { keepUndefined: true })}\`.`);
-	require_assertIsBoolean.assertIsBoolean(keepNullable, { message({ currentType, validType }) {
-		return `Parameter \`keepNullable\` property of the \`options\` (second parameter)  must be of type \`${validType}\`, but received: \`${currentType}\`.`;
-	} });
-	require_assertIsBoolean.assertIsBoolean(keepTrailingSlash, { message({ currentType, validType }) {
-		return `Parameter \`keepTrailingSlash\` property of the \`options\` (second parameter)  must be of type \`${validType}\`, but received: \`${currentType}\`.`;
-	} });
-	require_assertIsBoolean.assertIsBoolean(localhostDomain, { message({ currentType, validType }) {
-		return `Parameter \`localhostDomain\` property of the \`options\` (second parameter) must be of type \`${validType}\`, but received: \`${currentType}\`.`;
-	} });
-	let ignoreDomainExtsSet;
-	if (!require_assertIsBoolean.isUndefined(ignoreDomainExtensions)) {
-		if (!require_assertIsBoolean.isSet(ignoreDomainExtensions) && !require_assertIsBoolean.isArray(ignoreDomainExtensions)) throw new TypeError(`Parameter \`ignoreDomainExtensions\` must be of type a \`Set<string>\` or \`string[]\`, but received: \`${require_assertIsBoolean.getPreciseType(ignoreDomainExtensions)}\`.`);
-		ignoreDomainExtsSet = require_assertIsBoolean.isSet(ignoreDomainExtensions) ? ignoreDomainExtensions : new Set(ignoreDomainExtensions);
-		let idx = 0;
-		for (const ext of ignoreDomainExtsSet) {
-			if (!require_assertIsBoolean.isNonEmptyString(ext)) throw new TypeError(`Parameter \`ignoreDomainExtensions[${idx}]\` must be a \`string\` and \`non-empty string\`, but received: \`${require_safeStableStringify.safeStableStringify(ext, { keepUndefined: true })}\`.`);
-			if (!ext.startsWith(".")) throw new TypeError(`Parameter \`ignoreDomainExtensions[${idx}]\` must start with a dot (.), but received: ${require_safeStableStringify.safeStableStringify(ext, { keepUndefined: true })}`);
-			idx++;
-		}
-	}
-	try {
-		if (keepNullable && (require_assertIsBoolean.isNil(pathname) || !require_assertIsBoolean.isString(pathname))) {
-			if (require_assertIsBoolean.isNull(pathname)) return null;
-			return;
-		}
-		let currentPathName = require_assertIsBoolean.isNonEmptyString(pathname) ? pathname : defaultPath;
-		currentPathName = require_removeSpaces.removeSpaces(currentPathName, { trimOnly: true }).replace(/\s+/g, "");
-		currentPathName = stripLeadingDomain(currentPathName, {
-			keepTrailingSlash,
-			localhostDomain,
-			ignoreDomainExtensions: ignoreDomainExtsSet
-		});
-		let _pathName = currentPathName;
-		let search = "";
-		let hash = "";
-		const searchIndex = currentPathName.indexOf("?");
-		const hashIndex = currentPathName.indexOf("#");
-		if (searchIndex !== -1) search = currentPathName.slice(searchIndex, hashIndex !== -1 ? hashIndex : void 0);
-		if (hashIndex !== -1) hash = currentPathName.slice(hashIndex);
-		const endIndex = Math.min(searchIndex !== -1 ? searchIndex : currentPathName.length, hashIndex !== -1 ? hashIndex : currentPathName.length);
-		_pathName = currentPathName.slice(0, endIndex);
-		_pathName = "/" + _pathName.replace(/^\/+/, "").replace(/\/{2,}/g, "/");
-		if (!keepTrailingSlash && _pathName !== "/") _pathName = _pathName.replace(/\/+$/, "");
-		_pathName = decodeUnicodeSequences(_pathName);
-		search = decodeUnicodeSequences(search);
-		hash = decodeUnicodeSequences(hash);
-		return _pathName + search + hash;
-	} catch (error) {
-		throwError(error);
-	}
-}
-const decodeUnicodeSequences = (str) => {
-	return str.replace(/(?:%(?:[0-9A-F]{2})){2,}/gi, (match) => {
-		try {
-			const decoded = decodeURIComponent(match);
-			if (/^[\u0000-\u007F]+$/.test(decoded)) return match;
-			return decoded;
-		} catch {
-			return match;
-		}
-	});
-};
-const stripLeadingDomain = (path, options) => {
-	let currentPath = path;
-	const { ignoreDomainExtensions, localhostDomain } = options;
-	if (/^https?:\/\//i.test(currentPath)) try {
-		const url = new URL(currentPath);
-		currentPath = url.pathname.replace(/^\/+/, "").replace(/\/{2,}/g, "/") + url.search + url.hash;
-		return ensureLeadingSlash(currentPath);
-	} catch (error) {
-		throwError(error);
-	}
-	if (currentPath.startsWith("/")) currentPath = currentPath.replace(/\/{2,}/g, "/").slice(1);
-	const segments = currentPath.split("/");
-	const firstPart = segments[0];
-	const domainPart = firstPart.split(":")[0];
-	const isDomain = require_isValidDomain.isValidDomain(domainPart, {
-		subdomain: true,
-		allowUnicode: true,
-		wildcard: true,
-		allowLocalhost: localhostDomain,
-		allowPort: true,
-		allowProtocol: true,
-		topLevel: false
-	});
-	let hasIgnoredExtension = false;
-	if (ignoreDomainExtensions) {
-		for (const ext of ignoreDomainExtensions) if (firstPart.endsWith(ext)) {
-			hasIgnoredExtension = true;
-			break;
-		}
-	}
-	if (isDomain && !hasIgnoredExtension) segments.shift();
-	return ensureLeadingSlash(segments.join("/"));
-};
-const ensureLeadingSlash = (path) => {
-	if (!path.startsWith("/")) path = "/" + path;
-	return path;
-};
-const throwError = (error) => {
-	const err = require_assertIsBoolean.isError(error) ? error : /* @__PURE__ */ new Error("Unknown error from function `normalizePathname()`.");
-	throw new NormalizePathnameError(`Failed to normalize pathname in function \`normalizePathname()\`: ${err.message}`, err);
-};
-const formatEnvPort = (envVar, options = {}) => {
-	if (!require_assertIsBoolean.isNonEmptyString(envVar)) return "";
-	require_assertIsBoolean.assertIsPlainObject(options, { message: ({ currentType, validType }) => `Second parameter (\`options\`) must be of type \`${validType}\`, but received: \`${currentType}\`.` });
-	const prefixColon = require_assertIsBoolean.hasOwnProp(options, "prefixColon") ? options.prefixColon : false;
-	if (!require_assertIsBoolean.isBoolean(prefixColon)) throw new TypeError(`Parameter \`prefixColon\` property of the \`options\` (second parameter) must be of type \`boolean\`, but received: \`${require_assertIsBoolean.getPreciseType(prefixColon)}\`.`);
-	const digitsOnly = envVar.replace(/\D+/g, "");
-	if (require_isEmptyString.isEmptyString(digitsOnly)) return "";
-	return prefixColon ? `:${digitsOnly}` : digitsOnly;
-};
-Object.defineProperty(exports, 'formatEnvPort', {
-  enumerable: true,
-  get: function () {
-    return formatEnvPort;
-  }
-});
-Object.defineProperty(exports, 'normalizePathname', {
-  enumerable: true,
-  get: function () {
-    return normalizePathname;
-  }
-});
-//# sourceMappingURL=formatEnvPort-hHNvOim-.cjs.map

package/dist/formatEnvPort-hHNvOim-.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatEnvPort-hHNvOim-.cjs","names":["isFunction","isNonEmptyString","getPreciseType","safeStableStringify","isUndefined","isSet","isArray","isNil","isString","isNull","removeSpaces","isValidDomain","isError","isNonEmptyString","hasOwnProp","isBoolean","getPreciseType","isEmptyString"],"sources":["../src/urls/_private/NormalizePathnameError.ts","../src/urls/pathname/normalizePathname.ts","../src/urls/utils/formatEnvPort.ts"],"sourcesContent":["import { isFunction } from \"@/predicates/is/isFunction\";\n\n/** ---------------------------------\n * * ***Custom Error for Pathname Normalization Failures***\n * --------------------------------- */\nexport class NormalizePathnameError extends Error {\n  /** * ***The original error that triggered this normalization failure.***\n   *\n   * **Always available for backward compatibility.**\n   */\n  public readonly originalError: Error;\n\n  constructor(message: string, originalError: Error) {\n    // Pass a `cause` option if the runtime supports it (ignored by older engines).\n    super(message, isFunction(Error) ? { cause: originalError } : undefined);\n\n    this.name = \"NormalizePathnameError\";\n    this.originalError = originalError;\n\n    // Preserve stack trace when available (Node.js & modern browsers).\n    if (isFunction(Error.captureStackTrace)) {\n      Error.captureStackTrace(this, NormalizePathnameError);\n    } else {\n      // Fallback for very old environments.\n      this.stack = new Error(message).stack;\n    }\n  }\n\n  /** * ***Safe JSON representation for logging or IPC.*** */\n  toJSON() {\n    return {\n      name: this.name,\n      message: this.message,\n      stack: this.stack,\n      originalError: {\n        name: this.originalError.name,\n        message: this.originalError.message,\n        stack: this.originalError.stack\n      }\n    };\n  }\n}\n","import type { OverrideTypes, Prettify } from \"@rzl-zone/ts-types-plus\";\n\nimport { isSet } from \"@/predicates/is/isSet\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isNull } from \"@/predicates/is/isNull\";\nimport { isArray } from \"@/predicates/is/isArray\";\nimport { isError } from \"@/predicates/is/isError\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isValidDomain } from \"@/predicates/is/isValidDomain\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport { removeSpaces } from \"@/strings/sanitizations/removeSpaces\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\nimport { NormalizePathnameError } from \"../_private/NormalizePathnameError\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\n\n/** Options when `keepNullable` is false (default).\n *\n * Returns `defaultPath` if `pathname` is empty or invalid.\n */\ntype UnKeepNullableOptions = {\n  /** * ***Fallback value returned if `pathname` is empty-string or invalid.***\n   *\n   * Must be a **`non-empty string`**, defaultValue: `\"/\"`.\n   *\n   * @defaultValue `\"/\"`.\n   */\n  defaultPath?: string;\n\n  /** * ***Whether to preserve `null` or `undefined`, defaultValue: `false`.***\n   *\n   * @defaultValue `false`.\n   */\n  keepNullable?: false;\n};\n\n/** Options when `keepNullable` is true.\n *\n * Preserves `null` or `undefined` instead of returning `defaultPath`.\n */\ntype KeepNullableOptions = {\n  /** * ***Fallback path is ignored when `keepNullable` is true **(except if\n   * `pathname` is empty-string or invalid, even this `true`)**,\n   * defaultValue: `\"/\"`.***\n   *\n   * @defaultValue `\"/\"`.\n   */\n  defaultPath?: string;\n\n  /** * ***Preserve `null` or `undefined` as-is if `true` (defaultValue: `false`).***\n   *\n   * - ***⚠️ Notes:***\n   *      - Keep returning `defaultPath` if `pathname` is empty-string, even this `true`.\n   *\n   * **Must be `true` in this type.**\n   */\n  keepNullable?: true;\n};\n\ntype MainNormalizePathnameOptions = {\n  /** --------------------------------------------------------\n   * * ***Preserve trailing slash at the end of the normalized pathname, defaultValue: `false`.***\n   * --------------------------------------------------------\n   *\n   * @defaultValue `false`\n   */\n  keepTrailingSlash?: boolean;\n\n  /** --------------------------------------------------------\n   * * ***Allow special localhost domain at the beginning of the pathname.***\n   * --------------------------------------------------------\n   * @description\n   * If `true`, the first segment of the pathname that is `/localhost` or `localhost`\n   * (with or without a port, e.g., `localhost:3000`) will be treated as a special domain\n   * and **removed** from the normalized pathname.\n   *\n   * - **Examples (`localhostDomain: true`)**:\n   *    - `\"/localhost/path\"` ➔ `\"/path\"`\n   *    - `\"localhost:3000/path\"` ➔ `\"/path\"`\n   *    - `\"localhost\"` ➔ `\"/\"` (entire path removed)\n   *\n   * - Only the **first path segment** is affected. Any subsequent occurrences of `\"localhost\"`\n   *   will remain intact.\n   *\n   * @defaultValue `false`\n   */\n  localhostDomain?: boolean;\n\n  /**\n   * --------------------------------------------------------\n   * * ***Custom list of file extensions that prevent the first path segment from being treated as a domain.***\n   * --------------------------------------------------------\n   *\n   * **Description:**\n   * - The first segment of a pathname is often interpreted as a domain (e.g., `example.com`).\n   * - If this first segment ends with any of the extensions listed here, it will **not** be considered a domain,\n   *   and will instead be preserved as part of the relative path.\n   * - This is useful for cases where filenames appear at the start of a path and you want them treated as relative paths,\n   *   such as `\"image.png?version=2\"` or `\"archive.tar.gz#download\"`.\n   * - Only the **first path segment** is affected; all other segments are processed normally.\n   * - **Ignored** if:\n   *    1. The pathname starts with a full URL protocol (`http://` or `https://`), e.g., `\"https://example.com/file.png\"`.\n   *    2. The first path segment is already a valid domain, e.g., `\"example.com/image.png\"`.\n   *\n   * **Type & Validation:**\n   * - Must be a `Set<string>` or `string[]`.\n   * - Each string **must include the leading dot**, e.g., `.png`, `.tar.gz`.\n   * - Multi-part extensions (like `.tar.gz`, `.tar.bz`) are supported.\n   * - Throws a **TypeError** if:\n   *    1. The type is not a `Set<string>` or `string[]`.\n   *    2. Any string in the array/set is empty.\n   *    3. Any string does not start with a dot (`.`).\n   *\n   * **Usage Notes:**\n   * - Only applied when the first segment is otherwise domain-like **and** pathname is relative or domain-like without protocol.\n   * - Query strings (`?x=1`) and hash fragments (`#section`) are preserved.\n   *\n   * **Examples (relative paths, option active):**\n   * ```ts\n   * normalizePathname(\"image.png?version=2\", {\n   *   ignoreDomainExtensions: [\".png\", \".jpg\"]\n   * });\n   * // ➔ \"/image.png?version=2\"\n   *\n   * normalizePathname(\"archive.tar.gz#download\", {\n   *   ignoreDomainExtensions: new Set([\".tar.gz\"])\n   * });\n   * // ➔ \"/archive.tar.gz#download\"\n   *\n   * normalizePathname(\"script.js?module=true#top\", {\n   *   ignoreDomainExtensions: [\".js\"]\n   * });\n   * // ➔ \"/script.js?module=true#top\"\n   * ```\n   *\n   * **Examples (full URL or explicit domain - option ignored):**\n   * ```ts\n   * normalizePathname(\"https://example.com/image.png?version=2\", {\n   *   ignoreDomainExtensions: [\".png\"]\n   * });\n   * // ➔ \"/image.png?version=2\"  // URL is parsed normally; ignoreDomainExtensions has no effect\n   *\n   * normalizePathname(\"example.com/script.js?module=true#top\", {\n   *   ignoreDomainExtensions: [\".js\"]\n   * });\n   * // ➔ \"/script.js?module=true#top\"  // domain recognized; option ignored\n   * ```\n   *\n   * **Notes:**\n   * - Only the **first path segment** is checked.\n   * - Prevents false-positive domain stripping for filenames that look like domains.\n   * - Throws **TypeError** if invalid type or invalid string is provided.\n   *\n   * @defaultValue `undefined` (feature inactive if not provided)\n   */\n  ignoreDomainExtensions?: Set<string> | string[];\n};\n\n/** Options for main `normalizePathname`.\n *\n * Combines `UnKeepNullableOptions` or `KeepNullableOptions` with trailing slash control.\n */\ntype NormalizePathnameOptions = Prettify<\n  MainNormalizePathnameOptions & (UnKeepNullableOptions | KeepNullableOptions)\n>;\n\ntype NormalizePathnameOptionsKeepNullableTrue = MainNormalizePathnameOptions &\n  KeepNullableOptions;\ntype NormalizePathnameOptionsKeepNullableFalse = MainNormalizePathnameOptions &\n  UnKeepNullableOptions;\n\ntype ResUnKeepNullable<T> = T extends undefined\n  ? string\n  : T extends null\n    ? string\n    : T extends null | undefined\n      ? string\n      : string;\n\ntype ResKeepNullable<T> = T extends string\n  ? string\n  : T extends undefined\n    ? undefined\n    : T extends null\n      ? null\n      : T extends null | undefined\n        ? null | undefined\n        : string | null | undefined;\n\n/** --------------------------------------------------------\n * * ***Utility: `normalizePathname`.***\n * --------------------------------------------------------\n *\n * - **Description:**\n *    Normalizes any pathname or URL string to a clean, predictable format.\n *    Useful for routing, file paths, and URL handling.\n *    - Handles:\n *      - Leading/trailing spaces\n *      - Internal spaces in path segments\n *      - Redundant slashes (`//`)\n *      - Full URLs vs relative paths\n *      - Query (`?`) and hash (`#`) preservation\n *      - Unicode & emoji characters\n *      - Optional nullable preservation (`keepNullable`)\n *      - Optional trailing slash preservation (`keepTrailingSlash`)\n *      - Optional removal of localhost first segment (`localhostDomain`)\n *      - Prevention of false-positive domain stripping (`ignoreDomainExtensions`)\n *\n * - **Key Steps Internally:**\n *    1. Validate `options` (plain object, correct types)\n *    2. Validate `defaultPath` (non-empty string if `keepNullable` is false)\n *    3. Validate `ignoreDomainExtensions` (Set<string> | string[], each starts with `.`)\n *    4. Handle nullable:\n *       - Returns `null` / `undefined` if `keepNullable: true`\n *       - Otherwise uses `defaultPath`\n *    5. Trim spaces, remove internal spaces\n *    6. If full URL: parse using `URL` constructor\n *    7. If relative path or domain-like:\n *       - Remove `localhost`/`localhost:port` if `localhostDomain`\n *       - Remove first segment if domain-like and **not** in `ignoreDomainExtensions`\n *    8. Normalize slashes\n *    9. Ensure leading slash\n *    10. Handle trailing slash\n *    11. Decode Unicode safely\n *    12. Return normalized pathname + search + hash\n *\n * - **Error Handling:**\n *    - **TypeError**:\n *       - `defaultPath` invalid (non-string or empty) when `keepNullable: false`\n *       - `keepNullable`, `keepTrailingSlash`, `localhostDomain` not boolean\n *       - `ignoreDomainExtensions` invalid\n *    - **NormalizePathnameError** (extends ***Error***):\n *       - Invalid URL parsing\n *       - Unexpected normalization errors\n *\n * - **Options:**\n *    ```ts\n *    {\n *      // fallback if invalid path, default: \"/\"\n *      defaultPath?: string;\n *      // preserve null/undefined, default: false\n *      keepNullable?: boolean;\n *      // preserve trailing slash, default: false\n *      keepTrailingSlash?: boolean;\n *      // remove localhost:port first segment, default: false\n *      localhostDomain?: boolean;\n *      // prevent domain stripping, default: undefined\n *      ignoreDomainExtensions?: Set<string> | string[];\n *    }\n *    ```\n *\n * @example\n * // Basic path cleaning\n * normalizePathname(\"   /foo//bar  \");\n * // ➔ \"/foo/bar\"\n *\n * // Trailing slash control\n * normalizePathname(\"/api//v1//user//\", { keepTrailingSlash: true });\n * // ➔ \"/api/v1/user/\"\n * normalizePathname(\"/api//v1//user//\", { keepTrailingSlash: false });\n * // ➔ \"/api/v1/user\"\n *\n * // Full URL normalization\n * normalizePathname(\"https://example.com//path///to/resource?x=1#hash\");\n * // ➔ \"/path/to/resource?x=1#hash\"\n *\n * // Null/undefined preservation\n * normalizePathname(null, { keepNullable: true });\n * // ➔ null\n * normalizePathname(undefined, { keepNullable: true });\n * // ➔ undefined\n *\n * // Default fallback\n * normalizePathname(\"\", { defaultPath: \"/home\" });\n * // ➔ \"/home\"\n *\n * // Localhost removal\n * normalizePathname(\"localhost:3000/path/to/resource\", { localhostDomain: true });\n * // ➔ \"/path/to/resource\"\n *\n * // Prevent false-positive domain stripping\n * normalizePathname(\"archive.tar.gz#download\", { ignoreDomainExtensions: [\".tar.gz\"] });\n * // ➔ \"/archive.tar.gz#download\"\n * normalizePathname(\"image.png?version=2\", { ignoreDomainExtensions: [\".png\"] });\n * // ➔ \"/image.png?version=2\"\n *\n * // Emojis and Unicode\n * normalizePathname(\"🔥//deep//path///🚀\");\n * // ➔ \"/🔥/deep/path/🚀\"\n *\n * // Query-only or hash-only\n * normalizePathname(\"?page=2\");\n * // ➔ \"/?page=2\"\n * normalizePathname(\"#section3\");\n * // ➔ \"/#section3\"\n *\n * // Complex nested paths\n * normalizePathname(\"   //nested///folder//file.txt  \");\n * // ➔ \"/nested/folder/file.txt\"\n *\n * // Invalid URL triggers error\n * try {\n *   normalizePathname(\"http://\");\n * } catch (e) {\n *   // console.log(e);\n * }\n *\n * // First segment is domain but ignored due to extension\n * normalizePathname(\"example.tar.bz/file\", { ignoreDomainExtensions: [\".tar.bz\"] });\n * // ➔ \"/example.tar.bz/file\"\n */\nexport function normalizePathname<T>(\n  pathname: T,\n  options?: NormalizePathnameOptionsKeepNullableFalse\n): ResUnKeepNullable<T>;\nexport function normalizePathname<T>(\n  pathname: T,\n  options?: NormalizePathnameOptionsKeepNullableTrue\n): ResKeepNullable<T>;\nexport function normalizePathname(\n  pathname: unknown,\n  options: NormalizePathnameOptions = {\n    defaultPath: \"/\",\n    keepNullable: false\n  }\n): string | null | undefined {\n  assertIsPlainObject(options, {\n    message({ currentType, validType }) {\n      return `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n\n  const {\n    defaultPath = \"/\",\n    keepNullable = false,\n    keepTrailingSlash = false,\n    localhostDomain = false,\n    ignoreDomainExtensions = undefined\n  } = options;\n\n  // Validate defaultPath\n  if (!isNonEmptyString(defaultPath)) {\n    throw new TypeError(\n      `Parameter \\`defaultPath\\` property of the \\`options\\` (second parameter) must be of type \\`string\\` and not empty-string, but received: \\`${getPreciseType(\n        defaultPath\n      )}\\`, with value: \\`${safeStableStringify(defaultPath, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  assertIsBoolean(keepNullable, {\n    message({ currentType, validType }) {\n      return `Parameter \\`keepNullable\\` property of the \\`options\\` (second parameter)  must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n  assertIsBoolean(keepTrailingSlash, {\n    message({ currentType, validType }) {\n      return `Parameter \\`keepTrailingSlash\\` property of the \\`options\\` (second parameter)  must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n  assertIsBoolean(localhostDomain, {\n    message({ currentType, validType }) {\n      return `Parameter \\`localhostDomain\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`;\n    }\n  });\n\n  let ignoreDomainExtsSet: Set<string> | undefined;\n\n  if (!isUndefined(ignoreDomainExtensions)) {\n    if (!isSet(ignoreDomainExtensions) && !isArray(ignoreDomainExtensions)) {\n      throw new TypeError(\n        `Parameter \\`ignoreDomainExtensions\\` must be of type a \\`Set<string>\\` or \\`string[]\\`, but received: \\`${getPreciseType(\n          ignoreDomainExtensions\n        )}\\`.`\n      );\n    }\n\n    ignoreDomainExtsSet = isSet(ignoreDomainExtensions)\n      ? ignoreDomainExtensions\n      : new Set(ignoreDomainExtensions);\n\n    // validation every ext\n    let idx = 0;\n    for (const ext of ignoreDomainExtsSet) {\n      if (!isNonEmptyString(ext)) {\n        throw new TypeError(\n          `Parameter \\`ignoreDomainExtensions[${idx}]\\` must be a \\`string\\` and \\`non-empty string\\`, but received: \\`${safeStableStringify(\n            ext,\n            { keepUndefined: true }\n          )}\\`.`\n        );\n      }\n      if (!ext.startsWith(\".\")) {\n        throw new TypeError(\n          `Parameter \\`ignoreDomainExtensions[${idx}]\\` must start with a dot (.), but received: ${safeStableStringify(\n            ext,\n            { keepUndefined: true }\n          )}`\n        );\n      }\n      idx++;\n    }\n  }\n\n  try {\n    if (keepNullable && (isNil(pathname) || !isString(pathname))) {\n      if (isNull(pathname)) return null;\n      return undefined;\n    }\n\n    // If the pathname is invalid (null, undefined, or an empty string), return the default value, only if `keepNullable` is false\n    let currentPathName: string = isNonEmptyString(pathname)\n      ? pathname\n      : defaultPath;\n\n    // Trim spaces from the string (only trim leading and trailing spaces)\n    currentPathName = removeSpaces(currentPathName, { trimOnly: true }).replace(\n      /\\s+/g,\n      \"\"\n    ); // remove all space\n\n    currentPathName = stripLeadingDomain(currentPathName, {\n      keepTrailingSlash,\n      localhostDomain,\n      ignoreDomainExtensions: ignoreDomainExtsSet\n    });\n\n    let _pathName: string = currentPathName;\n    let search = \"\";\n    let hash = \"\";\n\n    // relative path: extract search/hash manually\n    const searchIndex = currentPathName.indexOf(\"?\");\n    const hashIndex = currentPathName.indexOf(\"#\");\n\n    if (searchIndex !== -1) {\n      search = currentPathName.slice(\n        searchIndex,\n        hashIndex !== -1 ? hashIndex : undefined\n      );\n    }\n    if (hashIndex !== -1) {\n      hash = currentPathName.slice(hashIndex);\n    }\n\n    const endIndex = Math.min(\n      searchIndex !== -1 ? searchIndex : currentPathName.length,\n      hashIndex !== -1 ? hashIndex : currentPathName.length\n    );\n    _pathName = currentPathName.slice(0, endIndex);\n\n    // Normalize slashes\n    _pathName = \"/\" + _pathName.replace(/^\\/+/, \"\").replace(/\\/{2,}/g, \"/\");\n\n    // Trailing slash\n    // if (keepTrailingSlash && _pathName !== \"/\") {\n    // _pathName += \"/\"\n    // } else\n    if (!keepTrailingSlash && _pathName !== \"/\") {\n      _pathName = _pathName.replace(/\\/+$/, \"\");\n    }\n\n    // Decode Unicode safely\n    _pathName = decodeUnicodeSequences(_pathName);\n    search = decodeUnicodeSequences(search);\n    hash = decodeUnicodeSequences(hash);\n\n    return _pathName + search + hash;\n  } catch (error) {\n    // Handle any errors that occur during processing\n    throwError(error);\n  }\n}\n\n// --- Internal Helper Utils ----\n\n/** @internal */\nconst decodeUnicodeSequences = (str: string): string => {\n  return str.replace(/(?:%(?:[0-9A-F]{2})){2,}/gi, (match) => {\n    try {\n      const decoded = decodeURIComponent(match);\n      // eslint-disable-next-line no-control-regex\n      if (/^[\\u0000-\\u007F]+$/.test(decoded)) return match;\n      // eslint-enable-next-line no-control-regex\n      return decoded;\n    } catch {\n      return match;\n    }\n  });\n};\n/** @internal */\nconst stripLeadingDomain = (\n  path: string,\n  options: OverrideTypes<\n    MainNormalizePathnameOptions,\n    { ignoreDomainExtensions?: Set<string> }\n  >\n): string => {\n  let currentPath = path;\n\n  const { ignoreDomainExtensions, localhostDomain } = options;\n\n  // Full URL (protocol) -> only normalize path, ignore ignoreDomainExtensions\n  if (/^https?:\\/\\//i.test(currentPath)) {\n    try {\n      const url = new URL(currentPath);\n      currentPath =\n        url.pathname.replace(/^\\/+/, \"\").replace(/\\/{2,}/g, \"/\") +\n        url.search +\n        url.hash;\n\n      return ensureLeadingSlash(currentPath);\n    } catch (error) {\n      // fallback: keep as-is\n      // Handle any errors that occur during processing\n      throwError(error);\n    }\n  }\n\n  // relative path: remove leading slash\n  if (currentPath.startsWith(\"/\")) {\n    currentPath = currentPath.replace(/\\/{2,}/g, \"/\").slice(1);\n  }\n\n  // take first segment\n  const segments = currentPath.split(\"/\");\n  const firstPart = segments[0];\n  const domainPart = firstPart.split(\":\")[0];\n\n  const isDomain = isValidDomain(domainPart, {\n    subdomain: true,\n    allowUnicode: true,\n    wildcard: true,\n    allowLocalhost: localhostDomain,\n    allowPort: true,\n    allowProtocol: true,\n    topLevel: false\n  });\n\n  // ignoreDomainExtensions only applies for relative/non-protocol paths\n  let hasIgnoredExtension = false;\n  if (ignoreDomainExtensions) {\n    for (const ext of ignoreDomainExtensions) {\n      if (firstPart.endsWith(ext)) {\n        hasIgnoredExtension = true;\n        break;\n      }\n    }\n  }\n\n  if (isDomain && !hasIgnoredExtension) {\n    segments.shift(); // remove first segment\n  }\n\n  return ensureLeadingSlash(segments.join(\"/\"));\n};\n/** @internal */\nconst ensureLeadingSlash = (path: string): string => {\n  if (!path.startsWith(\"/\")) path = \"/\" + path;\n  return path;\n};\n/** @internal */\nconst throwError = (error: unknown): never => {\n  // Handle any errors that occur during processing\n  const err = isError(error)\n    ? error\n    : new Error(\"Unknown error from function `normalizePathname()`.\");\n  throw new NormalizePathnameError(\n    `Failed to normalize pathname in function \\`normalizePathname()\\`: ${err.message}`,\n    err\n  );\n};\n","import { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isEmptyString } from \"@/predicates/is/isEmptyString\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype FormatEnvPortOptions = {\n  /** Add prefix with a colon, defaultValue: `false`.\n   *\n   * @default false\n   */\n  prefixColon?: boolean;\n};\n\n/** -----------------------------------------------\n * * ***Utility: `formatEnvPort`.***\n * -----------------------------------------------\n * **Retrieves and formats an environment port variable.**\n * - **Behavior:**\n *    - Extracts only digits from the input.\n *    - If no digits found, returns an empty string.\n *    - By default does NOT prefix with a colon.\n *      - Use `{ prefixColon: true }` to prefix with a colon.\n * @param {string | null | undefined} envVar The environment variable string.\n * @param {FormatEnvPortOptions} [options] Optional object: `{ prefixColon?: boolean }`.\n * @returns {string} A string like `\":8080\"` or `\"8080\"`, or `\"\"` if no digits.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not an object or `prefixColon` is not boolean.\n * @example\n * formatEnvPort(\"port:8080\");\n * // ➔ \"8080\"\n * formatEnvPort(\"port:8080\", { prefixColon: true });\n * // ➔ \":8080\"\n */\nexport const formatEnvPort = (\n  envVar: string | null | undefined,\n  options: FormatEnvPortOptions = {}\n): string => {\n  if (!isNonEmptyString(envVar)) return \"\"; // Handle empty string case\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const prefixColon = hasOwnProp(options, \"prefixColon\")\n    ? options.prefixColon\n    : false;\n\n  if (!isBoolean(prefixColon)) {\n    throw new TypeError(\n      `Parameter \\`prefixColon\\` property of the \\`options\\` (second parameter) must be of type \\`boolean\\`, but received: \\`${getPreciseType(\n        prefixColon\n      )}\\`.`\n    );\n  }\n\n  const digitsOnly = envVar.replace(/\\D+/g, \"\");\n  if (isEmptyString(digitsOnly)) return \"\";\n\n  return prefixColon ? `:${digitsOnly}` : digitsOnly;\n};\n"],"mappings":"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"}

package/dist/formatters-QcZO_Cpx.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatters-QcZO_Cpx.js","names":["format","formatDns"],"sources":["../src/formatters/currencies/formatCurrency.ts","../src/formatters/numbers/formatNumber.ts","../src/formatters/phones/_private/formatPhoneNumber.utils.ts","../src/formatters/phones/formatPhoneNumber.ts","../src/formatters/strings/_private/censorEmail.utils.ts","../src/formatters/strings/censorEmail.ts","../src/formatters/strings/chunkString.ts","../src/formatters/strings/truncateString.ts","../src/formatters/times/formatDateFns.ts","../src/formatters/times/formatDateIntl.ts","../src/formatters/times/formatDateTime.ts","../src/formatters/times/getGMTOffset.ts"],"sourcesContent":["import type { FormatCurrencyOptions } from \"@/formatters/currencies/formatCurrency.types\";\n\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isFinite } from \"@/predicates/is/isFinite\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isInteger } from \"@/predicates/is/isInteger\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { isFunction } from \"@/predicates/is/isFunction\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport { parseCurrencyString } from \"@/conversions/currency/parsing\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\n/** @private ***Util helper for {@link formatCurrency}.*** */\nconst formatIndianNumber = ({\n  numStr,\n  separator\n}: {\n  numStr?: string;\n  separator: string;\n}) => {\n  const lastThree = numStr?.slice(-3);\n  const rest = numStr?.slice(0, -3);\n  if (!rest) return lastThree;\n  return (\n    rest.replace(/\\B(?=(\\d{2})+(?!\\d))/g, separator) + separator + lastThree\n  );\n};\n\n/** -------------------------------------------------------\n * * ***Utility: `formatCurrency`.***\n * -------------------------------------------------------\n * **Formats a number or messy currency string into a\n *   beautifully formatted currency string, with highly\n *   customizable separators, decimal control, rounding,\n *   currency symbols, and negative styling.**\n * - **✅ Highlights:**\n *    - ***Accepts:***\n *        - Pure numbers: `15300.95`.\n *        - Messy currency strings from **any locale**:\n *          - `\"Rp 15.000,21\"` ***(Indonesian / Euro)***.\n *          - `\"$12,345.60\"` ***(US)***.\n *          - `\"CHF 12'345.60\"` ***(Swiss)***.\n *          - `\"1,23,456.78\"` ***(Indian)***.\n * - Auto extracts numeric value with smart multi-locale parsing\n *   via ***`parseCurrencyString` utility function***.\n * - Strong type checks & clear errors for misconfigured options.\n * - **Handles:**\n *    - Thousands separators: `.`, `,`, `'`, ` `.\n *    - Decimal separators: `,`, `.`.\n *    - Decimal suffix (eg. `\".-\"`, `\" USD\"`).\n *    - Currency prefix (eg. `\"Rp \"`, `\"$ \"`).\n *    - Rounding: `\"round\"`, `\"ceil\"`, `\"floor\"`, or truncate.\n *    - Negative styling: dash `-`, brackets `( )`, absolute, or custom.\n * - **✅ How input is parsed:**\n *    - Removes all non-digit except `.`, `,`, `'` and spaces.\n *    - Detects bracket negatives: `\"(15.000,10)\"` ➔ `-15000.10`.\n *    - Uses last `,` or `.` as decimal separator (others are thousands).\n *    - Ignores currency symbols like `Rp`, `$` (must re-apply with `suffixCurrency`).\n * - **ℹ️ Note:**\n *    - Always re-apply symbols via `suffixCurrency`.\n *    - `parseCurrencyString` smartly detects last decimal,\n *   so `\"1.121.234,56\"` and `\"1,121,234.56\"` both parsed correctly.\n * @param {string|number} value\n *  ***The input value to format, examples:***\n *    - `\"Rp 15.000,21\"`.\n *    - `\"$12,345.60\"`.\n *    - `\"CHF 12'345.60\"`.\n *    - `15300.95`.\n * @param {FormatCurrencyOptions} [options] ***Optional configuration object.***\n * @param {FormatCurrencyOptions[\"separator\"]} [options.separator]\n *  ***Thousands separator:***\n *    - `{ separator: \".\" }` ➔ `1.000.000`.\n *    - *DefaultValue: `\".\"`.*\n * @param {FormatCurrencyOptions[\"separatorDecimals\"]} [options.separatorDecimals]\n *  ***Decimal separator:***\n *    - `{ separatorDecimals: \",\" }` ➔ `1.000,10`.\n *    - *DefaultValue: `\",\"`.*\n * @param {FormatCurrencyOptions[\"suffixCurrency\"]} [options.suffixCurrency]\n *  ***Prefix currency string:***\n *    - Does **not auto-keep input symbols**.\n *    - Must set manually e.g: `{ suffixCurrency: \"Rp \" }`.\n *        - `{ suffixCurrency: \"Rp \" }` ➔ `Rp 1.000`.\n *    - *DefaultValue: `\"\"`.*\n * @param {FormatCurrencyOptions[\"decimal\"]} [options.decimal]\n *  ***Whether to show decimals. If `false`, decimals are truncated:***\n *    - If `false`, cut the decimal.\n *    - *DefaultValue: `false`.*\n * @param {FormatCurrencyOptions[\"totalDecimal\"]} [options.totalDecimal]\n *  ***Total decimal digits:***\n *    - If `decimal: true` & `roundedDecimal: false`, simply cuts.\n *    - *DefaultValue: `2`.*\n * @param {FormatCurrencyOptions[\"separatorDecimals\"]} [options.suffixDecimal]\n *  ***Text appended after decimals:***\n *    - E.g: (`\".-\"`, `\" USD\"`).\n *    - Example 1: `\".-\"` ➔ `1.000,00.-`.\n *    - Example 2: `\" USD\"` ➔ `1.000,00 USD`.\n *    - *DefaultValue: `\"\"`.*\n * @param {FormatCurrencyOptions[\"endDecimal\"]} [options.endDecimal]\n *  ***Actually append `suffixDecimal`:***\n *    - *DefaultValue: `true`.*\n * @param {FormatCurrencyOptions[\"roundedDecimal\"]} [options.roundedDecimal]\n *  ***Rounding mode:***\n *    - `\"round\"` ➔ nearest.\n *    - `\"ceil\"` ➔ always up.\n *    - `\"floor\"` ➔ always down.\n *    - `false` ➔ truncate.\n *    - *DefaultValue: `\"round\"`.*\n * @param {FormatCurrencyOptions[\"negativeFormat\"]} [options.negativeFormat]\n *  ***How to format negatives:***\n *    - `\"dash\"` ➔ `-15.000`.\n *    - `\"brackets\"` ➔ `(15.000)`.\n *    - `\"abs\"` ➔ `15.000` (always positive).\n *    - Or object: `{ style: \"dash\" | \"brackets\" | \"abs\", space: true | false, custom: (formatted) => string }`.\n *    - *DefaultValue: `\"dash\"`.*\n * @param {FormatCurrencyOptions[\"indianFormat\"]} [options.indianFormat]\n *  ***Applies Indian Format:***\n *    - If `true`, formats as Indian: `12,34,567`.\n *    - Also forces `separator: \",\"`, `separatorDecimals: \".\"`.\n * @returns {string}\n *  ***Nicely formatted currency string, examples:***\n *    - `\"15.000,10\"`.\n *    - `\"Rp 15.000,10.-\"`.\n *    - `\"15'000.10 USD\"`.\n *    - `\"12,34,567.89\"`.\n * @throws **{@link TypeError | `TypeError`}** ***If:***\n *    - The `value` is not string or number.\n *    - Cannot parse to valid number.\n *    - Options have invalid types.\n * @example\n * // --- Number input (default, decimals off) ---\n * formatCurrency(1234567.89);\n * // ➔ \"1.234.567\"\n *\n * // --- Decimals enabled ---\n * formatCurrency(1234567.89, { decimal: true });\n * // ➔ \"1.234.567,89\"\n *\n * // --- Indian format ---\n * formatCurrency(1234567.89, { decimal: true, indianFormat: true });\n * // ➔ \"12,34,567.89\"\n *\n * // --- String input (Indonesian style) ---\n * formatCurrency(\"Rp 15.000,21\", { decimal: true });\n * // ➔ \"15.000,21\"\n *\n * // --- String input (US style) ---\n * formatCurrency(\"$12,345.60\", { decimal: true });\n * // ➔ \"12.345,60\"\n *\n * // --- String input (Swiss style) ---\n * formatCurrency(\"CHF 12'345.60\", { decimal: true });\n * // ➔ \"12'345,60\"\n *\n * // --- String input (Indian style) ---\n * formatCurrency(\"1,23,456.78\", { decimal: true, indianFormat: true });\n * // ➔ \"12,34,567.78\"\n *\n * // --- Negative numbers (dash) ---\n * formatCurrency(-1234.56, { decimal: true });\n * // ➔ \"-1.234,56\"\n *\n * // --- Negative numbers (brackets) ---\n * formatCurrency(-1234.56, {\n *   decimal: true,\n *   negativeFormat: \"brackets\"\n * });\n * // ➔ \"(1.234,56)\"\n *\n * // --- Negative numbers (custom object style) ---\n * formatCurrency(-1234.56, {\n *   decimal: true,\n *   negativeFormat: { style: \"brackets\", space: true }\n * });\n * // ➔ \"( 1.234,56 )\"\n *\n * // --- Negative numbers (custom function) ---\n * formatCurrency(-1234.56, {\n *   decimal: true,\n *   negativeFormat: { custom: (val) => `NEGATIVE[${val}]` }\n * });\n * // ➔ \"NEGATIVE[1.234,56]\"\n *\n * // --- With prefix currency ---\n * formatCurrency(1234.56, {\n *   decimal: true,\n *   suffixCurrency: \"Rp \"\n * });\n * // ➔ \"Rp 1.234,56\"\n *\n * // --- With suffix decimal ---\n * formatCurrency(1234.56, {\n *   decimal: true,\n *   suffixDecimal: \".-\"\n * });\n * // ➔ \"1.234,56.-\"\n *\n * // --- With suffix currency + suffix decimal ---\n * formatCurrency(1234.56, {\n *   decimal: true,\n *   suffixCurrency: \"Rp \",\n *   suffixDecimal: \".-\"\n * });\n * // ➔ \"Rp 1.234,56.-\"\n *\n * // --- Custom separators ---\n * formatCurrency(1234567.89, {\n *   decimal: true,\n *   separator: \"'\",\n *   separatorDecimals: \".\"\n * });\n * // ➔ \"1'234'567.89\"\n *\n * // --- Rounding: ceil ---\n * formatCurrency(1234.561, {\n *   decimal: true,\n *   roundedDecimal: \"ceil\"\n * });\n * // ➔ \"1.234,57\"\n *\n * // --- Rounding: floor ---\n * formatCurrency(1234.569, {\n *   decimal: true,\n *   roundedDecimal: \"floor\"\n * });\n * // ➔ \"1.234,56\"\n *\n * // --- Rounding: truncate (false) ---\n * formatCurrency(1234.569, {\n *   decimal: true,\n *   roundedDecimal: false\n * });\n * // ➔ \"1.234,56\"\n *\n * // --- Force no decimals (decimal: false) ---\n * formatCurrency(1234.567, { decimal: false });\n * // ➔ \"1.235\"\n *\n * // --- Edge case: messy input with dots & commas ---\n * formatCurrency(\"1.121.234,561\", {\n *   decimal: true,\n *   totalDecimal: 2,\n *   roundedDecimal: \"ceil\",\n *   suffixCurrency: \"Rp \",\n *   negativeFormat: { style: \"brackets\" }\n * });\n * // ➔ \"(Rp 1.121.234,57)\"\n *\n * // --- Edge case: integer string input ---\n * formatCurrency(\"1.121.234\", {\n *   decimal: true,\n *   suffixCurrency: \"Rp \",\n *   roundedDecimal: \"ceil\"\n * });\n * // ➔ \"Rp 1.121.234,00\"\n */\nexport const formatCurrency = (\n  value: string | number,\n  options: FormatCurrencyOptions = {}\n): string => {\n  if (!isString(value) && !isFinite(value)) {\n    throw new TypeError(\n      `First parameter (\\`value\\`) must be of type \\`string\\` or \\`primitive-number\\`, but received: \\`${getPreciseType(\n        value\n      )}\\`, with value: \\`${safeStableStringify(value, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const decimal = hasOwnProp(options, \"decimal\") ? options.decimal : false;\n  const totalDecimal = hasOwnProp(options, \"totalDecimal\")\n    ? options.totalDecimal\n    : 2;\n  const endDecimal = hasOwnProp(options, \"endDecimal\")\n    ? options.endDecimal\n    : true;\n  const indianFormat = hasOwnProp(options, \"indianFormat\")\n    ? options.indianFormat\n    : false;\n  const suffixCurrency = hasOwnProp(options, \"suffixCurrency\")\n    ? options.suffixCurrency\n    : \"\";\n  const suffixDecimal = hasOwnProp(options, \"suffixDecimal\")\n    ? options.suffixDecimal\n    : \"\";\n  const roundedDecimal = hasOwnProp(options, \"roundedDecimal\")\n    ? options.roundedDecimal\n    : \"round\";\n  const negativeFormat = hasOwnProp(options, \"negativeFormat\")\n    ? options.negativeFormat\n    : \"dash\";\n  let separatorDecimals = hasOwnProp(options, \"separatorDecimals\")\n    ? options.separatorDecimals\n    : \",\";\n  let separator = hasOwnProp(options, \"separator\") ? options.separator : \".\";\n\n  // validations\n  if (\n    !isString(separator) ||\n    !isString(separatorDecimals) ||\n    !isString(suffixCurrency) ||\n    !isString(suffixDecimal)\n  ) {\n    throw new TypeError(\n      `Parameter \\`separator\\`, \\`separatorDecimals\\`, \\`suffixCurrency\\` and \\`suffixDecimal\\` property of the \\`options\\` (second parameter) must be of type \\`string\\`, but received: ['separator': \\`${getPreciseType(\n        separator\n      )}\\`, 'separatorDecimals': \\`${getPreciseType(\n        separatorDecimals\n      )}\\`, 'suffixCurrency': \\`${getPreciseType(\n        suffixCurrency\n      )}\\`, 'suffixDecimal': \\`${getPreciseType(suffixDecimal)}\\`].`\n    );\n  }\n\n  if (\n    !isBoolean(decimal) ||\n    !isBoolean(endDecimal) ||\n    !isBoolean(indianFormat)\n  ) {\n    throw new TypeError(\n      `Parameter \\`decimal\\`, \\`endDecimal\\` and \\`indianFormat\\` property of the \\`options\\` (second parameter) must be of type \\`boolean\\`, but received: ['decimal': \\`${getPreciseType(\n        decimal\n      )}\\`, 'endDecimal': \\`${getPreciseType(\n        endDecimal\n      )}\\`, 'indianFormat': \\`${getPreciseType(indianFormat)}\\`].`\n    );\n  }\n\n  if (!isInteger(totalDecimal)) {\n    throw new TypeError(\n      `Parameter \\`totalDecimal\\` property of the \\`options\\` (second parameter) must be of type \\`integer-number\\`, but received: \\`${getPreciseType(\n        totalDecimal\n      )}\\`, with value: \\`${safeStableStringify(length, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  if (\n    !(\n      roundedDecimal === false ||\n      roundedDecimal === \"round\" ||\n      roundedDecimal === \"ceil\" ||\n      roundedDecimal === \"floor\"\n    )\n  ) {\n    throw new TypeError(\n      `Parameter \\`roundedDecimal\\` property of the \\`options\\` (second parameter) must be of type \\`false\\` or \\`string\\` must be one of \"round\" | \"ceil\" | \"floor\", but received: \\`${getPreciseType(\n        roundedDecimal\n      )}\\`, with value: \\`${safeStableStringify(roundedDecimal, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  if (\n    !(\n      negativeFormat === \"abs\" ||\n      negativeFormat === \"brackets\" ||\n      negativeFormat === \"dash\" ||\n      isPlainObject(negativeFormat)\n    )\n  ) {\n    throw new TypeError(\n      `Parameter \\`negativeFormat\\` property of the \\`options\\` (second parameter) must be of type \\`string\\` must be one of \"abs\" | \"brackets\" | \"dash\" or \\`plain-object\\` type, but received: \\`${getPreciseType(\n        negativeFormat\n      )}\\`, with value: \\`${safeStableStringify(negativeFormat, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  // parse number\n  const rawNum = isString(value) ? parseCurrencyString(value) : value;\n  if (isNaN(rawNum)) {\n    throw new TypeError(\n      \"First parameter (`value`) could not be parsed into a valid `number`.\"\n    );\n  }\n\n  let integerPart: string | undefined;\n  let decimalPartRaw: string | undefined;\n  let num = Math.abs(rawNum);\n  const factor = Math.pow(10, totalDecimal);\n\n  if (roundedDecimal) {\n    const scaled = num * factor;\n    switch (roundedDecimal) {\n      case \"round\":\n        num = Math.round(scaled) / factor;\n        break;\n      case \"ceil\":\n        num = Math.ceil(scaled) / factor;\n        break;\n      case \"floor\":\n        num = Math.floor(scaled) / factor;\n        break;\n    }\n  }\n\n  if (roundedDecimal) {\n    [integerPart, decimalPartRaw] = num.toFixed(totalDecimal).split(\".\");\n    decimalPartRaw = decimalPartRaw ?? \"\".padEnd(totalDecimal, \"0\");\n  } else {\n    // cut decimal manually\n    const split = String(num).split(\".\");\n    integerPart = split[0];\n    decimalPartRaw = (split[1] || \"\")\n      .slice(0, totalDecimal)\n      .padEnd(totalDecimal, \"0\");\n  }\n\n  let formattedInteger: string;\n\n  if (indianFormat) {\n    separator = \",\";\n    separatorDecimals = \".\";\n    formattedInteger =\n      (suffixCurrency.trim().length ? suffixCurrency : \"\") +\n      formatIndianNumber({ numStr: integerPart, separator });\n  } else {\n    formattedInteger =\n      (suffixCurrency.trim().length ? suffixCurrency : \"\") +\n      integerPart?.replace(/\\B(?=(\\d{3})+(?!\\d))/g, separator);\n  }\n\n  if (decimal && !isUndefined(decimalPartRaw) && totalDecimal > 0) {\n    let formattedDecimal = separatorDecimals + decimalPartRaw;\n    if (endDecimal) formattedDecimal += suffixDecimal;\n    formattedInteger += formattedDecimal;\n  }\n\n  // negative format\n  if (rawNum < 0) {\n    if (negativeFormat === \"dash\") {\n      formattedInteger = \"-\" + formattedInteger;\n    } else if (negativeFormat === \"brackets\") {\n      formattedInteger = \"(\" + formattedInteger + \")\";\n    } else if (negativeFormat === \"abs\") {\n      // no sign\n    } else if (isPlainObject(negativeFormat)) {\n      if (hasOwnProp(negativeFormat, \"custom\")) {\n        const formatCustomNegative = negativeFormat.custom;\n\n        if (!isFunction(formatCustomNegative)) {\n          throw new TypeError(\n            `Parameter \\`negativeFormat.custom\\` property of the \\`options\\` (second parameter) must be of type function: \\`(formatted: string) => string\\`, but received: \\`${getPreciseType(\n              formatCustomNegative\n            )}\\`.`\n          );\n        }\n\n        const result = formatCustomNegative(formattedInteger);\n\n        assertIsString(result, {\n          message: ({ currentType, validType }) =>\n            `Parameter \\`negativeFormat.custom\\` property of the \\`options\\` (second parameter) expected return a \\`${validType}\\` type value, but received: \\`${currentType}\\`.`\n        });\n\n        formattedInteger = result;\n      } else {\n        const formatStyleNegative = negativeFormat.style || \"dash\";\n        const formatSpaceNegative = !isUndefined(negativeFormat.space)\n          ? negativeFormat.space\n          : false;\n\n        assertIsBoolean(formatSpaceNegative, {\n          message: ({ currentType, validType }) =>\n            `Parameter \\`negativeFormat.space\\` property of the \\`options\\` (second parameter) must be of type \\`${validType} or undefined\\`, but received: \\`${currentType}\\`.`\n        });\n\n        if (\n          !(\n            formatStyleNegative === \"abs\" ||\n            formatStyleNegative === \"brackets\" ||\n            formatStyleNegative === \"dash\"\n          )\n        ) {\n          throw new TypeError(\n            `Parameter \\`negativeFormat.style\\` property of the \\`options\\` (second parameter) must be of type \\`string\\` must be of type \"abs\" | \"brackets\" | \"dash\", but received: \\`${getPreciseType(\n              formatStyleNegative\n            )}\\`, with value: \\`${safeStableStringify(formatStyleNegative, {\n              keepUndefined: true\n            })}\\`.`\n          );\n        }\n\n        switch (formatStyleNegative) {\n          case \"dash\":\n            formattedInteger =\n              \"-\" + (formatSpaceNegative ? \" \" : \"\") + formattedInteger;\n            break;\n          case \"brackets\":\n            formattedInteger = formatSpaceNegative\n              ? `( ${formattedInteger} )`\n              : `(${formattedInteger})`;\n            break;\n          case \"abs\":\n            // no sign\n            break;\n        }\n      }\n    }\n  }\n\n  return formattedInteger;\n};\n","import { isFinite } from \"@/predicates/is/isFinite\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `formatNumber`.***\n * ----------------------------------------------------------\n * **Formats a number or numeric string by adding a custom separator\n * every three digits (thousands separator), and intelligently flips\n * the decimal separator according to the chosen separator.**\n * - **Features:**\n *    - Converts a number to string before formatting.\n *    - Defaults to using `,` as the thousands separator.\n *    - If `.` is used as the separator, the decimal will automatically\n *      become `,`, and vice versa.\n *    - Handles input with existing formatting (e.g. \"1,234,567.89\") and normalizes it.\n *    - Supports custom separators, including spaces.\n *    - Preserves decimals even if more than 2 digits.\n * @param {string | number} value - The numeric value or string to format, can be plain numbers, or already formatted strings like `\"1,234,567.89\"`.\n * @param {string} [separator=\",\"] - The thousands separator to use, examples: `\",\"` ***(default)***, `\".\"`, `\" \"`, etc.\n * @returns {string} The formatted string with thousands separators and\n *   appropriate decimal separator.\n * @throws **{@link TypeError | `TypeError`}** if `value` is not a string or number, or `separator` is not a string.\n * @example\n * formatNumber(1000000);\n * // ➔ \"1,000,000\"\n * formatNumber(\"987654321\");\n * // ➔ \"987,654,321\"\n * formatNumber(1234567.89);\n * // ➔ \"1,234,567.89\"\n * formatNumber(\"1234567,89\");\n * // ➔ \"1,234,567.89\"\n * formatNumber(\"1234567.892\");\n * // ➔ \"1,234,567.892\"\n * formatNumber(\"1234567.89\", \".\");\n * // ➔ \"1.234.567,89\"\n * formatNumber(\"1234567,89\", \",\");\n * // ➔ \"1,234,567.89\"\n * formatNumber(\"987654321\", \" \");\n * // ➔ \"987 654 321\"\n * formatNumber(\"1,234,567.89\");\n * // ➔ \"1,234,567.89\"\n * formatNumber(\"1.234.567,89\", \",\");\n * // ➔ \"1,234,567.89\"\n * formatNumber(\"1.234.567,893\", \".\");\n * // ➔ \"1.234.567,893\"\n * formatNumber(\"1234.56\", \".\");\n * // ➔ \"1.234,56\"\n * formatNumber(\"1234,56\", \",\");\n * // ➔ \"1,234.56\"\n */\nexport const formatNumber = (\n  value: string | number,\n  separator: string = \",\"\n): string => {\n  if (!isString(value) && !isFinite(value)) {\n    throw new TypeError(\n      `First parameter (\\`value\\`) must be of type \\`string\\` or \\`primitive number\\`, but received: \\`${getPreciseType(\n        value\n      )}\\`.`\n    );\n  }\n\n  if (!isString(separator)) {\n    throw new TypeError(\n      `Second parameter (\\`separator\\`) must be of type \\`string\\` or empty as \\`undefined\\`, but received: \\`${getPreciseType(\n        separator\n      )}\\`.`\n    );\n  }\n\n  separator = isString(separator) ? separator : \",\";\n  const decimalSeparator =\n    separator === \".\" ? \",\" : separator === \",\" ? \".\" : \".\";\n\n  // Convert value to string\n  const stringValue = value.toString().trim();\n\n  // --- Normalize input ---\n  // Find the last decimal separator from the end\n  const lastDot = stringValue.lastIndexOf(\".\");\n  const lastComma = stringValue.lastIndexOf(\",\");\n\n  let actualDecimal = \"\";\n  if (lastDot > lastComma) {\n    actualDecimal = \".\";\n  } else if (lastComma > lastDot) {\n    actualDecimal = \",\";\n  }\n\n  // Split into integer and decimal parts\n  let integerPart = stringValue;\n  let decimalPart = \"\";\n  if (actualDecimal) {\n    const parts = stringValue.split(actualDecimal);\n    integerPart = parts.slice(0, -1).join(actualDecimal); // merge if more than one\n    decimalPart = parts.slice(-1)[0];\n  }\n\n  // Remove all non-digit characters from the integer part\n  integerPart = integerPart.replace(/[^\\d]/g, \"\");\n\n  // Format integer part with thousands separator\n  const formattedInteger = integerPart.replace(\n    /\\B(?=(\\d{3})+(?!\\d))/g,\n    separator\n  );\n\n  // Combine with decimal part if exists\n  return decimalPart\n    ? `${formattedInteger}${decimalSeparator}${decimalPart}`\n    : formattedInteger;\n};\n","import type { OmitStrict, Prettify } from \"@rzl-zone/ts-types-plus\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/* eslint-disable @typescript-eslint/no-unused-vars */\nimport type { formatPhoneNumber } from \"../formatPhoneNumber\";\nimport {\n  AsYouType,\n  type PhoneNumber,\n  type CountryCode\n} from \"libphonenumber-js/max\";\n\n/** @private ***Util constants `country code for special leading zero rule` for {@link formatPhoneNumber}.*** */\nexport const trunkZeroCountries: Record<string, string> = {\n  \"7\": \"Russia, Kazakhstan\",\n  \"20\": \"Egypt\",\n  \"27\": \"South Africa\",\n  \"30\": \"Greece\",\n  \"31\": \"Netherlands\",\n  \"32\": \"Belgium\",\n  \"33\": \"France\",\n  \"34\": \"Spain\",\n  \"36\": \"Hungary\",\n  \"39\": \"Italy, San Marino, Vatican\",\n  \"41\": \"Switzerland\",\n  \"43\": \"Austria\",\n  \"44\": \"United Kingdom\",\n  \"45\": \"Denmark\",\n  \"46\": \"Sweden\",\n  \"47\": \"Norway\",\n  \"48\": \"Poland\",\n  \"49\": \"Germany\",\n  \"51\": \"Peru\",\n  \"52\": \"Mexico\",\n  \"53\": \"Cuba\",\n  \"54\": \"Argentina\",\n  \"55\": \"Brazil\",\n  \"56\": \"Chile\",\n  \"57\": \"Colombia\",\n  \"58\": \"Venezuela\",\n  \"60\": \"Malaysia\",\n  \"61\": \"Australia\",\n  \"62\": \"Indonesia\",\n  \"63\": \"Philippines\",\n  \"64\": \"New Zealand\",\n  \"65\": \"Singapore\",\n  \"66\": \"Thailand\",\n  \"81\": \"Japan\",\n  \"82\": \"South Korea\",\n  \"84\": \"Vietnam\",\n  \"86\": \"China\",\n  \"90\": \"Turkey\",\n  \"91\": \"India\",\n  \"92\": \"Pakistan\",\n  \"351\": \"Portugal\",\n  \"352\": \"Luxembourg\",\n  \"355\": \"Albania\",\n  \"356\": \"Malta\",\n  \"358\": \"Finland\",\n  \"359\": \"Bulgaria\",\n  \"370\": \"Lithuania\",\n  \"371\": \"Latvia\",\n  \"372\": \"Estonia\",\n  \"373\": \"Moldova\",\n  \"374\": \"Armenia\",\n  \"375\": \"Belarus\",\n  \"376\": \"Andorra\",\n  \"377\": \"Monaco\",\n  \"378\": \"San Marino\",\n  \"379\": \"Vatican\",\n  \"971\": \"UAE\"\n};\n/** @private ***Util helper for {@link formatPhoneNumber}.*** */\nexport const isValidPhoneE164 = (value: unknown) => {\n  if (!isNonEmptyString(value)) return false;\n  return (\n    /^(\\+)?[0-9\\s().-]+$/.test(value) && value.replace(/\\D/g, \"\").length <= 15\n  );\n};\n\n/** @private ***Util parsing `phone-number` for {@link formatPhoneNumber}.*** */\nexport const parsingAsYouType = (\n  value: string,\n  defaultCountry?: CountryCode\n) => {\n  let parsed;\n  try {\n    parsed = new AsYouType(defaultCountry);\n    parsed.input(value);\n    return parsed;\n  } catch {\n    parsed?.reset();\n    return undefined;\n  }\n};\n\ntype ValidParseAsYouType = Prettify<\n  OmitStrict<AsYouType, \"getNumber\"> & {\n    getNumber(): PhoneNumber; // override agar tidak nullable\n  }\n>;\n\n/** @private ***Util validation parsing `phone-number` when using `AsYouType` for {@link formatPhoneNumber}.*** */\nexport const isValidParseAsYouType = (\n  parsedAsYouType?: AsYouType\n): parsedAsYouType is ValidParseAsYouType => {\n  const parsed = !!parsedAsYouType?.isValid() && !!parsedAsYouType.getNumber();\n  return parsed;\n};\n","import type {\n  FormatPhoneNumberMain,\n  FormatPhoneNumberTakeNumberOnly,\n  FormatPhoneNumberCheckValidOnly,\n  FormatPhoneNumberTransform,\n  ValueFormatPhoneNumber,\n  FormatPhoneNumberAllPassing,\n  FormatPhoneNumberAllPassingValidOnly,\n  FormatPhoneNumberAllPassingTakeOnly,\n  OutputFormat\n} from \"./_private/formatPhoneNumber.types\";\n\nimport { isSupportedCountry } from \"libphonenumber-js/max\";\n\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isNumber } from \"@/predicates/is/isNumber\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isBoolean } from \"@/predicates/is/isBoolean\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport {\n  parsingAsYouType,\n  isValidParseAsYouType\n} from \"./_private/formatPhoneNumber.utils\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\n/** -------------------------------------------------------\n * * ***Utility: `formatPhoneNumber`.***\n * -------------------------------------------------------\n * **Formats a phone number into a customizable local or international style.**\n * - **Type:** ***`Formatting Number`.***\n * - **Can also:**\n *    - Return only digits string when **digits-only mode** (`takeNumberOnly`):\n *      - Return empty-string (\"\"), if invalid number phone.\n *    - Return boolean when **validity-check mode** (`checkValidOnly`):\n *      - ***Return `true` if:***\n *          - A phone number is \"valid\" when it has valid length, and the actual phone number digits match the\n *            regular expressions for its country (parameter options `defaultCountry`).\n * - **E.164 compliance:**\n *    - Optional leading `+` is recommended but **not required**.\n *    - If Without leading `+`, you must passing `defaultCountry`.\n * @throws **{@link TypeError | `TypeError`}** if `value` is not string, number, null or undefined.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not an object or contains wrong types.\n * @param {ValueFormatPhoneNumber} value\n *  ***Phone number to format, accepts:***\n *   - `string` (recommended to preserve leading zeros).\n *   - `number` (leading zeros will be lost).\n *   - `null` or `undefined` (returns empty string).\n * @param {FormatPhoneNumberMain} [options]\n *  ***Main options object controlling:***\n *   - `separator` (**string**): Group separator, default `\" \"`.\n *   - `plusNumberCountry` (**string**): Country code with optional leading `+`.\n *   - `openingNumberCountry` (**string**): Characters before the country code, e.g. `\"(\"`.\n *   - `closingNumberCountry` (**string**): Characters after the country code, e.g. `\")\"`.\n *   - `checkValidOnly` (**boolean**): Return only validity.\n *   - `takeNumberOnly` (**boolean**): Return digits only.\n *   - `defaultCountry` (**string** - **`<ISO-3166-1 alpha-2>`**): Used to interpret numbers without an explicit `+<countryCode>`.\n * @returns {string|boolean} Formatted phone number string, digits-only string, or boolean.\n * @overload\n * @param {ValueFormatPhoneNumber} value The phone number input (string or number).\n * @param {FormatPhoneNumberCheckValidOnly} [options] With `checkValidOnly: true`.\n * Return a **validity-check mode** when `checkValidOnly: true`.\n * @returns {boolean} A boolean indicating whether the input is a valid phone number.\n * @overload\n * @param {ValueFormatPhoneNumber} value The phone number input (string or number).\n * @param {FormatPhoneNumberTransform} [options] With `takeNumberOnly: true`.\n * Return **digits-only mode** when `takeNumberOnly: true`.\n * @returns {string} A string of digits only.\n * @overload\n * @param {ValueFormatPhoneNumber} value The phone number input (string or number).\n * @param {FormatPhoneNumberTakeNumberOnly} [options] Options to customize format output (country code, separator, etc).\n * Return a **formatted phone number string** with custom formatting and (`checkValidOnly: false`, `takeNumberOnly: false`).\n * @returns {string} Formatting number. return a string of digits only with formatter.\n * @example\n * 1. ***Formatting Phone Number String:***\n * ```ts\n * formatPhoneNumber(\"081234567890\");\n * // ➔ \"0812 3456 7890\"\n * formatPhoneNumber(\"081234567890\", {\n *   separator: \"-\",\n *   plusNumberCountry: \"+44\",\n *   openingNumberCountry: \"(\",\n *   closingNumberCountry: \")\"\n * });\n * // ➔ \"(+44) 8123-4567-890\"\n * ```\n * 2. ***Digits-Only Mode:***\n *    ```ts\n *    formatPhoneNumber(\"(0812) 3456-7890\", {\n *      takeNumberOnly: true,\n *      defaultCountry: \"ID\"\n *    });\n *    // ➔ \"081234567890\"\n *    formatPhoneNumber(\"(0812) 3456-7890\", { takeNumberOnly: true });\n *    // ➔ \"\"\n *    formatPhoneNumber(\"(63) 917 123 4567\", {\n *      takeNumberOnly: true,\n *      defaultCountry: \"PH\"\n *    });\n *    // ➔ \"0917 123 4567\"\n *    formatPhoneNumber(\"(63) 4567-8901\", {\n *      takeNumberOnly: true,\n *      defaultCountry: \"PH\"\n *    });\n *    // ➔ \"\" // is not valid number from PH.\n *    formatPhoneNumber(\"(63) 917 123 4567\", { takeNumberOnly: true });\n *    // ➔ \"\"\n *    formatPhoneNumber(\"49 (151) 2345 6789\", {\n *      takeNumberOnly: true,\n *      defaultCountry: \"DE\"\n *    });\n *    // ➔ \"015123456789\"\n *    formatPhoneNumber(\"49 (151) 2345 6789\", { takeNumberOnly: true });\n *    // ➔ \"\"\n *    ```\n * 3. ***Validity-Check Mode:***\n *    ```ts\n *    formatPhoneNumber(\"+6281234567890\", { checkValidOnly: true });\n *    // ➔ true\n *    formatPhoneNumber(\"0812-3456-7890\", {\n *      checkValidOnly: true,\n *      defaultCountry: \"ID\"\n *    });\n *    // ➔ true\n *    formatPhoneNumber(\"0812 3456 7890\", { checkValidOnly: true });\n *    // ➔ false\n *    formatPhoneNumber(\"(0812) 3456-7890\", {\n *      checkValidOnly: true,\n *      defaultCountry: \"ID\"\n *    });\n *    // ➔ true\n *    formatPhoneNumber(\"(0812) 3456-7890\", { checkValidOnly: true});\n *    // ➔ false\n *    formatPhoneNumber(\"+44 20 7946 0958\", { checkValidOnly: true });\n *    // ➔ true\n *    formatPhoneNumber(\"+1 (800) 123-4567\", { checkValidOnly: true });\n *    // ➔ true\n *    formatPhoneNumber(\"+62.812.3456.7890\", { checkValidOnly: true });\n *    // ➔ true\n *    formatPhoneNumber(\"+62(812)3456-7890\", { checkValidOnly: true });\n *    // ➔ true\n *    formatPhoneNumber(\"+62abc123\", { checkValidOnly: true });\n *    // ➔ false\n *    formatPhoneNumber(\"invalid@@@\", { checkValidOnly: true });\n *    // ➔ false\n *    formatPhoneNumber(\"0812-3456-hello\", { checkValidOnly: true });\n *    // ➔ false\n *    ```\n */\nexport function formatPhoneNumber(\n  value: ValueFormatPhoneNumber,\n  options?: FormatPhoneNumberTransform\n): string;\n/** -------------------------------------------------------\n * * ***Utility: `formatPhoneNumber`.***\n * -------------------------------------------------------\n * **Formats a phone number into a customizable local or international style.**\n * - **Type:** ***`Digits-only Mode`.***\n * - **Can also:**\n *    - Return only digits string when **digits-only mode** (`takeNumberOnly`).\n *    - Return boolean when **validity-check mode** (`checkValidOnly`) using a\n *      regex for international-style phone numbers:\n *      - ***Valid if:***\n *          - Only contains digits, optional leading `+`, spaces, parentheses `()`,\n *            hyphens `-`, or dots `.`.\n *          - Digits-only length < 16.\n * - **E.164 compliance:**\n *    - Optional leading `+` is recommended but **not required**.\n *    - If Without leading `+`, you must passing `defaultCountry`.\n * @throws **{@link TypeError | `TypeError`}** if `value` is not string, number, null or undefined.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not an object or contains wrong types.\n * @param {ValueFormatPhoneNumber} value\n *   Phone number to format. Accepts:\n *   - `string` (recommended to preserve leading zeros)\n *   - `number` (leading zeros will be lost)\n *   - `null` or `undefined` (returns empty string).\n * @param {FormatPhoneNumberTakeNumberOnly} [options] Options to customize format output (country code, separator, etc).\n * @returns {string} Digits-only mode, return string a digits-only.\n * @example\n * ```ts\n * formatPhoneNumber(\"(0812) 3456-7890\", {\n *   takeNumberOnly: true,\n *   defaultCountry: \"ID\"\n * });\n * // ➔ \"081234567890\"\n * formatPhoneNumber(\"(0812) 3456-7890\", { takeNumberOnly: true });\n * // ➔ \"\"\n * formatPhoneNumber(\"(63) 917 123 4567\", {\n *   takeNumberOnly: true,\n *   defaultCountry: \"PH\"\n * });\n * // ➔ \"0917 123 4567\"\n * formatPhoneNumber(\"(63) 4567-8901\", {\n *   takeNumberOnly: true,\n *   defaultCountry: \"PH\"\n * });\n * // ➔ \"\" // is not valid number from PH.\n * formatPhoneNumber(\"(63) 917 123 4567\", { takeNumberOnly: true });\n * // ➔ \"\"\n * formatPhoneNumber(\"49 (151) 2345 6789\", {\n *   takeNumberOnly: true,\n *   defaultCountry: \"DE\"\n * });\n * // ➔ \"015123456789\"\n * formatPhoneNumber(\"49 (151) 2345 6789\", { takeNumberOnly: true });\n * // ➔ \"\"\n * ```\n */\nexport function formatPhoneNumber(\n  value: ValueFormatPhoneNumber,\n  options?: FormatPhoneNumberTakeNumberOnly\n): string;\n/** -------------------------------------------------------\n * * ***Utility: `formatPhoneNumber`.***\n * -------------------------------------------------------\n * **Formats a phone number into a customizable local or international style.**\n * - **Type:** ***`Validity-check Mode`.***\n * - **Can also:**\n *    - Return only digits string when **digits-only mode** (`takeNumberOnly`).\n *    - Return boolean when **validity-check mode** (`checkValidOnly`) using a\n *      regex for international-style phone numbers:\n *      - ***Valid if:***\n *          - Only contains digits, optional leading `+`, spaces, parentheses `()`,\n *            hyphens `-`, or dots `.`.\n *          - Digits-only length < 16.\n * - **E.164 compliance:**\n *    - Optional leading `+` is recommended but **not required**.\n *    - If Without leading `+`, you must passing `defaultCountry`.\n * @throws **{@link TypeError | `TypeError`}** if `value` is not string, number, null or undefined.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not an object or contains wrong types.\n * @param {ValueFormatPhoneNumber} value\n *  Phone number to format. Accepts:\n *   - `string` (recommended to preserve leading zeros).\n *   - `number` (leading zeros will be lost).\n *   - `null` or `undefined` (returns empty string).\n * @param {FormatPhoneNumberTakeNumberOnly} [options] Options to customize format output (country code, separator, etc).\n * @returns {boolean} Validity-check mode, return a boolean.\n * @example\n * ```ts\n * formatPhoneNumber(\"+6281234567890\", { checkValidOnly: true });\n * // ➔ true\n * formatPhoneNumber(\"0812-3456-7890\", {\n *   checkValidOnly: true,\n *   defaultCountry: \"ID\"\n * });\n * // ➔ true\n * formatPhoneNumber(\"0812 3456 7890\", { checkValidOnly: true });\n * // ➔ false\n * formatPhoneNumber(\"(0812) 3456-7890\", {\n *   checkValidOnly: true,\n *   defaultCountry: \"ID\"\n * });\n * // ➔ true\n * formatPhoneNumber(\"(0812) 3456-7890\", { checkValidOnly: true});\n * // ➔ false\n * formatPhoneNumber(\"+44 20 7946 0958\", { checkValidOnly: true });\n * // ➔ true\n * formatPhoneNumber(\"+1 (800) 123-4567\", { checkValidOnly: true });\n * // ➔ true\n * formatPhoneNumber(\"+62.812.3456.7890\", { checkValidOnly: true });\n * // ➔ true\n * formatPhoneNumber(\"+62(812)3456-7890\", { checkValidOnly: true });\n * // ➔ true\n * formatPhoneNumber(\"+62abc123\", { checkValidOnly: true });\n * // ➔ false\n * formatPhoneNumber(\"invalid@@@\", { checkValidOnly: true });\n * // ➔ false\n * formatPhoneNumber(\"0812-3456-hello\", { checkValidOnly: true });\n * // ➔ false\n * ```\n */\nexport function formatPhoneNumber(\n  value: ValueFormatPhoneNumber,\n  options?: FormatPhoneNumberCheckValidOnly\n): boolean;\n/** -------------------------------------------------------\n * * ***Utility: `formatPhoneNumber`.***\n * -------------------------------------------------------\n * **Formats a phone number into a customizable local or international style.**\n * - **Type:** ***Forced to `Validity-check Mode`***, because `checkValidOnly` has set to `true`.\n * - **Can also:**\n *    - Return only digits string when **digits-only mode** (`takeNumberOnly`).\n *    - Return boolean when **validity-check mode** (`checkValidOnly`) using a\n *      regex for international-style phone numbers:\n *      - ***Valid if:***\n *          - Only contains digits, optional leading `+`, spaces, parentheses `()`,\n *            hyphens `-`, or dots `.`.\n *          - Digits-only length < 16.\n * - **E.164 compliance:**\n *    - Optional leading `+` is recommended but **not required**.\n *    - If Without leading `+`, you must passing `defaultCountry`.\n * @throws **{@link TypeError | `TypeError`}** if `value` is not string, number, null or undefined.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not an object or contains wrong types.\n * @param {ValueFormatPhoneNumber} value\n *  Phone number to format. Accepts:\n *   - `string` (recommended to preserve leading zeros).\n *   - `number` (leading zeros will be lost).\n *   - `null` or `undefined` (returns empty string).\n * @param {FormatPhoneNumberTakeNumberOnly} [options] Options to customize format output (country code, separator, etc).\n * @returns {boolean} Validity-check mode, return a boolean.\n * @example\n * ```ts\n * formatPhoneNumber(\"+6281234567890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n * });\n * // ➔ true\n * formatPhoneNumber(\"0812-3456-7890\", {\n *   defaultCountry: \"ID\",\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n * });\n * // ➔ true\n * formatPhoneNumber(\"0812 3456 7890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n * });\n * // ➔ false\n * formatPhoneNumber(\"(0812) 3456-7890\", {\n *   defaultCountry: \"ID\",\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n * });\n * // ➔ true\n * formatPhoneNumber(\"(0812) 3456-7890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true\n * });\n * // ➔ false\n * formatPhoneNumber(\"+44 20 7946 0958\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true\n * });\n * // ➔ true\n * formatPhoneNumber(\"+1 (800) 123-4567\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true\n * });\n * // ➔ true\n * formatPhoneNumber(\"+62.812.3456.7890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true\n * });\n * // ➔ true\n * formatPhoneNumber(\"+62(812)3456-7890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true\n * });\n * // ➔ true\n * formatPhoneNumber(\"+62abc123\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true\n * });\n * // ➔ false\n * formatPhoneNumber(\"invalid@@@\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true\n * });\n * // ➔ false\n * formatPhoneNumber(\"0812-3456-hello\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true\n * });\n * // ➔ false\n * ```\n */\nexport function formatPhoneNumber(\n  value: ValueFormatPhoneNumber,\n  options?: FormatPhoneNumberAllPassingValidOnly\n): boolean;\n/** -------------------------------------------------------\n * * ***Utility: `formatPhoneNumber`.***\n * -------------------------------------------------------\n * **Formats a phone number into a customizable local or international style.**\n * - **Type:** ***Forced to `Digits-only Mode`***, because `takeNumberOnly` has set to `true`.\n * - **Can also:**\n *    - Return only digits string when **digits-only mode** (`takeNumberOnly`).\n *    - Return boolean when **validity-check mode** (`checkValidOnly`) using a\n *      regex for international-style phone numbers:\n *      - ***Valid if:***\n *          - Only contains digits, optional leading `+`, spaces, parentheses `()`,\n *            hyphens `-`, or dots `.`.\n *          - Digits-only length < 16.\n * - **E.164 compliance:**\n *    - Optional leading `+` is recommended but **not required**.\n *    - If Without leading `+`, you must passing `defaultCountry`.\n * @throws **{@link TypeError | `TypeError`}** if `value` is not string, number, null or undefined.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not an object or contains wrong types.\n * @param {ValueFormatPhoneNumber} value\n *   Phone number to format. Accepts:\n *   - `string` (recommended to preserve leading zeros)\n *   - `number` (leading zeros will be lost)\n *   - `null` or `undefined` (returns empty string).\n * @param {FormatPhoneNumberTakeNumberOnly} [options] Options to customize format output (country code, separator, etc).\n * @returns {string} Digits-only mode, return string a digits-only.\n * @example\n * ```ts\n * formatPhoneNumber(\"(0812) 3456-7890\", {\n *   defaultCountry: \"ID\",\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ \"081234567890\"\n * formatPhoneNumber(\"(0812) 3456-7890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ \"\"\n * formatPhoneNumber(\"(63) 917 123 4567\", {\n *   defaultCountry: \"PH\",\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ \"0917 123 4567\"\n * formatPhoneNumber(\"(63) 4567-8901\", {\n *   defaultCountry: \"PH\",\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ \"\" // is not valid number from PH.\n * formatPhoneNumber(\"(63) 917 123 4567\", { takeNumberOnly: true });\n * // ➔ \"\"\n * formatPhoneNumber(\"49 (151) 2345 6789\", {\n *   defaultCountry: \"DE\",\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ \"015123456789\"\n * formatPhoneNumber(\"49 (151) 2345 6789\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ \"\"\n * ```\n */\nexport function formatPhoneNumber(\n  value: ValueFormatPhoneNumber,\n  options?: FormatPhoneNumberAllPassingTakeOnly\n): string;\n/** -------------------------------------------------------\n * * ***Utility: `formatPhoneNumber`.***\n * -------------------------------------------------------\n * **Formats a phone number into a customizable local or international style.**\n * - **Type:** ***Forced to `Validity-check Mode`***, because `checkValidOnly` and `takeNumberOnly` has set to `true`,\n *          but `checkValidOnly` will prioritize one.\n * - **Can also:**\n *    - Return only digits string when **digits-only mode** (`takeNumberOnly`).\n *    - Return boolean when **validity-check mode** (`checkValidOnly`) using a\n *      regex for international-style phone numbers:\n *      - ***Valid if:***\n *          - Only contains digits, optional leading `+`, spaces, parentheses `()`,\n *            hyphens `-`, or dots `.`.\n *          - Digits-only length < 16.\n * - **E.164 compliance:**\n *    - Optional leading `+` is recommended but **not required**.\n *    - If Without leading `+`, you must passing `defaultCountry`.\n * @throws **{@link TypeError | `TypeError`}** if `value` is not string, number, null or undefined.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not an object or contains wrong types.\n * @param {ValueFormatPhoneNumber} value\n *  Phone number to format. Accepts:\n *   - `string` (recommended to preserve leading zeros).\n *   - `number` (leading zeros will be lost).\n *   - `null` or `undefined` (returns empty string).\n * @param {FormatPhoneNumberTakeNumberOnly} [options] Options to customize format output (country code, separator, etc).\n * @returns {boolean} Validity-check mode, return a boolean.\n * @example\n * ```ts\n * formatPhoneNumber(\"+6281234567890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ true\n * formatPhoneNumber(\"0812-3456-7890\", {\n *   defaultCountry: \"ID\",\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ true\n * formatPhoneNumber(\"0812 3456 7890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ false\n * formatPhoneNumber(\"(0812) 3456-7890\", {\n *   defaultCountry: \"ID\",\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ true\n * formatPhoneNumber(\"(0812) 3456-7890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ false\n * formatPhoneNumber(\"+44 20 7946 0958\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ true\n * formatPhoneNumber(\"+1 (800) 123-4567\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ true\n * formatPhoneNumber(\"+62.812.3456.7890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ true\n * formatPhoneNumber(\"+62(812)3456-7890\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ true\n * formatPhoneNumber(\"+62abc123\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ false\n * formatPhoneNumber(\"invalid@@@\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ false\n * formatPhoneNumber(\"0812-3456-hello\", {\n *   // Formatting Phone Number Options\n *   separator: \"-\",\n *   // Validity-check Mode\n *   checkValidOnly: true,\n *   // Digits-only Mode\n *   takeNumberOnly: true,\n * });\n * // ➔ false\n * ```\n */\nexport function formatPhoneNumber(\n  value: ValueFormatPhoneNumber,\n  options?: FormatPhoneNumberAllPassing\n): boolean;\nexport function formatPhoneNumber(\n  value: ValueFormatPhoneNumber,\n  options: FormatPhoneNumberMain = {}\n): string | boolean {\n  if (isNil(value)) return \"\";\n\n  if (!isString(value) && !isNumber(value)) {\n    throw new TypeError(\n      `First parameter (\\`value\\`) must be of type \\`string\\`, \\`number\\`, \\`null\\` or \\`undefined\\`, but received: \\`${getPreciseType(\n        value\n      )}\\`.`\n    );\n  }\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const takeNumberOnly = hasOwnProp(options, \"takeNumberOnly\")\n    ? options.takeNumberOnly\n    : false;\n  const checkValidOnly = hasOwnProp(options, \"checkValidOnly\")\n    ? options.checkValidOnly\n    : false;\n  const defaultCountry: typeof options.defaultCountry = hasOwnProp(\n    options,\n    \"defaultCountry\"\n  )\n    ? options.defaultCountry\n    : undefined;\n\n  const separator = hasOwnProp(options, \"separator\") ? options.separator : \" \";\n  const prependPlusCountryCode = hasOwnProp(options, \"prependPlusCountryCode\")\n    ? options.prependPlusCountryCode\n    : true;\n  const outputFormat: OutputFormat = hasOwnProp(options, \"outputFormat\")\n    ? options.outputFormat\n    : \"INTERNATIONAL\";\n  const openingNumberCountry = hasOwnProp(options, \"openingNumberCountry\")\n    ? options.openingNumberCountry\n    : \"\";\n  const closingNumberCountry = hasOwnProp(options, \"closingNumberCountry\")\n    ? options.closingNumberCountry\n    : \"\";\n\n  if (\n    !isBoolean(takeNumberOnly) ||\n    !isBoolean(checkValidOnly) ||\n    !isBoolean(prependPlusCountryCode)\n  ) {\n    throw new TypeError(\n      `Parameter \\`takeNumberOnly\\`, \\`checkValidOnly\\` and \\`prependPlusCountryCode\\` property of the \\`options\\` (second parameter) must be of type \\`boolean\\` or unset as \\`undefined\\` value, but received: ['takeNumberOnly': \\`${getPreciseType(\n        takeNumberOnly\n      )}\\`, 'checkValidOnly': \\`${getPreciseType(\n        checkValidOnly\n      )}\\`, 'prependPlusCountryCode': \\`${getPreciseType(prependPlusCountryCode)}\\`].`\n    );\n  }\n\n  if (!isUndefined(defaultCountry) && !isSupportedCountry(defaultCountry)) {\n    throw new TypeError(\n      `Parameter \\`defaultCountry\\` property of the \\`options\\` (second parameter) must be of type \\`string\\` as \\`CountryCode\\` (ISO-3166-1 alpha-2) or unset as \\`undefined\\` value, but received: \\`${getPreciseType(\n        defaultCountry\n      )}\\`, with value: \\`${safeStableStringify(defaultCountry, {\n        keepUndefined: true\n      })}\\`.\\n\\nSee: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements, for all ISO 3166-1 alpha-2 code.`\n    );\n  }\n\n  if (\n    ![\"INTERNATIONAL\", \"NATIONAL\", \"RFC3966\", \"E.164\"].includes(outputFormat)\n  ) {\n    throw new TypeError(\n      `Parameter \\`outputFormat\\` property of the \\`options\\` (second parameter) must be of type \\`string\\` as \\`OutputFormat\\` (\"NATIONAL\" | \"INTERNATIONAL\" | \"E.164\" | \"RFC3966\") or unset as \\`undefined\\` (default value to: \\`INTERNATIONAL\\`) value, but received: \\`${getPreciseType(\n        outputFormat\n      )}\\`, with value: ${safeStableStringify(outputFormat, { keepUndefined: true })}.`\n    );\n  }\n\n  if (\n    !isString(separator) ||\n    !isString(openingNumberCountry) ||\n    !isString(closingNumberCountry)\n  ) {\n    throw new TypeError(\n      `Parameter \\`separator\\`, \\`plusNumberCountry\\`, \\`openingNumberCountry\\` and \\`closingNumberCountry\\` property of the \\`options\\` (second parameter) must be of type \\`string\\` or unset as \\`undefined\\` value, but received: ['separator': \\`${getPreciseType(\n        separator\n      )}\\`,'openingNumberCountry': \\`${getPreciseType(\n        openingNumberCountry\n      )}\\`, 'closingNumberCountry': \\`${getPreciseType(closingNumberCountry)}\\`].`\n    );\n  }\n\n  if (!isString(value)) value = String(value);\n\n  const parsedPhoneNumber = parsingAsYouType(value, defaultCountry);\n  const validPhoneNumber = isValidParseAsYouType(parsedPhoneNumber);\n\n  if (checkValidOnly) return validPhoneNumber;\n\n  // todo: return empty-string is invalid phone-number input.\n  if (!validPhoneNumber) return \"\";\n\n  if (takeNumberOnly) {\n    return parsedPhoneNumber.getNumber().formatNational().replace(/\\D/g, \"\");\n  }\n\n  const num = parsedPhoneNumber.getNumber();\n  // Result example: \"+49 1512 3456789\"\n  const intlNumb = num.format(outputFormat);\n\n  if (outputFormat === \"INTERNATIONAL\") {\n    // Split to: [\"+49\", \"1512\", \"3456789\"]\n    const [cc, ...rest] = intlNumb.split(\" \");\n    const countryCode = prependPlusCountryCode ? cc : cc.replace(/^\\++/, \"\");\n    const restWithSeparator = rest.join(separator);\n\n    if (\n      isNonEmptyString(openingNumberCountry) &&\n      isNonEmptyString(closingNumberCountry)\n    ) {\n      return `${openingNumberCountry}${countryCode}${closingNumberCountry} ${restWithSeparator}`;\n    }\n\n    return `${countryCode} ${restWithSeparator}`;\n  }\n\n  if (outputFormat === \"NATIONAL\") {\n    const restWithSeparator = intlNumb.split(\" \").join(separator);\n\n    return `${restWithSeparator}`;\n  }\n\n  return intlNumb;\n}\n","// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { censorEmail } from \"../censorEmail\";\nimport { isUndefined } from \"@/predicates/is/isUndefined\";\n\n/** @private ***Util helper for {@link censorEmail}.*** */\nexport const hashSeedGenerate = (mode: \"random\" | \"fixed\", email: string) => {\n  const generateSeed = () => {\n    let hash = 0;\n    for (let i = 0; i < email.length; i++) {\n      hash = (hash << 5) - hash + email.charCodeAt(i);\n      hash |= 0; // Convert to 32bit int\n    }\n    return Math.abs(hash);\n  };\n\n  return mode === \"fixed\" ? generateSeed() : undefined;\n};\n\n/** ----------------------------------------------------------\n *  * ***Internal Randomly replaces characters in a string with \"\\*\".***\n * ----------------------------------------------------------\n *\n * @param {string} str - The string to censor.\n * @param {number} minCensor - Minimum number of characters to censor.\n * @param {number} maxPercentage - Maximum percentage of characters to censor.\n * @returns {string} - Censored string.\n *\n * @private ***Util helper for {@link censorEmail}.***\n */\nexport const _censor = (\n  str: string,\n  minCensor: number,\n  maxPercentage: number,\n  hashSeed: number | undefined\n): string => {\n  if (str.length <= minCensor) return \"*\".repeat(str.length);\n\n  const strArr = str.split(\"\");\n  const totalCensor = Math.max(\n    minCensor,\n    Math.ceil(str.length * maxPercentage)\n  );\n  const indexes = new Set<number>();\n\n  let i = 0;\n  while (indexes.size < totalCensor) {\n    const idx = !isUndefined(hashSeed)\n      ? (hashSeed + str.length + i * 31) % str.length\n      : Math.floor(Math.random() * str.length);\n    indexes.add(idx);\n    i++;\n  }\n\n  for (const index of indexes) {\n    strArr[index] = \"*\";\n  }\n\n  return strArr.join(\"\");\n};\n","import { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\nimport { _censor, hashSeedGenerate } from \"./_private/censorEmail.utils\";\n\ntype CensorEmailOptions = {\n  /** ----------------------------------------------------------\n   * * ***Censorship Mode.***\n   * ----------------------------------------------------------\n   * - **Valid value:**\n   *    - `\"fixed\"` (default) – Deterministic censorship based on a hash of the email, same input always produces the same output.\n   *    - `\"random\"` – Each character is randomly replaced every time the function is called.\n   */\n  mode?: \"random\" | \"fixed\";\n};\n\n/** ----------------------------------------------------------\n * * ***Utility: `censorEmail`.***\n * ----------------------------------------------------------\n * **Censors an email by replacing characters with `\"*\"` while supporting random or fixed mode.**\n * - **This function replaces parts of an email with asterisks to protect privacy.**\n *    - **Modes:**\n *        - `\"fixed\"` (default) – Deterministic censorship based on a hash of the email, same input always produces the same output.\n *        - `\"random\"` – Each character is randomly replaced every time the function is called.\n *    - **ℹ️ Note:**\n *        - Invalid emails or non-string input will return an empty-string (`\"\"`).\n * @param {string | null | undefined} email - The email address to censor.\n * @param {CensorEmailOptions} [options={}] - Options object for mode.\n * @returns {string} The censored email, or an empty string if input is invalid.\n * @throws **{@link TypeError | `TypeError`}** if `options` is not a plain object or `mode` is invalid.\n * @example\n * // Fixed mode (default, deterministic)\n * censorEmail(\"john.doe@gmail.com\");\n * // ➔ \"j**n.**e@g***l.com\"\n *\n * // Fixed mode explicitly\n * censorEmail(\"john.doe@gmail.com\", { mode: \"fixed\" });\n * // ➔ \"j**n.**e@g***l.com\"\n *\n * // Random mode (output may vary each time)\n * censorEmail(\"john.doe@gmail.com\", { mode: \"random\" });\n * // ➔ \"j*hn.***e@g***l.com\" (random)\n *\n * // Invalid email returns empty string\n * censorEmail(\"invalid-email\");\n * // ➔ \"\"\n */\nexport const censorEmail = (\n  email: string | null | undefined,\n  options: CensorEmailOptions = {}\n): string => {\n  if (!isNonEmptyString(email)) return \"\";\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Second parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const mode = hasOwnProp(options, \"mode\") ? options.mode : \"fixed\";\n\n  // Ensure mode is either \"random\" or \"fixed\"\n  if (mode !== \"random\" && mode !== \"fixed\") {\n    throw new TypeError(\n      `Parameter \\`mode\\` property of the \\`options\\` (second parameter) must be one of \"fixed\" or \"random\", but received: \\`${getPreciseType(\n        mode\n      )}\\`, with value: \\`${safeStableStringify(mode, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  // Strict email validation regex\n  const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/;\n  if (!emailRegex.test(email)) return \"\";\n\n  const [local, domain] = email.split(\"@\");\n  const domainParts = domain.split(\".\"); // Handle multi-level domain (e.g., example.co.uk)\n  if (domainParts.length < 2) return \"\"; // Invalid domain structure\n\n  const [domainName, ...tldParts] = domainParts;\n  const tld = tldParts.join(\".\");\n\n  const hashSeed = hashSeedGenerate(mode, email);\n\n  const localMinCensor = local.length < 4 ? 1 : 2;\n  const domainMinCensor = domainName.length < 4 ? 1 : 2;\n\n  const censoredLocal = _censor(local, localMinCensor, 0.6, hashSeed);\n  const censoredDomain = _censor(domainName, domainMinCensor, 0.5, hashSeed);\n  const censoredTLD = tld.length <= 2 ? tld : _censor(tld, 1, 0.4, hashSeed);\n\n  return `${censoredLocal}@${censoredDomain}.${censoredTLD}`;\n};\n","import { isNil } from \"@/predicates/is/isNil\";\nimport { isInteger } from \"@/predicates/is/isInteger\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\n\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\nimport { normalizeSpaces } from \"@/strings/sanitizations/normalizeSpaces\";\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\ntype ChunkStringOptions = {\n  /** ***The separator string to insert between characters or words.***\n   *\n   * - Used when inserting separators every `limiter` characters.\n   * - Default is a single space `\" \"`.\n   *\n   * @default \" \"\n   */\n  separator?: string;\n\n  /** ***Determines whether counting for `limiter` resets after each space.***\n   *\n   * - If `true`, the string is treated as words separated by spaces,\n   *   and separators are applied within words, then words are grouped.\n   * - If `false` ***(default)***, counting is continuous across the whole string,\n   *   treating spaces as normal characters.\n   *\n   * @default false\n   */\n  reCountAfterSpace?: boolean;\n};\n\n/** ----------------------------------------------\n * * ***Utility: `chunkString`.***\n * ----------------------------------------------\n * **Chunks a string by inserting a separator every `limiter` characters.**\n * - **This function handles two main behaviors based on `reCountAfterSpace`:**\n *    1. ***If `reCountAfterSpace` is `false` (default):***\n *        - The separator is inserted strictly every `limiter` characters throughout the entire string, regardless of spaces, spaces are treated as regular characters in the count.\n *            - Example: `chunkString(\"1234567890\", 3, \"-\")` ➔ `\"123-456-789-0\"`.\n *            - Example: `chunkString(\"Hello World\", 3, \"-\")` ➔ `\"Hel-lo -Wor-ld\"`.\n *    2. ***If `reCountAfterSpace` is `true`:***\n *        - The function first processes the input string to replace any multiple consecutive spaces with a\n *          single space (e.g., \"A   B\" becomes \"A B\").\n *      Then, it treats the string as a sequence of \"words\" (segments separated by single spaces).\n *            - Each word is processed independently:\n *              - if a word's length exceeds the `limiter`, separators are inserted internally within that word.\n *              - Words are then grouped. Each group will contain `limiter` number of words.\n *              - Words within the same group are joined by the specified `separator`.\n *              - Finally, these groups are joined by a single space, preserving the original word separation\n *                structure between groups.\n * @param {string} subject - ***The target string to chunk.****\n * @param {number} limiter\n *  ***The interval (number of characters) for inserting separators, behavior:***\n *   - If `reCountAfterSpace = false`, it counts characters.\n *   - If `reCountAfterSpace = true`, it counts both characters within words and words per group.\n * @param {ChunkStringOptions} [options={}] - ***Optional settings for separator and counting behavior.***\n * @returns {string} Return the formatted string with separators.\n * @example\n * // Basic usage\n * chunkString(\"1234567890\", 3);\n * // ➔ \"123 456 789 0\"\n *\n * // Basic usage `reCountAfterSpace = false` (default)\n * chunkString(\"1234567890\", 3, { separator: \"-\");\n * // ➔ \"123-456-789-0\"\n * chunkString(\"HelloWorld\", 2, { separator: \"_\", reCountAfterSpace: false });\n * // ➔ \"He_ll_oW_or_ld\"\n *\n * // Usage with reCountAfterSpace = true:\n * // Multiple spaces are normalized to single spaces before processing.\n * chunkString(\"AB  CD   EF GH\", 2, { separator: \"-\", reCountAfterSpace: true });\n * // ➔ \"AB-CD EF-GH\" (after normalization to \"AB CD EF GH\")\n * // Words \"AB\" and \"CD\" form a group and are joined by \"-\", \"EF\" and \"GH\" form another group.\n * // The groups \"AB-CD\" and \"EF-GH\" are then joined by a space.\n *\n * // Another usage with reCountAfterSpace = true:\n * chunkString(\"ABC DEF GHI JKL\", 3, { separator: \"-\", reCountAfterSpace: true });\n * // ➔ \"ABC-DEF-GHI JKL\"\n * // Words \"ABC\", \"DEF\", \"GHI\" form a group and are joined by \"-\".\n * // The word \"JKL\" forms its own group (as it's the last word and completes no other group).\n * // The groups \"ABC-DEF-GHI\" and \"JKL\" are then joined by a space.\n */\nexport function chunkString(\n  subject: string,\n  limiter: number,\n  options: ChunkStringOptions = {}\n): string {\n  if (isNil(subject) || limiter <= 0) return subject;\n\n  assertIsString(subject, {\n    message: ({ currentType, validType }) =>\n      `First parameter (\\`subject\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  if (!isInteger(limiter)) {\n    throw new TypeError(\n      `Second parameter (\\`limiter\\`) must be of type \\`integer-number\\`, but received: \\`${getPreciseType(\n        limiter\n      )}\\`, with value: \\`${safeStableStringify(limiter, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Third parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const separator = hasOwnProp(options, \"separator\") ? options.separator : \" \";\n  const reCountAfterSpace = hasOwnProp(options, \"reCountAfterSpace\")\n    ? options.reCountAfterSpace\n    : false;\n\n  assertIsString(separator, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`separator\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  assertIsBoolean(reCountAfterSpace, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`reCountAfterSpace\\` property of the \\`options\\` (third parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  subject = normalizeSpaces(subject);\n\n  // Handle reCountAfterSpace = false (assumed correct from previous iterations)\n  if (!reCountAfterSpace) {\n    let result = \"\";\n    let currentCount = 0;\n\n    for (let i = 0; i < subject.length; i++) {\n      const char = subject[i];\n      if (currentCount === limiter) {\n        result += separator;\n        currentCount = 0;\n      }\n      result += char;\n      currentCount++;\n    }\n    return result;\n  }\n\n  // --- Dynamic Logic for reCountAfterSpace = true ---\n  const words = subject.split(\" \"); // Split the string into individual words by spaces\n  const finalSegments: string[] = [];\n\n  let currentGroup: string[] = [];\n  let wordsInCurrentGroupCount = 0; // This counts how many words are in the current group\n\n  for (let i = 0; i < words.length; i++) {\n    const word = words[i];\n\n    // Check if the current word itself needs internal separators (e.g., \"HelloWorld\" with limiter 2)\n    // For the given test cases (\"AB\", \"CD\", \"ABC\"), this inner loop doesn't add separators,\n    // as the words themselves are shorter than or equal to the limiter.\n    let processedWord = \"\";\n    let charCountInWord = 0;\n    for (let j = 0; j < word.length; j++) {\n      processedWord += word[j];\n      charCountInWord++;\n      if (charCountInWord === limiter && j < word.length - 1) {\n        processedWord += separator;\n        charCountInWord = 0;\n      }\n    }\n\n    currentGroup.push(processedWord);\n    wordsInCurrentGroupCount++;\n\n    // If the current group has reached the limiter (e.g., 2 words for limiter=2, or 3 words for limiter=3)\n    // OR if it's the last word in the entire subject, finalize the group.\n    if (wordsInCurrentGroupCount === limiter || i === words.length - 1) {\n      finalSegments.push(currentGroup.join(separator)); // Join words within the group by separator\n      currentGroup = []; // Reset group for the next set of words\n      wordsInCurrentGroupCount = 0; // Reset group word count\n    }\n  }\n\n  // Finally, join the main segments (groups) with spaces\n  return finalSegments.join(\" \");\n}\n","import { isInteger } from \"@/predicates/is/isInteger\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isEmptyString } from \"@/predicates/is/isEmptyString\";\nimport { getPreciseType } from \"@/predicates/type/getPreciseType\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\nimport { safeStableStringify } from \"@/conversions/stringify/safeStableStringify\";\n\nimport { assertIsString } from \"@/assertions/strings/assertIsString\";\nimport { assertIsBoolean } from \"@/assertions/booleans/assertIsBoolean\";\nimport { assertIsPlainObject } from \"@/assertions/objects/assertIsPlainObject\";\n\ntype TruncateStringOptions = {\n  /** ***Maximum length of the truncated string **(default: `10`)**.***\n   *\n   * @default 10\n   */\n  length?: number;\n\n  /** ***String to append if truncation occurs.***\n   *\n   * - Will be trimmed first; defaults to `\"...\"` if empty.\n   *\n   * @default \"...\"\n   */\n  ending?: string;\n\n  /** ***Whether to trim the input string before truncation ***(default: `true`)***.***\n   *\n   * @default true\n   */\n  trim?: boolean;\n};\n\n/** ----------------------------------------------------------\n * * ***Utility: `truncateString`.***\n * ----------------------------------------------------------\n * **Features:**\n * - Truncates a string to a specified length and optionally appends an ending.\n * - Supports trimming the input before truncation.\n * - If truncation occurs, trailing spaces before the ending are removed.\n * - The `ending` parameter is always trimmed first; if empty, it defaults to `\"...\"`.\n * @param {string|null|undefined} text\n *  ***The input string to truncate, behavior:***\n *    - If `null`, `undefined`, or empty after trim, returns `\"\"`.\n * @param {TruncateStringOptions} [options]\n *  ***Optional settings:***\n *    - `length` (number, default 10): Maximum length of the truncated string.\n *    - `ending` (string, default `\"...\"`): String to append if truncation occurs.\n *    - `trim` (boolean, default `true`): Whether to trim the input before truncation.\n * @returns {string} The truncated string with optional trimming and ending, returns `\"\"` if input is empty or length < 1.\n * @throws **{@link TypeError | `TypeError`}** if `options.length` is not a finite number, or if `options.ending` is not a string, or if `options.trim` is not a boolean.\n * @example\n * truncateString(\"hello world\", { length: 5 });\n * // ➔ \"hello...\"\n * truncateString(\"hello world\", { length: 5, ending: \"---\" });\n * // ➔ \"hello---\"\n * truncateString(\"hello world\", { length: 5, ending: \"   \" });\n * // ➔ \"hello...\" (ending trimmed to default)\n * truncateString(\"hello world\", { length: 5, ending: \"   !!!   \" });\n * // ➔ \"hello!!!\" (ending trimmed)\n * truncateString(\"   long data string   \", { length: 8, ending: \"...\", trim: true });\n * // ➔ \"long dat...\"\n * truncateString(\"   long data string   \", { length: 8, ending: \"...\", trim: false });\n * // ➔ \"   long ...\"\n * truncateString(null, { length: 5 });\n * // ➔ \"\"\n */\nexport const truncateString = (\n  text: string | null | undefined,\n  options: TruncateStringOptions = {}\n): string => {\n  if (!isNonEmptyString(text)) return \"\";\n\n  assertIsPlainObject(options, {\n    message: ({ currentType, validType }) =>\n      `Seconds parameter (\\`options\\`) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  const trim = hasOwnProp(options, \"trim\") ? options.trim : true;\n  const length = hasOwnProp(options, \"length\") ? options.length : 10;\n  let ending = hasOwnProp(options, \"ending\") ? options.ending : \"...\";\n\n  if (!isInteger(length)) {\n    throw new TypeError(\n      `Parameter \\`length\\` property of the \\`options\\` (second parameter) must be of type \\`integer-number\\`, but received: \\`${getPreciseType(\n        length\n      )}\\`, with value: \\`${safeStableStringify(length, {\n        keepUndefined: true\n      })}\\`.`\n    );\n  }\n\n  if (length < 1) return \"\";\n\n  assertIsString(ending, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`ending\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  assertIsBoolean(trim, {\n    message: ({ currentType, validType }) =>\n      `Parameter \\`trim\\` property of the \\`options\\` (second parameter) must be of type \\`${validType}\\`, but received: \\`${currentType}\\`.`\n  });\n\n  if (isEmptyString(ending)) {\n    ending = \"...\";\n  } else {\n    ending = ending.trim();\n  }\n\n  const original = trim ? text.trim() : text;\n  const originalTrimmedLength = original.length;\n\n  if (originalTrimmedLength <= length) return original;\n\n  const sliced = original.slice(0, length);\n  const cleanSliced = trim ? sliced : sliced.trimEnd();\n\n  return cleanSliced + ending;\n};\n","import type { FormatDateFnsOptions } from \"./_private/formatDateFns.types\";\n\nimport { id, enUS } from \"date-fns/locale\";\nimport { format as formatDns, parse } from \"date-fns\";\n\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isDate } from \"@/predicates/is/isDate\";\nimport { hasOwnProp } from \"@/predicates/has/hasOwnProp\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `formatDateFns`.***\n * ----------------------------------------------------------\n * **Formats a date into a human-readable string using `date-fns`.**\n *  - **Features:**\n *    - Supports custom output formats using `date-fns/format`.\n *    - Can parse localized non-ISO strings via `inputFormat` & `inputLocale`.\n *    - Supports `locale` as `\"id\"`, `\"en\"` or `date-fns` `Locale` objects (like `id` or `enUS`).\n *    - Returns `null` if the date is invalid, not provided, or parsing fails.\n * @param {string | Date | null | undefined} date\n *  ***The date input to format, can be:***\n *   - A `Date` object.\n *   - An ISO string (e.g. `\"2024-01-01T12:00:00Z\"`).\n *   - A localized string (requires `inputFormat` + `inputLocale`).\n * @param {FormatDateFnsOptions} [options] ***Options for formatting and parsing.***\n * @param {FormatDateFnsOptions[\"format\"]} [options.format=\"dd MMM yyyy - HH:mm:ss\"]\n *   ***The output format string (passed to `date-fns/format`), e.g:***\n *    - `\"dd MMMM yyyy, HH:mm:ss\" ➔ \"14 Juli 2025, 17:25:42\"`.\n * @param {FormatDateFnsOptions[\"locale\"]} [options.locale=\"id\"]\n *   The output locale. If string, only `\"id\"` (Indonesian) or `\"en\"` (English)\n *   is recognized. Or you can pass a `date-fns` `Locale` object.\n *   - Example:\n *   ```ts\n *     import { ar } from \"date-fns/locale\";\n *     formatDateFns(new Date(), { locale: ar, format: \"PPPppp\" });\n *   ```\n * @param {FormatDateFnsOptions[\"inputLocale\"]} [options.inputLocale]\n *   Required if `date` is a localized non-ISO string. Used with `inputFormat`.\n *   - Example for Indonesian string:\n *   ```ts\n *     formatDateFns(\"14 Juli 2025 10:25:42\", { inputFormat: \"dd MMMM yyyy HH:mm:ss\", inputLocale: \"id\" });\n *   ```\n * @param {FormatDateFnsOptions[\"inputFormat\"]} [options.inputFormat]\n *   The format string to parse `date` if it is a non-ISO string.\n *   Required together with `inputLocale`.\n * @returns {string | null} A formatted date string or `null` if input is invalid.\n * @example\n * formatDateFns(new Date());\n * // ➔ \"14 Jul 2025 - 17:25:42\"\n * formatDateFns(\"2025-07-14T10:25:42Z\", { format: \"dd/MM/yyyy\", locale: \"en\" });\n * // ➔ \"14/07/2025\"\n * formatDateFns(\"14 Juli 2025 10:25:42\", {\n *   inputFormat: \"dd MMMM yyyy HH:mm:ss\",\n *   inputLocale: \"id\",\n *   format: \"yyyy-MM-dd\"\n * });\n * // ➔ \"2025-07-14\"\n * formatDateFns(null);\n * // ➔ null\n */\nexport const formatDateFns = (\n  date: string | Date | null | undefined,\n  options: FormatDateFnsOptions = {}\n): string | null => {\n  if (isNil(date) || !(isDate(date) || isNonEmptyString(date))) return null;\n\n  // Ensure options is an object and Defensive options check\n  if (!isPlainObject(options)) {\n    options = {};\n  }\n\n  const {\n    inputFormat,\n    locale = \"en\",\n    inputLocale = \"en\",\n    ...restOptions\n  } = options;\n\n  const format =\n    hasOwnProp(options, \"format\") && isNonEmptyString(options.format)\n      ? options.format\n      : \"dd MMM yyyy - HH:mm:ss\";\n\n  let parsedDate: Date;\n\n  try {\n    if (isNonEmptyString(date) && inputFormat && inputLocale) {\n      const valueOfInputLocale = isNonEmptyString(inputLocale)\n        ? inputLocale === \"id\"\n          ? id\n          : enUS\n        : inputLocale;\n\n      parsedDate = parse(date, inputFormat, new Date(), {\n        locale: valueOfInputLocale\n      });\n    } else {\n      parsedDate = new Date(date);\n    }\n\n    if (isNaN(parsedDate.getTime())) return null;\n\n    const valueOfLocale = isNonEmptyString(locale)\n      ? locale === \"id\"\n        ? id\n        : enUS\n      : locale;\n\n    return formatDns(parsedDate, format, {\n      ...restOptions,\n      locale: valueOfLocale\n    });\n  } catch {\n    return null;\n  }\n};\n","import type { FormatDateIntlOptions } from \"./_private/formatDateIntl.types\";\n\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isDate } from \"@/predicates/is/isDate\";\nimport { isPlainObject } from \"@/predicates/is/isPlainObject\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `formatDateIntl`.***\n * ----------------------------------------------------------\n * **Formats a date using the `Intl.DateTimeFormat` API.**\n *  - **Features:**\n *    - Supports custom locales (type-safe `SupportedLocales`).\n *    - Accepts additional `Intl.DateTimeFormatOptions` like `timeZone`, `hour12`, etc.\n *    - Defaults to `\"en-US\"` if `locale` is not provided or is an empty string.\n *    - Returns `null` if the date is invalid, not provided, or options are invalid.\n * @param {string | Date | null | undefined} date\n *  ***The date to format.***\n *    - Can be a `Date` object or an ISO string.\n *    - If invalid or not provided, returns `null`.\n * @param {FormatDateIntlOptions} [options] ***Optional formatting options for `Intl.DateTimeFormat`, use `locale` to specify the language & region format.***\n * @returns {string | null}\n *   - Formatted date string.\n *   - Returns `null` if date is invalid or options are of wrong type.\n * @example\n * formatDateIntl(new Date());\n * // ➔ \"7/14/2025\"\n * formatDateIntl(\"2025-07-14T00:00:00Z\", { locale: \"fr-FR\", dateStyle: \"long\" });\n * // ➔ \"14 juillet 2025\"\n * formatDateIntl(null);\n * // ➔ null\n * formatDateIntl(new Date(), { timeZone: \"UTC\", hour: \"2-digit\", minute: \"2-digit\" });\n * // ➔ \"01:30 AM\"\n */\nexport const formatDateIntl = (\n  date: string | Date | null | undefined,\n  options?: FormatDateIntlOptions\n): string | null => {\n  if (isNil(date) || !(isDate(date) || isNonEmptyString(date))) return null;\n\n  const parsedDate = new Date(date);\n  if (isNaN(parsedDate.getTime())) return null; // Handle invalid dates\n\n  // Ensure options is an object and Defensive options check\n  if (!isPlainObject(options)) {\n    options = {};\n  }\n\n  const { locale = \"en-US\", ...restProps } = options;\n\n  try {\n    return new Intl.DateTimeFormat(\n      isNonEmptyString(locale) ? locale.trim() : \"en-US\",\n      restProps\n    ).format(parsedDate);\n  } catch {\n    return null;\n  }\n};\n","import { isNaN } from \"@/predicates/is/isNaN\";\nimport { isNil } from \"@/predicates/is/isNil\";\nimport { isDate } from \"@/predicates/is/isDate\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `formatDateTime`.***\n * ----------------------------------------------------------\n * **Formats a date and time into a custom string format.**\n *  - **Features:**\n *    - Supports only `YYYY`, `MM`, `DD`, `hh`, `mm`, and `ss` as placeholders.\n *    - Uses a simple string replace (no locale).\n *    - Returns `null` if the date is invalid or not provided.\n *    - Defaults to `\"YYYY-MM-DD hh:mm:ss\"` format if none is specified.\n * @param {string | Date | null| undefined} date - The date to format.\n * @param {string} [format=\"YYYY-MM-DD hh:mm:ss\"] - The desired date format, if format is `null` or `undefined` will force to defaultValue, defaultValue is: `\"YYYY-MM-DD hh:mm:ss\"`.\n * @returns {string | null} The formatted date string or `null` if invalid.\n * @example\n * formatDateTime(new Date());\n * // ➔ \"2024-02-09 14:30:45\" (example output with current time)\n * formatDateTime(\"2023-07-01T14:30:45\");\n * // ➔ \"2023-07-01 14:30:45\"\n * formatDateTime(\"2023-07-01T14:30:45\", \"DD/MM/YYYY\");\n * // ➔ \"01/07/2023\"\n * formatDateTime(\"2023-07-01T14:30:45\", \"YYYY/MM/DD hh-mm-ss\");\n * // ➔ \"2023/07/01 14-30-45\"\n * formatDateTime(\"2023-07-01T14:30:45\", \"hh:mm\");\n * // ➔ \"14:30\"\n * formatDateTime(\"2023-07-01T14:30:45\", \"DATE: YYYY.MM.DD\");\n * // ➔ \"DATE: 2023.07.01\"\n * formatDateTime(\"2023-07-01T14:30:45\", \"Year: YYYY, Time: hh:mm:ss\");\n * // ➔ \"Year: 2023, Time: 14:30:45\"\n * formatDateTime(\"2023-07-01T14:30:45\", \"YYYY-MM\");\n * // ➔ \"2023-07\"\n * formatDateTime(\"2023-07-01T14:30:45\", \"YYYYYYYY\");\n * // ➔ \"20232023\"\n * formatDateTime(\"2023-07-01T14:30:45\", \"hh:mm:ss:ss\");\n * // ➔ \"14:30:45:45\"\n * formatDateTime(\"invalid-date\");\n * // ➔ null\n * formatDateTime(null);\n * // ➔ null\n * formatDateTime(undefined);\n * // ➔ null\n */\nexport const formatDateTime = (\n  date: string | Date | null | undefined,\n  format?: string\n): string | null => {\n  if (isNil(format)) {\n    format = \"YYYY-MM-DD hh:mm:ss\";\n  }\n\n  if (!isString(format)) return null;\n\n  // Handle missing or invalid date input type\n  if (isNil(date) || !(isDate(date) || isNonEmptyString(date))) {\n    return null;\n  }\n\n  try {\n    const parsedDate = new Date(date);\n    if (isNaN(parsedDate.getTime())) return null; // Handle invalid dates\n\n    const pad2 = (n: number) => n.toString().padStart(2, \"0\");\n\n    const map: Record<string, string> = {\n      YYYY: parsedDate.getFullYear().toString(),\n      MM: pad2(parsedDate.getMonth() + 1),\n      DD: pad2(parsedDate.getDate()),\n      hh: pad2(parsedDate.getHours()),\n      mm: pad2(parsedDate.getMinutes()),\n      ss: pad2(parsedDate.getSeconds())\n    };\n\n    const result = Object.entries(map).reduce(\n      (prev, [key, value]) => prev.split(key).join(value),\n      format\n    );\n\n    return !result.includes(\"NaN\") ? result : null;\n  } catch {\n    return null;\n  }\n};\n","import { isNil } from \"@/predicates/is/isNil\";\nimport { isNaN } from \"@/predicates/is/isNaN\";\nimport { isDate } from \"@/predicates/is/isDate\";\nimport { isString } from \"@/predicates/is/isString\";\nimport { isEmptyString } from \"@/predicates/is/isEmptyString\";\nimport { isNonEmptyString } from \"@/predicates/is/isNonEmptyString\";\n\n/** ----------------------------------------------------------\n * * ***Utility: `getGMTOffset`.***\n * ----------------------------------------------------------\n * **Returns the formatted GMT offset (e.g., `+0700`, `-0500`) for a given date.**\n *  - **Features:**\n *    - If `date` is **not provided** or empty string, it defaults to the current date/time.\n *    - If `date` is **invalid** or of wrong type (like object or number), it returns `\"0\"`.\n *    - The returned string follows the **GMT offset format** (`±HHMM`), where:\n *      - `±` is `+` if ahead of UTC, `-` if behind.\n *      - `HH` is two-digit hours.\n *      - `MM` is two-digit minutes.\n * @param {string | Date | null} [date]\n *  ***The date to get the GMT offset from.***\n *   - Accepts `Date` object or ISO date string (e.g., `\"2024-01-01T12:00:00Z\"`).\n *   - If `null`, `undefined`, or empty string, uses current system date.\n *   - If invalid date or wrong type (like `123` or `{}`), returns `\"0\"`.\n * @returns {string} The GMT offset string in format `±HHMM`,\n *   e.g. `\"+0700\"`, `\"-0530\"`, or `\"0\"` if invalid.\n * @example\n * getGMTOffset();\n * // ➔ \"+0700\" (depends on your system timezone)\n * getGMTOffset(new Date(\"2024-02-09T12:00:00Z\"));\n * // ➔ \"+0000\"\n * getGMTOffset(\"2024-02-09\");\n * // ➔ \"+0700\" (depends on your system timezone)\n * getGMTOffset(\"invalid-date\");\n * // ➔ \"0\"\n * getGMTOffset(123);\n * // ➔ \"0\"\n */\nexport const getGMTOffset = (date?: string | Date | null): string => {\n  try {\n    if (isNil(date) || (isString(date) && isEmptyString(date))) {\n      date = new Date(); // Default to current date\n    } else if (!(isDate(date) || isNonEmptyString(date))) {\n      return \"0\"; // Invalid type\n    }\n\n    const parsedDate = new Date(date);\n    if (isNaN(parsedDate.getTime())) return \"0\"; // Handle invalid dates\n\n    const padZero = (num: number) => num.toString().padStart(2, \"0\");\n\n    let offset = parsedDate.getTimezoneOffset();\n    const sign = offset < 0 ? \"+\" : \"-\";\n    offset = Math.abs(offset);\n\n    return `${sign}${padZero(Math.floor(offset / 60))}${padZero(offset % 60)}`;\n  } catch {\n    return \"0\";\n  }\n};\n"],"mappings":"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"}