ts-data-forge 9.0.0 → 9.0.1

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":"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"}

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

@@ -1,121 +1,26 @@
 import { range as range$1 } from '../../iterator/range.mjs';
 
-/**
- * Creates an array of zeros with the specified length.
- *
- * @example
- *
- * ```ts
- * const emptyZeros = Arr.zeros(0);
- *
- * const threeZeros = Arr.zeros(3);
- *
- * assert.deepStrictEqual(emptyZeros, []);
- *
- * assert.deepStrictEqual(threeZeros, [0, 0, 0]);
- * ```
- */
-const zeros = (len) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-Array.from({ length: len }, () => 0);
-/**
- * Creates a sequence of consecutive integers from 0 to `len-1`.
- *
- * @example
- *
- * ```ts
- * const emptySeq = Arr.seq(0);
- *
- * const firstFive = Arr.seq(5);
- *
- * assert.deepStrictEqual(emptySeq, []);
- *
- * assert.deepStrictEqual(firstFive, [0, 1, 2, 3, 4]);
- * ```
- */
-const seq = (len) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-Array.from({ length: len }, (_, i) => i);
-/**
- * Creates a new array of the specified length, filled with the initial value.
- *
- * @example
- *
- * ```ts
- * const threeOnes = Arr.create(3, 1);
- *
- * const emptyStrings = Arr.create(0, 'Ada');
- *
- * assert.deepStrictEqual(threeOnes, [1, 1, 1]);
- *
- * assert.deepStrictEqual(emptyStrings, []);
- * ```
- */
-const create = (len, init) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-Array.from({ length: Math.max(0, len) }, () => init);
-/**
- * Alias for `create`.
- *
- * @see {@link create}
- */
+const zeros = (len) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  Array.from({ length: len }, () => 0)
+);
+const seq = (len) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  Array.from({ length: len }, (_, i) => i)
+);
+const create = (len, init) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  Array.from({ length: Math.max(0, len) }, () => init)
+);
 const newArray = create;
-/**
- * Generates an array from a generator function.
- *
- * @example
- *
- * ```ts
- * const numbers = Arr.generate(function* () {
- *   yield 1;
- *
- *   yield 2;
- *
- *   yield 3;
- * });
- *
- * assert.deepStrictEqual(numbers, [1, 2, 3]);
- * ```
- */
 const generate = (generatorFn) => Array.from(generatorFn());
-/**
- * Generates an array from an async generator function.
- *
- * @example
- *
- * ```ts
- * const values = await Arr.generateAsync(async function* () {
- *   yield 'Ada';
- *
- *   await Promise.resolve();
- *
- *   yield 'Lovelace';
- * });
- *
- * assert.deepStrictEqual(values, ['Ada', 'Lovelace']);
- * ```
- */
 const generateAsync = (generatorFn) => Array.fromAsync(generatorFn());
