@pawells/typescript-common 2.0.0 → 2.1.6

package/{build → dist}/array/array-zip.js

@@ -3,7 +3,7 @@
  * The result length is capped at the shortest input array.
  *
  * @param arrays - Two or more arrays to zip
- * @returns Array of tuples — one tuple per index position
+ * @returns Array of tuples — one tuple per index position. Returns `[]` if `arrays` is empty or if any input array is `null` or `undefined`.
  *
  * @example
  * ```typescript
@@ -22,4 +22,3 @@ export function ArrayZip(...arrays) {
     const minLen = Math.min(...arrays.map((a) => a.length));
     return Array.from({ length: minLen }, (_, i) => arrays.map((a) => a[i]));
 }
-//# sourceMappingURL=array-zip.js.map

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

@@ -59,7 +59,7 @@ export interface IAssertArray2DArgs {
 }
 /**
  * Asserts that a value is an array, optionally validating its size.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The value to validate.
  * @param args - Optional size constraints.
  * @param exception - Optional custom exception to throw.
@@ -68,7 +68,7 @@ export interface IAssertArray2DArgs {
 export declare function AssertArray<T = unknown>(value: unknown, args?: IAssertArrayArgs, exception?: IAssertException): asserts value is T[];
 /**
  * Asserts that a value is a 2D array, optionally validating its dimensions.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The value to validate.
  * @param args - Optional dimension constraints.
  * @param exception - Optional custom exception to throw.
@@ -77,7 +77,7 @@ export declare function AssertArray<T = unknown>(value: unknown, args?: IAssertA
 export declare function AssertArray2D<T = unknown>(value: unknown, args?: IAssertArray2DArgs, exception?: IAssertException): asserts value is T[][];
 /**
  * Asserts that an array is not empty.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The array to validate.
  * @param exception - Optional custom exception to throw.
  * @throws {ArrayError} If the array is empty.
@@ -89,7 +89,7 @@ export declare function AssertArrayNotEmpty<T>(value: T[] | unknown, exception?:
  * Uses `array.every()` to check if all elements satisfy the predicate condition.
  * Throws an error if any element fails the test.
  *
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param array - The array to validate.
  * @param predicate - A function to test each element.
  * @param exception - Optional custom exception to throw.
@@ -102,7 +102,7 @@ export declare function AssertArrayAll<T>(array: T[], predicate: (el: T, idx: nu
  * Uses `array.some()` to check if any element satisfies the predicate condition.
  * Throws an error if no elements pass the test.
  *
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param array - The array to validate.
  * @param predicate - A function to test each element.
  * @param exception - Optional custom exception to throw.

package/{build → dist}/array/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/array/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAChC,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAClC,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,UAAW,SAAQ,WAAW;gBAC9B,OAAO,CAAC,EAAE,MAAM;CAG5B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAClC,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,gBAAgB,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,CA2BxI;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,kBAAuB,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,EAAE,CAoElJ;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,CAYnH;AAWD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAO1I;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAO1I"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/array/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAChC,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAClC,kCAAkC;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,UAAW,SAAQ,WAAW;gBAC9B,OAAO,CAAC,EAAE,MAAM;CAG5B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IAClC,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,gBAAgB,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,CA2BxI;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,kBAAuB,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,EAAE,CAqElJ;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,EAAE,CAYnH;AAWD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAO1I;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,EAAE,SAAS,GAAE,gBAAqB,GAAG,IAAI,CAO1I"}

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

@@ -13,7 +13,7 @@ export class ArrayError extends SimpleError {
 }
 /**
  * Asserts that a value is an array, optionally validating its size.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The value to validate.
  * @param args - Optional size constraints.
  * @param exception - Optional custom exception to throw.
@@ -44,7 +44,7 @@ export function AssertArray(value, args, exception = {}) {
 }
 /**
  * Asserts that a value is a 2D array, optionally validating its dimensions.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The value to validate.
  * @param args - Optional dimension constraints.
  * @param exception - Optional custom exception to throw.
@@ -57,14 +57,14 @@ export function AssertArray2D(value, args = {}, exception = {}) {
     AssertValueType(value, 'array', exception);
     // Type cast is safe after array validation
     const array = value;
-    // Validate that all elements are arrays (making it 2D)
-    if (!array.every((row) => Array.isArray(row))) {
-        let invalidPositions = array.map((row, idx) => {
-            if (!Array.isArray(row))
-                return idx;
-            return null;
-        });
-        invalidPositions = invalidPositions.filter((idx) => idx !== null);
+    // Validate that all elements are arrays (making it 2D) with single-pass collection of invalid positions
+    const invalidPositions = [];
+    for (let i = 0; i < array.length; i++) {
+        if (!Array.isArray(array[i])) {
+            invalidPositions.push(i);
+        }
+    }
+    if (invalidPositions.length > 0) {
         SetExceptionMessage(exception, `Expected 2D array but found non-array elements at positions: ${invalidPositions.join(', ')}`);
         ThrowException(exception);
     }
@@ -111,7 +111,7 @@ export function AssertArray2D(value, args = {}, exception = {}) {
 }
 /**
  * Asserts that an array is not empty.
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param value - The array to validate.
  * @param exception - Optional custom exception to throw.
  * @throws {ArrayError} If the array is empty.
@@ -141,7 +141,7 @@ function assertIsArray(array, exception) {
  * Uses `array.every()` to check if all elements satisfy the predicate condition.
  * Throws an error if any element fails the test.
  *
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param array - The array to validate.
  * @param predicate - A function to test each element.
  * @param exception - Optional custom exception to throw.
@@ -161,7 +161,7 @@ export function AssertArrayAll(array, predicate, exception = {}) {
  * Uses `array.some()` to check if any element satisfies the predicate condition.
  * Throws an error if no elements pass the test.
  *
- * @template T The type of array elements.
+ * @template T - The type of array elements.
  * @param array - The array to validate.
  * @param predicate - A function to test each element.
  * @param exception - Optional custom exception to throw.
@@ -175,4 +175,3 @@ export function AssertArrayAny(array, predicate, exception = {}) {
         ThrowException(exception);
     }
 }
-//# sourceMappingURL=assert.js.map

package/{build → dist}/array/index.d.ts

@@ -25,4 +25,5 @@ export * from './array-sample.js';
 export type * from './array-element.js';
 export type { TPredicate, TTransform, TComparator, TEqualityComparator } from './types.js';
 export * from './assert.js';
+export * from './iterators.js';
 //# sourceMappingURL=index.d.ts.map

package/{build → dist}/array/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/array/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,mBAAmB,oBAAoB,CAAC;AACxC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAC3F,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/array/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,mBAAmB,oBAAoB,CAAC;AACxC,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAC3F,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

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

@@ -23,4 +23,4 @@ export * from './array-sort-by.js';
 export * from './array-count-by.js';
 export * from './array-sample.js';
 export * from './assert.js';
-//# sourceMappingURL=index.js.map
+export * from './iterators.js';

package/dist/array/iterators.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Async generator function that filters array elements based on a predicate and optional filter criteria.
+ *
+ * Yields only elements that pass both the optional validator function and the filter criteria object.
+ * This is useful for streaming large datasets through memory-efficient async iteration.
+ *
+ * @template TObject The type of elements in the iterator
+ * @template TArgs The type of filter criteria object (extends Record<string, unknown>)
+ *
+ * @param iterator The async iterable to filter
+ * @param args Optional filter criteria object; if provided, only elements matching all criteria are yielded
+ * @param validator Optional predicate function returning true for elements to keep; called before filter criteria
+ *
+ * @returns {AsyncGenerator<TObject, void, unknown>} Async generator that yields filtered elements
+ *
+ * @remarks
+ * Elements are evaluated one at a time without batching. The validator is applied first; if it rejects
+ * an element, the filter criteria are not evaluated. If no args are provided, all elements (passing the
+ * validator if present) are passed through unchanged.
+ *
+ * @example
+ * async function* items() {
+ *   yield { id: 1, status: 'active' };
+ *   yield { id: 2, status: 'inactive' };
+ *   yield { id: 3, status: 'active' };
+ * }
+ *
+ * for await (const item of FilteredIterator(items(), { status: 'active' })) {
+ *   console.log(item); // Only logs items with status: 'active'
+ * }
+ *
+ * @example
+ * for await (const item of FilteredIterator(items(), undefined, (obj) => obj.id > 1)) {
+ *   console.log(item); // Only logs items with id > 1
+ * }
+ *
+ * @throws {TypeError} if iterator is null or undefined
+ */
+export declare function FilteredIterator<TObject, TArgs extends Record<string, unknown>>(iterator: AsyncIterable<TObject>, args?: TArgs, validator?: (obj: TObject) => boolean): AsyncGenerator<TObject, void, unknown>;
+//# sourceMappingURL=iterators.d.ts.map

package/dist/array/iterators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterators.d.ts","sourceRoot":"","sources":["../../src/array/iterators.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAuB,gBAAgB,CAAC,OAAO,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,GAAG,cAAc,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAcrN"}

package/dist/array/iterators.js

@@ -0,0 +1,54 @@
+import { ObjectFilter } from '../object/filter.js';
+/**
+ * Async generator function that filters array elements based on a predicate and optional filter criteria.
+ *
+ * Yields only elements that pass both the optional validator function and the filter criteria object.
+ * This is useful for streaming large datasets through memory-efficient async iteration.
+ *
+ * @template TObject The type of elements in the iterator
+ * @template TArgs The type of filter criteria object (extends Record<string, unknown>)
+ *
+ * @param iterator The async iterable to filter
+ * @param args Optional filter criteria object; if provided, only elements matching all criteria are yielded
+ * @param validator Optional predicate function returning true for elements to keep; called before filter criteria
+ *
+ * @returns {AsyncGenerator<TObject, void, unknown>} Async generator that yields filtered elements
+ *
+ * @remarks
+ * Elements are evaluated one at a time without batching. The validator is applied first; if it rejects
+ * an element, the filter criteria are not evaluated. If no args are provided, all elements (passing the
+ * validator if present) are passed through unchanged.
+ *
+ * @example
+ * async function* items() {
+ *   yield { id: 1, status: 'active' };
+ *   yield { id: 2, status: 'inactive' };
+ *   yield { id: 3, status: 'active' };
+ * }
+ *
+ * for await (const item of FilteredIterator(items(), { status: 'active' })) {
+ *   console.log(item); // Only logs items with status: 'active'
+ * }
+ *
+ * @example
+ * for await (const item of FilteredIterator(items(), undefined, (obj) => obj.id > 1)) {
+ *   console.log(item); // Only logs items with id > 1
+ * }
+ *
+ * @throws {TypeError} if iterator is null or undefined
+ */
+export async function* FilteredIterator(iterator, args, validator) {
+    for await (const obj of iterator) {
+        // Validate entity before filtering/yielding
+        if (validator && !validator(obj))
+            continue;
+        // If no filter args provided, pass through all events
+        if (!args || typeof args !== 'object' || Object.keys(args).length === 0) {
+            yield obj;
+            continue;
+        }
+        // Apply filter criteria
+        if (ObjectFilter(obj, args))
+            yield obj;
+    }
+}

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

@@ -35,9 +35,27 @@ export type TEqualityComparator<T> = (a: T, b: T) => boolean;
  *
  * @template T - The type of array elements
  */
+/**
+ * Comparison options for array operations.
+ *
+ * Provides a discriminated union where callers must choose exactly one strategy:
+ * - `comparator`: Custom equality function for specialized comparison logic
+ * - `useDeepEqual`: Deep structural equality checking
+ * - `keyFn`: Function to extract a primitive key for O(n+m) Set-based lookup
+ *
+ * Mutually exclusive at compile time via `never` literals.
+ */
 export type TArrayComparisonOptions<T> = {
-    comparator?: TEqualityComparator<T>;
+    comparator: TEqualityComparator<T>;
+    useDeepEqual?: never;
+    keyFn?: never;
+} | {
+    useDeepEqual: true;
+    comparator?: never;
+    keyFn?: never;
 } | {
-    useDeepEqual?: boolean;
+    keyFn: (item: T) => unknown;
+    comparator?: never;
+    useDeepEqual?: never;
 };
 //# sourceMappingURL=types.d.ts.map

package/{build → dist}/array/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/array/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAClC;IAAE,UAAU,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAA;CAAE,GACvC;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/array/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAErE;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE7D;;;;;GAKG;AACH;;;;;;;;;GASG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAClC;IAAE,UAAU,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC;IAAC,YAAY,CAAC,EAAE,KAAK,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GAC3E;IAAE,YAAY,EAAE,IAAI,CAAC;IAAC,UAAU,CAAC,EAAE,KAAK,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GACzD;IAAE,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,KAAK,CAAC;IAAC,YAAY,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC"}

package/dist/array/types.js

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

package/{build → dist}/array/unique.d.ts

@@ -5,7 +5,7 @@
  *
  * @template T - The type of array elements
  * @param array - The input array
- * @returns A new array containing only unique values (preserves first occurrence order)
+ * @returns A new array containing only unique values (preserves first occurrence order). Returns `[]` if `array` is `null`, `undefined`, or empty.
  *
  * @remarks Uses reference equality for objects. Two distinct objects with
  * identical property values are **not** considered equal and will both be kept.

package/{build → dist}/array/unique.js

@@ -5,7 +5,7 @@
  *
  * @template T - The type of array elements
  * @param array - The input array
- * @returns A new array containing only unique values (preserves first occurrence order)
+ * @returns A new array containing only unique values (preserves first occurrence order). Returns `[]` if `array` is `null`, `undefined`, or empty.
  *
  * @remarks Uses reference equality for objects. Two distinct objects with
  * identical property values are **not** considered equal and will both be kept.
@@ -23,4 +23,3 @@ export function Unique(array) {
     }
     return [...new Set(array)];
 }
-//# sourceMappingURL=unique.js.map

package/dist/asserts/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/asserts/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,qBAAa,WAAY,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM;CAM3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,SAAU,SAAQ,KAAK;IACnC,SAAgB,IAAI,EAAE,MAAM,CAAC;IAE7B,SAAgB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAE7D;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAkB5E;AAED;;;;;;;GAOG;AACH,qBAAa,eAAgB,SAAQ,SAAS;IAC7C;;;OAGG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG9D;AAED;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC5C;;;OAGG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG9D;AAED;;;;;;;;;;GAUG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAClD;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAGnF;AAED;;;;;;;;;GASG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC/C;;;OAGG;gBACS,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAGhE;AAED;;;;;;;;;GASG;AACH,qBAAa,aAAc,SAAQ,SAAS;IAC3C;;;OAGG;gBACS,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG3D;AAED;;;;;;;;;;GAUG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IACjD;;;OAGG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG9D"}

package/{build → dist}/asserts/errors.js

@@ -55,9 +55,12 @@ export class BaseError extends Error {
         this.name = this.constructor.name;
         this.Code = code;
         this.Context = context;
-        if (typeof Error.captureStackTrace === 'function') {
-            Error.captureStackTrace(this, this.constructor);
+        /* eslint-disable @typescript-eslint/no-explicit-any */
+        const ErrorWithCapture = Error;
+        if (typeof ErrorWithCapture.captureStackTrace === 'function') {
+            ErrorWithCapture.captureStackTrace(this, this.constructor);
         }
+        /* eslint-enable @typescript-eslint/no-explicit-any */
     }
 }
 /**
@@ -173,4 +176,3 @@ export class BufferOverflowError extends BaseError {
         super(`Buffer overflow: maximum size ${maxSize} exceeded`, 'BUFFER_OVERFLOW', context);
     }
 }
-//# sourceMappingURL=errors.js.map

package/{build → dist}/asserts/generic.d.ts

@@ -1,5 +1,25 @@
 import type { IAssertException, TGuard, TValidationPredicate } from './types.js';
 import { SimpleError } from './errors.js';
+/**
+ * Serializes a value to a human-readable string, safe for any value type.
+ *
+ * Prevents sensitive data exposure in error messages by:
+ * - Masking object contents (shows type name only, not property values)
+ * - Truncating long strings with a clear indication
+ * - Handling non-serializable values gracefully
+ *
+ * @param value - The value to serialize for display
+ * @param maxLength - Maximum characters to display for primitives (default: 100, capped at 10,000)
+ * @returns A safe string representation (at most maxLength chars plus "[truncated]" suffix)
+ *
+ * @example
+ * safeDisplay({ apiKey: 'secret123', username: 'john' }); // '[Object]'
+ * safeDisplay('x'.repeat(100)); // 'xxx....[truncated]'
+ * safeDisplay(circularRef); // '[non-serializable]'
+ *
+ * @internal Used internally by assertion functions to safely display values in error messages
+ */
+export declare function safeDisplay(value: unknown, maxLength?: number): string;
 /**
  * Gets the display type of a value including null and undefined.
  * Used for error messages in null/undefined assertions and type checking.
@@ -13,7 +33,7 @@ export declare function GetValueType(value: unknown): string;
  * Type alias for constructor functions.
  * Represents any class constructor that can be instantiated.
  */
-export type TConstructorFunction<T = any> = new (...args: any[]) => T;
+export type TConstructorFunction<T = unknown> = new (...args: any[]) => T;
 /**
  * Error thrown when a nullish assertion fails — the value is not null or undefined
  * but was expected to be. Used by {@link AssertNull} when the provided value is a
@@ -403,7 +423,7 @@ export declare function AssertInstanceOf<T>(value: unknown, constructor: TConstr
  * AssertFunction(123); // ✗ Throws FunctionError
  * AssertFunction(null); // ✗ Throws FunctionError
  */
-export declare function AssertFunction(value: unknown, exception?: IAssertException): asserts value is (...args: any[]) => any;
+export declare function AssertFunction(value: unknown, exception?: IAssertException): asserts value is (...args: unknown[]) => unknown;
 /**
  * Asserts that a value is a symbol.
  *
@@ -440,5 +460,5 @@ export declare function AssertSymbol(value: unknown, exception?: IAssertExceptio
  * AssertExtends(Derived, Base); // ✓ Valid
  * AssertExtends(Base, Derived); // ✗ Throws ExtendsError
  */
-export declare function AssertExtends(derived: abstract new (...args: any[]) => any, base: abstract new (...args: any[]) => any, exception?: IAssertException): void;
+export declare function AssertExtends(derived: abstract new (...args: any[]) => unknown, base: abstract new (...args: any[]) => unknown, exception?: IAssertException): void;
 //# sourceMappingURL=generic.d.ts.map

package/dist/asserts/generic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../src/asserts/generic.ts"],"names":[],"mappings":"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"}

package/{build → dist}/asserts/generic.js

@@ -1,15 +1,46 @@
 import { ObjectEquals } from './internal-utils.js';
 import { SetExceptionClass, SetExceptionMessage, ThrowException } from './utils.js';
 import { AssertionError, SimpleError } from './errors.js';
-/** Maximum number of characters to include from a value in an error message. */
-const MAX_VALUE_DISPLAY_LENGTH = 100;
-/** Serialises a value to a human-readable string, safe for any value type. */
-function safeDisplay(value) {
+/**
+ * Maximum length for safe value display in assertion error messages.
+ * Prevents verbose output and potential information disclosure.
+ */
+const MAX_SAFE_DISPLAY_LENGTH = 100;
+/**
+ * Serializes a value to a human-readable string, safe for any value type.
+ *
+ * Prevents sensitive data exposure in error messages by:
+ * - Masking object contents (shows type name only, not property values)
+ * - Truncating long strings with a clear indication
+ * - Handling non-serializable values gracefully
+ *
+ * @param value - The value to serialize for display
+ * @param maxLength - Maximum characters to display for primitives (default: 100, capped at 10,000)
+ * @returns A safe string representation (at most maxLength chars plus "[truncated]" suffix)
+ *
+ * @example
+ * safeDisplay({ apiKey: 'secret123', username: 'john' }); // '[Object]'
+ * safeDisplay('x'.repeat(100)); // 'xxx....[truncated]'
+ * safeDisplay(circularRef); // '[non-serializable]'
+ *
+ * @internal Used internally by assertion functions to safely display values in error messages
+ */
+export function safeDisplay(value, maxLength = MAX_SAFE_DISPLAY_LENGTH) {
+    // Cap maxLength to prevent memory exhaustion from extremely large values
+    const effectiveMaxLength = Math.min(maxLength, 10_000);
+    // For objects, use type name instead of full serialization to avoid leaking structure
+    if (typeof value === 'object' && value !== null) {
+        return `[${Object.getPrototypeOf(value)?.constructor?.name ?? 'Object'}]`;
+    }
+    // For primitives, truncate with clear indication
     try {
-        return (JSON.stringify(value) ?? String(value)).slice(0, MAX_VALUE_DISPLAY_LENGTH);
+        const serialized = JSON.stringify(value) ?? String(value);
+        return serialized.length > effectiveMaxLength
+            ? serialized.slice(0, effectiveMaxLength) + '...[truncated]'
+            : serialized;
     }
     catch {
-        return String(value).slice(0, MAX_VALUE_DISPLAY_LENGTH);
+        return '[non-serializable]';
     }
 }
 /**
@@ -177,6 +208,7 @@ export class ExtendsError extends SimpleError {
  * });                                               // ✗ Throws with custom message
  * ```
  */
