@kikiutils/shared 11.0.0 → 13.0.0

package/dist/element-plus.js

@@ -0,0 +1,37 @@
+//#region src/element-plus.ts
+/**
+* Creates a reusable Element Plus `<el-form-item>` validation rule with sensible defaults.
+*
+* This utility provides default values for `required`, `trigger`, and `type`,
+* while allowing overrides via the `options` parameter. It simplifies common
+* form validation rule creation and ensures consistency across forms.
+*
+* @param {string} message - The validation message to display when the rule fails
+* @param {FormItemRule} [options] - Optional overrides for the rule fields
+* @param {boolean} [options.required] - Whether the field is required (default: `true`)
+* @param {string | string[]} [options.trigger] - The event(s) that trigger validation (default: `'blur'`)
+* @param {RuleType} [options.type] - The expected type of the field (default: `'string'`)
+*
+* @returns A `FormItemRule` object that can be used in Element Plus form validation
+*
+* @example
+* ```typescript
+* import { createElFormItemRuleWithDefaults } from '@kikiutils/shared/element-plus';
+*
+* const rule = createElFormItemRuleWithDefaults('This field is required');
+* const optionalRule = createElFormItemRuleWithDefaults('Optional field', { required: false });
+* ```
+*/
+function createElFormItemRuleWithDefaults(message, options = {}) {
+	return {
+		...options,
+		message,
+		required: options.required ?? true,
+		trigger: options.trigger ?? "blur",
+		type: options.type ?? "string"
+	};
+}
+
+//#endregion
+export { createElFormItemRuleWithDefaults };
+//# sourceMappingURL=element-plus.js.map

package/dist/element-plus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-plus.js","names":[],"sources":["../src/element-plus.ts"],"sourcesContent":["import type { RuleType } from 'async-validator';\nimport type { FormItemRule } from 'element-plus';\n\nexport type DoNotRemoveOrUseThisType = RuleType;\n\n/**\n * Creates a reusable Element Plus `<el-form-item>` validation rule with sensible defaults.\n *\n * This utility provides default values for `required`, `trigger`, and `type`,\n * while allowing overrides via the `options` parameter. It simplifies common\n * form validation rule creation and ensures consistency across forms.\n *\n * @param {string} message - The validation message to display when the rule fails\n * @param {FormItemRule} [options] - Optional overrides for the rule fields\n * @param {boolean} [options.required] - Whether the field is required (default: `true`)\n * @param {string | string[]} [options.trigger] - The event(s) that trigger validation (default: `'blur'`)\n * @param {RuleType} [options.type] - The expected type of the field (default: `'string'`)\n *\n * @returns A `FormItemRule` object that can be used in Element Plus form validation\n *\n * @example\n * ```typescript\n * import { createElFormItemRuleWithDefaults } from '@kikiutils/shared/element-plus';\n *\n * const rule = createElFormItemRuleWithDefaults('This field is required');\n * const optionalRule = createElFormItemRuleWithDefaults('Optional field', { required: false });\n * ```\n */\nexport function createElFormItemRuleWithDefaults(message: string, options: FormItemRule = {}): FormItemRule {\n    return {\n        ...options,\n        message,\n        required: options.required ?? true,\n        trigger: options.trigger ?? 'blur',\n        type: options.type ?? 'string',\n    };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,iCAAiC,SAAiB,UAAwB,EAAE,EAAgB;AACxG,QAAO;EACH,GAAG;EACH;EACA,UAAU,QAAQ,YAAY;EAC9B,SAAS,QAAQ,WAAW;EAC5B,MAAM,QAAQ,QAAQ;EACzB"}

package/dist/enum.d.ts

@@ -1,3 +1,4 @@
+//#region src/enum.d.ts
 /**
  * Extracts only the numeric values from an enumeration-like object.
  *
@@ -21,7 +22,7 @@
  * console.log(getEnumNumberValues(RecordType)); // [0, 1]
  * ```
  */
-export declare function getEnumNumberValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], number>[];
+declare function getEnumNumberValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], number>[];
 /**
  * Extracts only the string values from an enumeration-like object.
  *
@@ -45,7 +46,7 @@ export declare function getEnumNumberValues<T extends Record<string, any>>(enumO
  * console.log(getEnumStringValues(RecordType)); // ['unknown']
  * ```
  */