-/**
- * Creates a shallow copy of an array.
- *
- * @example
- *
- * ```ts
- * const original = [{ id: 1 }, { id: 2 }] as const;
- *
- * const cloned = Arr.copy(original);
- *
- * assert.deepStrictEqual(cloned, original);
- *
- * assert.notStrictEqual(cloned, original);
- * ```
- */
-const copy = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-array.slice();
+const copy = (array) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.slice()
+);
 function range(start, end, step = 1) {
-    return Array.from(range$1(start, end, step));
+  return Array.from(range$1(start, end, step));
 }
 
 export { copy, create, generate, generateAsync, newArray, range, seq, zeros };

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":";;AAsBA;;;;;;;;;;;;;;AAcG;AACI,MAAM,KAAK,GAAG,CACnB,GAAM;AAMN;AACA,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,MAAM,CAAC;AAErC;;;;;;;;;;;;;;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;AA0DP,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":["import {\n  type ArrayOfLength,\n  type BoolOr,\n  type Index,\n  type IsUnion,\n  type List,\n  type Min,\n  type NonEmptyArray,\n  type NonZeroSafeIntWithSmallInt,\n  type PositiveSafeIntWithSmallInt,\n  type RelaxedExclude,\n  type SafeInt,\n  type SafeIntWithSmallInt,\n  type SafeUint,\n  type SafeUintWithSmallInt,\n  type Seq,\n  type SmallUint,\n} from 'ts-type-forge';\nimport { expectType } from '../../expect-type.mjs';\nimport { range as rangeIterator } from '../../iterator/index.mjs';\nimport { type SizeType } from '../../types.mjs';\n\n/**\n * Creates an array of zeros with the specified length.\n *\n * @example\n *\n * ```ts\n * const emptyZeros = Arr.zeros(0);\n *\n * const threeZeros = Arr.zeros(3);\n *\n * assert.deepStrictEqual(emptyZeros, []);\n *\n * assert.deepStrictEqual(threeZeros, [0, 0, 0]);\n * ```\n */\nexport const zeros = <N extends SizeType.ArgArr>(\n  len: N,\n): N extends SmallUint\n  ? ArrayOfLength<N, 0>\n  : N extends SizeType.ArgArrPositive\n    ? NonEmptyArray<0>\n    : readonly 0[] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Array.from({ length: len }, () => 0) as never;\n\n/**\n * Creates a sequence of consecutive integers from 0 to `len-1`.\n *\n * @example\n *\n * ```ts\n * const emptySeq = Arr.seq(0);\n *\n * const firstFive = Arr.seq(5);\n *\n * assert.deepStrictEqual(emptySeq, []);\n *\n * assert.deepStrictEqual(firstFive, [0, 1, 2, 3, 4]);\n * ```\n */\nexport const seq = <N extends SizeType.ArgArr>(\n  len: N,\n): N extends SmallUint\n  ? Seq<N>\n  : N extends SizeType.ArgArrPositive\n    ? NonEmptyArray<SizeType.Arr>\n    : readonly SizeType.Arr[] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Array.from({ length: len }, (_, i) => i) as never;\n\n/**\n * Creates a new array of the specified length, filled with the initial value.\n *\n * @example\n *\n * ```ts\n * const threeOnes = Arr.create(3, 1);\n *\n * const emptyStrings = Arr.create(0, 'Ada');\n *\n * assert.deepStrictEqual(threeOnes, [1, 1, 1]);\n *\n * assert.deepStrictEqual(emptyStrings, []);\n * ```\n */\nexport const create = <N extends SizeType.ArgArr, const V>(\n  len: N,\n  init: V,\n): N extends SmallUint\n  ? ArrayOfLength<N, V>\n  : N extends SizeType.ArgArrPositive\n    ? NonEmptyArray<V>\n    : readonly V[] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  Array.from({ length: Math.max(0, len) }, () => init) as never;\n\n/**\n * Alias for `create`.\n *\n * @see {@link create}\n */\nexport const newArray = create;\n\n/**\n * Generates an array from a generator function.\n *\n * @example\n *\n * ```ts\n * const numbers = Arr.generate(function* () {\n *   yield 1;\n *\n *   yield 2;\n *\n *   yield 3;\n * });\n *\n * assert.deepStrictEqual(numbers, [1, 2, 3]);\n * ```\n */\nexport const generate = <T,>(\n  generatorFn: () => Generator<T, void, unknown>,\n): readonly T[] => Array.from(generatorFn());\n\n/**\n * Generates an array from an async generator function.\n *\n * @example\n *\n * ```ts\n * const values = await Arr.generateAsync(async function* () {\n *   yield 'Ada';\n *\n *   await Promise.resolve();\n *\n *   yield 'Lovelace';\n * });\n *\n * assert.deepStrictEqual(values, ['Ada', 'Lovelace']);\n * ```\n */\nexport const generateAsync = <T,>(\n  generatorFn: () => AsyncGenerator<T, void, unknown>,\n): Promise<readonly T[]> => Array.fromAsync(generatorFn());\n\n/**\n * Creates a shallow copy of an array.\n *\n * @example\n *\n * ```ts\n * const original = [{ id: 1 }, { id: 2 }] as const;\n *\n * const cloned = Arr.copy(original);\n *\n * assert.deepStrictEqual(cloned, original);\n *\n * assert.notStrictEqual(cloned, original);\n * ```\n */\nexport const copy = <const Ar extends readonly unknown[]>(array: Ar): Ar =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.slice() as unknown as Ar;\n\ntype LT = Readonly<{ [N in SmallUint]: Index<N> }>;\n\ntype RangeList<S extends SmallUint, E extends SmallUint> =\n  BoolOr<IsUnion<S>, IsUnion<E>> extends true\n    ? readonly RelaxedExclude<LT[E], LT[Min<S>]>[] // Avoid incorrect type calculation for unions with Seq\n    : List.Skip<S, Seq<E>>;\n\nexpectType<RangeList<1, 5>, readonly [1, 2, 3, 4]>('=');\n\nexpectType<RangeList<1, 2>, readonly [1]>('=');\n\nexpectType<RangeList<1, 1>, readonly []>('=');\n\nexpectType<RangeList<1, 1 | 3>, readonly (1 | 2)[]>('=');\n\nexpectType<RangeList<1 | 3, 3 | 5>, readonly (1 | 2 | 3 | 4)[]>('=');\n\nexpectType<RangeList<1 | 2 | 3, 5 | 6 | 7>, readonly (1 | 2 | 3 | 4 | 5 | 6)[]>(\n  '=',\n);\n\nexpectType<RangeList<5, 1>, readonly []>('=');\n\n/**\n * Creates an array of numbers within a specified range with optional step.\n *\n * @example\n *\n * ```ts\n * const ascending = Arr.range(asUint32(1), asUint32(5));\n *\n * const empty = Arr.range(asUint32(2), asUint32(2));\n *\n * assert.deepStrictEqual(ascending, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(empty, []);\n * ```\n */\nexport function range<S extends SmallUint, E extends SmallUint>(\n  start: S,\n  end: E,\n  step?: 1,\n): RangeList<S, E>;\n\nexport function range(\n  start: SafeUintWithSmallInt,\n  end: SafeUintWithSmallInt,\n  step?: PositiveSafeIntWithSmallInt,\n): readonly SafeUint[];\n\nexport function range(\n  start: SafeIntWithSmallInt,\n  end: SafeIntWithSmallInt,\n  step?: NonZeroSafeIntWithSmallInt,\n): readonly SafeInt[];\n\nexport function range(\n  start: SafeIntWithSmallInt,\n  end: SafeIntWithSmallInt,\n  step: NonZeroSafeIntWithSmallInt = 1,\n): readonly SafeInt[] {\n  return Array.from(rangeIterator(start, end, step));\n}\n"],"names":["rangeIterator"],"mappings":";;AAqCO,MAAM,QAAQ,CACnB,GAAA;AAAA;AAAA,EAOA,MAAM,IAAA,CAAK,EAAE,QAAQ,GAAA,EAAI,EAAG,MAAM,CAAC;AAAA;AAiB9B,MAAM,MAAM,CACjB,GAAA;AAAA;AAAA,EAOA,KAAA,CAAM,KAAK,EAAE,MAAA,EAAQ,KAAI,EAAG,CAAC,CAAA,EAAG,CAAA,KAAM,CAAC;AAAA;MAiB5B,MAAA,GAAS,CACpB,GAAA,EACA,IAAA;AAAA;AAAA,EAOA,KAAA,CAAM,IAAA,CAAK,EAAE,MAAA,EAAQ,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,GAAG,CAAA,EAAE,EAAG,MAAM,IAAI;AAAA;AAO9C,MAAM,QAAA,GAAW;AAmBjB,MAAM,WAAW,CACtB,WAAA,KACiB,KAAA,CAAM,IAAA,CAAK,aAAa;AAmBpC,MAAM,gBAAgB,CAC3B,WAAA,KAC0B,KAAA,CAAM,SAAA,CAAU,aAAa;AAiBlD,MAAM,OAAO,CAAsC,KAAA;AAAA;AAAA,EAExD,MAAM,KAAA;AAAM;AA0DP,SAAS,KAAA,CACd,KAAA,EACA,GAAA,EACA,IAAA,GAAmC,CAAA,EACf;AACpB,EAAA,OAAO,MAAM,IAAA,CAAKA,OAAA,CAAc,KAAA,EAAO,GAAA,EAAK,IAAI,CAAC,CAAA;AACnD;;;;"}

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":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAQ,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,IAAI,EACT,KAAK,QAAQ,EACb,KAAK,IAAI,EACV,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"array-utils-element-access.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-element-access.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAQ,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,IAAI,EACT,KAAK,QAAQ,EACb,KAAK,IAAI,EACV,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;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,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,CAEiD,CAAC;AAE7E;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,SAC/C,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

