ts-data-forge 5.0.1 → 5.1.1

package/README.md

@@ -140,6 +140,7 @@ The `expectType` utility allows you to make assertions about types at compile ti
 import { expectType } from 'ts-data-forge';
 
 type User = { id: number; name: string };
+
 type Admin = { id: number; name: string; role: 'admin' };
 
 // Assert that Admin extends User
@@ -170,7 +171,7 @@ const maybeValue = Optional.some(42);
 
 const doubled = Optional.map(maybeValue, (x) => x * 2);
 
-assert(Optional.unwrapOr(doubled, 0) === 84);
+assert.isTrue(Optional.unwrapOr(doubled, 0) === 84);
 
 // Result for error handling
 const success = Result.ok(42);
@@ -200,16 +201,19 @@ const handleStatus = (status: Status, data?: string): string =>
         error: 'An error occurred',
     });
 
-assert(handleStatus('loading') === 'Please wait...');
-assert(handleStatus('success', 'Hello') === 'Data: Hello');
-assert(handleStatus('error') === 'An error occurred');
+assert.isTrue(handleStatus('loading') === 'Please wait...');
+
+assert.isTrue(handleStatus('success', 'Hello') === 'Data: Hello');
+
+assert.isTrue(handleStatus('error') === 'An error occurred');
 
 // Pattern matching with Result
 const processResult = (result: Result<number, string>): string =>
     Result.isOk(result) ? `Success: ${result.value}` : `Error: ${result.value}`;
 
-assert(processResult(Result.ok(42)) === 'Success: 42');
-assert(processResult(Result.err('Failed')) === 'Error: Failed');
+assert.isTrue(processResult(Result.ok(42)) === 'Success: 42');
+
+assert.isTrue(processResult(Result.err('Failed')) === 'Error: Failed');
 ```
 
 ### 3. Number Utilities with `Num` and Branded Number Types
@@ -220,35 +224,43 @@ The `Num` object provides safe and convenient functions for numerical operations
 import { Num } from 'ts-data-forge';
 
 // Basic conversions
-assert(Num.from('123') === 123);
-assert(Number.isNaN(Num.from('abc')));
+assert.isTrue(Num.from('123') === 123);
+
+assert.isTrue(Number.isNaN(Num.from('abc')));
 
 // Range checking
 const inRange = Num.isInRange(0, 10);
 
-assert(inRange(5));
-assert(inRange(0)); // (inclusive lower bound)
-assert(!inRange(10)); // (exclusive upper bound)
+assert.isTrue(inRange(5));
+
+assert.isTrue(inRange(0)); // (inclusive lower bound)
+
+assert.isFalse(inRange(10)); // (exclusive upper bound)
 
 // Clamping values
 const clamp = Num.clamp(0, 100);
 
-assert(clamp(150) === 100);
-assert(clamp(-10) === 0);
+assert.isTrue(clamp(150) === 100);
+
+assert.isTrue(clamp(-10) === 0);
 
 // Rounding utilities
 const round2 = Num.round(2);
 
-assert(round2(3.141_59) === 3.14);
-assert(Num.roundAt(3.141_59, 3) === 3.142);
-assert(Num.roundToInt(3.7) === 4);
+assert.isTrue(round2(3.141_59) === 3.14);
+
+assert.isTrue(Num.roundAt(3.141_59, 3) === 3.142);
+
+assert.isTrue(Num.roundToInt(3.7) === 4);
 
 // Type guards
 const value = 5; // example value
+
 if (Num.isNonZero(value)) {
     // value is guaranteed to be non-zero
     const result = Num.div(10, value); // Safe division
-    assert(result === 2);
+
+    assert.isTrue(result === 2);
 }
 ```
 
