@kikiutils/shared 10.3.0 → 10.4.1

package/dist/enum.cjs

@@ -3,12 +3,12 @@
 /**
  * Extracts only the numeric values from an enumeration-like object.
  *
- * @template T - The type of the enum object.
+ * @template T - The type of the enum object
  *
- * @param {T} enumObject - The enumeration-like object to extract numeric values from.
- * The object can contain numeric values, string values, or both.
+ * @param {T} enumObject - The enumeration-like object to extract numeric values from,
+ * the object can contain numeric values, string values, or both.
  *
- * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object.
+ * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object
  *
  * @example
  * ```typescript
@@ -29,12 +29,12 @@ function getEnumNumberValues(enumObject) {
 /**
  * Extracts only the string values from an enumeration-like object.
  *
- * @template T - The type of the enum object.
+ * @template T - The type of the enum object
  *
- * @param {T} enumObject - The enumeration-like object to extract string values from.
- * The object can contain numeric values, string values, or both.
+ * @param {T} enumObject - The enumeration-like object to extract string values from,
+ * the object can contain numeric values, string values, or both.
  *
- * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object.
+ * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object
  *
  * @example
  * ```typescript
@@ -59,12 +59,12 @@ function getEnumStringValues(enumObject) {
  * that occurs with numeric enums. It works with pure numeric enums, pure string enums,
  * and mixed enums.
  *
- * @template T - The type of the enum object.
+ * @template T - The type of the enum object
  *
- * @param {T} enumObject - The enumeration-like object to extract values from.
- * The object can contain numeric values, string values, or both.
+ * @param {T} enumObject - The enumeration-like object to extract values from,
+ * the object can contain numeric values, string values, or both.
  *
- * @returns {(T[keyof T])[]} An array containing all the values from the enum object.
+ * @returns {(T[keyof T])[]} An array containing all the values from the enum object
  *
  * @example
  * ```typescript

package/dist/enum.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"enum.cjs","sources":["../src/enum.ts"],"sourcesContent":["/**\n * Extracts only the numeric values from an enumeration-like object.\n *\n * @template T - The type of the enum object.\n *\n * @param {T} enumObject - The enumeration-like object to extract numeric values from.\n * The object can contain numeric values, string values, or both.\n *\n * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object.\n *\n * @example\n * ```typescript\n * import { getEnumNumberValues } from '@kikiutils/shared/enum';\n *\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumNumberValues(RecordType)); // [0, 1]\n * ```\n */\nexport function getEnumNumberValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], number>[] {\n    return getEnumValues(enumObject).filter((value) => typeof value === 'number');\n}\n\n/**\n * Extracts only the string values from an enumeration-like object.\n *\n * @template T - The type of the enum object.\n *\n * @param {T} enumObject - The enumeration-like object to extract string values from.\n * The object can contain numeric values, string values, or both.\n *\n * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object.\n *\n * @example\n * ```typescript\n * import { getEnumStringValues } from '@kikiutils/shared/enum';\n *\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumStringValues(RecordType)); // ['unknown']\n * ```\n */\nexport function getEnumStringValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], string>[] {\n    return getEnumValues(enumObject).filter((value) => typeof value === 'string');\n}\n\n/**\n * Extracts all values from an enumeration-like object.\n *\n * This function handles TypeScript enums correctly by accounting for the reverse mapping\n * that occurs with numeric enums. It works with pure numeric enums, pure string enums,\n * and mixed enums.\n *\n * @template T - The type of the enum object.\n *\n * @param {T} enumObject - The enumeration-like object to extract values from.\n * The object can contain numeric values, string values, or both.\n *\n * @returns {(T[keyof T])[]} An array containing all the values from the enum object.\n *\n * @example\n * ```typescript\n * import { getEnumValues } from '@kikiutils/shared/enum';\n *\n * // Numeric enum\n * enum Status {\n *   Active = 0,\n *   Inactive = 1,\n *   Pending = 2\n * }\n *\n * console.log(getEnumValues(Status)); // [0, 1, 2]\n *\n * // String enum\n * enum Color {\n *   Red = 'RED',\n *   Green = 'GREEN',\n *   Blue = 'BLUE'\n * }\n *\n * console.log(getEnumValues(Color)); // ['RED', 'GREEN', 'BLUE']\n *\n * // Mixed enum\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumValues(RecordType)); // [0, 1, 'unknown']\n * ```\n */\nexport function getEnumValues<T extends Record<string, any>>(enumObject: T): (T[keyof T])[] {\n    const values = Object.values(enumObject);\n    const hasNumberValues = values.some((value) => typeof value === 'number');\n    if (!hasNumberValues) return values;\n    return Object.keys(enumObject).filter((key) => Number.isNaN(Number(key))).map((key) => enumObject[key]);\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,mBAAmB,CAAgC,UAAa,EAAA;AAC5E,IAAA,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACjF;AAEA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,mBAAmB,CAAgC,UAAa,EAAA;AAC5E,IAAA,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACjF;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CG;AACG,SAAU,aAAa,CAAgC,UAAa,EAAA;IACtE,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;AACxC,IAAA,MAAM,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACzE,IAAA,IAAI,CAAC,eAAe;AAAE,QAAA,OAAO,MAAM;AACnC,IAAA,OAAO,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,UAAU,CAAC,GAAG,CAAC,CAAC;AAC3G;;;;;;"}
+{"version":3,"file":"enum.cjs","sources":["../src/enum.ts"],"sourcesContent":["/**\n * Extracts only the numeric values from an enumeration-like object.\n *\n * @template T - The type of the enum object\n *\n * @param {T} enumObject - The enumeration-like object to extract numeric values from,\n * the object can contain numeric values, string values, or both.\n *\n * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object\n *\n * @example\n * ```typescript\n * import { getEnumNumberValues } from '@kikiutils/shared/enum';\n *\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumNumberValues(RecordType)); // [0, 1]\n * ```\n */\nexport function getEnumNumberValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], number>[] {\n    return getEnumValues(enumObject).filter((value) => typeof value === 'number');\n}\n\n/**\n * Extracts only the string values from an enumeration-like object.\n *\n * @template T - The type of the enum object\n *\n * @param {T} enumObject - The enumeration-like object to extract string values from,\n * the object can contain numeric values, string values, or both.\n *\n * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object\n *\n * @example\n * ```typescript\n * import { getEnumStringValues } from '@kikiutils/shared/enum';\n *\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumStringValues(RecordType)); // ['unknown']\n * ```\n */\nexport function getEnumStringValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], string>[] {\n    return getEnumValues(enumObject).filter((value) => typeof value === 'string');\n}\n\n/**\n * Extracts all values from an enumeration-like object.\n *\n * This function handles TypeScript enums correctly by accounting for the reverse mapping\n * that occurs with numeric enums. It works with pure numeric enums, pure string enums,\n * and mixed enums.\n *\n * @template T - The type of the enum object\n *\n * @param {T} enumObject - The enumeration-like object to extract values from,\n * the object can contain numeric values, string values, or both.\n *\n * @returns {(T[keyof T])[]} An array containing all the values from the enum object\n *\n * @example\n * ```typescript\n * import { getEnumValues } from '@kikiutils/shared/enum';\n *\n * // Numeric enum\n * enum Status {\n *   Active = 0,\n *   Inactive = 1,\n *   Pending = 2\n * }\n *\n * console.log(getEnumValues(Status)); // [0, 1, 2]\n *\n * // String enum\n * enum Color {\n *   Red = 'RED',\n *   Green = 'GREEN',\n *   Blue = 'BLUE'\n * }\n *\n * console.log(getEnumValues(Color)); // ['RED', 'GREEN', 'BLUE']\n *\n * // Mixed enum\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumValues(RecordType)); // [0, 1, 'unknown']\n * ```\n */\nexport function getEnumValues<T extends Record<string, any>>(enumObject: T): (T[keyof T])[] {\n    const values = Object.values(enumObject);\n    const hasNumberValues = values.some((value) => typeof value === 'number');\n    if (!hasNumberValues) return values;\n    return Object.keys(enumObject).filter((key) => Number.isNaN(Number(key))).map((key) => enumObject[key]);\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,mBAAmB,CAAgC,UAAa,EAAA;AAC5E,IAAA,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACjF;AAEA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,mBAAmB,CAAgC,UAAa,EAAA;AAC5E,IAAA,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACjF;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CG;AACG,SAAU,aAAa,CAAgC,UAAa,EAAA;IACtE,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;AACxC,IAAA,MAAM,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACzE,IAAA,IAAI,CAAC,eAAe;AAAE,QAAA,OAAO,MAAM;AACnC,IAAA,OAAO,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,UAAU,CAAC,GAAG,CAAC,CAAC;AAC3G;;;;;;"}

package/dist/enum.d.ts

@@ -1,12 +1,12 @@
 /**
  * Extracts only the numeric values from an enumeration-like object.
  *
- * @template T - The type of the enum object.
+ * @template T - The type of the enum object
  *
- * @param {T} enumObject - The enumeration-like object to extract numeric values from.
- * The object can contain numeric values, string values, or both.
+ * @param {T} enumObject - The enumeration-like object to extract numeric values from,
+ * the object can contain numeric values, string values, or both.
  *
- * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object.
+ * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object
  *
  * @example
  * ```typescript
@@ -25,12 +25,12 @@ export declare function getEnumNumberValues<T extends Record<string, any>>(enumO
 /**
  * Extracts only the string values from an enumeration-like object.
  *
- * @template T - The type of the enum object.
+ * @template T - The type of the enum object
  *
- * @param {T} enumObject - The enumeration-like object to extract string values from.
- * The object can contain numeric values, string values, or both.
+ * @param {T} enumObject - The enumeration-like object to extract string values from,
+ * the object can contain numeric values, string values, or both.
  *
- * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object.
+ * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object
  *
  * @example
  * ```typescript
@@ -53,12 +53,12 @@ export declare function getEnumStringValues<T extends Record<string, any>>(enumO
  * that occurs with numeric enums. It works with pure numeric enums, pure string enums,
  * and mixed enums.
  *
- * @template T - The type of the enum object.
+ * @template T - The type of the enum object
  *
- * @param {T} enumObject - The enumeration-like object to extract values from.
- * The object can contain numeric values, string values, or both.
+ * @param {T} enumObject - The enumeration-like object to extract values from,
+ * the object can contain numeric values, string values, or both.
  *
- * @returns {(T[keyof T])[]} An array containing all the values from the enum object.
+ * @returns {(T[keyof T])[]} An array containing all the values from the enum object
  *
  * @example
  * ```typescript

package/dist/enum.mjs

@@ -1,12 +1,12 @@
 /**
  * Extracts only the numeric values from an enumeration-like object.
  *
- * @template T - The type of the enum object.
+ * @template T - The type of the enum object
  *
- * @param {T} enumObject - The enumeration-like object to extract numeric values from.
- * The object can contain numeric values, string values, or both.
+ * @param {T} enumObject - The enumeration-like object to extract numeric values from,
+ * the object can contain numeric values, string values, or both.
  *
- * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object.
+ * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object
  *
  * @example
  * ```typescript
@@ -27,12 +27,12 @@ function getEnumNumberValues(enumObject) {
 /**
  * Extracts only the string values from an enumeration-like object.
  *
- * @template T - The type of the enum object.
+ * @template T - The type of the enum object
  *
- * @param {T} enumObject - The enumeration-like object to extract string values from.
- * The object can contain numeric values, string values, or both.
+ * @param {T} enumObject - The enumeration-like object to extract string values from,
+ * the object can contain numeric values, string values, or both.
  *
- * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object.
+ * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object
  *
  * @example
  * ```typescript
@@ -57,12 +57,12 @@ function getEnumStringValues(enumObject) {
  * that occurs with numeric enums. It works with pure numeric enums, pure string enums,
  * and mixed enums.
  *
- * @template T - The type of the enum object.
+ * @template T - The type of the enum object
  *
- * @param {T} enumObject - The enumeration-like object to extract values from.
- * The object can contain numeric values, string values, or both.
+ * @param {T} enumObject - The enumeration-like object to extract values from,
+ * the object can contain numeric values, string values, or both.
  *
- * @returns {(T[keyof T])[]} An array containing all the values from the enum object.
+ * @returns {(T[keyof T])[]} An array containing all the values from the enum object
  *
  * @example
  * ```typescript

package/dist/enum.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"enum.mjs","sources":["../src/enum.ts"],"sourcesContent":["/**\n * Extracts only the numeric values from an enumeration-like object.\n *\n * @template T - The type of the enum object.\n *\n * @param {T} enumObject - The enumeration-like object to extract numeric values from.\n * The object can contain numeric values, string values, or both.\n *\n * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object.\n *\n * @example\n * ```typescript\n * import { getEnumNumberValues } from '@kikiutils/shared/enum';\n *\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumNumberValues(RecordType)); // [0, 1]\n * ```\n */\nexport function getEnumNumberValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], number>[] {\n    return getEnumValues(enumObject).filter((value) => typeof value === 'number');\n}\n\n/**\n * Extracts only the string values from an enumeration-like object.\n *\n * @template T - The type of the enum object.\n *\n * @param {T} enumObject - The enumeration-like object to extract string values from.\n * The object can contain numeric values, string values, or both.\n *\n * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object.\n *\n * @example\n * ```typescript\n * import { getEnumStringValues } from '@kikiutils/shared/enum';\n *\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumStringValues(RecordType)); // ['unknown']\n * ```\n */\nexport function getEnumStringValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], string>[] {\n    return getEnumValues(enumObject).filter((value) => typeof value === 'string');\n}\n\n/**\n * Extracts all values from an enumeration-like object.\n *\n * This function handles TypeScript enums correctly by accounting for the reverse mapping\n * that occurs with numeric enums. It works with pure numeric enums, pure string enums,\n * and mixed enums.\n *\n * @template T - The type of the enum object.\n *\n * @param {T} enumObject - The enumeration-like object to extract values from.\n * The object can contain numeric values, string values, or both.\n *\n * @returns {(T[keyof T])[]} An array containing all the values from the enum object.\n *\n * @example\n * ```typescript\n * import { getEnumValues } from '@kikiutils/shared/enum';\n *\n * // Numeric enum\n * enum Status {\n *   Active = 0,\n *   Inactive = 1,\n *   Pending = 2\n * }\n *\n * console.log(getEnumValues(Status)); // [0, 1, 2]\n *\n * // String enum\n * enum Color {\n *   Red = 'RED',\n *   Green = 'GREEN',\n *   Blue = 'BLUE'\n * }\n *\n * console.log(getEnumValues(Color)); // ['RED', 'GREEN', 'BLUE']\n *\n * // Mixed enum\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumValues(RecordType)); // [0, 1, 'unknown']\n * ```\n */\nexport function getEnumValues<T extends Record<string, any>>(enumObject: T): (T[keyof T])[] {\n    const values = Object.values(enumObject);\n    const hasNumberValues = values.some((value) => typeof value === 'number');\n    if (!hasNumberValues) return values;\n    return Object.keys(enumObject).filter((key) => Number.isNaN(Number(key))).map((key) => enumObject[key]);\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,mBAAmB,CAAgC,UAAa,EAAA;AAC5E,IAAA,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACjF;AAEA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,mBAAmB,CAAgC,UAAa,EAAA;AAC5E,IAAA,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACjF;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CG;AACG,SAAU,aAAa,CAAgC,UAAa,EAAA;IACtE,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;AACxC,IAAA,MAAM,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACzE,IAAA,IAAI,CAAC,eAAe;AAAE,QAAA,OAAO,MAAM;AACnC,IAAA,OAAO,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,UAAU,CAAC,GAAG,CAAC,CAAC;AAC3G;;;;"}
+{"version":3,"file":"enum.mjs","sources":["../src/enum.ts"],"sourcesContent":["/**\n * Extracts only the numeric values from an enumeration-like object.\n *\n * @template T - The type of the enum object\n *\n * @param {T} enumObject - The enumeration-like object to extract numeric values from,\n * the object can contain numeric values, string values, or both.\n *\n * @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object\n *\n * @example\n * ```typescript\n * import { getEnumNumberValues } from '@kikiutils/shared/enum';\n *\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumNumberValues(RecordType)); // [0, 1]\n * ```\n */\nexport function getEnumNumberValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], number>[] {\n    return getEnumValues(enumObject).filter((value) => typeof value === 'number');\n}\n\n/**\n * Extracts only the string values from an enumeration-like object.\n *\n * @template T - The type of the enum object\n *\n * @param {T} enumObject - The enumeration-like object to extract string values from,\n * the object can contain numeric values, string values, or both.\n *\n * @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object\n *\n * @example\n * ```typescript\n * import { getEnumStringValues } from '@kikiutils/shared/enum';\n *\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumStringValues(RecordType)); // ['unknown']\n * ```\n */\nexport function getEnumStringValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], string>[] {\n    return getEnumValues(enumObject).filter((value) => typeof value === 'string');\n}\n\n/**\n * Extracts all values from an enumeration-like object.\n *\n * This function handles TypeScript enums correctly by accounting for the reverse mapping\n * that occurs with numeric enums. It works with pure numeric enums, pure string enums,\n * and mixed enums.\n *\n * @template T - The type of the enum object\n *\n * @param {T} enumObject - The enumeration-like object to extract values from,\n * the object can contain numeric values, string values, or both.\n *\n * @returns {(T[keyof T])[]} An array containing all the values from the enum object\n *\n * @example\n * ```typescript\n * import { getEnumValues } from '@kikiutils/shared/enum';\n *\n * // Numeric enum\n * enum Status {\n *   Active = 0,\n *   Inactive = 1,\n *   Pending = 2\n * }\n *\n * console.log(getEnumValues(Status)); // [0, 1, 2]\n *\n * // String enum\n * enum Color {\n *   Red = 'RED',\n *   Green = 'GREEN',\n *   Blue = 'BLUE'\n * }\n *\n * console.log(getEnumValues(Color)); // ['RED', 'GREEN', 'BLUE']\n *\n * // Mixed enum\n * enum RecordType {\n *   Receive = 0,\n *   Send = 1,\n *   Unknown = 'unknown'\n * }\n *\n * console.log(getEnumValues(RecordType)); // [0, 1, 'unknown']\n * ```\n */\nexport function getEnumValues<T extends Record<string, any>>(enumObject: T): (T[keyof T])[] {\n    const values = Object.values(enumObject);\n    const hasNumberValues = values.some((value) => typeof value === 'number');\n    if (!hasNumberValues) return values;\n    return Object.keys(enumObject).filter((key) => Number.isNaN(Number(key))).map((key) => enumObject[key]);\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,mBAAmB,CAAgC,UAAa,EAAA;AAC5E,IAAA,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACjF;AAEA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,mBAAmB,CAAgC,UAAa,EAAA;AAC5E,IAAA,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACjF;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CG;AACG,SAAU,aAAa,CAAgC,UAAa,EAAA;IACtE,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;AACxC,IAAA,MAAM,eAAe,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,KAAK,OAAO,KAAK,KAAK,QAAQ,CAAC;AACzE,IAAA,IAAI,CAAC,eAAe;AAAE,QAAA,OAAO,MAAM;AACnC,IAAA,OAAO,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,UAAU,CAAC,GAAG,CAAC,CAAC;AAC3G;;;;"}

package/dist/env.cjs

@@ -12,7 +12,7 @@ class EnvironmentNotFoundError extends Error {
     /**
      * Creates a new EnvironmentNotFoundError.
      *
-     * @param {string} key - The missing environment variable key.
+     * @param {string} key - The missing environment variable key
      */
     constructor(key) {
         super(`Missing environment variable: ${key}`);
@@ -27,11 +27,11 @@ class EnvironmentNotFoundError extends Error {
  * Only checks for `process.env[key] === undefined`. An empty string (e.g. '') or any falsy string
  * value like `'0'` or `'false'` is considered a valid (defined) value.
  *
- * @param {string} key - The environment variable key to retrieve.
+ * @param {string} key - The environment variable key to retrieve
  *
- * @returns {string} The value of the environment variable.
+ * @returns {string} The value of the environment variable
  *
- * @throws {EnvironmentNotFoundError} If the environment variable is not defined.
+ * @throws {EnvironmentNotFoundError} If the environment variable is not defined
  *
  * @example
  * ```typescript

package/dist/env.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"env.cjs","sources":["../src/env.ts"],"sourcesContent":["/**\n * Custom error class for handling missing environment variables.\n *\n * Extends the built-in `Error` class and includes the missing key.\n *\n * @extends {Error}\n */\nexport class EnvironmentNotFoundError extends Error {\n    readonly key: string;\n\n    /**\n     * Creates a new EnvironmentNotFoundError.\n     *\n     * @param {string} key - The missing environment variable key.\n     */\n    constructor(key: string) {\n        super(`Missing environment variable: ${key}`);\n        this.key = key;\n        this.name = this.constructor.name;\n        Error.captureStackTrace?.(this, this.constructor);\n    }\n}\n\n/**\n * Retrieves the value of an environment variable, or throws an error if it is not defined.\n *\n * Only checks for `process.env[key] === undefined`. An empty string (e.g. '') or any falsy string\n * value like `'0'` or `'false'` is considered a valid (defined) value.\n *\n * @param {string} key - The environment variable key to retrieve.\n *\n * @returns {string} The value of the environment variable.\n *\n * @throws {EnvironmentNotFoundError} If the environment variable is not defined.\n *\n * @example\n * ```typescript\n * process.env.API_KEY = '';\n * checkAndGetEnvValue('API_KEY'); // ✅ Returns '' (still considered \"defined\")\n *\n * delete process.env.API_KEY;\n * checkAndGetEnvValue('API_KEY'); // ❌ Throws EnvironmentNotFoundError\n * ```\n */\nexport function checkAndGetEnvValue(key: string): string {\n    if (process.env[key] === undefined) throw new EnvironmentNotFoundError(key);\n    return process.env[key];\n}\n"],"names":[],"mappings":";;AAAA;;;;;;AAMG;AACG,MAAO,wBAAyB,SAAQ,KAAK,CAAA;AACtC,IAAA,GAAG;AAEZ;;;;AAIG;AACH,IAAA,WAAA,CAAY,GAAW,EAAA;AACnB,QAAA,KAAK,CAAC,CAAA,8BAAA,EAAiC,GAAG,CAAA,CAAE,CAAC;AAC7C,QAAA,IAAI,CAAC,GAAG,GAAG,GAAG;QACd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI;QACjC,KAAK,CAAC,iBAAiB,GAAG,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC;IACrD;AACH;AAED;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,mBAAmB,CAAC,GAAW,EAAA;AAC3C,IAAA,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS;AAAE,QAAA,MAAM,IAAI,wBAAwB,CAAC,GAAG,CAAC;AAC3E,IAAA,OAAO,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;AAC3B;;;;;"}
+{"version":3,"file":"env.cjs","sources":["../src/env.ts"],"sourcesContent":["/**\n * Custom error class for handling missing environment variables.\n *\n * Extends the built-in `Error` class and includes the missing key.\n *\n * @extends {Error}\n */\nexport class EnvironmentNotFoundError extends Error {\n    readonly key: string;\n\n    /**\n     * Creates a new EnvironmentNotFoundError.\n     *\n     * @param {string} key - The missing environment variable key\n     */\n    constructor(key: string) {\n        super(`Missing environment variable: ${key}`);\n        this.key = key;\n        this.name = this.constructor.name;\n        Error.captureStackTrace?.(this, this.constructor);\n    }\n}\n\n/**\n * Retrieves the value of an environment variable, or throws an error if it is not defined.\n *\n * Only checks for `process.env[key] === undefined`. An empty string (e.g. '') or any falsy string\n * value like `'0'` or `'false'` is considered a valid (defined) value.\n *\n * @param {string} key - The environment variable key to retrieve\n *\n * @returns {string} The value of the environment variable\n *\n * @throws {EnvironmentNotFoundError} If the environment variable is not defined\n *\n * @example\n * ```typescript\n * process.env.API_KEY = '';\n * checkAndGetEnvValue('API_KEY'); // ✅ Returns '' (still considered \"defined\")\n *\n * delete process.env.API_KEY;\n * checkAndGetEnvValue('API_KEY'); // ❌ Throws EnvironmentNotFoundError\n * ```\n */\nexport function checkAndGetEnvValue(key: string): string {\n    if (process.env[key] === undefined) throw new EnvironmentNotFoundError(key);\n    return process.env[key];\n}\n"],"names":[],"mappings":";;AAAA;;;;;;AAMG;AACG,MAAO,wBAAyB,SAAQ,KAAK,CAAA;AACtC,IAAA,GAAG;AAEZ;;;;AAIG;AACH,IAAA,WAAA,CAAY,GAAW,EAAA;AACnB,QAAA,KAAK,CAAC,CAAA,8BAAA,EAAiC,GAAG,CAAA,CAAE,CAAC;AAC7C,QAAA,IAAI,CAAC,GAAG,GAAG,GAAG;QACd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI;QACjC,KAAK,CAAC,iBAAiB,GAAG,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC;IACrD;AACH;AAED;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,mBAAmB,CAAC,GAAW,EAAA;AAC3C,IAAA,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS;AAAE,QAAA,MAAM,IAAI,wBAAwB,CAAC,GAAG,CAAC;AAC3E,IAAA,OAAO,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;AAC3B;;;;;"}

package/dist/env.d.ts

@@ -10,7 +10,7 @@ export declare class EnvironmentNotFoundError extends Error {
     /**
      * Creates a new EnvironmentNotFoundError.
      *
-     * @param {string} key - The missing environment variable key.
+     * @param {string} key - The missing environment variable key
      */
     constructor(key: string);
 }
@@ -20,11 +20,11 @@ export declare class EnvironmentNotFoundError extends Error {
  * Only checks for `process.env[key] === undefined`. An empty string (e.g. '') or any falsy string
  * value like `'0'` or `'false'` is considered a valid (defined) value.
  *
- * @param {string} key - The environment variable key to retrieve.
+ * @param {string} key - The environment variable key to retrieve
  *
- * @returns {string} The value of the environment variable.
+ * @returns {string} The value of the environment variable
  *
- * @throws {EnvironmentNotFoundError} If the environment variable is not defined.
+ * @throws {EnvironmentNotFoundError} If the environment variable is not defined
  *
  * @example
  * ```typescript

package/dist/env.mjs

@@ -10,7 +10,7 @@ class EnvironmentNotFoundError extends Error {
     /**
      * Creates a new EnvironmentNotFoundError.
      *
-     * @param {string} key - The missing environment variable key.
+     * @param {string} key - The missing environment variable key
      */
     constructor(key) {
         super(`Missing environment variable: ${key}`);
@@ -25,11 +25,11 @@ class EnvironmentNotFoundError extends Error {
  * Only checks for `process.env[key] === undefined`. An empty string (e.g. '') or any falsy string
  * value like `'0'` or `'false'` is considered a valid (defined) value.
  *
- * @param {string} key - The environment variable key to retrieve.
+ * @param {string} key - The environment variable key to retrieve
  *
- * @returns {string} The value of the environment variable.
+ * @returns {string} The value of the environment variable
  *
- * @throws {EnvironmentNotFoundError} If the environment variable is not defined.
+ * @throws {EnvironmentNotFoundError} If the environment variable is not defined
  *
  * @example
  * ```typescript

package/dist/env.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"env.mjs","sources":["../src/env.ts"],"sourcesContent":["/**\n * Custom error class for handling missing environment variables.\n *\n * Extends the built-in `Error` class and includes the missing key.\n *\n * @extends {Error}\n */\nexport class EnvironmentNotFoundError extends Error {\n    readonly key: string;\n\n    /**\n     * Creates a new EnvironmentNotFoundError.\n     *\n     * @param {string} key - The missing environment variable key.\n     */\n    constructor(key: string) {\n        super(`Missing environment variable: ${key}`);\n        this.key = key;\n        this.name = this.constructor.name;\n        Error.captureStackTrace?.(this, this.constructor);\n    }\n}\n\n/**\n * Retrieves the value of an environment variable, or throws an error if it is not defined.\n *\n * Only checks for `process.env[key] === undefined`. An empty string (e.g. '') or any falsy string\n * value like `'0'` or `'false'` is considered a valid (defined) value.\n *\n * @param {string} key - The environment variable key to retrieve.\n *\n * @returns {string} The value of the environment variable.\n *\n * @throws {EnvironmentNotFoundError} If the environment variable is not defined.\n *\n * @example\n * ```typescript\n * process.env.API_KEY = '';\n * checkAndGetEnvValue('API_KEY'); // ✅ Returns '' (still considered \"defined\")\n *\n * delete process.env.API_KEY;\n * checkAndGetEnvValue('API_KEY'); // ❌ Throws EnvironmentNotFoundError\n * ```\n */\nexport function checkAndGetEnvValue(key: string): string {\n    if (process.env[key] === undefined) throw new EnvironmentNotFoundError(key);\n    return process.env[key];\n}\n"],"names":[],"mappings":"AAAA;;;;;;AAMG;AACG,MAAO,wBAAyB,SAAQ,KAAK,CAAA;AACtC,IAAA,GAAG;AAEZ;;;;AAIG;AACH,IAAA,WAAA,CAAY,GAAW,EAAA;AACnB,QAAA,KAAK,CAAC,CAAA,8BAAA,EAAiC,GAAG,CAAA,CAAE,CAAC;AAC7C,QAAA,IAAI,CAAC,GAAG,GAAG,GAAG;QACd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI;QACjC,KAAK,CAAC,iBAAiB,GAAG,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC;IACrD;AACH;AAED;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,mBAAmB,CAAC,GAAW,EAAA;AAC3C,IAAA,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS;AAAE,QAAA,MAAM,IAAI,wBAAwB,CAAC,GAAG,CAAC;AAC3E,IAAA,OAAO,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;AAC3B;;;;"}
+{"version":3,"file":"env.mjs","sources":["../src/env.ts"],"sourcesContent":["/**\n * Custom error class for handling missing environment variables.\n *\n * Extends the built-in `Error` class and includes the missing key.\n *\n * @extends {Error}\n */\nexport class EnvironmentNotFoundError extends Error {\n    readonly key: string;\n\n    /**\n     * Creates a new EnvironmentNotFoundError.\n     *\n     * @param {string} key - The missing environment variable key\n     */\n    constructor(key: string) {\n        super(`Missing environment variable: ${key}`);\n        this.key = key;\n        this.name = this.constructor.name;\n        Error.captureStackTrace?.(this, this.constructor);\n    }\n}\n\n/**\n * Retrieves the value of an environment variable, or throws an error if it is not defined.\n *\n * Only checks for `process.env[key] === undefined`. An empty string (e.g. '') or any falsy string\n * value like `'0'` or `'false'` is considered a valid (defined) value.\n *\n * @param {string} key - The environment variable key to retrieve\n *\n * @returns {string} The value of the environment variable\n *\n * @throws {EnvironmentNotFoundError} If the environment variable is not defined\n *\n * @example\n * ```typescript\n * process.env.API_KEY = '';\n * checkAndGetEnvValue('API_KEY'); // ✅ Returns '' (still considered \"defined\")\n *\n * delete process.env.API_KEY;\n * checkAndGetEnvValue('API_KEY'); // ❌ Throws EnvironmentNotFoundError\n * ```\n */\nexport function checkAndGetEnvValue(key: string): string {\n    if (process.env[key] === undefined) throw new EnvironmentNotFoundError(key);\n    return process.env[key];\n}\n"],"names":[],"mappings":"AAAA;;;;;;AAMG;AACG,MAAO,wBAAyB,SAAQ,KAAK,CAAA;AACtC,IAAA,GAAG;AAEZ;;;;AAIG;AACH,IAAA,WAAA,CAAY,GAAW,EAAA;AACnB,QAAA,KAAK,CAAC,CAAA,8BAAA,EAAiC,GAAG,CAAA,CAAE,CAAC;AAC7C,QAAA,IAAI,CAAC,GAAG,GAAG,GAAG;QACd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI;QACjC,KAAK,CAAC,iBAAiB,GAAG,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC;IACrD;AACH;AAED;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,mBAAmB,CAAC,GAAW,EAAA;AAC3C,IAAA,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS;AAAE,QAAA,MAAM,IAAI,wBAAwB,CAAC,GAAG,CAAC;AAC3E,IAAA,OAAO,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;AAC3B;;;;"}

package/dist/general.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"general.cjs","sources":["../src/general.ts"],"sourcesContent":["/* eslint-disable jsdoc/check-param-names */\n\n/**\n * Extracts the first value from an array or returns the value itself if it's not an array.\n *\n * - If `value` is an array, returns the first element.\n * - If `value` is not an array, returns `value` directly.\n * - If the result is `null` or `undefined`, and `defaultValue` is provided, returns `defaultValue` instead.\n *\n * @template T - The type of the input value(s).\n * @template D - The type of the default value (if provided).\n *\n * @param {T | T[]} value - A single value or an array of values.\n * @param {D} [defaultValue] - A fallback value if the result is `null` or `undefined`.\n *\n * @returns {T | D | undefined} The first value or the fallback.\n *\n * @example\n * ```typescript\n * import { extractFirstValue } from '@kikiutils/shared/general';\n *\n * console.log(extractFirstValue([1, 2, 3])); // 1\n * console.log(extractFirstValue('hello'));  // hello\n * console.log(extractFirstValue([], 'default')); // default\n * console.log(extractFirstValue(undefined, 'fallback')); // fallback\n * ```\n */\nexport function extractFirstValue<T>(value: T | T[]): T | undefined;\nexport function extractFirstValue<T, D>(value: T | T[], defaultValue: D): D | NonNullable<T>;\nexport function extractFirstValue<T, D>(value: T | T[], defaultValue?: D) {\n    return (Array.isArray(value) ? value[0] : value) ?? defaultValue;\n}\n\n/* eslint-enable jsdoc/check-param-names */\n"],"names":[],"mappings":";;AAAA;AA6BM,SAAU,iBAAiB,CAAO,KAAc,EAAE,YAAgB,EAAA;IACpE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,KAAK,YAAY;AACpE;AAEA;;;;"}
+{"version":3,"file":"general.cjs","sources":["../src/general.ts"],"sourcesContent":["/* eslint-disable jsdoc/check-param-names */\n\n/**\n * Extracts the first value from an array or returns the value itself if it's not an array.\n *\n * - If `value` is an array, returns the first element.\n * - If `value` is not an array, returns `value` directly.\n * - If the result is `null` or `undefined`, and `defaultValue` is provided, returns `defaultValue` instead.\n *\n * @template T - The type of the input value(s)\n * @template D - The type of the default value (if provided)\n *\n * @param {T | T[]} value - A single value or an array of values\n * @param {D} [defaultValue] - A fallback value if the result is `null` or `undefined`\n *\n * @returns {T | D | undefined} The first value or the fallback\n *\n * @example\n * ```typescript\n * import { extractFirstValue } from '@kikiutils/shared/general';\n *\n * console.log(extractFirstValue([1, 2, 3])); // 1\n * console.log(extractFirstValue('hello'));  // hello\n * console.log(extractFirstValue([], 'default')); // default\n * console.log(extractFirstValue(undefined, 'fallback')); // fallback\n * ```\n */\nexport function extractFirstValue<T>(value: T | T[]): T | undefined;\nexport function extractFirstValue<T, D>(value: T | T[], defaultValue: D): D | NonNullable<T>;\nexport function extractFirstValue<T, D>(value: T | T[], defaultValue?: D) {\n    return (Array.isArray(value) ? value[0] : value) ?? defaultValue;\n}\n\n/* eslint-enable jsdoc/check-param-names */\n"],"names":[],"mappings":";;AAAA;AA6BM,SAAU,iBAAiB,CAAO,KAAc,EAAE,YAAgB,EAAA;IACpE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,KAAK,YAAY;AACpE;AAEA;;;;"}

package/dist/general.d.ts

@@ -5,13 +5,13 @@
  * - If `value` is not an array, returns `value` directly.
  * - If the result is `null` or `undefined`, and `defaultValue` is provided, returns `defaultValue` instead.
  *
- * @template T - The type of the input value(s).
- * @template D - The type of the default value (if provided).
+ * @template T - The type of the input value(s)
+ * @template D - The type of the default value (if provided)
  *
- * @param {T | T[]} value - A single value or an array of values.
- * @param {D} [defaultValue] - A fallback value if the result is `null` or `undefined`.
+ * @param {T | T[]} value - A single value or an array of values
+ * @param {D} [defaultValue] - A fallback value if the result is `null` or `undefined`
  *
- * @returns {T | D | undefined} The first value or the fallback.
+ * @returns {T | D | undefined} The first value or the fallback
  *
  * @example
  * ```typescript

package/dist/general.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"general.mjs","sources":["../src/general.ts"],"sourcesContent":["/* eslint-disable jsdoc/check-param-names */\n\n/**\n * Extracts the first value from an array or returns the value itself if it's not an array.\n *\n * - If `value` is an array, returns the first element.\n * - If `value` is not an array, returns `value` directly.\n * - If the result is `null` or `undefined`, and `defaultValue` is provided, returns `defaultValue` instead.\n *\n * @template T - The type of the input value(s).\n * @template D - The type of the default value (if provided).\n *\n * @param {T | T[]} value - A single value or an array of values.\n * @param {D} [defaultValue] - A fallback value if the result is `null` or `undefined`.\n *\n * @returns {T | D | undefined} The first value or the fallback.\n *\n * @example\n * ```typescript\n * import { extractFirstValue } from '@kikiutils/shared/general';\n *\n * console.log(extractFirstValue([1, 2, 3])); // 1\n * console.log(extractFirstValue('hello'));  // hello\n * console.log(extractFirstValue([], 'default')); // default\n * console.log(extractFirstValue(undefined, 'fallback')); // fallback\n * ```\n */\nexport function extractFirstValue<T>(value: T | T[]): T | undefined;\nexport function extractFirstValue<T, D>(value: T | T[], defaultValue: D): D | NonNullable<T>;\nexport function extractFirstValue<T, D>(value: T | T[], defaultValue?: D) {\n    return (Array.isArray(value) ? value[0] : value) ?? defaultValue;\n}\n\n/* eslint-enable jsdoc/check-param-names */\n"],"names":[],"mappings":"AAAA;AA6BM,SAAU,iBAAiB,CAAO,KAAc,EAAE,YAAgB,EAAA;IACpE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,KAAK,YAAY;AACpE;AAEA;;;;"}
+{"version":3,"file":"general.mjs","sources":["../src/general.ts"],"sourcesContent":["/* eslint-disable jsdoc/check-param-names */\n\n/**\n * Extracts the first value from an array or returns the value itself if it's not an array.\n *\n * - If `value` is an array, returns the first element.\n * - If `value` is not an array, returns `value` directly.\n * - If the result is `null` or `undefined`, and `defaultValue` is provided, returns `defaultValue` instead.\n *\n * @template T - The type of the input value(s)\n * @template D - The type of the default value (if provided)\n *\n * @param {T | T[]} value - A single value or an array of values\n * @param {D} [defaultValue] - A fallback value if the result is `null` or `undefined`\n *\n * @returns {T | D | undefined} The first value or the fallback\n *\n * @example\n * ```typescript\n * import { extractFirstValue } from '@kikiutils/shared/general';\n *\n * console.log(extractFirstValue([1, 2, 3])); // 1\n * console.log(extractFirstValue('hello'));  // hello\n * console.log(extractFirstValue([], 'default')); // default\n * console.log(extractFirstValue(undefined, 'fallback')); // fallback\n * ```\n */\nexport function extractFirstValue<T>(value: T | T[]): T | undefined;\nexport function extractFirstValue<T, D>(value: T | T[], defaultValue: D): D | NonNullable<T>;\nexport function extractFirstValue<T, D>(value: T | T[], defaultValue?: D) {\n    return (Array.isArray(value) ? value[0] : value) ?? defaultValue;\n}\n\n/* eslint-enable jsdoc/check-param-names */\n"],"names":[],"mappings":"AAAA;AA6BM,SAAU,iBAAiB,CAAO,KAAc,EAAE,YAAgB,EAAA;IACpE,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,KAAK,YAAY;AACpE;AAEA;;;;"}

package/dist/math.cjs

@@ -9,11 +9,11 @@ const decimal_js = require('decimal.js');
  * - Supports custom decimal places and optional percentage symbol.
  * - Returns `'0.00%'` if result is `NaN` or division is invalid.
  *
- * @param {CalculableValue} molecular - The numerator of the fraction.
- * @param {CalculableValue} denominator - The denominator of the fraction.
- * @param {ToPercentageStringOptions} [options] - Optional output settings.
+ * @param {CalculableValue} molecular - The numerator of the fraction
+ * @param {CalculableValue} denominator - The denominator of the fraction
+ * @param {ToPercentageStringOptions} [options] - Optional output settings
  *
- * @returns {string} Formatted percentage string.
+ * @returns {string} Formatted percentage string
  *
  * @example
  * ```typescript

package/dist/math.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"math.cjs","sources":["../src/math.ts"],"sourcesContent":["import { Decimal } from 'decimal.js';\n\ntype CalculableValue = Decimal.Value | { toString: () => string };\n\n/**\n * Options for configuring the output of `toPercentageString`.\n */\nexport interface ToPercentageStringOptions {\n    /**\n     * Number of decimal places to include in the result.\n     *\n     * @default 2\n     */\n    decimalPlaces?: number;\n\n    /**\n     * Whether to include the '%' symbol in the result.\n     *\n     * @default true\n     */\n    withSymbol?: boolean;\n}\n\n/**\n * Converts a fraction (numerator / denominator) into a percentage string.\n *\n * - Uses `decimal.js` for precise decimal calculations.\n * - Supports custom decimal places and optional percentage symbol.\n * - Returns `'0.00%'` if result is `NaN` or division is invalid.\n *\n * @param {CalculableValue} molecular - The numerator of the fraction.\n * @param {CalculableValue} denominator - The denominator of the fraction.\n * @param {ToPercentageStringOptions} [options] - Optional output settings.\n *\n * @returns {string} Formatted percentage string.\n *\n * @example\n * ```typescript\n * import { toPercentageString } from '@kikiutils/shared/math';\n *\n * console.log(toPercentageString(50, 200)); // 25.00%\n * console.log(toPercentageString(50, 200, { withSymbol: false })); // 25.00\n * console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%\n * ```\n */\nexport function toPercentageString(\n    molecular: CalculableValue,\n    denominator: CalculableValue,\n    options?: ToPercentageStringOptions,\n) {\n    const molecularDecimal = new Decimal(molecular.toString());\n    const denominatorDecimal = new Decimal(denominator.toString());\n    const calculationResult = molecularDecimal.div(denominatorDecimal);\n    const result = calculationResult.isNaN()\n        ? '0.00'\n        : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);\n\n    return options?.withSymbol ?? true ? `${result}%` : result;\n}\n"],"names":["Decimal"],"mappings":";;;;AAuBA;;;;;;;;;;;;;;;;;;;;;AAqBG;SACa,kBAAkB,CAC9B,SAA0B,EAC1B,WAA4B,EAC5B,OAAmC,EAAA;IAEnC,MAAM,gBAAgB,GAAG,IAAIA,kBAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC1D,MAAM,kBAAkB,GAAG,IAAIA,kBAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;IAC9D,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,GAAG,CAAC,kBAAkB,CAAC;AAClE,IAAA,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK;AAClC,UAAE;AACF,UAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,IAAI,CAAC,CAAC;AAEvE,IAAA,OAAO,OAAO,EAAE,UAAU,IAAI,IAAI,GAAG,CAAA,EAAG,MAAM,CAAA,CAAA,CAAG,GAAG,MAAM;AAC9D;;;;"}
+{"version":3,"file":"math.cjs","sources":["../src/math.ts"],"sourcesContent":["import { Decimal } from 'decimal.js';\n\ntype CalculableValue = Decimal.Value | { toString: () => string };\n\n/**\n * Options for configuring the output of `toPercentageString`.\n */\nexport interface ToPercentageStringOptions {\n    /**\n     * Number of decimal places to include in the result.\n     *\n     * @default 2\n     */\n    decimalPlaces?: number;\n\n    /**\n     * Whether to include the '%' symbol in the result.\n     *\n     * @default true\n     */\n    withSymbol?: boolean;\n}\n\n/**\n * Converts a fraction (numerator / denominator) into a percentage string.\n *\n * - Uses `decimal.js` for precise decimal calculations.\n * - Supports custom decimal places and optional percentage symbol.\n * - Returns `'0.00%'` if result is `NaN` or division is invalid.\n *\n * @param {CalculableValue} molecular - The numerator of the fraction\n * @param {CalculableValue} denominator - The denominator of the fraction\n * @param {ToPercentageStringOptions} [options] - Optional output settings\n *\n * @returns {string} Formatted percentage string\n *\n * @example\n * ```typescript\n * import { toPercentageString } from '@kikiutils/shared/math';\n *\n * console.log(toPercentageString(50, 200)); // 25.00%\n * console.log(toPercentageString(50, 200, { withSymbol: false })); // 25.00\n * console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%\n * ```\n */\nexport function toPercentageString(\n    molecular: CalculableValue,\n    denominator: CalculableValue,\n    options?: ToPercentageStringOptions,\n) {\n    const molecularDecimal = new Decimal(molecular.toString());\n    const denominatorDecimal = new Decimal(denominator.toString());\n    const calculationResult = molecularDecimal.div(denominatorDecimal);\n    const result = calculationResult.isNaN()\n        ? '0.00'\n        : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);\n\n    return options?.withSymbol ?? true ? `${result}%` : result;\n}\n"],"names":["Decimal"],"mappings":";;;;AAuBA;;;;;;;;;;;;;;;;;;;;;AAqBG;SACa,kBAAkB,CAC9B,SAA0B,EAC1B,WAA4B,EAC5B,OAAmC,EAAA;IAEnC,MAAM,gBAAgB,GAAG,IAAIA,kBAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC1D,MAAM,kBAAkB,GAAG,IAAIA,kBAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;IAC9D,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,GAAG,CAAC,kBAAkB,CAAC;AAClE,IAAA,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK;AAClC,UAAE;AACF,UAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,IAAI,CAAC,CAAC;AAEvE,IAAA,OAAO,OAAO,EAAE,UAAU,IAAI,IAAI,GAAG,CAAA,EAAG,MAAM,CAAA,CAAA,CAAG,GAAG,MAAM;AAC9D;;;;"}

package/dist/math.d.ts

@@ -26,11 +26,11 @@ export interface ToPercentageStringOptions {
  * - Supports custom decimal places and optional percentage symbol.
  * - Returns `'0.00%'` if result is `NaN` or division is invalid.
  *
- * @param {CalculableValue} molecular - The numerator of the fraction.
- * @param {CalculableValue} denominator - The denominator of the fraction.
- * @param {ToPercentageStringOptions} [options] - Optional output settings.
+ * @param {CalculableValue} molecular - The numerator of the fraction
+ * @param {CalculableValue} denominator - The denominator of the fraction
+ * @param {ToPercentageStringOptions} [options] - Optional output settings
  *
- * @returns {string} Formatted percentage string.
+ * @returns {string} Formatted percentage string
  *
  * @example
  * ```typescript

package/dist/math.mjs

@@ -7,11 +7,11 @@ import { Decimal } from 'decimal.js';
  * - Supports custom decimal places and optional percentage symbol.
  * - Returns `'0.00%'` if result is `NaN` or division is invalid.
  *
- * @param {CalculableValue} molecular - The numerator of the fraction.
- * @param {CalculableValue} denominator - The denominator of the fraction.
- * @param {ToPercentageStringOptions} [options] - Optional output settings.
+ * @param {CalculableValue} molecular - The numerator of the fraction
+ * @param {CalculableValue} denominator - The denominator of the fraction
+ * @param {ToPercentageStringOptions} [options] - Optional output settings
  *
- * @returns {string} Formatted percentage string.
+ * @returns {string} Formatted percentage string
  *
  * @example
  * ```typescript

package/dist/math.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"math.mjs","sources":["../src/math.ts"],"sourcesContent":["import { Decimal } from 'decimal.js';\n\ntype CalculableValue = Decimal.Value | { toString: () => string };\n\n/**\n * Options for configuring the output of `toPercentageString`.\n */\nexport interface ToPercentageStringOptions {\n    /**\n     * Number of decimal places to include in the result.\n     *\n     * @default 2\n     */\n    decimalPlaces?: number;\n\n    /**\n     * Whether to include the '%' symbol in the result.\n     *\n     * @default true\n     */\n    withSymbol?: boolean;\n}\n\n/**\n * Converts a fraction (numerator / denominator) into a percentage string.\n *\n * - Uses `decimal.js` for precise decimal calculations.\n * - Supports custom decimal places and optional percentage symbol.\n * - Returns `'0.00%'` if result is `NaN` or division is invalid.\n *\n * @param {CalculableValue} molecular - The numerator of the fraction.\n * @param {CalculableValue} denominator - The denominator of the fraction.\n * @param {ToPercentageStringOptions} [options] - Optional output settings.\n *\n * @returns {string} Formatted percentage string.\n *\n * @example\n * ```typescript\n * import { toPercentageString } from '@kikiutils/shared/math';\n *\n * console.log(toPercentageString(50, 200)); // 25.00%\n * console.log(toPercentageString(50, 200, { withSymbol: false })); // 25.00\n * console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%\n * ```\n */\nexport function toPercentageString(\n    molecular: CalculableValue,\n    denominator: CalculableValue,\n    options?: ToPercentageStringOptions,\n) {\n    const molecularDecimal = new Decimal(molecular.toString());\n    const denominatorDecimal = new Decimal(denominator.toString());\n    const calculationResult = molecularDecimal.div(denominatorDecimal);\n    const result = calculationResult.isNaN()\n        ? '0.00'\n        : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);\n\n    return options?.withSymbol ?? true ? `${result}%` : result;\n}\n"],"names":[],"mappings":";;AAuBA;;;;;;;;;;;;;;;;;;;;;AAqBG;SACa,kBAAkB,CAC9B,SAA0B,EAC1B,WAA4B,EAC5B,OAAmC,EAAA;IAEnC,MAAM,gBAAgB,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC1D,MAAM,kBAAkB,GAAG,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;IAC9D,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,GAAG,CAAC,kBAAkB,CAAC;AAClE,IAAA,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK;AAClC,UAAE;AACF,UAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,IAAI,CAAC,CAAC;AAEvE,IAAA,OAAO,OAAO,EAAE,UAAU,IAAI,IAAI,GAAG,CAAA,EAAG,MAAM,CAAA,CAAA,CAAG,GAAG,MAAM;AAC9D;;;;"}
+{"version":3,"file":"math.mjs","sources":["../src/math.ts"],"sourcesContent":["import { Decimal } from 'decimal.js';\n\ntype CalculableValue = Decimal.Value | { toString: () => string };\n\n/**\n * Options for configuring the output of `toPercentageString`.\n */\nexport interface ToPercentageStringOptions {\n    /**\n     * Number of decimal places to include in the result.\n     *\n     * @default 2\n     */\n    decimalPlaces?: number;\n\n    /**\n     * Whether to include the '%' symbol in the result.\n     *\n     * @default true\n     */\n    withSymbol?: boolean;\n}\n\n/**\n * Converts a fraction (numerator / denominator) into a percentage string.\n *\n * - Uses `decimal.js` for precise decimal calculations.\n * - Supports custom decimal places and optional percentage symbol.\n * - Returns `'0.00%'` if result is `NaN` or division is invalid.\n *\n * @param {CalculableValue} molecular - The numerator of the fraction\n * @param {CalculableValue} denominator - The denominator of the fraction\n * @param {ToPercentageStringOptions} [options] - Optional output settings\n *\n * @returns {string} Formatted percentage string\n *\n * @example\n * ```typescript\n * import { toPercentageString } from '@kikiutils/shared/math';\n *\n * console.log(toPercentageString(50, 200)); // 25.00%\n * console.log(toPercentageString(50, 200, { withSymbol: false })); // 25.00\n * console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%\n * ```\n */\nexport function toPercentageString(\n    molecular: CalculableValue,\n    denominator: CalculableValue,\n    options?: ToPercentageStringOptions,\n) {\n    const molecularDecimal = new Decimal(molecular.toString());\n    const denominatorDecimal = new Decimal(denominator.toString());\n    const calculationResult = molecularDecimal.div(denominatorDecimal);\n    const result = calculationResult.isNaN()\n        ? '0.00'\n        : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);\n\n    return options?.withSymbol ?? true ? `${result}%` : result;\n}\n"],"names":[],"mappings":";;AAuBA;;;;;;;;;;;;;;;;;;;;;AAqBG;SACa,kBAAkB,CAC9B,SAA0B,EAC1B,WAA4B,EAC5B,OAAmC,EAAA;IAEnC,MAAM,gBAAgB,GAAG,IAAI,OAAO,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC1D,MAAM,kBAAkB,GAAG,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;IAC9D,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,GAAG,CAAC,kBAAkB,CAAC;AAClE,IAAA,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK;AAClC,UAAE;AACF,UAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,IAAI,CAAC,CAAC;AAEvE,IAAA,OAAO,OAAO,EAAE,UAAU,IAAI,IAAI,GAAG,CAAA,EAAG,MAAM,CAAA,CAAA,CAAG,GAAG,MAAM;AAC9D;;;;"}

package/dist/number.cjs

@@ -7,10 +7,10 @@ const millify = require('millify');
  *
  * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.
  *
- * @param {number} value - The number to format.
- * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.
+ * @param {number} value - The number to format
+ * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`
  *
- * @returns {string} The compact number string.
+ * @returns {string} The compact number string
  *
  * @example
  * ```typescript

package/dist/number.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"number.cjs","sources":["../src/number.ts"],"sourcesContent":["import { millify } from 'millify';\n\n/**\n * Converts a large number into a compact, human-readable string using `millify`.\n *\n * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.\n *\n * @param {number} value - The number to format.\n * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.\n *\n * @returns {string} The compact number string.\n *\n * @example\n * ```typescript\n * import { toCompactNumberString } from '@kikiutils/shared/number';\n *\n * console.log(toCompactNumberString(1234567)); // 1.23m\n * console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m\n * ```\n */\nexport function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]) {\n    return millify(\n        value,\n        {\n            lowercase: true,\n            precision: 2,\n            ...options,\n        },\n    );\n}\n"],"names":["millify"],"mappings":";;;;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG,SAAU,qBAAqB,CAAC,KAAa,EAAE,OAAuC,EAAA;IACxF,OAAOA,eAAO,CACV,KAAK,EACL;AACI,QAAA,SAAS,EAAE,IAAI;AACf,QAAA,SAAS,EAAE,CAAC;AACZ,QAAA,GAAG,OAAO;AACb,KAAA,CACJ;AACL;;;;"}
+{"version":3,"file":"number.cjs","sources":["../src/number.ts"],"sourcesContent":["import { millify } from 'millify';\n\n/**\n * Converts a large number into a compact, human-readable string using `millify`.\n *\n * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.\n *\n * @param {number} value - The number to format\n * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`\n *\n * @returns {string} The compact number string\n *\n * @example\n * ```typescript\n * import { toCompactNumberString } from '@kikiutils/shared/number';\n *\n * console.log(toCompactNumberString(1234567)); // 1.23m\n * console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m\n * ```\n */\nexport function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]) {\n    return millify(\n        value,\n        {\n            lowercase: true,\n            precision: 2,\n            ...options,\n        },\n    );\n}\n"],"names":["millify"],"mappings":";;;;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG,SAAU,qBAAqB,CAAC,KAAa,EAAE,OAAuC,EAAA;IACxF,OAAOA,eAAO,CACV,KAAK,EACL;AACI,QAAA,SAAS,EAAE,IAAI;AACf,QAAA,SAAS,EAAE,CAAC;AACZ,QAAA,GAAG,OAAO;AACb,KAAA,CACJ;AACL;;;;"}

package/dist/number.d.ts

@@ -4,10 +4,10 @@ import { millify } from 'millify';
  *
  * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.
  *
- * @param {number} value - The number to format.
- * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.
+ * @param {number} value - The number to format
+ * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`
  *
- * @returns {string} The compact number string.
+ * @returns {string} The compact number string
  *
  * @example
  * ```typescript

package/dist/number.mjs

@@ -5,10 +5,10 @@ import { millify } from 'millify';
  *
  * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.
  *
- * @param {number} value - The number to format.
- * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.
+ * @param {number} value - The number to format
+ * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`
  *
- * @returns {string} The compact number string.
+ * @returns {string} The compact number string
  *
  * @example
  * ```typescript

package/dist/number.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"number.mjs","sources":["../src/number.ts"],"sourcesContent":["import { millify } from 'millify';\n\n/**\n * Converts a large number into a compact, human-readable string using `millify`.\n *\n * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.\n *\n * @param {number} value - The number to format.\n * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`.\n *\n * @returns {string} The compact number string.\n *\n * @example\n * ```typescript\n * import { toCompactNumberString } from '@kikiutils/shared/number';\n *\n * console.log(toCompactNumberString(1234567)); // 1.23m\n * console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m\n * ```\n */\nexport function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]) {\n    return millify(\n        value,\n        {\n            lowercase: true,\n            precision: 2,\n            ...options,\n        },\n    );\n}\n"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG,SAAU,qBAAqB,CAAC,KAAa,EAAE,OAAuC,EAAA;IACxF,OAAO,OAAO,CACV,KAAK,EACL;AACI,QAAA,SAAS,EAAE,IAAI;AACf,QAAA,SAAS,EAAE,CAAC;AACZ,QAAA,GAAG,OAAO;AACb,KAAA,CACJ;AACL;;;;"}
+{"version":3,"file":"number.mjs","sources":["../src/number.ts"],"sourcesContent":["import { millify } from 'millify';\n\n/**\n * Converts a large number into a compact, human-readable string using `millify`.\n *\n * Applies lowercase units (e.g. 'k', 'm') and default precision of 2, unless overridden.\n *\n * @param {number} value - The number to format\n * @param {Parameters<typeof millify>[1]} [options] - Optional configuration passed to `millify`\n *\n * @returns {string} The compact number string\n *\n * @example\n * ```typescript\n * import { toCompactNumberString } from '@kikiutils/shared/number';\n *\n * console.log(toCompactNumberString(1234567)); // 1.23m\n * console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m\n * ```\n */\nexport function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]) {\n    return millify(\n        value,\n        {\n            lowercase: true,\n            precision: 2,\n            ...options,\n        },\n    );\n}\n"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG,SAAU,qBAAqB,CAAC,KAAa,EAAE,OAAuC,EAAA;IACxF,OAAO,OAAO,CACV,KAAK,EACL;AACI,QAAA,SAAS,EAAE,IAAI;AACf,QAAA,SAAS,EAAE,CAAC;AACZ,QAAA,GAAG,OAAO;AACb,KAAA,CACJ;AACL;;;;"}

package/dist/object.cjs

@@ -10,10 +10,10 @@
  * It is designed for use cases such as signature generation, cache key construction,
  * or any context requiring consistent and predictable object serialization.
  *
- * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays.
- * @param {string} kvSeparator - The string used to separate each key from its value (default: '=').
- * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&').
- * @returns {string} A deterministic string representation of the input object.
+ * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays
+ * @param {string} kvSeparator - The string used to separate each key from its value (default: '=')
+ * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&')
+ * @returns {string} A deterministic string representation of the input object
  *
  * @example
  * ```typescript

package/dist/object.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"object.cjs","sources":["../src/object.ts"],"sourcesContent":["/**\n * Serializes a nested object into a deterministic, flat string format.\n *\n * This function recursively traverses the input object (including nested objects and arrays),\n * flattens it into key paths using dot notation (e.g. \"a.b.0.c\"), sorts all keys,\n * and joins each key-value pair into a string with customizable separators.\n *\n * It is designed for use cases such as signature generation, cache key construction,\n * or any context requiring consistent and predictable object serialization.\n *\n * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays.\n * @param {string} kvSeparator - The string used to separate each key from its value (default: '=').\n * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&').\n * @returns {string} A deterministic string representation of the input object.\n *\n * @example\n * ```typescript\n * import { stringifyObjectDeterministically } from '@kikiutils/shared/object';\n *\n * console.log(stringifyObjectDeterministically({ b: 2, a: { x: 1, y: [3, 4] } })); // a.x=1&a.y.0=3&a.y.1=4&b=2\n * console.log(stringifyObjectDeterministically({ foo: 'bar' }, ':', '|')); // foo:bar\n * ```\n */\nexport function stringifyObjectDeterministically(\n    input: Record<string, any>,\n    kvSeparator: string = '=',\n    pairSeparator: string = '&',\n) {\n    const entries: string[] = [];\n\n    function walk(object: any, path: string[] = []) {\n        if (Array.isArray(object)) {\n            object.forEach((value, index) => {\n                walk(\n                    value,\n                    [\n                        ...path,\n                        index.toString(),\n                    ],\n                );\n            });\n        } else if (\n            object !== null\n            && typeof object === 'object'\n            && Object.prototype.toString.call(object) === '[object Object]'\n        ) {\n            Object.keys(object).sort().forEach((key) => {\n                walk(\n                    object[key],\n                    [\n                        ...path,\n                        key,\n                    ],\n                );\n            });\n        } else entries.push(`${path.join('.')}${kvSeparator}${String(object)}`);\n    }\n\n    walk(input);\n    return entries.sort().join(pairSeparator);\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,gCAAgC,CAC5C,KAA0B,EAC1B,WAAA,GAAsB,GAAG,EACzB,aAAA,GAAwB,GAAG,EAAA;IAE3B,MAAM,OAAO,GAAa,EAAE;AAE5B,IAAA,SAAS,IAAI,CAAC,MAAW,EAAE,OAAiB,EAAE,EAAA;AAC1C,QAAA,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACvB,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,KAAI;gBAC5B,IAAI,CACA,KAAK,EACL;AACI,oBAAA,GAAG,IAAI;oBACP,KAAK,CAAC,QAAQ,EAAE;AACnB,iBAAA,CACJ;AACL,YAAA,CAAC,CAAC;QACN;aAAO,IACH,MAAM,KAAK;eACR,OAAO,MAAM,KAAK;AAClB,eAAA,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,iBAAiB,EACjE;AACE,YAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,CAAC,GAAG,KAAI;AACvC,gBAAA,IAAI,CACA,MAAM,CAAC,GAAG,CAAC,EACX;AACI,oBAAA,GAAG,IAAI;oBACP,GAAG;AACN,iBAAA,CACJ;AACL,YAAA,CAAC,CAAC;QACN;;AAAO,YAAA,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA,EAAG,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA,CAAE,CAAC;IAC3E;IAEA,IAAI,CAAC,KAAK,CAAC;IACX,OAAO,OAAO,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC;AAC7C;;;;"}
+{"version":3,"file":"object.cjs","sources":["../src/object.ts"],"sourcesContent":["/**\n * Serializes a nested object into a deterministic, flat string format.\n *\n * This function recursively traverses the input object (including nested objects and arrays),\n * flattens it into key paths using dot notation (e.g. \"a.b.0.c\"), sorts all keys,\n * and joins each key-value pair into a string with customizable separators.\n *\n * It is designed for use cases such as signature generation, cache key construction,\n * or any context requiring consistent and predictable object serialization.\n *\n * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays\n * @param {string} kvSeparator - The string used to separate each key from its value (default: '=')\n * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&')\n * @returns {string} A deterministic string representation of the input object\n *\n * @example\n * ```typescript\n * import { stringifyObjectDeterministically } from '@kikiutils/shared/object';\n *\n * console.log(stringifyObjectDeterministically({ b: 2, a: { x: 1, y: [3, 4] } })); // a.x=1&a.y.0=3&a.y.1=4&b=2\n * console.log(stringifyObjectDeterministically({ foo: 'bar' }, ':', '|')); // foo:bar\n * ```\n */\nexport function stringifyObjectDeterministically(\n    input: Record<string, any>,\n    kvSeparator: string = '=',\n    pairSeparator: string = '&',\n) {\n    const entries: string[] = [];\n\n    function walk(object: any, path: string[] = []) {\n        if (Array.isArray(object)) {\n            object.forEach((value, index) => {\n                walk(\n                    value,\n                    [\n                        ...path,\n                        index.toString(),\n                    ],\n                );\n            });\n        } else if (\n            object !== null\n            && typeof object === 'object'\n            && Object.prototype.toString.call(object) === '[object Object]'\n        ) {\n            Object.keys(object).sort().forEach((key) => {\n                walk(\n                    object[key],\n                    [\n                        ...path,\n                        key,\n                    ],\n                );\n            });\n        } else entries.push(`${path.join('.')}${kvSeparator}${String(object)}`);\n    }\n\n    walk(input);\n    return entries.sort().join(pairSeparator);\n}\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,gCAAgC,CAC5C,KAA0B,EAC1B,WAAA,GAAsB,GAAG,EACzB,aAAA,GAAwB,GAAG,EAAA;IAE3B,MAAM,OAAO,GAAa,EAAE;AAE5B,IAAA,SAAS,IAAI,CAAC,MAAW,EAAE,OAAiB,EAAE,EAAA;AAC1C,QAAA,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACvB,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,KAAI;gBAC5B,IAAI,CACA,KAAK,EACL;AACI,oBAAA,GAAG,IAAI;oBACP,KAAK,CAAC,QAAQ,EAAE;AACnB,iBAAA,CACJ;AACL,YAAA,CAAC,CAAC;QACN;aAAO,IACH,MAAM,KAAK;eACR,OAAO,MAAM,KAAK;AAClB,eAAA,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,iBAAiB,EACjE;AACE,YAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,CAAC,GAAG,KAAI;AACvC,gBAAA,IAAI,CACA,MAAM,CAAC,GAAG,CAAC,EACX;AACI,oBAAA,GAAG,IAAI;oBACP,GAAG;AACN,iBAAA,CACJ;AACL,YAAA,CAAC,CAAC;QACN;;AAAO,YAAA,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA,EAAG,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA,CAAE,CAAC;IAC3E;IAEA,IAAI,CAAC,KAAK,CAAC;IACX,OAAO,OAAO,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC;AAC7C;;;;"}

package/dist/object.d.ts

@@ -8,10 +8,10 @@
  * It is designed for use cases such as signature generation, cache key construction,
  * or any context requiring consistent and predictable object serialization.
  *
- * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays.
- * @param {string} kvSeparator - The string used to separate each key from its value (default: '=').
- * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&').
- * @returns {string} A deterministic string representation of the input object.
+ * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays
+ * @param {string} kvSeparator - The string used to separate each key from its value (default: '=')
+ * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&')
+ * @returns {string} A deterministic string representation of the input object
  *
  * @example
  * ```typescript

package/dist/object.mjs

@@ -8,10 +8,10 @@
  * It is designed for use cases such as signature generation, cache key construction,
  * or any context requiring consistent and predictable object serialization.
  *
- * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays.
- * @param {string} kvSeparator - The string used to separate each key from its value (default: '=').
- * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&').
- * @returns {string} A deterministic string representation of the input object.
+ * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays
+ * @param {string} kvSeparator - The string used to separate each key from its value (default: '=')
+ * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&')
+ * @returns {string} A deterministic string representation of the input object
  *
  * @example
  * ```typescript

package/dist/object.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"object.mjs","sources":["../src/object.ts"],"sourcesContent":["/**\n * Serializes a nested object into a deterministic, flat string format.\n *\n * This function recursively traverses the input object (including nested objects and arrays),\n * flattens it into key paths using dot notation (e.g. \"a.b.0.c\"), sorts all keys,\n * and joins each key-value pair into a string with customizable separators.\n *\n * It is designed for use cases such as signature generation, cache key construction,\n * or any context requiring consistent and predictable object serialization.\n *\n * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays.\n * @param {string} kvSeparator - The string used to separate each key from its value (default: '=').\n * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&').\n * @returns {string} A deterministic string representation of the input object.\n *\n * @example\n * ```typescript\n * import { stringifyObjectDeterministically } from '@kikiutils/shared/object';\n *\n * console.log(stringifyObjectDeterministically({ b: 2, a: { x: 1, y: [3, 4] } })); // a.x=1&a.y.0=3&a.y.1=4&b=2\n * console.log(stringifyObjectDeterministically({ foo: 'bar' }, ':', '|')); // foo:bar\n * ```\n */\nexport function stringifyObjectDeterministically(\n    input: Record<string, any>,\n    kvSeparator: string = '=',\n    pairSeparator: string = '&',\n) {\n    const entries: string[] = [];\n\n    function walk(object: any, path: string[] = []) {\n        if (Array.isArray(object)) {\n            object.forEach((value, index) => {\n                walk(\n                    value,\n                    [\n                        ...path,\n                        index.toString(),\n                    ],\n                );\n            });\n        } else if (\n            object !== null\n            && typeof object === 'object'\n            && Object.prototype.toString.call(object) === '[object Object]'\n        ) {\n            Object.keys(object).sort().forEach((key) => {\n                walk(\n                    object[key],\n                    [\n                        ...path,\n                        key,\n                    ],\n                );\n            });\n        } else entries.push(`${path.join('.')}${kvSeparator}${String(object)}`);\n    }\n\n    walk(input);\n    return entries.sort().join(pairSeparator);\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,gCAAgC,CAC5C,KAA0B,EAC1B,WAAA,GAAsB,GAAG,EACzB,aAAA,GAAwB,GAAG,EAAA;IAE3B,MAAM,OAAO,GAAa,EAAE;AAE5B,IAAA,SAAS,IAAI,CAAC,MAAW,EAAE,OAAiB,EAAE,EAAA;AAC1C,QAAA,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACvB,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,KAAI;gBAC5B,IAAI,CACA,KAAK,EACL;AACI,oBAAA,GAAG,IAAI;oBACP,KAAK,CAAC,QAAQ,EAAE;AACnB,iBAAA,CACJ;AACL,YAAA,CAAC,CAAC;QACN;aAAO,IACH,MAAM,KAAK;eACR,OAAO,MAAM,KAAK;AAClB,eAAA,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,iBAAiB,EACjE;AACE,YAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,CAAC,GAAG,KAAI;AACvC,gBAAA,IAAI,CACA,MAAM,CAAC,GAAG,CAAC,EACX;AACI,oBAAA,GAAG,IAAI;oBACP,GAAG;AACN,iBAAA,CACJ;AACL,YAAA,CAAC,CAAC;QACN;;AAAO,YAAA,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA,EAAG,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA,CAAE,CAAC;IAC3E;IAEA,IAAI,CAAC,KAAK,CAAC;IACX,OAAO,OAAO,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC;AAC7C;;;;"}
+{"version":3,"file":"object.mjs","sources":["../src/object.ts"],"sourcesContent":["/**\n * Serializes a nested object into a deterministic, flat string format.\n *\n * This function recursively traverses the input object (including nested objects and arrays),\n * flattens it into key paths using dot notation (e.g. \"a.b.0.c\"), sorts all keys,\n * and joins each key-value pair into a string with customizable separators.\n *\n * It is designed for use cases such as signature generation, cache key construction,\n * or any context requiring consistent and predictable object serialization.\n *\n * @param {Record<string, any>} input - The object to serialize. Can contain nested objects and arrays\n * @param {string} kvSeparator - The string used to separate each key from its value (default: '=')\n * @param {string} pairSeparator - The string used to separate each key-value pair (default: '&')\n * @returns {string} A deterministic string representation of the input object\n *\n * @example\n * ```typescript\n * import { stringifyObjectDeterministically } from '@kikiutils/shared/object';\n *\n * console.log(stringifyObjectDeterministically({ b: 2, a: { x: 1, y: [3, 4] } })); // a.x=1&a.y.0=3&a.y.1=4&b=2\n * console.log(stringifyObjectDeterministically({ foo: 'bar' }, ':', '|')); // foo:bar\n * ```\n */\nexport function stringifyObjectDeterministically(\n    input: Record<string, any>,\n    kvSeparator: string = '=',\n    pairSeparator: string = '&',\n) {\n    const entries: string[] = [];\n\n    function walk(object: any, path: string[] = []) {\n        if (Array.isArray(object)) {\n            object.forEach((value, index) => {\n                walk(\n                    value,\n                    [\n                        ...path,\n                        index.toString(),\n                    ],\n                );\n            });\n        } else if (\n            object !== null\n            && typeof object === 'object'\n            && Object.prototype.toString.call(object) === '[object Object]'\n        ) {\n            Object.keys(object).sort().forEach((key) => {\n                walk(\n                    object[key],\n                    [\n                        ...path,\n                        key,\n                    ],\n                );\n            });\n        } else entries.push(`${path.join('.')}${kvSeparator}${String(object)}`);\n    }\n\n    walk(input);\n    return entries.sort().join(pairSeparator);\n}\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACG,SAAU,gCAAgC,CAC5C,KAA0B,EAC1B,WAAA,GAAsB,GAAG,EACzB,aAAA,GAAwB,GAAG,EAAA;IAE3B,MAAM,OAAO,GAAa,EAAE;AAE5B,IAAA,SAAS,IAAI,CAAC,MAAW,EAAE,OAAiB,EAAE,EAAA;AAC1C,QAAA,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACvB,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,KAAI;gBAC5B,IAAI,CACA,KAAK,EACL;AACI,oBAAA,GAAG,IAAI;oBACP,KAAK,CAAC,QAAQ,EAAE;AACnB,iBAAA,CACJ;AACL,YAAA,CAAC,CAAC;QACN;aAAO,IACH,MAAM,KAAK;eACR,OAAO,MAAM,KAAK;AAClB,eAAA,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,iBAAiB,EACjE;AACE,YAAA,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,CAAC,GAAG,KAAI;AACvC,gBAAA,IAAI,CACA,MAAM,CAAC,GAAG,CAAC,EACX;AACI,oBAAA,GAAG,IAAI;oBACP,GAAG;AACN,iBAAA,CACJ;AACL,YAAA,CAAC,CAAC;QACN;;AAAO,YAAA,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA,EAAG,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA,CAAE,CAAC;IAC3E;IAEA,IAAI,CAAC,KAAK,CAAC;IACX,OAAO,OAAO,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC;AAC7C;;;;"}

package/dist/random.cjs

@@ -10,15 +10,15 @@
  *
  * This function supports any return type by using a generic type parameter.
  *
- * @template T - The return type of the generator function.
+ * @template T - The return type of the generator function
  *
- * @param {(length: number) => T} generator - A function that accepts a length and returns a value of type T.
- * @param {number} minMin - Lower bound of the first random range.
- * @param {number} minMax - Upper bound of the first random range.
- * @param {number} maxMin - Lower bound of the second random range.
- * @param {number} maxMax - Upper bound of the second random range.
+ * @param {(length: number) => T} generator - A function that accepts a length and returns a value of type T
+ * @param {number} minMin - Lower bound of the first random range
+ * @param {number} minMax - Upper bound of the first random range
+ * @param {number} maxMin - Lower bound of the second random range
+ * @param {number} maxMax - Upper bound of the second random range
  *
- * @returns {T} The result of the generator function using the computed final length.
+ * @returns {T} The result of the generator function using the computed final length
  */
 function generateWithNestedRandomLength(generator, minMin, minMax, maxMin, maxMax) {
     const random = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;