@pawells/typescript-common 2.0.0 → 2.1.6

package/{build → dist}/object/types.d.ts

@@ -1,64 +1,3 @@
-/**
- * A constructor function type for creating objects of type O.
- * @template O The object type to construct.
- */
-export type TConstructableObject<O extends object = object> = new (...args: any[]) => O;
-/**
- * Omits properties from B that are not in A.
- * @template A Base type.
- * @template B Type to filter.
- */
-export type TObjectOmitExtraProperties<A, B> = {
-    [K in keyof B]: K extends A ? B[K] : never;
-};
-/**
- * Extracts the property keys of an object type.
- * @template O The object type.
- */
-export type TObjectProperties<O extends object> = keyof O;
-/**
- * Extracts property keys of a specific type from an object.
- * @template O Object type.
- * @template PropertyType The type to match.
- */
-export type TObjectPropertiesOfType<O extends object, PropertyType> = keyof {
-    [K in keyof O as O[K] extends PropertyType ? K : never]: any;
-};
-/**
- * Omits properties of a specific type from an object.
- * @template O Object type.
- * @template PropertyType The type to omit.
- */
-export type TObjectOmitPropertiesOfType<O extends object, PropertyType> = {
-    [K in keyof O as O[K] extends PropertyType ? never : K]: O[K];
-};
-/**
- * Represents the union of all property values in an object.
- * @template T Object type.
- */
-export type TObjectPropertyType<T extends object> = T[keyof T];
-/**
- * Extracts properties shared between two object types.
- * @template A First object type.
- * @template B Second object type.
- */
-export type TObjectSharedProperties<A extends object, B extends object> = {
-    [K in keyof A & keyof B]: K extends keyof A ? A[K] : never;
-};
-/**
- * Extracts keys of array properties from an object type.
- * @template T Object type.
- */
-export type TObjectArrayProperties<T extends object> = {
-    [K in keyof T]: T[K] extends Array<any> ? K : never;
-}[keyof T];
-/**
- * Generates nested dot-notation keys for an object type.
- * @template ObjectType The object type.
- */
-export type TObjectNestedKeyOf<ObjectType extends object> = {
-    [Key in keyof ObjectType & (string | number)]: ObjectType[Key] extends object ? `${Key}` | `${Key}.${TObjectNestedKeyOf<ObjectType[Key]>}` : `${Key}`;
-}[keyof ObjectType & (string | number)];
 /**
  * Options for object filtering behavior.
  */

package/dist/object/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/object/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,4HAA4H;IAC5H,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACnC,8EAA8E;IAC9E,sBAAsB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7C,iHAAiH;IACjH,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IAC1C,qGAAqG;IACrG,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,4HAA4H;IAC5H,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACnC,8EAA8E;IAC9E,sBAAsB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7C,iHAAiH;IACjH,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC,0FAA0F;IAC1F,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,MAAM,2BAA2B,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtI;;;GAGG;AACH,MAAM,MAAM,2BAA2B,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;AAE7J;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC;AAE9E;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,EAAE,OAAO,SAAS,MAAM,GAAG,MAAM,IAAI,CACjG,KAAK,EAAE,MAAM,KACT,OAAO,CAAC;AAEb;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAElF;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE3F;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CACrF,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,KACP,OAAO,CAAC;AAEb;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CACrF,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,KACP,OAAO,CAAC"}

package/dist/object/types.js

@@ -0,0 +1 @@
+export {};

package/{build → dist}/string/assert.d.ts