@@ -272,14 +284,20 @@ import {
 
 // Basic branded types
 const integer = asInt(42); // Int - any integer
+
 const unsigned = asUint(42); // Uint - non-negative integer
+
 const finite = asFiniteNumber(3.14); // FiniteNumber - finite floating-point
+
 const safeInt = asSafeInt(42); // SafeInt - integer in safe range
 
-assert(integer === 42);
-assert(unsigned === 42);
-assert(finite === 3.14);
-assert(safeInt === 42);
+assert.isTrue(integer === 42);
+
+assert.isTrue(unsigned === 42);
+
+assert.isTrue(finite === 3.14);
+
+assert.isTrue(safeInt === 42);
 
 // This line would cause a runtime error:
 assert.throw(() => {
@@ -288,30 +306,42 @@ assert.throw(() => {
 
 // Range-constrained types (16-bit, 32-bit)
 const int16 = asInt16(1000); // Int16: [-32768, 32767]
+
 const uint32 = asUint32(3_000_000_000); // Uint32: [0, 4294967295]
-assert(int16 === 1000);
-assert(uint32 === 3_000_000_000);
+
+assert.isTrue(int16 === 1000);
+
+assert.isTrue(uint32 === 3_000_000_000);
 
 // Non-zero and positive variants
 const nonZeroInt = asNonZeroInt(5); // NonZeroInt - excludes zero
+
 const positiveInt = asPositiveInt(10); // PositiveInt - excludes zero and negatives
-assert(nonZeroInt === 5);
-assert(positiveInt === 10);
+
+assert.isTrue(nonZeroInt === 5);
+
+assert.isTrue(positiveInt === 10);
 
 // Type-safe arithmetic with automatic clamping
 const sum = Int16.add(int16, asInt16(2000)); // Int16 (3000)
+
 const clamped = Int16.clamp(100_000); // Int16 (32767 - clamped to MAX_VALUE)
-assert(sum === 3000);
-assert(clamped === 32_767);
+
+assert.isTrue(sum === 3000);
+
+assert.isTrue(clamped === 32_767);
 
 // Safe division with non-zero types
 const ratio = NonZeroInt.div(asNonZeroInt(10), nonZeroInt); // No division by zero risk
-assert(ratio === 2);
+
+assert.isTrue(ratio === 2);
 
 // Random generation within type constraints
 const randomInt16 = Int16.random(); // Int16 (random value in valid range)
-assert(-32_768 <= randomInt16);
-assert(randomInt16 <= 32_767);
+
+assert.isTrue(-32_768 <= randomInt16);
+
+assert.isTrue(randomInt16 <= 32_767);
 ```
 
 ### 4. Array Utilities with `Arr`
@@ -326,13 +356,14 @@ const numbers: readonly number[] = [1, 2, 3, 4, 5, 2, 3];
 // Reduction
 const sum = Arr.sum(numbers);
 
-assert(sum === 20);
+assert.isTrue(sum === 20);
 
 // Type-safe length checking
 if (Arr.isArrayAtLeastLength(numbers, 2)) {
     // numbers is now guaranteed to have at least 2 elements
     expectType<typeof numbers, readonly [number, number, ...number[]]>('=');
-    assert(numbers[1] === 2); // Safe access to index 1
+
+    assert.isTrue(numbers[1] === 2); // Safe access to index 1
 }
 
 // Take first n elements
@@ -347,9 +378,11 @@ assert.deepStrictEqual(unique, [1, 2, 3, 4, 5]);
 
 // Array creation
 const zeros: readonly [0, 0, 0, 0, 0] = Arr.zeros(5);
+
 assert.deepStrictEqual(zeros, [0, 0, 0, 0, 0]);
 
 const range: readonly [1, 2, 3] = Arr.range(1, 4);
+
 assert.deepStrictEqual(range, [1, 2, 3]);
 
 const people = [
@@ -360,12 +393,14 @@ const people = [
 
 // Find maximum by property
 const oldestPerson = Arr.maxBy(people, (person) => person.age);
+
 assert.deepStrictEqual(
     oldestPerson,
     Optional.some({ name: 'Charlie', age: 35 } as const),
 );
+
 if (Optional.isSome(oldestPerson)) {
-    assert(oldestPerson.value.name === 'Charlie');
+    assert.isTrue(oldestPerson.value.name === 'Charlie');
 }
 ```
 
@@ -378,24 +413,30 @@ import { Arr, IMap, ISet, Optional } from 'ts-data-forge';
 
 // IMap usage - immutable operations
 const originalMap = IMap.create<string, number>([]);
+
 const mapWithOne = originalMap.set('one', 1);
+
 const mapWithTwo = mapWithOne.set('two', 2);
 
 // Original map is unchanged
-assert(originalMap.size === 0);
+assert.isTrue(originalMap.size === 0);
+
 assert.deepStrictEqual(mapWithTwo.get('one'), Optional.some(1));
 
-assert(!mapWithTwo.has('three'));
+assert.isFalse(mapWithTwo.has('three'));
 
 // Using pipe for fluent updates
 const sequence = Arr.seq(10); // [0, 1, 2, ..., 9]
+
 const pairs = sequence.map(
     (i) => [i, i.toString()] as readonly [number, string],
 );
+
 const skipped = Arr.skip(pairs, 1); // [[1, "1"], ..., [9, "9"]]
+
 const idMap = IMap.create<number, string>(skipped);
 
-assert(idMap.size === 9);
+assert.isTrue(idMap.size === 9);
 
 // Efficient batch updates with withMutations
 const idMapUpdated = idMap.withMutations([
@@ -404,15 +445,18 @@ const idMapUpdated = idMap.withMutations([
     { type: 'delete', key: 4 },
 ]);
 
-assert(idMapUpdated.size === 9);
+assert.isTrue(idMapUpdated.size === 9);
 
 // ISet usage
 const originalSet = ISet.create<number>([]);
+
 const setWithItems = originalSet.add(1).add(2).add(1); // Duplicate ignored
 
-assert(originalSet.size === 0); // (unchanged)
-assert(setWithItems.has(1));
-assert(setWithItems.size === 2);
+assert.isTrue(originalSet.size === 0); // (unchanged)
+
+assert.isTrue(setWithItems.has(1));
+
+assert.isTrue(setWithItems.size === 2);
 ```
 
 ### 6. Type Guards
@@ -431,6 +475,7 @@ const processData = (data: unknown): string | undefined => {
     ) {
         return `Hello, ${data.name}!`;
     }
+
     return undefined;
 };
 
@@ -443,9 +488,11 @@ if (isNonNullObject(value)) {
 }
 
 // Example usage
-assert(processData({ name: 'Alice' }) === 'Hello, Alice!');
-assert(processData({ age: 30 }) === undefined);
-assert(processData('not an object') === undefined);
+assert.isTrue(processData({ name: 'Alice' }) === 'Hello, Alice!');
+
+assert.isTrue(processData({ age: 30 }) === undefined);
+
+assert.isTrue(processData('not an object') === undefined);
 ```
 
 ### 7. Iteration with `range`
@@ -457,6 +504,7 @@ import { range } from 'ts-data-forge';
 
 // Traditional for loop using range
 const mut_values: number[] = [];
+
 for (const i of range(0, 5)) {
     mut_values.push(i);
 }
@@ -465,13 +513,16 @@ assert.deepStrictEqual(mut_values, [0, 1, 2, 3, 4]);
 
 // Create arrays from ranges
 const numbers = Array.from(range(1, 4));
-const squares = Array.from(range(1, 6), (x) => x * x);
+
+const squares = Array.from(range(1, 6), (x) => x ** 2);
 
 assert.deepStrictEqual(numbers, [1, 2, 3]);
+
 assert.deepStrictEqual(squares, [1, 4, 9, 16, 25]);
 
 // Step ranges
 const mut_stepValues: number[] = [];
+
 for (const i of range(0, 10, 2)) {
     mut_stepValues.push(i);
 }
@@ -484,15 +535,12 @@ assert.deepStrictEqual(mut_stepValues, [0, 2, 4, 6, 8]);
 Safely work with readonly types when interfacing with mutable APIs.
 
 ```tsx
+import { Autocomplete, TextField } from '@mui/material';
+import { produce } from 'immer';
 import type * as React from 'react';
 import { castMutable } from 'ts-data-forge';
 
 // Example: Material-UI Autocomplete
-import { Autocomplete, TextField } from '@mui/material';
-
-// Immer.js example
-import { produce } from 'immer';
-
 export const SomeComponent: React.FC = () => (
     <Autocomplete
         options={castMutable(readonlyOptions)}
@@ -539,9 +587,12 @@ const updatedState = produce(initialState, (draft) => {
 });
 
 assert.deepStrictEqual(initialState.items, ['item1', 'item2']);
+
 assert.deepStrictEqual(updatedState.items, ['newItem1', 'newItem2']);
 ```
 
+**Note**: While [immer](https://immerjs.github.io/immer/) provides `castDraft` with similar usage, it recursively converts types to mutable, resulting in a more complex (fat) type implementation. When you only need shallow mutability conversion, using `castMutable` can potentially reduce type-checking computation overhead.
+
 ## Modules Overview
 
 - **`expect-type`**: Compile-time type assertion utilities for testing and verification.
@@ -560,7 +611,7 @@ assert.deepStrictEqual(updatedState.items, ['newItem1', 'newItem2']);
 - **Type Safety**: All utilities are designed with TypeScript's type system in mind, providing compile-time guarantees.
 - **Immutability**: Data structures and operations promote immutable patterns for safer, more predictable code.
 - **Functional Programming**: Support for functional programming paradigms with utilities like `Optional`, `Result`, and `pipe`.
-- **Zero Runtime Dependencies**: The library has no external runtime dependencies, keeping your bundle size minimal.
+- **Zero Runtime Dependencies**: The library has no external runtime dependencies except for [@sindresorhus/is](https://github.com/sindresorhus/is), keeping your bundle size minimal.
 - **Comprehensive Testing**: All utilities are thoroughly tested with both runtime and compile-time tests.
 
 **Important Notes:**

package/dist/array/impl/array-utils-creation.d.mts

@@ -5,9 +5,11 @@
  *
  * ```ts
  * const emptyZeros = Arr.zeros(0);
+ *
  * const threeZeros = Arr.zeros(3);
  *
  * assert.deepStrictEqual(emptyZeros, []);
+ *
  * assert.deepStrictEqual(threeZeros, [0, 0, 0]);
  * ```
  */
@@ -19,9 +21,11 @@ export declare const zeros: <N extends SizeType.ArgArr>(len: N) => N extends Sma
  *
  * ```ts
  * const emptySeq = Arr.seq(0);
+ *
  * const firstFive = Arr.seq(5);
  *
  * assert.deepStrictEqual(emptySeq, []);
+ *
  * assert.deepStrictEqual(firstFive, [0, 1, 2, 3, 4]);
  * ```
  */
@@ -33,9 +37,11 @@ export declare const seq: <N extends SizeType.ArgArr>(len: N) => N extends Small
  *
  * ```ts
  * const threeOnes = Arr.create(3, 1);
+ *
  * const emptyStrings = Arr.create(0, 'Ada');
  *
  * assert.deepStrictEqual(threeOnes, [1, 1, 1]);
+ *
  * assert.deepStrictEqual(emptyStrings, []);
  * ```
  */
@@ -54,7 +60,9 @@ export declare const newArray: <const V, N extends SizeType.ArgArr>(len: N, init
  * ```ts
  * const numbers = Arr.generate(function* () {
  *   yield 1;
+ *
  *   yield 2;
+ *
  *   yield 3;
  * });
  *
@@ -70,7 +78,9 @@ export declare const generate: <T>(generatorFn: () => Generator<T, void, unknown
  * ```ts
  * const values = await Arr.generateAsync(async function* () {
  *   yield 'Ada';
+ *
  *   await Promise.resolve();
+ *
  *   yield 'Lovelace';
  * });
  *
@@ -85,9 +95,11 @@ export declare const generateAsync: <T>(generatorFn: () => AsyncGenerator<T, voi
  *
  * ```ts
  * const original = [{ id: 1 }, { id: 2 }] as const;
+ *
  * const cloned = Arr.copy(original);
  *
  * assert.deepStrictEqual(cloned, original);
+ *
  * assert.notStrictEqual(cloned, original);
  * ```
  */
@@ -103,9 +115,11 @@ type RangeList<S extends SmallUint, E extends SmallUint> = BoolOr<IsUnion<S>, Is
  *
  * ```ts
  * const ascending = Arr.range(asUint32(1), asUint32(5));
+ *
  * const empty = Arr.range(asUint32(2), asUint32(2));
  *
  * assert.deepStrictEqual(ascending, [1, 2, 3, 4]);
+ *
  * assert.deepStrictEqual(empty, []);
  * ```
  */

package/dist/array/impl/array-utils-creation.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-creation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-creation.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"array-utils-creation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-creation.mts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,EAC7C,KAAK,CAAC,KACL,CAAC,SAAS,SAAS,GAClB,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GACnB,CAAC,SAAS,QAAQ,CAAC,cAAc,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EAEiC,CAAC;AAElD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,EAC3C,KAAK,CAAC,KACL,CAAC,SAAS,SAAS,GAClB,GAAG,CAAC,CAAC,CAAC,GACN,CAAC,SAAS,QAAQ,CAAC,cAAc,GAC/B,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,GAC3B,SAAS,QAAQ,CAAC,GAAG,EAEwB,CAAC;AAEpD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,QAAQ,CAAC,MAAM,EACvD,KAAK,CAAC,EACN,MAAM,CAAC,KACN,CAAC,SAAS,SAAS,GAClB,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GACnB,CAAC,SAAS,QAAQ,CAAC,cAAc,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EAE+C,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,QAAQ,SAhBQ,CAAC,EAAE,CAAC,SAAS,QAAQ,CAAC,MAAM,OAClD,CAAC,QACA,CAAC,KACN,CAAC,SAAS,SAAS,GAClB,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,GACnB,CAAC,SAAS,QAAQ,CAAC,cAAc,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EASc,CAAC;AAE/B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,aAAa,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,KAC7C,SAAS,CAAC,EAA+B,CAAC;AAE7C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAC7B,aAAa,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,KAClD,OAAO,CAAC,SAAS,CAAC,EAAE,CAAmC,CAAC;AAE3D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,OAAO,EAAE,KAAG,EAEtC,CAAC;AAEjC,KAAK,EAAE,GAAG,QAAQ,CAAC;KAChB,CAAC,IAAI,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC;CAC3B,CAAC,CAAC;AAEH,KAAK,SAAS,CAAC,CAAC,SAAS,SAAS,EAAE,CAAC,SAAS,SAAS,IACrD,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,GACvC,SAAS,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAC5C,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAkB3B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,SAAS,EAAE,CAAC,SAAS,SAAS,EAC5D,KAAK,EAAE,CAAC,EACR,GAAG,EAAE,CAAC,EACN,IAAI,CAAC,EAAE,CAAC,GACP,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEnB,wBAAgB,KAAK,CACnB,KAAK,EAAE,oBAAoB,EAC3B,GAAG,EAAE,oBAAoB,EACzB,IAAI,CAAC,EAAE,2BAA2B,GACjC,SAAS,QAAQ,EAAE,CAAC;AAEvB,wBAAgB,KAAK,CACnB,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,mBAAmB,EACxB,IAAI,CAAC,EAAE,0BAA0B,GAChC,SAAS,OAAO,EAAE,CAAC"}

package/dist/array/impl/array-utils-creation.mjs

@@ -7,9 +7,11 @@ import { range as range$1 } from '../../iterator/range.mjs';
  *
  * ```ts
  * const emptyZeros = Arr.zeros(0);
+ *
  * const threeZeros = Arr.zeros(3);
  *
  * assert.deepStrictEqual(emptyZeros, []);
+ *
  * assert.deepStrictEqual(threeZeros, [0, 0, 0]);
  * ```
  */
@@ -23,9 +25,11 @@ Array.from({ length: len }).fill(0);
  *
  * ```ts
  * const emptySeq = Arr.seq(0);
+ *
  * const firstFive = Arr.seq(5);
  *
  * assert.deepStrictEqual(emptySeq, []);
+ *
  * assert.deepStrictEqual(firstFive, [0, 1, 2, 3, 4]);
  * ```
  */
@@ -39,9 +43,11 @@ Array.from({ length: len }, (_, i) => i);
  *
  * ```ts
  * const threeOnes = Arr.create(3, 1);
+ *
  * const emptyStrings = Arr.create(0, 'Ada');
  *
  * assert.deepStrictEqual(threeOnes, [1, 1, 1]);
+ *
  * assert.deepStrictEqual(emptyStrings, []);
  * ```
  */
@@ -62,7 +68,9 @@ const newArray = create;
  * ```ts
  * const numbers = Arr.generate(function* () {
  *   yield 1;
+ *
  *   yield 2;
+ *
  *   yield 3;
  * });
  *
@@ -78,7 +86,9 @@ const generate = (generatorFn) => Array.from(generatorFn());
  * ```ts
  * const values = await Arr.generateAsync(async function* () {
  *   yield 'Ada';
+ *
  *   await Promise.resolve();
+ *
  *   yield 'Lovelace';
  * });
  *
@@ -93,9 +103,11 @@ const generateAsync = (generatorFn) => Array.fromAsync(generatorFn());
  *
  * ```ts
  * const original = [{ id: 1 }, { id: 2 }] as const;
+ *
  * const cloned = Arr.copy(original);
  *
  * assert.deepStrictEqual(cloned, original);
+ *
  * assert.notStrictEqual(cloned, original);
  * ```
  */

package/dist/array/impl/array-utils-creation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-creation.mjs","sources":["../../../src/array/impl/array-utils-creation.mts"],"sourcesContent":[null],"names":["rangeIterator"],"mappings":";;AAGA;;;;;;;;;;;;AAYG;AACI,MAAM,KAAK,GAAG,CACnB,GAAM;AAMN;AACA,KAAK,CAAC,IAAI,CAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;AAEvC;;;;;;;;;;;;AAYG;AACI,MAAM,GAAG,GAAG,CACjB,GAAM;AAMN;AACA,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC;AAEzC;;;;;;;;;;;;AAYG;MACU,MAAM,GAAG,CACpB,GAAM,EACN,IAAO;AAMP;AACA,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,MAAM,IAAI;AAErD;;;;AAIG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;;;;;;;AAcG;AACI,MAAM,QAAQ,GAAG,CACtB,WAA8C,KAC7B,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE;AAE3C;;;;;;;;;;;;;;AAcG;AACI,MAAM,aAAa,GAAG,CAC3B,WAAmD,KACzB,KAAK,CAAC,SAAS,CAAC,WAAW,EAAE;AAEzD;;;;;;;;;;;;AAYG;AACI,MAAM,IAAI,GAAG,CAAsC,KAAS;AACjE;AACA,KAAK,CAAC,KAAK;AAoDP,SAAU,KAAK,CACnB,KAA0B,EAC1B,GAAwB,EACxB,OAAmC,CAAC,EAAA;AAEpC,IAAA,OAAO,KAAK,CAAC,IAAI,CAACA,OAAa,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AACpD;;;;"}
+{"version":3,"file":"array-utils-creation.mjs","sources":["../../../src/array/impl/array-utils-creation.mts"],"sourcesContent":[null],"names":["rangeIterator"],"mappings":";;AAGA;;;;;;;;;;;;;;AAcG;AACI,MAAM,KAAK,GAAG,CACnB,GAAM;AAMN;AACA,KAAK,CAAC,IAAI,CAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;AAEvC;;;;;;;;;;;;;;AAcG;AACI,MAAM,GAAG,GAAG,CACjB,GAAM;AAMN;AACA,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;AAcG;MACU,MAAM,GAAG,CACpB,GAAM,EACN,IAAO;AAMP;AACA,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,MAAM,IAAI;AAErD;;;;AAIG;AACI,MAAM,QAAQ,GAAG;AAExB;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,QAAQ,GAAG,CACtB,WAA8C,KAC7B,KAAK,CAAC,IAAI,CAAC,WAAW,EAAE;AAE3C;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,aAAa,GAAG,CAC3B,WAAmD,KACzB,KAAK,CAAC,SAAS,CAAC,WAAW,EAAE;AAEzD;;;;;;;;;;;;;;AAcG;AACI,MAAM,IAAI,GAAG,CAAsC,KAAS;AACjE;AACA,KAAK,CAAC,KAAK;AA4DP,SAAU,KAAK,CACnB,KAA0B,EAC1B,GAAwB,EACxB,OAAmC,CAAC,EAAA;AAEpC,IAAA,OAAO,KAAK,CAAC,IAAI,CAACA,OAAa,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AACpD;;;;"}

package/dist/array/impl/array-utils-element-access.d.mts

@@ -7,11 +7,15 @@
  * const letters: readonly string[] = ['a', 'b', 'c'];
  *
  * const two = Arr.at(letters, 1);
+ *
  * const last = Arr.at(-1)(letters);
+ *
  * const missing = Arr.at(letters, 5);
  *
  * assert.deepStrictEqual(two, Optional.some('b'));
+ *
  * assert.deepStrictEqual(last, Optional.some('c'));
+ *
  * assert.deepStrictEqual(missing, Optional.none);
  * ```
  */
@@ -24,12 +28,15 @@ export declare function at(index: SizeType.ArgArrWithNegative): <E>(array: reado
  *
  * ```ts
  * const users = [{ id: 1 }, { id: 2 }];
+ *
  * const empty: { id: number }[] = [];
  *
  * const first = Arr.head(users);
+ *
  * const none = Arr.head(empty);
  *
  * assert.deepStrictEqual(first, Optional.some({ id: 1 }));
+ *
  * assert.deepStrictEqual(none, Optional.none);
  * ```
  */
@@ -41,12 +48,15 @@ export declare const head: <const Ar extends readonly unknown[]>(array: Ar) => A
  *
  * ```ts
  * const queue = ['first', 'second'];
+ *
  * const emptyQueue: string[] = [];
  *
  * const lastValue = Arr.last(queue);
+ *
  * const none = Arr.last(emptyQueue);
  *
  * assert.deepStrictEqual(lastValue, Optional.some('second'));
+ *
  * assert.deepStrictEqual(none, Optional.none);
  * ```
  */

package/dist/array/impl/array-utils-element-access.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-element-access.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-element-access.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACpD,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,yBAAyB,CAAC,EAAE,CAAC,GACnC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;AAIxB,wBAAgB,EAAE,CAChB,KAAK,EAAE,QAAQ,CAAC,kBAAkB,GACjC,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;AAyB3C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACtD,OAAO,EAAE,KACR,EAAE,SAAS,SAAS,EAAE,GACrB,IAAI,GACJ,EAAE,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,GACzC,IAAI,CAAC,CAAC,CAAC,GACP,EAAE,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAC/B,IAAI,CAAC,CAAC,CAAC,GACP,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAEiD,CAAC;AAE7E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACtD,OAAO,EAAE,KACR,EAAE,SAAS,SAAS,EAAE,GACrB,IAAI,GACJ,EAAE,SAAS,SAAS,CAAC,GAAG,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC,GACzC,IAAI,CAAC,CAAC,CAAC,GACP,EAAE,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAC/B,IAAI,CAAC,CAAC,CAAC,GACP,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAEkD,CAAC;AAE9E;;;;GAIG;AACH,eAAO,MAAM,KAAK,SA7CS,EAAE,SAAS,SAAS,OAAO,EAAE,SAC/C,EAAE,KACR,EAAE,SAAS,SAAS,EAAE,GACrB,IAAI,GACJ,EAAE,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,GACzC,IAAI,CAAC,CAAC,CAAC,GACP,EAAE,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAC/B,IAAI,CAAC,CAAC,CAAC,GACP,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAqCF,CAAC"}
+{"version":3,"file":"array-utils-element-access.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-element-access.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACpD,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,yBAAyB,CAAC,EAAE,CAAC,GACnC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;AAIxB,wBAAgB,EAAE,CAChB,KAAK,EAAE,QAAQ,CAAC,kBAAkB,GACjC,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;AA4B3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACtD,OAAO,EAAE,KACR,EAAE,SAAS,SAAS,EAAE,GACrB,IAAI,GACJ,EAAE,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,GACzC,IAAI,CAAC,CAAC,CAAC,GACP,EAAE,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAC/B,IAAI,CAAC,CAAC,CAAC,GACP,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAEiD,CAAC;AAE7E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACtD,OAAO,EAAE,KACR,EAAE,SAAS,SAAS,EAAE,GACrB,IAAI,GACJ,EAAE,SAAS,SAAS,CAAC,GAAG,OAAO,EAAE,EAAE,MAAM,CAAC,CAAC,GACzC,IAAI,CAAC,CAAC,CAAC,GACP,EAAE,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAC/B,IAAI,CAAC,CAAC,CAAC,GACP,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAEkD,CAAC;AAE9E;;;;GAIG;AACH,eAAO,MAAM,KAAK,SAhDS,EAAE,SAAS,SAAS,OAAO,EAAE,SAC/C,EAAE,KACR,EAAE,SAAS,SAAS,EAAE,GACrB,IAAI,GACJ,EAAE,SAAS,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,GACzC,IAAI,CAAC,CAAC,CAAC,GACP,EAAE,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAC/B,IAAI,CAAC,CAAC,CAAC,GACP,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,CAwCF,CAAC"}

package/dist/array/impl/array-utils-element-access.mjs

@@ -25,12 +25,15 @@ function at(...args) {
  *
  * ```ts
  * const users = [{ id: 1 }, { id: 2 }];
+ *
  * const empty: { id: number }[] = [];
  *
  * const first = Arr.head(users);
+ *
  * const none = Arr.head(empty);
  *
  * assert.deepStrictEqual(first, Optional.some({ id: 1 }));
+ *
  * assert.deepStrictEqual(none, Optional.none);
  * ```
  */
@@ -44,12 +47,15 @@ const head = (array) =>
  *
  * ```ts
  * const queue = ['first', 'second'];
+ *
  * const emptyQueue: string[] = [];
  *
  * const lastValue = Arr.last(queue);
+ *
  * const none = Arr.last(emptyQueue);
  *
  * assert.deepStrictEqual(lastValue, Optional.some('second'));
+ *
  * assert.deepStrictEqual(none, Optional.none);
  * ```
  */

package/dist/array/impl/array-utils-element-access.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-element-access.mjs","sources":["../../../src/array/impl/array-utils-element-access.mts"],"sourcesContent":[null],"names":["index","Optional.none","Optional.some"],"mappings":";;;;;AA8BM,SAAU,EAAE,CAChB,GAAG,IAE8C,EAAA;AAEjD,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAEA,OAAK,CAAC,GAAG,IAAI;AAC3B,YAAA,OAAO,IAAI,CAACA,OAAK,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,GAAGA,OAAK,GAAGA,OAAK,CAAC,CAAC,GAAG,CACvD,CAAC,eAAe,KACd,eAAe,GAAG,CAAC,IAAI,eAAe,IAAI,KAAK,CAAC;kBAC5CC;AACF;oBACEC,IAAa,CAAC,KAAK,CAAC,eAAe,CAAE,CAAC,CAC7C,CAAC,KAAK;QACT;QACA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YACpB,OAAO,CAAC,KAAK,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;QACpC;;AAEJ;AAEA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,IAAI,GAAG,CAClB,KAAS;AAQT;AACA,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,GAAGD,IAAa,GAAGC,IAAa,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;AAeG;AACI,MAAM,IAAI,GAAG,CAClB,KAAS;AAQT;AACA,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,GAAGD,IAAa,GAAGC,IAAa,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AAEnE;;;;AAIG;AACI,MAAM,KAAK,GAAG;;;;"}
+{"version":3,"file":"array-utils-element-access.mjs","sources":["../../../src/array/impl/array-utils-element-access.mts"],"sourcesContent":[null],"names":["index","Optional.none","Optional.some"],"mappings":";;;;;AAkCM,SAAU,EAAE,CAChB,GAAG,IAE8C,EAAA;AAEjD,IAAA,QAAQ,IAAI,CAAC,MAAM;QACjB,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,EAAEA,OAAK,CAAC,GAAG,IAAI;AAE3B,YAAA,OAAO,IAAI,CAACA,OAAK,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,GAAGA,OAAK,GAAGA,OAAK,CAAC,CAAC,GAAG,CACvD,CAAC,eAAe,KACd,eAAe,GAAG,CAAC,IAAI,eAAe,IAAI,KAAK,CAAC;kBAC5CC;AACF;oBACEC,IAAa,CAAC,KAAK,CAAC,eAAe,CAAE,CAAC,CAC7C,CAAC,KAAK;QACT;QAEA,KAAK,CAAC,EAAE;AACN,YAAA,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI;YAEpB,OAAO,CAAC,KAAK,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC;QACpC;;AAEJ;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,IAAI,GAAG,CAClB,KAAS;AAQT;AACA,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,GAAGD,IAAa,GAAGC,IAAa,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,IAAI,GAAG,CAClB,KAAS;AAQT;AACA,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,GAAGD,IAAa,GAAGC,IAAa,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AAEnE;;;;AAIG;AACI,MAAM,KAAK,GAAG;;;;"}