+// @internal — Do not import from this module directly. Use asserts/index.ts instead.
 export function AssertEquals(value, expected, exception = {}) {
     SetExceptionClass(exception, AssertionError);
     if (!ObjectEquals(value, expected)) {
@@ -535,6 +567,7 @@ export function AssertSymbol(value, exception = {}) {
  * AssertExtends(Derived, Base); // ✓ Valid
  * AssertExtends(Base, Derived); // ✗ Throws ExtendsError
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function AssertExtends(derived, base, exception = {}) {
     SetExceptionClass(exception, ExtendsError);
     if (typeof derived !== 'function' || typeof base !== 'function') {
@@ -556,4 +589,3 @@ export function AssertExtends(derived, base, exception = {}) {
         ThrowException(exception);
     }
 }
-//# sourceMappingURL=generic.js.map

package/dist/asserts/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @module asserts
+ * @description Aggregation barrel for all assertion functions.
+ * Exports both generic assertion primitives (like AssertNull, AssertNotNull, AssertEquals, etc.)
+ * and domain-specific validators (AssertArray, AssertBoolean, AssertNumber, AssertObject, AssertString).
+ *
+ * Domain-specific assertions are re-exported here as a convenience so callers can import
+ * all assertion functions from a single entry point. They originate from their respective
+ * domain modules (array/, boolean/, number/, object/, string/).
+ *
+ * Note: Internal utility functions (SetExceptionClass, SetExceptionMessage, ThrowException,
+ * AssertValueType, safeDisplay, GetValueType) are NOT exported from this barrel as they are
+ * part of the internal assertion implementation contract and should not be relied upon by external code.
+ */
+/**
+ * Export all array assertion functions and types
+ */
+export * from '../array/assert.js';
+/**
+ * Export all boolean assertion functions and types
+ */
+export * from '../boolean/assert.js';
+/**
+ * Export generic assertion functions (but not internal utilities)
+ */
+export { AssertEquals, AssertNotEquals, AssertNull, AssertNotNull, AssertPredicate, AssertIsType, AssertInstanceOf, AssertFunction, AssertSymbol, AssertExtends, NullError, NotNullError, PredicateError, TypeGuardError, InstanceOfError, FunctionError, SymbolError, ExtendsError, type TConstructorFunction, } from './generic.js';
+/**
+ * Export all number assertion functions and types
+ */
+export * from '../number/assert.js';
+/**
+ * Export all object assertion functions and types
+ */
+export * from '../object/assert.js';
+/**
+ * Export all string assertion functions and types
+ */
+export * from '../string/assert.js';
+/**
+ * Export type definitions and interfaces
+ */
+export * from './types.js';
+/**
+ * Export error classes for standardized error handling
+ */
+export * from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/asserts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/asserts/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;GAEG;AACH,cAAc,oBAAoB,CAAC;AAEnC;;GAEG;AACH,cAAc,sBAAsB,CAAC;AAErC;;GAEG;AACH,OAAO,EACN,YAAY,EACZ,eAAe,EACf,UAAU,EACV,aAAa,EACb,eAAe,EACf,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,aAAa,EACb,SAAS,EACT,YAAY,EACZ,cAAc,EACd,cAAc,EACd,eAAe,EACf,aAAa,EACb,WAAW,EACX,YAAY,EACZ,KAAK,oBAAoB,GACzB,MAAM,cAAc,CAAC;AAEtB;;GAEG;AACH,cAAc,qBAAqB,CAAC;AAEpC;;GAEG;AACH,cAAc,qBAAqB,CAAC;AAEpC;;GAEG;AACH,cAAc,qBAAqB,CAAC;AAEpC;;GAEG;AACH,cAAc,YAAY,CAAC;AAE3B;;GAEG;AACH,cAAc,aAAa,CAAC"}

package/dist/asserts/index.js

@@ -0,0 +1,46 @@
+/**
+ * @module asserts
+ * @description Aggregation barrel for all assertion functions.
+ * Exports both generic assertion primitives (like AssertNull, AssertNotNull, AssertEquals, etc.)
+ * and domain-specific validators (AssertArray, AssertBoolean, AssertNumber, AssertObject, AssertString).
+ *
+ * Domain-specific assertions are re-exported here as a convenience so callers can import
+ * all assertion functions from a single entry point. They originate from their respective
+ * domain modules (array/, boolean/, number/, object/, string/).
+ *
+ * Note: Internal utility functions (SetExceptionClass, SetExceptionMessage, ThrowException,
+ * AssertValueType, safeDisplay, GetValueType) are NOT exported from this barrel as they are
+ * part of the internal assertion implementation contract and should not be relied upon by external code.
+ */
+/**
+ * Export all array assertion functions and types
+ */
+export * from '../array/assert.js';
+/**
+ * Export all boolean assertion functions and types
+ */
+export * from '../boolean/assert.js';
+/**
+ * Export generic assertion functions (but not internal utilities)
+ */
+export { AssertEquals, AssertNotEquals, AssertNull, AssertNotNull, AssertPredicate, AssertIsType, AssertInstanceOf, AssertFunction, AssertSymbol, AssertExtends, NullError, NotNullError, PredicateError, TypeGuardError, InstanceOfError, FunctionError, SymbolError, ExtendsError, } from './generic.js';
+/**
+ * Export all number assertion functions and types
+ */
+export * from '../number/assert.js';
+/**
+ * Export all object assertion functions and types
+ */
+export * from '../object/assert.js';
+/**
+ * Export all string assertion functions and types
+ */
+export * from '../string/assert.js';
+/**
+ * Export type definitions and interfaces
+ */
+export * from './types.js';
+/**
+ * Export error classes for standardized error handling
+ */
+export * from './errors.js';

package/{build → dist}/asserts/internal-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal-utils.d.ts","sourceRoot":"","sources":["../../src/asserts/internal-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAGxF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"internal-utils.d.ts","sourceRoot":"","sources":["../../src/asserts/internal-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AAEH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAGxF,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/{build → dist}/asserts/internal-utils.js

@@ -3,4 +3,3 @@
  */
 // Single source of truth — the canonical implementation lives in the object module.
 export { ObjectEquals } from '../object/equals.js';
-//# sourceMappingURL=internal-utils.js.map