@@ -4,69 +4,30 @@ import { pipe } from '../../functional/pipe.mjs';
 import '@sindresorhus/is';
 
 function at(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, index$1] = args;
-            return pipe(index$1 < 0 ? array.length + index$1 : index$1).map((normalizedIndex) => normalizedIndex < 0 || normalizedIndex >= array.length
-                ? none
-                : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    some(array[normalizedIndex])).value;
-        }
-        case 1: {
-            const [index] = args;
-            return (array) => at(array, index);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, index$1] = args;
+      return pipe(index$1 < 0 ? array.length + index$1 : index$1).map(
+        (normalizedIndex) => normalizedIndex < 0 || normalizedIndex >= array.length ? none : (
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          some(array[normalizedIndex])
+        )
+      ).value;
     }
+    case 1: {
+      const [index] = args;
+      return (array) => at(array, index);
+    }
+  }
 }
-/**
- * Returns the first element of an array as an Optional.
- *
- * @example
- *
- * ```ts
- * const users = [{ id: 1 }, { id: 2 }] as const;
- *
- * const empty: readonly Readonly<{ id: number }>[] = [] as const;
- *
- * const first = Arr.head(users);
- *
- * const none = Arr.head(empty);
- *
- * assert.deepStrictEqual(first, Optional.some({ id: 1 }));
- *
- * assert.deepStrictEqual(none, Optional.none);
- * ```
- */
-const head = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-(array.length === 0 ? none : some(array.at(0)));
-/**
- * Returns the last element of an array as an Optional.
- *
- * @example
- *
- * ```ts
- * const queue = ['first', 'second'] as const;
- *
- * const emptyQueue: readonly string[] = [] as const;
- *
- * const lastValue = Arr.last(queue);
- *
- * const none = Arr.last(emptyQueue);
- *
- * assert.deepStrictEqual(lastValue, Optional.some('second'));
- *
- * assert.deepStrictEqual(none, Optional.none);
- * ```
- */
-const last = (array) => 
-// eslint-disable-next-line total-functions/no-unsafe-type-assertion
-(array.length === 0 ? none : some(array.at(-1)));
-/**
- * Alias for `head`.
- *
- * @see {@link head}
- */
+const head = (array) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.length === 0 ? none : some(array.at(0))
+);
+const last = (array) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.length === 0 ? none : some(array.at(-1))
+);
 const first = head;
 
 export { at, first, head, last };

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":";;;;;AAyCM,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;;;;"}
+{"version":3,"file":"array-utils-element-access.mjs","sources":["../../../src/array/impl/array-utils-element-access.mts"],"sourcesContent":["import { type NonEmptyArray } from 'ts-type-forge';\nimport { Optional, pipe } from '../../functional/index.mjs';\nimport {\n  type ArgArrayIndexWithNegative,\n  type None,\n  type SizeType,\n  type Some,\n} from '../../types.mjs';\n\n/**\n * Safely retrieves an element at a given index from an array, returning an Optional.\n *\n * @example\n *\n * ```ts\n * const letters: readonly string[] = ['a', 'b', 'c'] as const;\n *\n * const two = Arr.at(letters, 1);\n *\n * const last = Arr.at(-1)(letters);\n *\n * const missing = Arr.at(letters, 5);\n *\n * assert.deepStrictEqual(two, Optional.some('b'));\n *\n * assert.deepStrictEqual(last, Optional.some('c'));\n *\n * assert.deepStrictEqual(missing, Optional.none);\n * ```\n */\nexport function at<const Ar extends readonly unknown[]>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n): Optional<Ar[number]>;\n\n// Curried version\n\nexport function at(\n  index: SizeType.ArgArrWithNegative,\n): <E>(array: readonly E[]) => Optional<E>;\n\nexport function at<E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArrWithNegative]\n    | readonly [index: SizeType.ArgArrWithNegative]\n): Optional<E> | ((array: readonly E[]) => Optional<E>) {\n  switch (args.length) {\n    case 2: {\n      const [array, index] = args;\n\n      return pipe(index < 0 ? array.length + index : index).map(\n        (normalizedIndex) =>\n          normalizedIndex < 0 || normalizedIndex >= array.length\n            ? Optional.none\n            : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n              Optional.some(array[normalizedIndex]!),\n      ).value;\n    }\n\n    case 1: {\n      const [index] = args;\n\n      return (array) => at(array, index);\n    }\n  }\n}\n\n/**\n * Returns the first element of an array as an Optional.\n *\n * @example\n *\n * ```ts\n * const users = [{ id: 1 }, { id: 2 }] as const;\n *\n * const empty: readonly Readonly<{ id: number }>[] = [] as const;\n *\n * const first = Arr.head(users);\n *\n * const none = Arr.head(empty);\n *\n * assert.deepStrictEqual(first, Optional.some({ id: 1 }));\n *\n * assert.deepStrictEqual(none, Optional.none);\n * ```\n */\nexport const head = <const Ar extends readonly unknown[]>(\n  array: Ar,\n): Ar extends readonly []\n  ? None\n  : Ar extends readonly [infer E, ...unknown[]]\n    ? Some<E>\n    : Ar extends NonEmptyArray<infer E>\n      ? Some<E>\n      : Optional<Ar[number]> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  (array.length === 0 ? Optional.none : Optional.some(array.at(0))) as never;\n\n/**\n * Returns the last element of an array as an Optional.\n *\n * @example\n *\n * ```ts\n * const queue = ['first', 'second'] as const;\n *\n * const emptyQueue: readonly string[] = [] as const;\n *\n * const lastValue = Arr.last(queue);\n *\n * const none = Arr.last(emptyQueue);\n *\n * assert.deepStrictEqual(lastValue, Optional.some('second'));\n *\n * assert.deepStrictEqual(none, Optional.none);\n * ```\n */\nexport const last = <const Ar extends readonly unknown[]>(\n  array: Ar,\n): Ar extends readonly []\n  ? None\n  : Ar extends readonly [...unknown[], infer E]\n    ? Some<E>\n    : Ar extends NonEmptyArray<infer E>\n      ? Some<E>\n      : Optional<Ar[number]> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  (array.length === 0 ? Optional.none : Optional.some(array.at(-1))) as never;\n\n/**\n * Alias for `head`.\n *\n * @see {@link head}\n */\nexport const first = head;\n"],"names":["index","Optional.none","Optional.some"],"mappings":";;;;;AAyCO,SAAS,MACX,IAAA,EAGmD;AACtD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAOA,OAAK,CAAA,GAAI,IAAA;AAEvB,MAAA,OAAO,KAAKA,OAAA,GAAQ,CAAA,GAAI,MAAM,MAAA,GAASA,OAAA,GAAQA,OAAK,CAAA,CAAE,GAAA;AAAA,QACpD,CAAC,eAAA,KACC,eAAA,GAAkB,KAAK,eAAA,IAAmB,KAAA,CAAM,SAC5CC,IAAS;AAAA;AAAA,UAETC,IAAS,CAAK,KAAA,CAAM,eAAe,CAAE;AAAA;AAAA,OAC7C,CAAE,KAAA;AAAA,IACJ;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAK,CAAA,GAAI,IAAA;AAEhB,MAAA,OAAO,CAAC,KAAA,KAAU,EAAA,CAAG,KAAA,EAAO,KAAK,CAAA;AAAA,IACnC;AAAA;AAEJ;AAqBO,MAAM,OAAO,CAClB,KAAA;AAAA;AAAA,EASC,KAAA,CAAM,MAAA,KAAW,CAAA,GAAID,IAAS,GAAOC,IAAS,CAAK,KAAA,CAAM,EAAA,CAAG,CAAC,CAAC;AAAA;AAqB1D,MAAM,OAAO,CAClB,KAAA;AAAA;AAAA,EASC,KAAA,CAAM,MAAA,KAAW,CAAA,GAAID,IAAS,GAAOC,IAAS,CAAK,KAAA,CAAM,EAAA,CAAG,EAAE,CAAC;AAAA;AAO3D,MAAM,KAAA,GAAQ;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"array-utils-iterators.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-iterators.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,OAAO,GAAc,CAAC,EACjC,OAAO,SAAS,CAAC,EAAE,KAClB,aAAa,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,CAI1C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GAAc,CAAC,EAAE,OAAO,SAAS,CAAC,EAAE,KAAG,aAAa,CAAC,CAAC,CAIxE,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,GAAc,CAAC,EACjC,OAAO,SAAS,CAAC,EAAE,KAClB,aAAa,CAAC,QAAQ,CAAC,GAAG,CAI5B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAbiB,CAAC,SAC1B,SAAS,CAAC,EAAE,KAClB,aAAa,CAAC,QAAQ,CAAC,GAAG,CAWF,CAAC"}
+{"version":3,"file":"array-utils-iterators.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-iterators.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,OAAO,GAAc,CAAC,SAC1B,SAAS,CAAC,EAAE,KAClB,aAAa,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,CAI1C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GAAc,CAAC,SAAS,SAAS,CAAC,EAAE,KAAG,aAAa,CAAC,CAAC,CAIxE,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,GAAc,CAAC,SAC1B,SAAS,CAAC,EAAE,KAClB,aAAa,CAAC,QAAQ,CAAC,GAAG,CAI5B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAbiB,CAAC,SAC1B,SAAS,CAAC,EAAE,KAClB,aAAa,CAAC,QAAQ,CAAC,GAAG,CAWF,CAAC"}

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

@@ -35,75 +35,21 @@ import '../../number/enum/uint8.mjs';
 import '../../number/num.mjs';
 import '../../number/refined-number-utils.mjs';
 
-/**
- * Returns an iterator of `[index, value]` pairs for an array.
- *
- * @example
- *
- * ```ts
- * const tags = ['alpha', 'beta', 'gamma'] as const;
- *
- * const entryList = Array.from(
- *   Arr.entries(tags),
- *   ([index, tag]) => [Number(index), tag] as const,
- * );
- *
- * assert.deepStrictEqual(
- *   entryList,
- *   Array.from([
- *     [0, 'alpha'],
- *     [1, 'beta'],
- *     [2, 'gamma'],
- *   ]),
- * );
- * ```
- */
 const entries = function* (array) {
-    for (const [index, value] of array.entries()) {
-        yield [asUint32(index), value];
-    }
+  for (const [index, value] of array.entries()) {
+    yield [asUint32(index), value];
+  }
 };
-/**
- * Returns an iterator of values for an array.
- *
- * @example
- *
- * ```ts
- * const players = ['Ada', 'Grace', 'Alan'] as readonly string[];
- *
- * const valueList = Array.from(Arr.values(players));
- *
- * assert.deepStrictEqual(valueList, players);
- * ```
- */
 const values = function* (array) {
-    for (const value of array) {
-        yield value;
-    }
+  for (const value of array) {
+    yield value;
+  }
 };
-/**
- * Returns an iterator of indices for an array.
- *
- * @example
- *
- * ```ts
- * const items = ['zero', 'one', 'two'] as const;
- *
- * const indexList = Array.from(Arr.indices(items));
- *
- * assert.deepStrictEqual(indexList, [0, 1, 2]);
- * ```
- */
 const indices = function* (array) {
-    for (const key of array.keys()) {
-        yield asUint32(key);
-    }
+  for (const key of array.keys()) {
+    yield asUint32(key);
+  }
 };
-/**
- * Alias for `indices`.
- *
- * @see {@link indices}
- */
 const keys = indices;
 
 export { entries, indices, keys, values };

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

@@ -1 +1 @@
-{"version":3,"file":"array-utils-iterators.mjs","sources":["../../../src/array/impl/array-utils-iterators.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,OAAO,GAAG,WACrB,KAAmB,EAAA;AAEnB,IAAA,KAAK,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE;QAC5C,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAU;IACzC;AACF;AAEA;;;;;;;;;;;;AAYG;AACI,MAAM,MAAM,GAAG,WAAc,KAAmB,EAAA;AACrD,IAAA,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE;AACzB,QAAA,MAAM,KAAK;IACb;AACF;AAEA;;;;;;;;;;;;AAYG;AACI,MAAM,OAAO,GAAG,WACrB,KAAmB,EAAA;IAEnB,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE;AAC9B,QAAA,MAAM,QAAQ,CAAC,GAAG,CAAC;IACrB;AACF;AAEA;;;;AAIG;AACI,MAAM,IAAI,GAAG;;;;"}
+{"version":3,"file":"array-utils-iterators.mjs","sources":["../../../src/array/impl/array-utils-iterators.mts"],"sourcesContent":["import { asUint32 } from '../../number/index.mjs';\nimport { type SizeType } from '../../types.mjs';\n\n/**\n * Returns an iterator of `[index, value]` pairs for an array.\n *\n * @example\n *\n * ```ts\n * const tags = ['alpha', 'beta', 'gamma'] as const;\n *\n * const entryList = Array.from(\n *   Arr.entries(tags),\n *   ([index, tag]) => [Number(index), tag] as const,\n * );\n *\n * assert.deepStrictEqual(\n *   entryList,\n *   Array.from([\n *     [0, 'alpha'],\n *     [1, 'beta'],\n *     [2, 'gamma'],\n *   ]),\n * );\n * ```\n */\nexport const entries = function* <E>(\n  array: readonly E[],\n): ArrayIterator<readonly [SizeType.Arr, E]> {\n  for (const [index, value] of array.entries()) {\n    yield [asUint32(index), value] as const;\n  }\n};\n\n/**\n * Returns an iterator of values for an array.\n *\n * @example\n *\n * ```ts\n * const players = ['Ada', 'Grace', 'Alan'] as readonly string[];\n *\n * const valueList = Array.from(Arr.values(players));\n *\n * assert.deepStrictEqual(valueList, players);\n * ```\n */\nexport const values = function* <E>(array: readonly E[]): ArrayIterator<E> {\n  for (const value of array) {\n    yield value;\n  }\n};\n\n/**\n * Returns an iterator of indices for an array.\n *\n * @example\n *\n * ```ts\n * const items = ['zero', 'one', 'two'] as const;\n *\n * const indexList = Array.from(Arr.indices(items));\n *\n * assert.deepStrictEqual(indexList, [0, 1, 2]);\n * ```\n */\nexport const indices = function* <E>(\n  array: readonly E[],\n): ArrayIterator<SizeType.Arr> {\n  for (const key of array.keys()) {\n    yield asUint32(key);\n  }\n};\n\n/**\n * Alias for `indices`.\n *\n * @see {@link indices}\n */\nexport const keys = indices;\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BO,MAAM,OAAA,GAAU,WACrB,KAAA,EAC2C;AAC3C,EAAA,KAAA,MAAW,CAAC,KAAA,EAAO,KAAK,CAAA,IAAK,KAAA,CAAM,SAAQ,EAAG;AAC5C,IAAA,MAAM,CAAC,QAAA,CAAS,KAAK,CAAA,EAAG,KAAK,CAAA;AAAA,EAC/B;AACF;AAeO,MAAM,MAAA,GAAS,WAAc,KAAA,EAAuC;AACzE,EAAA,KAAA,MAAW,SAAS,KAAA,EAAO;AACzB,IAAA,MAAM,KAAA;AAAA,EACR;AACF;AAeO,MAAM,OAAA,GAAU,WACrB,KAAA,EAC6B;AAC7B,EAAA,KAAA,MAAW,GAAA,IAAO,KAAA,CAAM,IAAA,EAAK,EAAG;AAC9B,IAAA,MAAM,SAAS,GAAG,CAAA;AAAA,EACpB;AACF;AAOO,MAAM,IAAA,GAAO;;;;"}

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

@@ -39,106 +39,106 @@ import '@sindresorhus/is';
 import { create, copy } from './array-utils-creation.mjs';
 
 function set(...args) {
-    switch (args.length) {
-        case 3: {
-            const [array, index, newValue] = args;
-            return array.with(index, newValue);
-        }
-        case 2: {
-            const [index, newValue] = args;
-            return (array) => set(array, index, newValue);
-        }
+  switch (args.length) {
+    case 3: {
+      const [array, index, newValue] = args;
+      return array.with(index, newValue);
     }
+    case 2: {
+      const [index, newValue] = args;
+      return (array) => set(array, index, newValue);
+    }
+  }
 }
 function toUpdated(...args) {
-    switch (args.length) {
-        case 3: {
-            const [array, index, updater] = args;
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            return array.with(index, updater(array[index]));
-        }
-        case 2: {
-            const [index, updater] = args;
-            return (array) => toUpdated(array, index, updater);
-        }
+  switch (args.length) {
+    case 3: {
+      const [array, index, updater] = args;
+      return array.with(index, updater(array[index]));
+    }
+    case 2: {
+      const [index, updater] = args;
+      return (array) => toUpdated(array, index, updater);
     }
+  }
 }
 function toInserted(...args) {
-    switch (args.length) {
-        case 3: {
-            const [array, index, newValue] = args;
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            return array.toSpliced(index, 0, newValue);
-        }
-        case 2: {
-            const [index, newValue] = args;
-            return (array) => toInserted(array, index, newValue);
-        }
+  switch (args.length) {
+    case 3: {
+      const [array, index, newValue] = args;
+      return array.toSpliced(
+        index,
+        0,
+        newValue
+      );
     }
+    case 2: {
+      const [index, newValue] = args;
+      return (array) => toInserted(array, index, newValue);
+    }
+  }
 }
 function toRemoved(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, index] = args;
-            return array.toSpliced(index, 1);
-        }
-        case 1: {
-            const [index] = args;
-            return (array) => toRemoved(array, index);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, index] = args;
+      return array.toSpliced(index, 1);
+    }
+    case 1: {
+      const [index] = args;
+      return (array) => toRemoved(array, index);
     }
+  }
 }
 function toPushed(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, newValue] = args;
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            return array.toSpliced(array.length, 0, newValue);
-        }
-        case 1: {
-            const [newValue] = args;
-            return (array) => toPushed(array, newValue);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, newValue] = args;
+      return array.toSpliced(array.length, 0, newValue);
     }