-export declare function getEnumStringValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], string>[];
+declare function getEnumStringValues<T extends Record<string, any>>(enumObject: T): Extract<T[keyof T], string>[];
 /**
  * Extracts all values from an enumeration-like object.
  *
@@ -92,5 +93,7 @@ export declare function getEnumStringValues<T extends Record<string, any>>(enumO
  * console.log(getEnumValues(RecordType)); // [0, 1, 'unknown']
  * ```
  */
-export declare function getEnumValues<T extends Record<string, any>>(enumObject: T): (T[keyof T])[];
+declare function getEnumValues<T extends Record<string, any>>(enumObject: T): (T[keyof T])[];
+//#endregion
+export { getEnumNumberValues, getEnumStringValues, getEnumValues };
 //# sourceMappingURL=enum.d.ts.map

package/dist/enum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../src/enum.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAE/G;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAE/G;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAK1F"}
+{"version":3,"file":"enum.d.ts","names":[],"sources":["../src/enum.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;;AA2BA;;;;;;;;AAkDA;;;;;;AAAuF,iBA7EvE,mBA6EuE,CAAA,UA7EzC,MA6EyC,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,CAAA,UAAA,EA7ER,CA6EQ,CAAA,EA7EJ,OA6EI,CA7EI,CA6EJ,CAAA,MA7EY,CA6EZ,CAAA,EAAA,MAAA,CAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;iBAlDvE,8BAA8B,iCAAiC,IAAI,QAAQ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkDnF,wBAAwB,iCAAiC,KAAK,QAAQ"}

package/dist/enum.js

@@ -0,0 +1,108 @@
+//#region src/enum.ts
+/**
+* Extracts only the numeric values from an enumeration-like 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.
+*
+* @returns {Extract<T[keyof T], number>[]} An array of numeric values extracted from the enum object
+*
+* @example
+* ```typescript
+* import { getEnumNumberValues } from '@kikiutils/shared/enum';
+*
+* enum RecordType {
+*   Receive = 0,
+*   Send = 1,
+*   Unknown = 'unknown'
+* }
+*
+* console.log(getEnumNumberValues(RecordType)); // [0, 1]
+* ```
+*/
+function getEnumNumberValues(enumObject) {
+	return getEnumValues(enumObject).filter((value) => typeof value === "number");
+}
+/**
+* Extracts only the string values from an enumeration-like 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.
+*
+* @returns {Extract<T[keyof T], string>[]} An array of string values extracted from the enum object
+*
+* @example
+* ```typescript
+* import { getEnumStringValues } from '@kikiutils/shared/enum';
+*
+* enum RecordType {
+*   Receive = 0,
+*   Send = 1,
+*   Unknown = 'unknown'
+* }
+*
+* console.log(getEnumStringValues(RecordType)); // ['unknown']
+* ```
+*/
+function getEnumStringValues(enumObject) {
+	return getEnumValues(enumObject).filter((value) => typeof value === "string");
+}
+/**
+* Extracts all values from an enumeration-like object.
+*
+* This function handles TypeScript enums correctly by accounting for the reverse mapping
+* 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
+*
+* @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
+*
+* @example
+* ```typescript
+* import { getEnumValues } from '@kikiutils/shared/enum';
+*
+* // Numeric enum
+* enum Status {
+*   Active = 0,
+*   Inactive = 1,
+*   Pending = 2
+* }
+*
+* console.log(getEnumValues(Status)); // [0, 1, 2]
+*
+* // String enum
+* enum Color {
+*   Red = 'RED',
+*   Green = 'GREEN',
+*   Blue = 'BLUE'
+* }
+*
+* console.log(getEnumValues(Color)); // ['RED', 'GREEN', 'BLUE']
+*
+* // Mixed enum
+* enum RecordType {
+*   Receive = 0,
+*   Send = 1,
+*   Unknown = 'unknown'
+* }
+*
+* console.log(getEnumValues(RecordType)); // [0, 1, 'unknown']
+* ```
+*/
+function getEnumValues(enumObject) {
+	const values = Object.values(enumObject);
+	if (!values.some((value) => typeof value === "number")) return values;
+	return Object.keys(enumObject).filter((key) => Number.isNaN(Number(key))).map((key) => enumObject[key]);
+}
+
+//#endregion
+export { getEnumNumberValues, getEnumStringValues, getEnumValues };
+//# sourceMappingURL=enum.js.map

package/dist/enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.js","names":[],"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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,oBAAmD,YAA8C;AAC7G,QAAO,cAAc,WAAW,CAAC,QAAQ,UAAU,OAAO,UAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;AA0BjF,SAAgB,oBAAmD,YAA8C;AAC7G,QAAO,cAAc,WAAW,CAAC,QAAQ,UAAU,OAAO,UAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDjF,SAAgB,cAA6C,YAA+B;CACxF,MAAM,SAAS,OAAO,OAAO,WAAW;AAExC,KAAI,CADoB,OAAO,MAAM,UAAU,OAAO,UAAU,SAAS,CACnD,QAAO;AAC7B,QAAO,OAAO,KAAK,WAAW,CAAC,QAAQ,QAAQ,OAAO,MAAM,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,WAAW,KAAK"}

package/dist/env.d.ts

@@ -1,3 +1,4 @@
+//#region src/env.d.ts
 /**
  * Custom error class for handling missing environment variables.
  *
@@ -5,14 +6,14 @@
  *
  * @extends {Error}
  */
-export declare class EnvironmentNotFoundError extends Error {
-    readonly key: string;
-    /**
-     * Creates a new EnvironmentNotFoundError.
-     *
-     * @param {string} key - The missing environment variable key
-     */
-    constructor(key: string);
+declare class EnvironmentNotFoundError extends Error {
+  readonly key: string;
+  /**
+   * Creates a new EnvironmentNotFoundError.
+   *
+   * @param {string} key - The missing environment variable key
+   */
+  constructor(key: string);
 }
 /**
  * Retrieves the value of an environment variable, or throws an error if it is not defined.
@@ -35,5 +36,7 @@ export declare class EnvironmentNotFoundError extends Error {
  * checkAndGetEnvValue('API_KEY'); // ❌ Throws EnvironmentNotFoundError
  * ```
  */
-export declare function checkAndGetEnvValue(key: string): string;
+declare function checkAndGetEnvValue(key: string): string;
+//#endregion
+export { EnvironmentNotFoundError, checkAndGetEnvValue };
 //# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;;;OAIG;gBACS,GAAG,EAAE,MAAM;CAM1B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGvD"}
+{"version":3,"file":"env.d.ts","names":[],"sources":["../src/env.ts"],"sourcesContent":[],"mappings":";;AAOA;AAqCA;;;;;cArCa,wBAAA,SAAiC,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC9B,mBAAA"}

package/dist/env.js

@@ -0,0 +1,51 @@
+//#region src/env.ts
+/**
+* Custom error class for handling missing environment variables.
+*
+* Extends the built-in `Error` class and includes the missing key.
+*
+* @extends {Error}
+*/
+var EnvironmentNotFoundError = class extends Error {
+	key;
+	/**
+	* Creates a new EnvironmentNotFoundError.
+	*
+	* @param {string} key - The missing environment variable key
+	*/
+	constructor(key) {
+		super(`Missing environment variable: ${key}`);
+		this.key = key;
+		this.name = this.constructor.name;
+		Error.captureStackTrace?.(this, this.constructor);
+	}
+};
+/**
+* Retrieves the value of an environment variable, or throws an error if it is not defined.
+*
+* 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
+*
+* @returns {string} The value of the environment variable
+*
+* @throws {EnvironmentNotFoundError} If the environment variable is not defined
+*
+* @example
+* ```typescript
+* process.env.API_KEY = '';
+* checkAndGetEnvValue('API_KEY'); // ✅ Returns '' (still considered "defined")
+*
+* delete process.env.API_KEY;
+* checkAndGetEnvValue('API_KEY'); // ❌ Throws EnvironmentNotFoundError
+* ```
+*/
+function checkAndGetEnvValue(key) {
+	if (process.env[key] === void 0) throw new EnvironmentNotFoundError(key);
+	return process.env[key];
+}
+
+//#endregion
+export { EnvironmentNotFoundError, checkAndGetEnvValue };
+//# sourceMappingURL=env.js.map

package/dist/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","names":[],"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"],"mappings":";;;;;;;;AAOA,IAAa,2BAAb,cAA8C,MAAM;CAChD,AAAS;;;;;;CAOT,YAAY,KAAa;AACrB,QAAM,iCAAiC,MAAM;AAC7C,OAAK,MAAM;AACX,OAAK,OAAO,KAAK,YAAY;AAC7B,QAAM,oBAAoB,MAAM,KAAK,YAAY;;;;;;;;;;;;;;;;;;;;;;;;AAyBzD,SAAgB,oBAAoB,KAAqB;AACrD,KAAI,QAAQ,IAAI,SAAS,OAAW,OAAM,IAAI,yBAAyB,IAAI;AAC3E,QAAO,QAAQ,IAAI"}

package/dist/general.d.ts

@@ -1,3 +1,4 @@
+//#region src/general.d.ts
 /**
  * Extracts the first value from an array or returns the value itself if it's not an array.
  *
@@ -23,6 +24,8 @@
  * console.log(extractFirstValue(undefined, 'fallback')); // fallback
  * ```
  */
-export declare function extractFirstValue<T>(value: T | T[]): T | undefined;
-export declare function extractFirstValue<T, D>(value: T | T[], defaultValue: D): D | NonNullable<T>;
+declare function extractFirstValue<T>(value: T | T[]): T | undefined;
+declare function extractFirstValue<T, D>(value: T | T[], defaultValue: D): D | NonNullable<T>;
+//#endregion
+export { extractFirstValue };
 //# sourceMappingURL=general.d.ts.map

package/dist/general.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"general.d.ts","sourceRoot":"","sources":["../src/general.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AACpE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,YAAY,EAAE,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"general.d.ts","names":[],"sources":["../src/general.ts"],"sourcesContent":[],"mappings":";;AA2BA;;;;;;AACA;;;;;;;;;;;;;;;;;;iBADgB,4BAA4B,IAAI,MAAM;iBACtC,+BAA+B,IAAI,mBAAmB,IAAI,IAAI,YAAY"}

package/dist/general.js

@@ -0,0 +1,8 @@
+//#region src/general.ts
+function extractFirstValue(value, defaultValue) {
+	return (Array.isArray(value) ? value[0] : value) ?? defaultValue;
+}
+
+//#endregion
+export { extractFirstValue };
+//# sourceMappingURL=general.js.map

package/dist/general.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.js","names":[],"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"],"mappings":";AA6BA,SAAgB,kBAAwB,OAAgB,cAAkB;AACtE,SAAQ,MAAM,QAAQ,MAAM,GAAG,MAAM,KAAK,UAAU"}

package/dist/hash.d.ts

@@ -1,3 +1,4 @@
+//#region src/hash.d.ts
 /**
  * This file provides a set of functions for creating SHA-3 hash digests
  * using different bit lengths (224, 256, 384, 512).
@@ -11,8 +12,10 @@
  * console.log(sha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80
  * ```
  */
-export declare const sha3224: (data: string | Uint8Array) => string;
-export declare const sha3256: (data: string | Uint8Array) => string;
-export declare const sha3384: (data: string | Uint8Array) => string;
-export declare const sha3512: (data: string | Uint8Array) => string;
+declare function sha3224(data: string | Uint8Array): string;
+declare function sha3256(data: string | Uint8Array): string;
+declare function sha3384(data: string | Uint8Array): string;
+declare function sha3512(data: string | Uint8Array): string;
+//#endregion
+export { sha3224, sha3256, sha3384, sha3512 };
 //# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAUH,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,GAAG,UAAU,WAA+B,CAAC;AACjF,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,GAAG,UAAU,WAA+B,CAAC;AACjF,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,GAAG,UAAU,WAA+B,CAAC;AACjF,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,GAAG,UAAU,WAA+B,CAAC"}
+{"version":3,"file":"hash.d.ts","names":[],"sources":["../src/hash.ts"],"sourcesContent":[],"mappings":";;AAyBA;AAIA;AAIA;AAIA;;;;;;;;;iBAZgB,OAAA,gBAAuB;iBAIvB,OAAA,gBAAuB;iBAIvB,OAAA,gBAAuB;iBAIvB,OAAA,gBAAuB"}

package/dist/hash.js

@@ -0,0 +1,20 @@
+import { sha3_224, sha3_256, sha3_384, sha3_512 } from "@noble/hashes/sha3";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils";
+
+//#region src/hash.ts
+function sha3224(data) {
+	return bytesToHex(sha3_224(typeof data === "string" ? utf8ToBytes(data) : data));
+}
+function sha3256(data) {
+	return bytesToHex(sha3_256(typeof data === "string" ? utf8ToBytes(data) : data));
+}
+function sha3384(data) {
+	return bytesToHex(sha3_384(typeof data === "string" ? utf8ToBytes(data) : data));
+}
+function sha3512(data) {
+	return bytesToHex(sha3_512(typeof data === "string" ? utf8ToBytes(data) : data));
+}
+
+//#endregion
+export { sha3224, sha3256, sha3384, sha3512 };
+//# sourceMappingURL=hash.js.map

package/dist/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","names":[],"sources":["../src/hash.ts"],"sourcesContent":["/**\n * This file provides a set of functions for creating SHA-3 hash digests\n * using different bit lengths (224, 256, 384, 512).\n * These functions use the [@noble/hashes](https://github.com/paulmillr/noble-hashes) library to generate the hashes.\n * Can be used in the browser, mainly for Nuxt/Vue and other frameworks compiled and executed in the browser.\n *\n * @example\n * ```typescript\n * import { sha3256 } from '@kikiutils/shared/hash';\n *\n * console.log(sha3256('test')); // 36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80\n * ```\n */\n\nimport {\n    sha3_224,\n    sha3_256,\n    sha3_384,\n    sha3_512,\n} from '@noble/hashes/sha3';\nimport {\n    bytesToHex,\n    utf8ToBytes,\n} from '@noble/hashes/utils';\n\nexport function sha3224(data: string | Uint8Array) {\n    return bytesToHex(sha3_224(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n\nexport function sha3256(data: string | Uint8Array) {\n    return bytesToHex(sha3_256(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n\nexport function sha3384(data: string | Uint8Array) {\n    return bytesToHex(sha3_384(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n\nexport function sha3512(data: string | Uint8Array) {\n    return bytesToHex(sha3_512(typeof data === 'string' ? utf8ToBytes(data) : data));\n}\n"],"mappings":";;;;AAyBA,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC;;AAGpF,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC;;AAGpF,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC;;AAGpF,SAAgB,QAAQ,MAA2B;AAC/C,QAAO,WAAW,SAAS,OAAO,SAAS,WAAW,YAAY,KAAK,GAAG,KAAK,CAAC"}

package/dist/math.d.ts

@@ -1,23 +1,25 @@
-import { Decimal } from 'decimal.js';
+import { Decimal } from "decimal.js";
+
+//#region src/math.d.ts
 type CalculableValue = Decimal.Value | {
-    toString: () => string;
+  toString: () => string;
 };
 /**
  * Options for configuring the output of `toPercentageString`.
  */
-export interface ToPercentageStringOptions {
-    /**
-     * Number of decimal places to include in the result.
-     *
-     * @default 2
-     */
-    decimalPlaces?: number;
-    /**
-     * Whether to include the '%' symbol in the result.
-     *
-     * @default true
-     */
-    withSymbol?: boolean;
+interface ToPercentageStringOptions {
+  /**
+   * Number of decimal places to include in the result.
+   *
+   * @default 2
+   */
+  decimalPlaces?: number;
+  /**
+   * Whether to include the '%' symbol in the result.
+   *
+   * @default true
+   */
+  withSymbol?: boolean;
 }
 /**
  * Converts a fraction (numerator / denominator) into a percentage string.
@@ -41,6 +43,7 @@ export interface ToPercentageStringOptions {
  * console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%
  * ```
  */
-export declare function toPercentageString(molecular: CalculableValue, denominator: CalculableValue, options?: ToPercentageStringOptions): string;
-export {};
+declare function toPercentageString(molecular: CalculableValue, denominator: CalculableValue, options?: ToPercentageStringOptions): string;
+//#endregion
+export { ToPercentageStringOptions, toPercentageString };
 //# sourceMappingURL=math.d.ts.map

package/dist/math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,KAAK,eAAe,GAAG,OAAO,CAAC,KAAK,GAAG;IAAE,QAAQ,EAAE,MAAM,MAAM,CAAA;CAAE,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,kBAAkB,CAC9B,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,eAAe,EAC5B,OAAO,CAAC,EAAE,yBAAyB,UAUtC"}
+{"version":3,"file":"math.d.ts","names":[],"sources":["../src/math.ts"],"sourcesContent":[],"mappings":";;;KAEK,eAAA,GAAkB,OAAA,CAAQ;;AAFM,CAAA;AAOrC;AAsCA;;AACe,UAvCE,yBAAA,CAuCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBADC,kBAAA,YACD,8BACE,2BACH"}

package/dist/math.js

@@ -0,0 +1,36 @@
+import { Decimal } from "decimal.js";
+
+//#region src/math.ts
+/**
+* Converts a fraction (numerator / denominator) into a percentage string.
+*
+* - Uses `decimal.js` for precise decimal calculations.
+* - 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
+*
+* @returns {string} Formatted percentage string
+*
+* @example
+* ```typescript
+* import { toPercentageString } from '@kikiutils/shared/math';
+*
+* console.log(toPercentageString(50, 200)); // 25.00%
+* console.log(toPercentageString(50, 200, { withSymbol: false })); // 25.00
+* console.log(toPercentageString(50, 200, { decimalPlaces: 1 })); // 25.0%
+* ```
+*/
+function toPercentageString(molecular, denominator, options) {
+	const molecularDecimal = new Decimal(molecular.toString());
+	const denominatorDecimal = new Decimal(denominator.toString());
+	const calculationResult = molecularDecimal.div(denominatorDecimal);
+	const result = calculationResult.isNaN() ? "0.00" : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);
+	return options?.withSymbol ?? true ? `${result}%` : result;
+}
+
+//#endregion
+export { toPercentageString };
+//# sourceMappingURL=math.js.map

package/dist/math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","names":[],"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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,mBACZ,WACA,aACA,SACF;CACE,MAAM,mBAAmB,IAAI,QAAQ,UAAU,UAAU,CAAC;CAC1D,MAAM,qBAAqB,IAAI,QAAQ,YAAY,UAAU,CAAC;CAC9D,MAAM,oBAAoB,iBAAiB,IAAI,mBAAmB;CAClE,MAAM,SAAS,kBAAkB,OAAO,GAClC,SACA,kBAAkB,MAAM,IAAI,CAAC,QAAQ,SAAS,iBAAiB,EAAE;AAEvE,QAAO,SAAS,cAAc,OAAO,GAAG,OAAO,KAAK"}

package/dist/number.d.ts

@@ -1,4 +1,7 @@
-import { millify } from 'millify';
+import { millify } from "millify";
+
+//#region src/number.d.ts
+
 /**
  * Converts a large number into a compact, human-readable string using `millify`.
  *
@@ -17,5 +20,7 @@ import { millify } from 'millify';
  * console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m
  * ```
  */
-export declare function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]): string;
+declare function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]): string;
+//#endregion
+export { toCompactNumberString };
 //# sourceMappingURL=number.d.ts.map

package/dist/number.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../src/number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,UAS3F"}
+{"version":3,"file":"number.d.ts","names":[],"sources":["../src/number.ts"],"sourcesContent":[],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;;;;iBAAgB,qBAAA,0BAA+C,kBAAkB"}

package/dist/number.js

@@ -0,0 +1,32 @@
+import { millify } from "millify";
+
+//#region src/number.ts
+/**
+* Converts a large number into a compact, human-readable string using `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`
+*
+* @returns {string} The compact number string
+*
+* @example
+* ```typescript
+* import { toCompactNumberString } from '@kikiutils/shared/number';
+*
+* console.log(toCompactNumberString(1234567)); // 1.23m
+* console.log(toCompactNumberString(1234567, { precision: 3 })); // 1.235m
+* ```
+*/
+function toCompactNumberString(value, options) {
+	return millify(value, {
+		lowercase: true,
+		precision: 2,
+		...options
+	});
+}
+
+//#endregion
+export { toCompactNumberString };
+//# sourceMappingURL=number.js.map

package/dist/number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.js","names":[],"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"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,sBAAsB,OAAe,SAAyC;AAC1F,QAAO,QACH,OACA;EACI,WAAW;EACX,WAAW;EACX,GAAG;EACN,CACJ"}

package/dist/object.d.ts

@@ -1,3 +1,4 @@
+//#region src/object.d.ts
 /**
  * Serializes a nested object into a deterministic, flat string format.
  *
@@ -21,5 +22,7 @@
  * console.log(stringifyObjectDeterministically({ foo: 'bar' }, ':', '|')); // foo:bar
  * ```
  */
-export declare function stringifyObjectDeterministically(input: Record<string, any>, kvSeparator?: string, pairSeparator?: string): string;
+declare function stringifyObjectDeterministically(input: Record<string, any>, kvSeparator?: string, pairSeparator?: string): string;
+//#endregion
+export { stringifyObjectDeterministically };
 //# sourceMappingURL=object.d.ts.map

package/dist/object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gCAAgC,CAC5C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,WAAW,GAAE,MAAY,EACzB,aAAa,GAAE,MAAY,UAkC9B"}
+{"version":3,"file":"object.d.ts","names":[],"sources":["../src/object.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;;;;;;;;;;;;;;;;iBAAgB,gCAAA,QACL"}

package/dist/object.js

@@ -0,0 +1,42 @@
+//#region src/object.ts
+/**
+* Serializes a nested object into a deterministic, flat string format.
+*
+* This function recursively traverses the input object (including nested objects and arrays),
+* flattens it into key paths using dot notation (e.g. "a.b.0.c"), sorts all keys,
+* and joins each key-value pair into a string with customizable separators.
+*
+* 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
+*
+* @example
+* ```typescript
+* import { stringifyObjectDeterministically } from '@kikiutils/shared/object';
+*
+* console.log(stringifyObjectDeterministically({ b: 2, a: { x: 1, y: [3, 4] } })); // a.x=1&a.y.0=3&a.y.1=4&b=2
+* console.log(stringifyObjectDeterministically({ foo: 'bar' }, ':', '|')); // foo:bar
+* ```
+*/
+function stringifyObjectDeterministically(input, kvSeparator = "=", pairSeparator = "&") {
+	const entries = [];
+	function walk(object, path = []) {
+		if (Array.isArray(object)) object.forEach((value, index) => {
+			walk(value, [...path, index.toString()]);
+		});
+		else if (object !== null && typeof object === "object" && Object.prototype.toString.call(object) === "[object Object]") Object.keys(object).sort().forEach((key) => {
+			walk(object[key], [...path, key]);
+		});
+		else entries.push(`${path.join(".")}${kvSeparator}${String(object)}`);
+	}
+	walk(input);
+	return entries.sort().join(pairSeparator);
+}
+
+//#endregion
+export { stringifyObjectDeterministically };
+//# sourceMappingURL=object.js.map

package/dist/object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.js","names":["entries: string[]"],"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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,iCACZ,OACA,cAAsB,KACtB,gBAAwB,KAC1B;CACE,MAAMA,UAAoB,EAAE;CAE5B,SAAS,KAAK,QAAa,OAAiB,EAAE,EAAE;AAC5C,MAAI,MAAM,QAAQ,OAAO,CACrB,QAAO,SAAS,OAAO,UAAU;AAC7B,QACI,OACA,CACI,GAAG,MACH,MAAM,UAAU,CACnB,CACJ;IACH;WAEF,WAAW,QACR,OAAO,WAAW,YAClB,OAAO,UAAU,SAAS,KAAK,OAAO,KAAK,kBAE9C,QAAO,KAAK,OAAO,CAAC,MAAM,CAAC,SAAS,QAAQ;AACxC,QACI,OAAO,MACP,CACI,GAAG,MACH,IACH,CACJ;IACH;MACC,SAAQ,KAAK,GAAG,KAAK,KAAK,IAAI,GAAG,cAAc,OAAO,OAAO,GAAG;;AAG3E,MAAK,MAAM;AACX,QAAO,QAAQ,MAAM,CAAC,KAAK,cAAc"}