@@ -3,8 +3,13 @@ import { SimpleError } from '../asserts/errors.js';
 /**
  * Error thrown when a value is not a valid string or fails a string assertion.
  *
+ * @returns A StringError instance with the provided message
+ * @throws N/A - This is an error class constructor
+ *
  * @example
+ * ```typescript
  * throw new StringError('Value is not a valid string');
+ * ```
  */
 export declare class StringError extends SimpleError {
     constructor(message?: string);
@@ -97,5 +102,24 @@ export declare function AssertStringNotEmpty(value: unknown, exception?: IAssert
  * AssertStringMatches("user2@example.com", emailPattern); // Uses cached pattern
  * ```
  */
+/**
+ * Asserts that the provided value matches the specified regular expression pattern.
+ *
+ * Uses an LRU cache to store compiled RegExp objects for repeated pattern matching,
+ * improving performance for long-running processes with dynamic regex patterns.
+ *
+ * @remarks
+ * - Cache size: 100 entries
+ * - Cache is LRU-evicted (least recently used entry is removed when size is exceeded)
+ * - When to expect cache behavior: dynamic regex patterns with long-running processes
+ *
+ * @param value - The string to test against the pattern
+ * @param regex - The regular expression pattern to match
+ * @param exception - Optional exception configuration
+ * @throws StringError if the value does not match the pattern
+ * @example
+ * AssertStringMatches('test@example.com', /^[^@]+@[^@]+\.[^@]+$/); // passes
+ * AssertStringMatches('invalid-email', /^[^@]+@[^@]+\.[^@]+$/); // throws
+ */
 export declare function AssertStringMatches(value: string, regex: RegExp, exception?: IAssertException): void;
 //# sourceMappingURL=assert.d.ts.map

package/dist/string/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/string/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AA8CnD;;;;;;;;;;GAUG;AACH,qBAAa,WAAY,SAAQ,WAAW;gBAC/B,OAAO,CAAC,EAAE,MAAM;CAG5B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAGtG;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAY9G;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAsBxG"}

package/{build → dist}/string/assert.js

@@ -19,6 +19,12 @@ const REGEX_PATTERN_CACHE = new LRUCache(MAX_CACHE_SIZE);
  * Gets a cached regex pattern or creates and caches a new one.
  * This optimization improves performance when the same regex patterns are used repeatedly.
  *
+ * The cache key format `${source}:::${flags}` is safe because:
+ * - The `source` parameter is validated by RegExp constructor (throws on invalid patterns)
+ * - The `flags` parameter is validated by RegExp constructor (throws on invalid flags)
+ * - No user-supplied input is included in the cache key beyond these validated components
+ * - The separator ':::' cannot appear in valid regex flags, preventing key collision
+ *
  * @param source - The regex pattern source string
  * @param flags - The regex flags string
  * @returns The compiled RegExp object
@@ -37,8 +43,13 @@ function getCachedRegex(source, flags = '') {
 /**
  * Error thrown when a value is not a valid string or fails a string assertion.
  *
+ * @returns A StringError instance with the provided message
+ * @throws N/A - This is an error class constructor
+ *
  * @example
+ * ```typescript
  * throw new StringError('Value is not a valid string');
+ * ```
  */
 export class StringError extends SimpleError {
     constructor(message) {
@@ -148,6 +159,25 @@ export function AssertStringNotEmpty(value, exception = {}) {
  * AssertStringMatches("user2@example.com", emailPattern); // Uses cached pattern
  * ```
  */
+/**
+ * Asserts that the provided value matches the specified regular expression pattern.
+ *
+ * Uses an LRU cache to store compiled RegExp objects for repeated pattern matching,
+ * improving performance for long-running processes with dynamic regex patterns.
+ *
+ * @remarks
+ * - Cache size: 100 entries
+ * - Cache is LRU-evicted (least recently used entry is removed when size is exceeded)
+ * - When to expect cache behavior: dynamic regex patterns with long-running processes
+ *
+ * @param value - The string to test against the pattern
+ * @param regex - The regular expression pattern to match
+ * @param exception - Optional exception configuration
+ * @throws StringError if the value does not match the pattern
+ * @example
+ * AssertStringMatches('test@example.com', /^[^@]+@[^@]+\.[^@]+$/); // passes
+ * AssertStringMatches('invalid-email', /^[^@]+@[^@]+\.[^@]+$/); // throws
+ */
 export function AssertStringMatches(value, regex, exception = {}) {
     SetExceptionClass(exception, StringError);
     AssertString(value, exception); // Ensure value is a string before matching
@@ -169,4 +199,3 @@ export function AssertStringMatches(value, regex, exception = {}) {
         ThrowException(exception);
     }
 }
-//# sourceMappingURL=assert.js.map

package/{build → dist}/string/case-conversion.js

@@ -121,4 +121,3 @@ export function SnakeCase(value) {
 export function ScreamingSnakeCase(value) {
     return SnakeCase(value).toUpperCase();
 }
-//# sourceMappingURL=case-conversion.js.map

package/{build → dist}/string/comparison.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"comparison.d.ts","sourceRoot":"","sources":["../../src/string/comparison.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,eAAe,GAAE,OAAe,GAAG,OAAO,CAK5F"}
+{"version":3,"file":"comparison.d.ts","sourceRoot":"","sources":["../../src/string/comparison.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,eAAe,UAAQ,GAAG,OAAO,CAQnF"}

package/{build → dist}/string/comparison.js

@@ -18,8 +18,10 @@
  */
 export function StringEquals(a, b, caseInsensitive = false) {
     if (caseInsensitive) {
+        // Note: toLowerCase() allocates a new string per call.
+        // For performance-critical loops (>1000 calls/sec), consider:
+        // a.localeCompare(b, undefined, { sensitivity: 'accent' }) which avoids allocations.
         return a.toLowerCase() === b.toLowerCase();
     }
     return a === b;
 }
-//# sourceMappingURL=comparison.js.map

package/{build → dist}/string/formatting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../../src/string/formatting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE7D;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAW9C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAC3B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,aAAa,GAAG,WAAW,GACjC,MAAM,CAoBR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,SAAQ,GAAG,MAAM,CAUvF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,SAAM,EAAE,MAAM,UAAO,GAAG,MAAM,CASxF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAG9E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CASpE"}
+{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../../src/string/formatting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAM7D;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAW9C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAC3B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,aAAa,GAAG,WAAW,GACjC,MAAM,CAoBR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,SAAQ,GAAG,MAAM,CAUvF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,SAAM,EAAE,MAAM,UAAO,GAAG,MAAM,CASxF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAG9E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CASpE"}

package/{build → dist}/string/formatting.js

@@ -1,3 +1,6 @@
+// Unicode flag (u) ensures consistent behavior with multi-byte characters (emoji, combining marks).
+const INDEX_PLACEHOLDER_REGEX = /\{(\d+)\}/gu;
+const KEY_PLACEHOLDER_REGEX = /\{(\w+)\}/gu;
 /**
  * Escapes a string for safe use in HTML by replacing special characters with
  * their HTML entity equivalents.
@@ -49,12 +52,12 @@ export function FormatString(template, params) {
     if (template && typeof template === 'string') {
         if (params && (Array.isArray(params) || typeof params === 'object')) {
             if (Array.isArray(params)) {
-                return template.replace(/{(\d+)}/g, (match, index) => {
+                return template.replace(INDEX_PLACEHOLDER_REGEX, (match, index) => {
                     const value = params[parseInt(index, 10)];
                     return value !== undefined && value !== null ? String(value) : match;
                 });
             }
-            return template.replace(/{(\w+)}/g, (match, key) => {
+            return template.replace(KEY_PLACEHOLDER_REGEX, (match, key) => {
                 const value = params[key];
                 return value !== undefined && value !== null ? String(value) : match;
             });
@@ -188,4 +191,3 @@ export function CountOccurrences(str, substr) {
     }
     return count;
 }
-//# sourceMappingURL=formatting.js.map

package/{build → dist}/string/index.js

@@ -13,4 +13,3 @@ export * from './formatting.js';
 export * from './transformation.js';
 export * from './comparison.js';
 export * from './assert.js';
-//# sourceMappingURL=index.js.map

package/{build → dist}/string/transformation.js

@@ -40,4 +40,3 @@ export function Slugify(input) {
     }
     return '';
 }
-//# sourceMappingURL=transformation.js.map

package/dist/string/types.d.ts

@@ -0,0 +1,118 @@
+/**
+ * String validator function type.
+ *
+ * A validator function that tests if a string meets certain criteria.
+ *
+ * @param value - The string to validate
+ * @returns true if the string passes validation, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const isLong: TStringValidator = (s) => s.length > 10;
+ * isLong('hello'); // false
+ * isLong('hello world'); // true
+ * ```
+ */
+export type TStringValidator = (value: string) => boolean;
+/**
+ * String formatter function type with optional parameters.
+ *
+ * A formatter function that transforms a string with optional formatting parameters.
+ *
+ * @param value - The string to format
+ * @param params - Optional formatting parameters
+ * @returns The formatted string
+ *
+ * @example
+ * ```typescript
+ * const uppercase: TStringFormatter = (s) => s.toUpperCase();
+ * uppercase('hello'); // 'HELLO'
+ * ```
+ */
+export type TStringFormatter = (value: string, ...params: unknown[]) => string;
+/**
+ * String transformer function type.
+ *
+ * A transformer function that converts input to a transformed string output.
+ *
+ * @param input - The input string
+ * @returns The transformed string
+ *
+ * @example
+ * ```typescript
+ * const reverse: TStringTransformer = (s) => Array.from(s).reverse().join('');
+ * reverse('hello'); // 'olleh'
+ * ```
+ */
+export type TStringTransformer = (input: string) => string;
+/**
+ * Case converter function type.
+ *
+ * A function that converts a string to a specific case format (camelCase, PascalCase, etc.).
+ *
+ * @param value - The string to convert
+ * @returns The string in the target case format
+ *
+ * @example
+ * ```typescript
+ * const toCamel: TCaseConverter = (s) => s.replace(/-(.)/g, (_, c) => c.toUpperCase());
+ * toCamel('hello-world'); // 'helloWorld'
+ * ```
+ */
+export type TCaseConverter = (value: string) => string;
+/**
+ * String predicate function type.
+ *
+ * A predicate function that tests if a string meets a specific condition.
+ *
+ * @param value - The string to test
+ * @returns true if the string passes the predicate, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const isEmail: TStringPredicate = (s) => s.includes('@');
+ * isEmail('user@example.com'); // true
+ * isEmail('invalid'); // false
+ * ```
+ */
+export type TStringPredicate = (value: string) => boolean;
+/**
+ * Format parameter value types.
+ *
+ * Supported types for placeholder values in string formatting operations.
+ *
+ * @returns N/A - This is a type alias
+ *
+ * @example
+ * ```typescript
+ * const values: TFormatValue[] = [42, 'hello', true, null, undefined];
+ * ```
+ */
+export type TFormatValue = string | number | boolean | null | undefined;
+/**
+ * Format parameters as key-value pairs.
+ *
+ * Object structure for named placeholder substitution in string formatting.
+ *
+ * @returns N/A - This is a type alias
+ *
+ * @example
+ * ```typescript
+ * const params: TFormatParams = { name: 'World', count: 42 };
+ * ```
+ */
+export type TFormatParams = Record<string, TFormatValue>;
+/**
+ * Format parameters as positional array.
+ *
+ * Array structure for positional placeholder substitution in string formatting.
+ *
+ * @returns N/A - This is a type alias
+ *
+ * @example
+ * ```typescript
+ * const args: TFormatArgs = ['World', 42, true];
+ * ```
+ */
+export type TFormatArgs = TFormatValue[];
+//# sourceMappingURL=types.d.ts.map

package/dist/string/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/string/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC;AAE/E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAE1D;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC;AAExE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG,YAAY,EAAE,CAAC"}

package/dist/string/types.js

@@ -0,0 +1 @@
+export {};

package/{build → dist}/string/validation.js

@@ -36,4 +36,3 @@ const HEX_PATTERN = /^(?<prefix>#|0x)?(?<hex>[0-9a-f]+)$/iu;
 export function IsHexString(value) {
     return HEX_PATTERN.test(value);
 }
-//# sourceMappingURL=validation.js.map

package/dist/time/elapsed-time/constants.d.ts

@@ -0,0 +1,36 @@
+import type { IDefaultUnitLabels, IFormats } from './types.js';
+/**
+ * Default unit label sets for all predefined formatting styles.
+ * Provides pre-defined label configurations for concise, short, medium, and long time formats.
+ *
+ * Each style object maps time units (week, day, hour, minute, second, millisecond) to their labels.
+ * Labels can be static strings (concise, short, medium) or functions that handle pluralization (long).
+ * All label sets include a `style` property for runtime identification.
+ *
+ * @example
+ * ```typescript
+ * // Using concise labels: single-character abbreviations
+ * const conciseLabel = DEFAULT_UNIT_LABELS.concise.hour;  // "h"
+ *
+ * // Using long labels: function-based with pluralization
+ * const longLabel = DEFAULT_UNIT_LABELS.long.hour(1);     // "hour"
+ * const longLabel2 = DEFAULT_UNIT_LABELS.long.hour(2);    // "hours"
+ *
+ * // Using medium labels: readable abbreviations
+ * const mediumLabel = DEFAULT_UNIT_LABELS.medium.hour;    // "hour"
+ * ```
+ */
+export declare const DEFAULT_UNIT_LABELS: IDefaultUnitLabels;
+/**
+ * Predefined format configurations for elapsed time formatting.
+ * Each configuration provides unitLabels and optional display options for a specific format style.
+ *
+ * @remarks
+ * The `long` format configuration defines pluralization logic for unit labels (e.g., "hour" vs "hours").
+ * This logic is duplicated in the `ElapsedTime._FormatLong()` private method, which handles the special
+ * formatting requirements of the long format with its own pluralization. Both locations must be kept in
+ * sync when modifying singular/plural unit names. This duplication exists because the FORMATS constant
+ * provides label templates while _FormatLong() handles the actual runtime transformation.
+ */
+export declare const FORMATS: IFormats;
+//# sourceMappingURL=constants.d.ts.map

package/{build → dist}/time/elapsed-time/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/time/elapsed-time/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,kBAuCxB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,QAkEZ,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/time/elapsed-time/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mBAAmB,EAAE,kBAqCxB,CAAC;AAEX;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,EAAE,QA4DZ,CAAC"}

package/{build → dist}/time/elapsed-time/constants.js

@@ -1,8 +1,27 @@
 /**
- * Default unit labels for different formatting styles.
+ * Default unit label sets for all predefined formatting styles.
+ * Provides pre-defined label configurations for concise, short, medium, and long time formats.
+ *
+ * Each style object maps time units (week, day, hour, minute, second, millisecond) to their labels.
+ * Labels can be static strings (concise, short, medium) or functions that handle pluralization (long).
+ * All label sets include a `style` property for runtime identification.
+ *
+ * @example
+ * ```typescript
+ * // Using concise labels: single-character abbreviations
+ * const conciseLabel = DEFAULT_UNIT_LABELS.concise.hour;  // "h"
+ *
+ * // Using long labels: function-based with pluralization
+ * const longLabel = DEFAULT_UNIT_LABELS.long.hour(1);     // "hour"
+ * const longLabel2 = DEFAULT_UNIT_LABELS.long.hour(2);    // "hours"
+ *
+ * // Using medium labels: readable abbreviations
+ * const mediumLabel = DEFAULT_UNIT_LABELS.medium.hour;    // "hour"
+ * ```
  */
 export const DEFAULT_UNIT_LABELS = {
     concise: {
+        style: 'concise',
         day: 'd',
         hour: 'h',
         millisecond: 'ms',
@@ -11,6 +30,7 @@ export const DEFAULT_UNIT_LABELS = {
         week: 'w',
     },
     long: {
+        style: 'long',
         day: (value) => `${value === 1 ? 'day' : 'days'}`,
         hour: (value) => `${value === 1 ? 'hour' : 'hours'}`,
         millisecond: (value) => `${value === 1 ? 'millisecond' : 'milliseconds'}`,
@@ -19,6 +39,7 @@ export const DEFAULT_UNIT_LABELS = {
         week: (value) => `${value === 1 ? 'week' : 'weeks'}`,
     },
     medium: {
+        style: 'medium',
         day: 'day',
         hour: 'hour',
         millisecond: 'ms',
@@ -27,6 +48,7 @@ export const DEFAULT_UNIT_LABELS = {
         week: 'week',
     },
     short: {
+        style: 'short',
         day: 'd',
         hour: 'hr',
         millisecond: 'ms',
@@ -36,7 +58,15 @@ export const DEFAULT_UNIT_LABELS = {
     },
 };
 /**
- * Predefined formatter styles with comprehensive formatting options.
+ * Predefined format configurations for elapsed time formatting.
+ * Each configuration provides unitLabels and optional display options for a specific format style.
+ *
+ * @remarks
+ * The `long` format configuration defines pluralization logic for unit labels (e.g., "hour" vs "hours").
+ * This logic is duplicated in the `ElapsedTime._FormatLong()` private method, which handles the special
+ * formatting requirements of the long format with its own pluralization. Both locations must be kept in
+ * sync when modifying singular/plural unit names. This duplication exists because the FORMATS constant
+ * provides label templates while _FormatLong() handles the actual runtime transformation.
  */
 export const FORMATS = {
     /**
@@ -93,4 +123,3 @@ export const FORMATS = {
         },
     },
 };
-//# sourceMappingURL=constants.js.map