+    case 1: {
+      const [newValue] = args;
+      return (array) => toPushed(array, newValue);
+    }
+  }
 }
 function toUnshifted(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, newValue] = args;
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            return array.toSpliced(0, 0, newValue);
-        }
-        case 1: {
-            const [newValue] = args;
-            return (array) => toUnshifted(array, newValue);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, newValue] = args;
+      return array.toSpliced(0, 0, newValue);
+    }
+    case 1: {
+      const [newValue] = args;
+      return (array) => toUnshifted(array, newValue);
     }
+  }
 }
 function toFilled(...args) {
-    switch (args.length) {
-        case 2: {
-            const [array, value] = args;
-            return create(asPositiveUint32(array.length), value);
-        }
-        case 1: {
-            const [value] = args;
-            return (array) => toFilled(array, value);
-        }
+  switch (args.length) {
+    case 2: {
+      const [array, value] = args;
+      return create(asPositiveUint32(array.length), value);
     }
+    case 1: {
+      const [value] = args;
+      return (array) => toFilled(array, value);
+    }
+  }
 }
 function toRangeFilled(...args) {
-    switch (args.length) {
-        case 3: {
-            const [array, value, [start, end]] = args;
-            const mut_cp = castMutable(copy(array));
-            mut_cp.fill(value, start, end);
-            return mut_cp;
-        }
-        case 2: {
-            const [value, fillRange] = args;
-            return (array) => toRangeFilled(array, value, fillRange);
-        }
+  switch (args.length) {
+    case 3: {
+      const [array, value, [start, end]] = args;
+      const mut_cp = castMutable(copy(array));
+      mut_cp.fill(value, start, end);
+      return mut_cp;
+    }
+    case 2: {
+      const [value, fillRange] = args;
+      return (array) => toRangeFilled(array, value, fillRange);
     }
+  }
 }
 
 export { set, toFilled, toInserted, toPushed, toRangeFilled, toRemoved, toUnshifted, toUpdated };

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

@@ -1 +1 @@
-{"version":3,"file":"array-utils-modification.mjs","sources":["../../../src/array/impl/array-utils-modification.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"array-utils-modification.mjs","sources":["../../../src/array/impl/array-utils-modification.mts"],"sourcesContent":["import {\n  type ArrayOfLength,\n  type Increment,\n  type IsFixedLengthList,\n  type NonEmptyArray,\n} from 'ts-type-forge';\nimport { asPositiveUint32 } from '../../number/index.mjs';\nimport { castMutable } from '../../others/index.mjs';\nimport {\n  type ArgArrayIndex,\n  type ArgArrayIndexWithNegative,\n  type SizeType,\n} from '../../types.mjs';\nimport { copy, create } from './array-utils-creation.mjs';\n\n/**\n * Returns a new array with an element at the specified index replaced.\n *\n * @example\n *\n * ```ts\n * const scores: readonly number[] = [10, 20, 30] as const;\n *\n * const updated = Arr.set(scores, 1, 25);\n *\n * assert.deepStrictEqual(updated, [10, 25, 30]);\n * ```\n */\nexport function set<const Ar extends readonly unknown[], const V = Ar[number]>(\n  array: Ar,\n  index: ArgArrayIndex<Ar>,\n  newValue: V,\n): IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\n// curried version\nexport function set<const V>(\n  index: SizeType.ArgArr,\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\nexport function set<E, const V = E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArr, newValue: V]\n    | readonly [index: SizeType.ArgArr, newValue: V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3: {\n      const [array, index, newValue] = args;\n\n      return (array as readonly (E | V)[]).with(index, newValue);\n    }\n\n    case 2: {\n      const [index, newValue] = args;\n\n      return (array) => set(array, index, newValue);\n    }\n  }\n}\n\n/**\n * Returns a new array with an element at the specified index updated by applying a function.\n *\n * @example\n *\n * ```ts\n * const temperatures: readonly number[] = [20, 21, 22] as const;\n *\n * const increased = Arr.toUpdated(temperatures, 1, (value) => value + 5);\n *\n * const incrementLast = Arr.toUpdated<number>(\n *   2,\n *   (value) => value + 1,\n * )(temperatures);\n *\n * assert.deepStrictEqual(increased, [20, 26, 22]);\n *\n * assert.deepStrictEqual(incrementLast, [20, 21, 23]);\n * ```\n */\nexport function toUpdated<\n  const Ar extends readonly unknown[],\n  const V = Ar[number],\n>(\n  array: Ar,\n  index: ArgArrayIndex<Ar>,\n  updater: (prev: Ar[number]) => V,\n): IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\n// curried version\nexport function toUpdated<E, const V = E>(\n  index: SizeType.ArgArr,\n  updater: (prev: E) => V,\n): <const Ar extends readonly E[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\nexport function toUpdated<E, V = E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        index: SizeType.ArgArr,\n        updater: (prev: E) => V,\n      ]\n    | readonly [index: SizeType.ArgArr, updater: (prev: E) => V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3: {\n      const [array, index, updater] = args;\n\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      return (array as readonly (E | V)[]).with(index, updater(array[index]!));\n    }\n\n    case 2: {\n      const [index, updater] = args;\n\n      return (array) => toUpdated(array, index, updater);\n    }\n  }\n}\n\n/**\n * Returns a new array with a value inserted at the specified index.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 4] as const;\n *\n * const withThree = Arr.toInserted(numbers, 2, 3);\n *\n * const appendFive = Arr.toInserted(3, 5)(numbers);\n *\n * assert.deepStrictEqual(withThree, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(appendFive, [1, 2, 4, 5]);\n * ```\n */\nexport function toInserted<\n  const Ar extends readonly unknown[],\n  const V = Ar[number],\n>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n  newValue: V,\n): IsFixedLengthList<Ar> extends true\n  ? ArrayOfLength<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n  : NonEmptyArray<Ar[number] | V>;\n\n// curried version\nexport function toInserted<const V>(\n  index: SizeType.ArgArrWithNegative,\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? ArrayOfLength<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n  : NonEmptyArray<Ar[number] | V>;\n\nexport function toInserted<E, const V = E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        index: SizeType.ArgArrWithNegative,\n        newValue: V,\n      ]\n    | readonly [index: SizeType.ArgArrWithNegative, newValue: V]\n): NonEmptyArray<E | V> | ((array: readonly E[]) => NonEmptyArray<E | V>) {\n  switch (args.length) {\n    case 3: {\n      const [array, index, newValue] = args;\n\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      return (array as readonly (E | V)[]).toSpliced(\n        index,\n        0,\n        newValue,\n      ) as unknown as NonEmptyArray<E | V>;\n    }\n\n    case 2: {\n      const [index, newValue] = args;\n\n      return (array) => toInserted(array, index, newValue);\n    }\n  }\n}\n\ntype CastToNumber<T> = T extends number ? T : never;\n\n/**\n * Returns a new array with the element at the specified index removed.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'd'] as const;\n *\n * const withoutSecond = Arr.toRemoved(letters, 1);\n *\n * const withoutFirstCurried = Arr.toRemoved(0)(letters);\n *\n * assert.deepStrictEqual(withoutSecond, ['a', 'c', 'd']);\n *\n * assert.deepStrictEqual(withoutFirstCurried, ['b', 'c', 'd']);\n * ```\n */\nexport function toRemoved<const Ar extends readonly unknown[]>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n): readonly Ar[number][];\n\nexport function toRemoved(\n  index: SizeType.ArgArrWithNegative,\n): <E>(array: readonly E[]) => readonly E[];\n\nexport function toRemoved<E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArrWithNegative]\n    | readonly [index: SizeType.ArgArrWithNegative]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, index] = args;\n\n      return array.toSpliced(index, 1);\n    }\n\n    case 1: {\n      const [index] = args;\n\n      return (array) => toRemoved(array, index);\n    }\n  }\n}\n\n/**\n * Returns a new array with a value appended to the end.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2] as const;\n *\n * const appended = Arr.toPushed(base, 3);\n *\n * const appendedCurried = Arr.toPushed(4)(base);\n *\n * assert.deepStrictEqual(appended, [1, 2, 3]);\n *\n * assert.deepStrictEqual(appendedCurried, [1, 2, 4]);\n * ```\n */\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [...Ar, V];\n\nexport function toPushed<const V>(\n  newValue: V,\n): <const Ar extends readonly unknown[]>(array: Ar) => readonly [...Ar, V];\n\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n  ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [...Ar, V] | ((array: Ar) => readonly [...Ar, V]) {\n  switch (args.length) {\n    case 2: {\n      const [array, newValue] = args;\n\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      return array.toSpliced(array.length, 0, newValue) as unknown as readonly [\n        ...Ar,\n        V,\n      ];\n    }\n\n    case 1: {\n      const [newValue] = args;\n\n      return (array) => toPushed(array, newValue);\n    }\n  }\n}\n\n/**\n * Returns a new array with a value prepended to the beginning.\n *\n * @example\n *\n * ```ts\n * const base = [2, 3] as const;\n *\n * const prefixed = Arr.toUnshifted(base, 1);\n *\n * const prefixedCurried = Arr.toUnshifted(0)(base);\n *\n * assert.deepStrictEqual(prefixed, [1, 2, 3]);\n *\n * assert.deepStrictEqual(prefixedCurried, [0, 2, 3]);\n * ```\n */\nexport function toUnshifted<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [V, ...Ar];\n\nexport function toUnshifted<const V>(\n  newValue: V,\n): <const Ar extends readonly unknown[]>(array: Ar) => readonly [V, ...Ar];\n\nexport function toUnshifted<Ar extends readonly unknown[], const V>(\n  ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [V, ...Ar] | ((array: Ar) => readonly [V, ...Ar]) {\n  switch (args.length) {\n    case 2: {\n      const [array, newValue] = args;\n\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      return array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];\n    }\n\n    case 1: {\n      const [newValue] = args;\n\n      return (array) => toUnshifted(array, newValue);\n    }\n  }\n}\n\n/**\n * Returns a new array with all elements replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2, 3] as const;\n *\n * const filled = Arr.toFilled(base, 0);\n *\n * const filledCurried = Arr.toFilled('x')(base);\n *\n * assert.deepStrictEqual(filled, [0, 0, 0]);\n *\n * assert.deepStrictEqual(filledCurried, ['x', 'x', 'x']);\n * ```\n */\nexport function toFilled<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  value: V,\n): IsFixedLengthList<Ar> extends true\n  ? ArrayOfLength<Ar['length'], V>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<V>\n    : readonly V[];\n\n// curried version\nexport function toFilled<const V>(\n  value: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? ArrayOfLength<Ar['length'], V>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<V>\n    : readonly V[];\n\nexport function toFilled<E>(\n  ...args: readonly [array: readonly E[], value: E] | readonly [value: E]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [array, value] = args;\n\n      return create(asPositiveUint32(array.length), value);\n    }\n\n    case 1: {\n      const [value] = args;\n\n      return (array) => toFilled(array, value);\n    }\n  }\n}\n\n/**\n * Returns a new array with elements in the specified range replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [0, 1, 2, 3, 4] as const;\n *\n * const filledMiddle = Arr.toRangeFilled(base, 9, [1, 4]);\n *\n * const filledPrefix = Arr.toRangeFilled(8, [0, 2])(base);\n *\n * assert.deepStrictEqual(filledMiddle, [0, 9, 9, 9, 4]);\n *\n * assert.deepStrictEqual(filledPrefix, [8, 8, 2, 3, 4]);\n * ```\n */\nexport function toRangeFilled<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  value: V,\n  fillRange: readonly [\n    start: ArgArrayIndexWithNegative<Ar>,\n    end: ArgArrayIndexWithNegative<Ar>,\n  ],\n): IsFixedLengthList<Ar> extends true\n  ? ArrayOfLength<Ar['length'], V | Ar[number]>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<V | Ar[number]>\n    : readonly (V | Ar[number])[];\n\n// curried version\nexport function toRangeFilled<const V>(\n  value: V,\n  fillRange: readonly [\n    start: SizeType.ArgArrWithNegative,\n    end: SizeType.ArgArrWithNegative,\n  ],\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? ArrayOfLength<Ar['length'], V | Ar[number]>\n  : Ar extends NonEmptyArray<unknown>\n    ? NonEmptyArray<V | Ar[number]>\n    : readonly (V | Ar[number])[];\n\nexport function toRangeFilled<E, const V>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        value: V,\n        fillRange: readonly [\n          start: SizeType.ArgArrWithNegative,\n          end: SizeType.ArgArrWithNegative,\n        ],\n      ]\n    | readonly [\n        value: V,\n        fillRange: readonly [\n          start: SizeType.ArgArrWithNegative,\n          end: SizeType.ArgArrWithNegative,\n        ],\n      ]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3: {\n      const [array, value, [start, end]] = args;\n\n      const mut_cp: (E | V)[] = castMutable(copy(array));\n\n      mut_cp.fill(value, start, end);\n\n      return mut_cp;\n    }\n\n    case 2: {\n      const [value, fillRange] = args;\n\n      return (array) => toRangeFilled(array, value, fillRange);\n    }\n  }\n}\n"],"names":[],"mappings":"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"}