npm - ts-data-forge - Versions diffs - 12.2.0 → 12.2.2 - Mend

ts-data-forge 12.2.0 → 12.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (79) hide show

package/README.md CHANGED Viewed

@@ -200,12 +200,9 @@ const divideAndFormat = (
 ): Result<string, string> =>
     pipe(denominator)
         .map((d) => (d !== 0 ? Result.ok(d) : Result.err('Division by zero')))
-        .map((result) => Result.map(result, (d) => numerator / d))
-        .map((result) =>
-            Result.map(result, (value) => `Result: ${value.toFixed(2)}`),
-        )
-        .map((result) => Result.mapErr(result, (error) => `Error: ${error}`))
-        .value;
+        .map(Result.map((d: number) => numerator / d))
+        .map(Result.map((value: number) => `Result: ${value.toFixed(2)}`))
+        .map(Result.mapErr((error: string) => `Error: ${error}`)).value;
 assert.deepStrictEqual(divideAndFormat(10, 2), Result.ok('Result: 5.00'));

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

@@ -53,7 +53,7 @@ export declare const create: <N extends SizeType.ArgArr, const V>(len: N, init:
  *
  * @see {@link create}
  */
-export declare const newArray: <N extends SizeType.ArgArr, const V>(len: N, init: V) => N extends StructuralPrefixLength ? FixedLengthTuple<N, V> : N extends SizeType.ArgArrPositive ? NonEmptyArray<V> : readonly V[];
+export declare const newArray: typeof create;
 /**
  * Generates an array from a generator function.
  *

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

	@@ -1 +1 @@
1	- {"version":3,"file":"array-utils-creation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-creation.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,gBAAgB,EACrB,KAAK,KAAK,EACV,KAAK,OAAO,EACZ,KAAK,IAAI,EACT,KAAK,GAAG,EACR,KAAK,aAAa,EAClB,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAChC,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,mBAAmB,EACxB,KAAK,QAAQ,EACb,KAAK,oBAAoB,EACzB,KAAK,GAAG,EACR,KAAK,SAAS,EACd,KAAK,sBAAsB,EAC5B,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,OACxC,CAAC,KACL,CAAC,SAAS,SAAS,GAClB,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,GACtB,CAAC,SAAS,QAAQ,CAAC,cAAc,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EAE+B,CAAC;AAEhD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,OACtC,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,CAAC,SAAS,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,OAClD,CAAC,QACA,CAAC,KACN,CAAC,SAAS,sBAAsB,GAC/B,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,GACtB,CAAC,SAAS,QAAQ,CAAC,cAAc,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EAE+C,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,QAAQ,~~GAhBE~~,CAAC~~,SAAS,QAAQ,CAAC,MAAM,QAAQ,CAAC,OAClD,CAAC,QACA,CAAC,KACN,CAAC,SAAS,sBAAsB,GAC/B,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,GACtB,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,eACX,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,KAC7C,SAAS,CAAC,EAA+B,CAAC;AAE7C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,eAChB,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,SAAS,EAAE,KAAG,EAEtC,CAAC;AAEjC,KAAK,EAAE,GAAG,QAAQ,CAAC;KAAG,CAAC,IAAI,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC;CAAE,CAAC,CAAC;AAEnD,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"}
1	+ {"version":3,"file":"array-utils-creation.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-creation.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,MAAM,EACX,KAAK,gBAAgB,EACrB,KAAK,KAAK,EACV,KAAK,OAAO,EACZ,KAAK,IAAI,EACT,KAAK,GAAG,EACR,KAAK,aAAa,EAClB,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAChC,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,mBAAmB,EACxB,KAAK,QAAQ,EACb,KAAK,oBAAoB,EACzB,KAAK,GAAG,EACR,KAAK,SAAS,EACd,KAAK,sBAAsB,EAC5B,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,OACxC,CAAC,KACL,CAAC,SAAS,SAAS,GAClB,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,GACtB,CAAC,SAAS,QAAQ,CAAC,cAAc,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EAE+B,CAAC;AAEhD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,OACtC,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,CAAC,SAAS,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,OAClD,CAAC,QACA,CAAC,KACN,CAAC,SAAS,sBAAsB,GAC/B,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,GACtB,CAAC,SAAS,QAAQ,CAAC,cAAc,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EAE+C,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,QAAQ,eAAS,CAAC;AAE/B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,eACX,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,KAC7C,SAAS,CAAC,EAA+B,CAAC;AAE7C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,eAChB,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,SAAS,EAAE,KAAG,EAEtC,CAAC;AAEjC,KAAK,EAAE,GAAG,QAAQ,CAAC;KAAG,CAAC,IAAI,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC;CAAE,CAAC,CAAC;AAEnD,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-element-access.d.mts CHANGED Viewed

@@ -69,5 +69,5 @@ export declare const last: <const Ar extends readonly unknown[]>(array: Ar) => A
  *
  * @see {@link head}
  */
-export declare const first: <const Ar extends readonly unknown[]>(array: Ar) => Ar extends readonly [] ? None : Ar extends readonly [infer E, ...unknown[]] ? Some<E> : Ar extends NonEmptyTuple<infer E> ? Some<E> : Optional<Ar[number]>;
+export declare const first: typeof head;
 //# sourceMappingURL=array-utils-element-access.d.mts.map

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

	@@ -1 +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,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~~"}
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;AA2B3C;;;;;;;;;;;;;;;;;;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,aAAO,CAAC"}

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

@@ -5,21 +5,18 @@ 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);
-    }
+    case 2:
+      return atImpl(...args);
+    case 1:
+      return (array) => atImpl(array, ...args);
   }
 }
+const atImpl = (array, index$1) => 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;
 const head = (array) => (
   // eslint-disable-next-line total-functions/no-unsafe-type-assertion
   array.length === 0 ? none : some(array.at(0))

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

	@@ -1 +1 @@
1	- {"version":3,"file":"array-utils-element-access.mjs","sources":["../../../src/array/impl/array-utils-element-access.mts"],"sourcesContent":["import { type NonEmptyTuple } 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 NonEmptyTuple<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 NonEmptyTuple<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;;;;"}
1	+ {"version":3,"file":"array-utils-element-access.mjs","sources":["../../../src/array/impl/array-utils-element-access.mts"],"sourcesContent":["import { type NonEmptyTuple } 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 return atImpl(...args);\n\n case 1:\n return (array) => atImpl(array, ...args);\n }\n}\n\nconst atImpl = <E,>(\n array: readonly E[],\n index: SizeType.ArgArrWithNegative,\n): Optional<E> =>\n pipe(index < 0 ? array.length + index : index).map((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 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 NonEmptyTuple<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 NonEmptyTuple<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;AACH,MAAA,OAAO,MAAA,CAAO,GAAG,IAAI,CAAA;AAAA,IAEvB,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,MAAA,CAAO,KAAA,EAAO,GAAG,IAAI,CAAA;AAAA;AAE7C;AAEA,MAAM,MAAA,GAAS,CACb,KAAA,EACAA,OAAA,KAEA,IAAA,CAAKA,OAAA,GAAQ,CAAA,GAAI,KAAA,CAAM,MAAA,GAASA,OAAA,GAAQA,OAAK,CAAA,CAAE,GAAA;AAAA,EAAI,CAAC,eAAA,KAClD,eAAA,GAAkB,KAAK,eAAA,IAAmB,KAAA,CAAM,SAC5CC,IAAS;AAAA;AAAA,IAETC,IAAS,CAAK,KAAA,CAAM,eAAe,CAAE;AAAA;AAC3C,CAAA,CAAE,KAAA;AAqBG,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 CHANGED Viewed

@@ -56,5 +56,5 @@ export declare const indices: <E>(array: readonly E[]) => ArrayIterator<SizeType
  *
  * @see {@link indices}
  */
-export declare const keys: <E>(array: readonly E[]) => ArrayIterator<SizeType.Arr>;
+export declare const keys: typeof indices;
 //# sourceMappingURL=array-utils-iterators.d.mts.map

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

	@@ -1 +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,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~~"}
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,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,gBAAU,CAAC"}

package/dist/array/impl/array-utils-length-bounded-array-cast.d.mts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"array-utils-length-bounded-array-cast.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-length-bounded-array-cast.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAQvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,MAAM,SAAS,eAAe,EAC9B,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC;AAGrE,wBAAgB,kBAAkB,CAAC,MAAM,SAAS,eAAe,EAC/D,MAAM,EAAE,MAAM,GACb,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC/B,EAAE,EAAE,EAAE,KACH,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC;~~AA4B~~/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,EACjC,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,SAAS,GAAG,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC;AAG5E,wBAAgB,gBAAgB,CAAC,SAAS,SAAS,eAAe,EAChE,SAAS,EAAE,SAAS,GACnB,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC/B,EAAE,EAAE,EAAE,KACH,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC;~~AA4BhD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,EACjC,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,SAAS,GAAG,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC;AAG5E,wBAAgB,gBAAgB,CAAC,SAAS,SAAS,eAAe,EAChE,SAAS,EAAE,SAAS,GACnB,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC/B,EAAE,EAAE,EAAE,KACH,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC;~~AA4BhD~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,oBAAoB,CAClC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,EACjC,SAAS,SAAS,eAAe,EAEjC,EAAE,EAAE,EAAE,EACN,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,GACnB,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC;AAG7D,wBAAgB,oBAAoB,CAClC,SAAS,SAAS,eAAe,EACjC,SAAS,SAAS,eAAe,EAEjC,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,GACnB,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC/B,EAAE,EAAE,EAAE,KACH,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC;~~AAgC~~/D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,GAAI,EAAE,SAAS,SAAS,OAAO,EAAE,MACvD,EAAE,KACL,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAM9B,CAAC"}
1	+ {"version":3,"file":"array-utils-length-bounded-array-cast.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-length-bounded-array-cast.mts"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-length-bounded-array-cast.mjs CHANGED Viewed

@@ -1,73 +1,73 @@
-import { isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray, isMinLengthArray } from './array-utils-length-bounded-array-guard.mjs';
+import { isMinLengthArray, isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray } from './array-utils-length-bounded-array-guard.mjs';
 function asFixedLengthArray(...args) {
   switch (args.length) {
-    case 2: {
-      const [xs, length] = args;
-      if (!isFixedLengthArray(xs, length)) {
-        throw new TypeError(
-          `Expected an array of length ${length}, got an array of length ${xs.length}`
-        );
-      }
-      return xs;
-    }
-    case 1: {
-      const [length] = args;
-      return (xs) => asFixedLengthArray(xs, length);
-    }
+    case 2:
+      return asFixedLengthArrayImpl(...args);
+    case 1:
+      return (xs) => asFixedLengthArrayImpl(xs, ...args);
   }
 }
+const asFixedLengthArrayImpl = (xs, length) => {
+  const actualLength = xs.length;
+  if (!isFixedLengthArray(xs, length)) {
+    throw new TypeError(
+      `Expected an array of length ${length}, got an array of length ${actualLength}`
+    );
+  }
+  return xs;
+};
 function asMinLengthArray(...args) {
   switch (args.length) {
-    case 2: {
-      const [xs, minLength] = args;
-      if (!isMinLengthArray(xs, minLength)) {
-        throw new TypeError(
-          `Expected an array of length >= ${minLength}, got an array of length ${xs.length}`
-        );
-      }
-      return xs;
-    }
-    case 1: {
-      const [minLength] = args;
-      return (xs) => asMinLengthArray(xs, minLength);
-    }
+    case 2:
+      return asMinLengthArrayImpl(...args);
+    case 1:
+      return (xs) => asMinLengthArrayImpl(xs, ...args);
   }
 }
+const asMinLengthArrayImpl = (xs, minLength) => {
+  const actualLength = xs.length;
+  if (!isMinLengthArray(xs, minLength)) {
+    throw new TypeError(
+      `Expected an array of length >= ${minLength}, got an array of length ${actualLength}`
+    );
+  }
+  return xs;
+};
 function asMaxLengthArray(...args) {
   switch (args.length) {
-    case 2: {
-      const [xs, maxLength] = args;
-      if (!isMaxLengthArray(xs, maxLength)) {
-        throw new TypeError(
-          `Expected an array of length <= ${maxLength}, got an array of length ${xs.length}`
-        );
-      }
-      return xs;
-    }
-    case 1: {
-      const [maxLength] = args;
-      return (xs) => asMaxLengthArray(xs, maxLength);
-    }
+    case 2:
+      return asMaxLengthArrayImpl(...args);
+    case 1:
+      return (xs) => asMaxLengthArrayImpl(xs, ...args);
   }
 }
+const asMaxLengthArrayImpl = (xs, maxLength) => {
+  const actualLength = xs.length;
+  if (!isMaxLengthArray(xs, maxLength)) {
+    throw new TypeError(
+      `Expected an array of length <= ${maxLength}, got an array of length ${actualLength}`
+    );
+  }
+  return xs;
+};
 function asBoundedLengthArray(...args) {
   switch (args.length) {
-    case 3: {
-      const [xs, minLength, maxLength] = args;
-      if (!isBoundedLengthArray(xs, minLength, maxLength)) {
-        throw new TypeError(
-          `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${xs.length}`
-        );
-      }
-      return xs;
-    }
-    case 2: {
-      const [minLength, maxLength] = args;
-      return (xs) => asBoundedLengthArray(xs, minLength, maxLength);
-    }
+    case 3:
+      return asBoundedLengthArrayImpl(...args);
+    case 2:
+      return (xs) => asBoundedLengthArrayImpl(xs, ...args);
   }
 }
+const asBoundedLengthArrayImpl = (xs, minLength, maxLength) => {
+  const actualLength = xs.length;
+  if (!isBoundedLengthArray(xs, minLength, maxLength)) {
+    throw new TypeError(
+      `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${actualLength}`
+    );
+  }
+  return xs;
+};
 const asNonEmptyArray = (xs) => {
   if (!isMinLengthArray(xs, 1)) {
     throw new TypeError("Expected a non-empty array, got an empty array");

package/dist/array/impl/array-utils-length-bounded-array-cast.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"array-utils-length-bounded-array-cast.mjs","sources":["../../../src/array/impl/array-utils-length-bounded-array-cast.mts"],"sourcesContent":["import {\n type BoundedLengthArray,\n type FixedLengthArray,\n type MaxLengthArray,\n type MinLengthArray,\n type NonEmptyArray,\n type SupportedLength,\n} from 'ts-type-forge';\nimport {\n isBoundedLengthArray,\n isFixedLengthArray,\n isMaxLengthArray,\n isMinLengthArray,\n} from './array-utils-length-bounded-array-guard.mjs';\n\n/*\n Casts an array to `FixedLengthArray<Length, E>` after checking that it has\n * exactly `length` elements.\n \n Use this instead of writing `xs as unknown as FixedLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection, so the result also benefits from the\n * structural tuple prefix (in-range indexed access without `undefined` under\n * `noUncheckedIndexedAccess`).\n \n Supports a curried overload: calling it with only `length` returns a\n * function that casts an array, which is convenient for `pipe`/`map`.\n \n @example\n \n ```ts\n * const rgb = Arr.asFixedLengthArray([255, 128, 0], 3);\n \n const atMost5: MaxLengthArray<5, number> = rgb; // OK (3 <= 5)\n * const red: number = rgb[0]; // OK — no `undefined`\n \n // curried version\n * const asRgb = Arr.asFixedLengthArray(3);\n * const green = asRgb([0, 255, 0]);\n \n // Arr.asFixedLengthArray([255, 128], 3); // throws TypeError\n * ```\n \n @template Xs - The input array type (tuple types are preserved).\n * @template Length - The exact number of elements.\n * @param xs - The array to cast.\n * @param length - The exact number of elements.\n * @returns `xs` typed as `FixedLengthArray<Length, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length !== length`.\n /\nexport function asFixedLengthArray<\n Xs extends readonly unknown[],\n Length extends SupportedLength,\n>(xs: Xs, length: Length): FixedLengthArray<Length, Xs[number]> & Xs;\n\n// Curried version\nexport function asFixedLengthArray<Length extends SupportedLength>(\n length: Length,\n): <Xs extends readonly unknown[]>(\n xs: Xs,\n) => FixedLengthArray<Length, Xs[number]> & Xs;\n\nexport function asFixedLengthArray<E>(\n ...args:\n \| readonly [xs: readonly E[], length: SupportedLength]\n \| readonly [length: SupportedLength]\n): readonly E[] \| ((xs: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 2: {\n const [xs, length] = args;\n\n if (!isFixedLengthArray(xs, length)) {\n throw new TypeError(\n `Expected an array of length ${length}, got an array of length ${xs.length}`,\n );\n }\n\n return xs;\n }\n\n case 1: {\n const [length] = args;\n\n return (xs) => asFixedLengthArray(xs, length);\n }\n }\n}\n\n/\n Casts an array to `MinLengthArray<MinLength, E>` after checking that it has\n * at least `minLength` elements.\n \n Use this instead of writing `xs as unknown as MinLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection, so the result also benefits from the\n * structural tuple prefix (indexed access below `min(N, 10)` without\n * `undefined` under `noUncheckedIndexedAccess`).\n \n Supports a curried overload: calling it with only `minLength` returns a\n * function that casts an array, which is convenient for `pipe`/`map`.\n \n @example\n \n ```ts\n * const history = Arr.asMinLengthArray([0, 1, 2, 3], 3);\n \n const nonEmpty: MinLengthArray<1, number> = history; // OK (3 >= 1)\n * const first: number = history[0]; // OK — no `undefined`\n \n // curried version\n * const asHistory = Arr.asMinLengthArray(3);\n * const next = asHistory([4, 5, 6, 7]);\n \n // Arr.asMinLengthArray([0], 3); // throws TypeError\n * ```\n \n @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param minLength - The minimum number of elements (inclusive).\n * @returns `xs` typed as `MinLengthArray<MinLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength`.\n /\nexport function asMinLengthArray<\n Xs extends readonly unknown[],\n MinLength extends SupportedLength,\n>(xs: Xs, minLength: MinLength): MinLengthArray<MinLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asMinLengthArray<MinLength extends SupportedLength>(\n minLength: MinLength,\n): <Xs extends readonly unknown[]>(\n xs: Xs,\n) => MinLengthArray<MinLength, Xs[number]> & Xs;\n\nexport function asMinLengthArray<E>(\n ...args:\n \| readonly [xs: readonly E[], minLength: SupportedLength]\n \| readonly [minLength: SupportedLength]\n): readonly E[] \| ((xs: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 2: {\n const [xs, minLength] = args;\n\n if (!isMinLengthArray(xs, minLength)) {\n throw new TypeError(\n `Expected an array of length >= ${minLength}, got an array of length ${xs.length}`,\n );\n }\n\n return xs;\n }\n\n case 1: {\n const [minLength] = args;\n\n return (xs) => asMinLengthArray(xs, minLength);\n }\n }\n}\n\n/\n Casts an array to `MaxLengthArray<MaxLength, E>` after checking that it has\n * at most `maxLength` elements.\n \n Use this instead of writing `xs as unknown as MaxLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection.\n \n Supports a curried overload: calling it with only `maxLength` returns a\n * function that casts an array, which is convenient for `pipe`/`map`.\n \n @example\n \n ```ts\n * const tags = Arr.asMaxLengthArray(['a', 'b', 'c'], 8);\n \n const relaxed: MaxLengthArray<16, string> = tags; // OK (8 <= 16)\n \n // curried version\n * const asTags = Arr.asMaxLengthArray(8);\n * const more = asTags(['d', 'e']);\n \n // Arr.asMaxLengthArray(['a', 'b', 'c'], 2); // throws TypeError\n * ```\n \n @template Xs - The input array type (tuple types are preserved).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `xs` typed as `MaxLengthArray<MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length > maxLength`.\n /\nexport function asMaxLengthArray<\n Xs extends readonly unknown[],\n MaxLength extends SupportedLength,\n>(xs: Xs, maxLength: MaxLength): MaxLengthArray<MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asMaxLengthArray<MaxLength extends SupportedLength>(\n maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n xs: Xs,\n) => MaxLengthArray<MaxLength, Xs[number]> & Xs;\n\nexport function asMaxLengthArray<E>(\n ...args:\n \| readonly [xs: readonly E[], maxLength: SupportedLength]\n \| readonly [maxLength: SupportedLength]\n): readonly E[] \| ((xs: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 2: {\n const [xs, maxLength] = args;\n\n if (!isMaxLengthArray(xs, maxLength)) {\n throw new TypeError(\n `Expected an array of length <= ${maxLength}, got an array of length ${xs.length}`,\n );\n }\n\n return xs;\n }\n\n case 1: {\n const [maxLength] = args;\n\n return (xs) => asMaxLengthArray(xs, maxLength);\n }\n }\n}\n\n/\n Casts an array to `BoundedLengthArray<MinLength, MaxLength, E>` after\n * checking that its length is within the inclusive range\n * `[minLength, maxLength]`.\n \n Use this instead of writing\n * `xs as unknown as BoundedLengthArray<Min, Max, E>`: the length is verified\n * at runtime, and the original array type (e.g. tuple types) is preserved via\n * intersection.\n \n Supports a curried overload: calling it with only `minLength` and\n * `maxLength` returns a function that casts an array, which is convenient for\n * `pipe`/`map`.\n \n @example\n \n ```ts\n * const selection = Arr.asBoundedLengthArray([1, 2, 3], 1, 5);\n \n const relaxed: BoundedLengthArray<0, 100, number> = selection; // OK\n \n // curried version\n * const asSelection = Arr.asBoundedLengthArray(1, 5);\n * const next = asSelection([4, 5]);\n \n // Arr.asBoundedLengthArray([], 1, 5); // throws TypeError\n * ```\n \n @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param minLength - The minimum number of elements (inclusive).\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `xs` typed as\n * `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength \|\| xs.length > maxLength`.\n /\nexport function asBoundedLengthArray<\n Xs extends readonly unknown[],\n MinLength extends SupportedLength,\n MaxLength extends SupportedLength,\n>(\n xs: Xs,\n minLength: MinLength,\n maxLength: MaxLength,\n): BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asBoundedLengthArray<\n MinLength extends SupportedLength,\n MaxLength extends SupportedLength,\n>(\n minLength: MinLength,\n maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n xs: Xs,\n) => BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;\n\nexport function asBoundedLengthArray<E>(\n ...args:\n \| readonly [\n xs: readonly E[],\n minLength: SupportedLength,\n maxLength: SupportedLength,\n ]\n \| readonly [minLength: SupportedLength, maxLength: SupportedLength]\n): readonly E[] \| ((xs: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 3: {\n const [xs, minLength, maxLength] = args;\n\n if (!isBoundedLengthArray(xs, minLength, maxLength)) {\n throw new TypeError(\n `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${xs.length}`,\n );\n }\n\n return xs;\n }\n\n case 2: {\n const [minLength, maxLength] = args;\n\n return (xs) => asBoundedLengthArray(xs, minLength, maxLength);\n }\n }\n}\n\n/\n Casts an array to `NonEmptyArray<E>` after checking that it has at least one\n * element.\n \n `NonEmptyArray<E>` is an alias of `MinLengthArray<1, E>`, so this is the\n * length-1 specialization of {@link asMinLengthArray}. Use this instead of\n * writing `xs as unknown as NonEmptyArray<E>`: the length is verified at\n * runtime, and the original array type (e.g. tuple types) is preserved via\n * intersection, so the result also benefits from the structural tuple prefix\n * (`xs[0]` without `undefined` under `noUncheckedIndexedAccess`).\n \n @example\n \n ```ts\n * const history = Arr.asNonEmptyArray([0, 1, 2, 3]);\n \n const first: number = history[0]; // OK — no `undefined`\n \n // Arr.asNonEmptyArray([]); // throws TypeError\n * ```\n \n @template Xs - The input array type (tuple types are preserved).\n * @param xs - The array to cast.\n * @returns `xs` typed as `NonEmptyArray<Xs[number]> & Xs`.\n * @throws {TypeError} If `xs` is empty.\n */\nexport const asNonEmptyArray = <Xs extends readonly unknown[]>(\n xs: Xs,\n): NonEmptyArray<Xs[number]> & Xs => {\n if (!isMinLengthArray(xs, 1)) {\n throw new TypeError('Expected a non-empty array, got an empty array');\n }\n\n return xs;\n};\n"],"names":[],"mappings":";;AA8DO,SAAS,sBACX,IAAA,EAGkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,EAAA,EAAI,MAAM,CAAA,GAAI,IAAA;AAErB,MAAA,IAAI,CAAC,kBAAA,CAAmB,EAAA,EAAI,MAAM,CAAA,EAAG;AACnC,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,CAAA,4BAAA,EAA+B,MAAM,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,SAC5E;AAAA,MACF;AAEA,MAAA,OAAO,EAAA;AAAA,IACT;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,MAAM,CAAA,GAAI,IAAA;AAEjB,MAAA,OAAO,CAAC,EAAA,KAAO,kBAAA,CAAmB,EAAA,EAAI,MAAM,CAAA;AAAA,IAC9C;AAAA;AAEJ;AAiDO,SAAS,oBACX,IAAA,EAGkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,EAAA,EAAI,SAAS,CAAA,GAAI,IAAA;AAExB,MAAA,IAAI,CAAC,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA,EAAG;AACpC,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,SAClF;AAAA,MACF;AAEA,MAAA,OAAO,EAAA;AAAA,IACT;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,EAAA,KAAO,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA;AAAA,IAC/C;AAAA;AAEJ;AA8CO,SAAS,oBACX,IAAA,EAGkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,EAAA,EAAI,SAAS,CAAA,GAAI,IAAA;AAExB,MAAA,IAAI,CAAC,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA,EAAG;AACpC,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,SAClF;AAAA,MACF;AAEA,MAAA,OAAO,EAAA;AAAA,IACT;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,EAAA,KAAO,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA;AAAA,IAC/C;AAAA;AAEJ;AA6DO,SAAS,wBACX,IAAA,EAOkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,EAAA,EAAI,SAAA,EAAW,SAAS,CAAA,GAAI,IAAA;AAEnC,MAAA,IAAI,CAAC,oBAAA,CAAqB,EAAA,EAAI,SAAA,EAAW,SAAS,CAAA,EAAG;AACnD,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,mCAAmC,SAAS,CAAA,EAAA,EAAK,SAAS,CAAA,0BAAA,EAA6B,GAAG,MAAM,CAAA;AAAA,SAClG;AAAA,MACF;AAEA,MAAA,OAAO,EAAA;AAAA,IACT;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAA,EAAW,SAAS,CAAA,GAAI,IAAA;AAE/B,MAAA,OAAO,CAAC,EAAA,KAAO,oBAAA,CAAqB,EAAA,EAAI,WAAW,SAAS,CAAA;AAAA,IAC9D;AAAA;AAEJ;AA4BO,MAAM,eAAA,GAAkB,CAC7B,EAAA,KACmC;AACnC,EAAA,IAAI,CAAC,gBAAA,CAAiB,EAAA,EAAI,CAAC,CAAA,EAAG;AAC5B,IAAA,MAAM,IAAI,UAAU,gDAAgD,CAAA;AAAA,EACtE;AAEA,EAAA,OAAO,EAAA;AACT;;;;"}
1	+ {"version":3,"file":"array-utils-length-bounded-array-cast.mjs","sources":["../../../src/array/impl/array-utils-length-bounded-array-cast.mts"],"sourcesContent":["import {\n type BoundedLengthArray,\n type FixedLengthArray,\n type MaxLengthArray,\n type MinLengthArray,\n type NonEmptyArray,\n type SupportedLength,\n} from 'ts-type-forge';\nimport {\n isBoundedLengthArray,\n isFixedLengthArray,\n isMaxLengthArray,\n isMinLengthArray,\n} from './array-utils-length-bounded-array-guard.mjs';\n\n/*\n Casts an array to `FixedLengthArray<Length, E>` after checking that it has\n * exactly `length` elements.\n \n Use this instead of writing `xs as unknown as FixedLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection, so the result also benefits from the\n * structural tuple prefix (in-range indexed access without `undefined` under\n * `noUncheckedIndexedAccess`).\n \n Supports a curried overload: calling it with only `length` returns a\n * function that casts an array, which is convenient for `pipe`/`map`.\n \n @example\n \n ```ts\n * const rgb = Arr.asFixedLengthArray([255, 128, 0], 3);\n \n const atMost5: MaxLengthArray<5, number> = rgb; // OK (3 <= 5)\n * const red: number = rgb[0]; // OK — no `undefined`\n \n // curried version\n * const asRgb = Arr.asFixedLengthArray(3);\n * const green = asRgb([0, 255, 0]);\n \n // Arr.asFixedLengthArray([255, 128], 3); // throws TypeError\n * ```\n \n @template Xs - The input array type (tuple types are preserved).\n * @template Length - The exact number of elements.\n * @param xs - The array to cast.\n * @param length - The exact number of elements.\n * @returns `xs` typed as `FixedLengthArray<Length, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length !== length`.\n /\nexport function asFixedLengthArray<\n Xs extends readonly unknown[],\n Length extends SupportedLength,\n>(xs: Xs, length: Length): FixedLengthArray<Length, Xs[number]> & Xs;\n\n// Curried version\nexport function asFixedLengthArray<Length extends SupportedLength>(\n length: Length,\n): <Xs extends readonly unknown[]>(\n xs: Xs,\n) => FixedLengthArray<Length, Xs[number]> & Xs;\n\nexport function asFixedLengthArray<E>(\n ...args:\n \| readonly [xs: readonly E[], length: SupportedLength]\n \| readonly [length: SupportedLength]\n): readonly E[] \| ((xs: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 2:\n return asFixedLengthArrayImpl(...args);\n\n case 1:\n return (xs) => asFixedLengthArrayImpl(xs, ...args);\n }\n}\n\nconst asFixedLengthArrayImpl = <E,>(\n xs: readonly E[],\n length: SupportedLength,\n): readonly E[] => {\n const actualLength = xs.length;\n\n if (!isFixedLengthArray(xs, length)) {\n throw new TypeError(\n `Expected an array of length ${length}, got an array of length ${actualLength}`,\n );\n }\n\n return xs;\n};\n\n/\n Casts an array to `MinLengthArray<MinLength, E>` after checking that it has\n * at least `minLength` elements.\n \n Use this instead of writing `xs as unknown as MinLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection, so the result also benefits from the\n * structural tuple prefix (indexed access below `min(N, 10)` without\n * `undefined` under `noUncheckedIndexedAccess`).\n \n Supports a curried overload: calling it with only `minLength` returns a\n * function that casts an array, which is convenient for `pipe`/`map`.\n \n @example\n \n ```ts\n * const history = Arr.asMinLengthArray([0, 1, 2, 3], 3);\n \n const nonEmpty: MinLengthArray<1, number> = history; // OK (3 >= 1)\n * const first: number = history[0]; // OK — no `undefined`\n \n // curried version\n * const asHistory = Arr.asMinLengthArray(3);\n * const next = asHistory([4, 5, 6, 7]);\n \n // Arr.asMinLengthArray([0], 3); // throws TypeError\n * ```\n \n @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param minLength - The minimum number of elements (inclusive).\n * @returns `xs` typed as `MinLengthArray<MinLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength`.\n /\nexport function asMinLengthArray<\n Xs extends readonly unknown[],\n MinLength extends SupportedLength,\n>(xs: Xs, minLength: MinLength): MinLengthArray<MinLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asMinLengthArray<MinLength extends SupportedLength>(\n minLength: MinLength,\n): <Xs extends readonly unknown[]>(\n xs: Xs,\n) => MinLengthArray<MinLength, Xs[number]> & Xs;\n\nexport function asMinLengthArray<E>(\n ...args:\n \| readonly [xs: readonly E[], minLength: SupportedLength]\n \| readonly [minLength: SupportedLength]\n): readonly E[] \| ((xs: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 2:\n return asMinLengthArrayImpl(...args);\n\n case 1:\n return (xs) => asMinLengthArrayImpl(xs, ...args);\n }\n}\n\nconst asMinLengthArrayImpl = <E,>(\n xs: readonly E[],\n minLength: SupportedLength,\n): readonly E[] => {\n const actualLength = xs.length;\n\n if (!isMinLengthArray(xs, minLength)) {\n throw new TypeError(\n `Expected an array of length >= ${minLength}, got an array of length ${actualLength}`,\n );\n }\n\n return xs;\n};\n\n/\n Casts an array to `MaxLengthArray<MaxLength, E>` after checking that it has\n * at most `maxLength` elements.\n \n Use this instead of writing `xs as unknown as MaxLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection.\n \n Supports a curried overload: calling it with only `maxLength` returns a\n * function that casts an array, which is convenient for `pipe`/`map`.\n \n @example\n \n ```ts\n * const tags = Arr.asMaxLengthArray(['a', 'b', 'c'], 8);\n \n const relaxed: MaxLengthArray<16, string> = tags; // OK (8 <= 16)\n \n // curried version\n * const asTags = Arr.asMaxLengthArray(8);\n * const more = asTags(['d', 'e']);\n \n // Arr.asMaxLengthArray(['a', 'b', 'c'], 2); // throws TypeError\n * ```\n \n @template Xs - The input array type (tuple types are preserved).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `xs` typed as `MaxLengthArray<MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length > maxLength`.\n /\nexport function asMaxLengthArray<\n Xs extends readonly unknown[],\n MaxLength extends SupportedLength,\n>(xs: Xs, maxLength: MaxLength): MaxLengthArray<MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asMaxLengthArray<MaxLength extends SupportedLength>(\n maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n xs: Xs,\n) => MaxLengthArray<MaxLength, Xs[number]> & Xs;\n\nexport function asMaxLengthArray<E>(\n ...args:\n \| readonly [xs: readonly E[], maxLength: SupportedLength]\n \| readonly [maxLength: SupportedLength]\n): readonly E[] \| ((xs: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 2:\n return asMaxLengthArrayImpl(...args);\n\n case 1:\n return (xs) => asMaxLengthArrayImpl(xs, ...args);\n }\n}\n\nconst asMaxLengthArrayImpl = <E,>(\n xs: readonly E[],\n maxLength: SupportedLength,\n): readonly E[] => {\n const actualLength = xs.length;\n\n if (!isMaxLengthArray(xs, maxLength)) {\n throw new TypeError(\n `Expected an array of length <= ${maxLength}, got an array of length ${actualLength}`,\n );\n }\n\n return xs;\n};\n\n/\n Casts an array to `BoundedLengthArray<MinLength, MaxLength, E>` after\n * checking that its length is within the inclusive range\n * `[minLength, maxLength]`.\n \n Use this instead of writing\n * `xs as unknown as BoundedLengthArray<Min, Max, E>`: the length is verified\n * at runtime, and the original array type (e.g. tuple types) is preserved via\n * intersection.\n \n Supports a curried overload: calling it with only `minLength` and\n * `maxLength` returns a function that casts an array, which is convenient for\n * `pipe`/`map`.\n \n @example\n \n ```ts\n * const selection = Arr.asBoundedLengthArray([1, 2, 3], 1, 5);\n \n const relaxed: BoundedLengthArray<0, 100, number> = selection; // OK\n \n // curried version\n * const asSelection = Arr.asBoundedLengthArray(1, 5);\n * const next = asSelection([4, 5]);\n \n // Arr.asBoundedLengthArray([], 1, 5); // throws TypeError\n * ```\n \n @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param minLength - The minimum number of elements (inclusive).\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `xs` typed as\n * `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength \|\| xs.length > maxLength`.\n /\nexport function asBoundedLengthArray<\n Xs extends readonly unknown[],\n MinLength extends SupportedLength,\n MaxLength extends SupportedLength,\n>(\n xs: Xs,\n minLength: MinLength,\n maxLength: MaxLength,\n): BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asBoundedLengthArray<\n MinLength extends SupportedLength,\n MaxLength extends SupportedLength,\n>(\n minLength: MinLength,\n maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n xs: Xs,\n) => BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;\n\nexport function asBoundedLengthArray<E>(\n ...args:\n \| readonly [\n xs: readonly E[],\n minLength: SupportedLength,\n maxLength: SupportedLength,\n ]\n \| readonly [minLength: SupportedLength, maxLength: SupportedLength]\n): readonly E[] \| ((xs: readonly E[]) => readonly E[]) {\n switch (args.length) {\n case 3:\n return asBoundedLengthArrayImpl(...args);\n\n case 2:\n return (xs) => asBoundedLengthArrayImpl(xs, ...args);\n }\n}\n\nconst asBoundedLengthArrayImpl = <E,>(\n xs: readonly E[],\n minLength: SupportedLength,\n maxLength: SupportedLength,\n): readonly E[] => {\n const actualLength = xs.length;\n\n if (!isBoundedLengthArray(xs, minLength, maxLength)) {\n throw new TypeError(\n `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${actualLength}`,\n );\n }\n\n return xs;\n};\n\n/\n Casts an array to `NonEmptyArray<E>` after checking that it has at least one\n * element.\n \n `NonEmptyArray<E>` is an alias of `MinLengthArray<1, E>`, so this is the\n * length-1 specialization of {@link asMinLengthArray}. Use this instead of\n * writing `xs as unknown as NonEmptyArray<E>`: the length is verified at\n * runtime, and the original array type (e.g. tuple types) is preserved via\n * intersection, so the result also benefits from the structural tuple prefix\n * (`xs[0]` without `undefined` under `noUncheckedIndexedAccess`).\n \n @example\n \n ```ts\n * const history = Arr.asNonEmptyArray([0, 1, 2, 3]);\n \n const first: number = history[0]; // OK — no `undefined`\n \n // Arr.asNonEmptyArray([]); // throws TypeError\n * ```\n \n @template Xs - The input array type (tuple types are preserved).\n * @param xs - The array to cast.\n * @returns `xs` typed as `NonEmptyArray<Xs[number]> & Xs`.\n * @throws {TypeError} If `xs` is empty.\n */\nexport const asNonEmptyArray = <Xs extends readonly unknown[]>(\n xs: Xs,\n): NonEmptyArray<Xs[number]> & Xs => {\n if (!isMinLengthArray(xs, 1)) {\n throw new TypeError('Expected a non-empty array, got an empty array');\n }\n\n return xs;\n};\n"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-modification.d.mts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"array-utils-modification.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-modification.mts"],"names":[],"mappings":"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~~AA2BlC~~;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CACxB,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACnC,KAAK,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,EAEpB,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,yBAAyB,CAAC,EAAE,CAAC,EACpC,QAAQ,EAAE,CAAC,GACV,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACjC,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GACvE,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AAGlC,wBAAgB,UAAU,CAAC,KAAK,CAAC,CAAC,EAChC,KAAK,EAAE,QAAQ,CAAC,kBAAkB,EAClC,QAAQ,EAAE,CAAC,GACV,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACrC,KAAK,EAAE,EAAE,KACN,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACnC,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GACvE,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;~~AA+BlC~~,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAC3D,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,yBAAyB,CAAC,EAAE,CAAC,GACnC,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC;AAEzB,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,CAAC,kBAAkB,GACjC,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,SAAS,CAAC,EAAE,CAAC;~~AAsB5C~~;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,EACnE,KAAK,EAAE,EAAE,EACT,QAAQ,EAAE,CAAC,GACV,SAAS,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AAEvD,wBAAgB,QAAQ,CAAC,KAAK,CAAC,CAAC,EAC9B,QAAQ,EAAE,CAAC,GACV,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACrC,KAAK,EAAE,EAAE,KACN,SAAS,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;~~AAwBzD~~;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,EACtE,KAAK,EAAE,EAAE,EACT,QAAQ,EAAE,CAAC,GACV,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;AAEvD,wBAAgB,WAAW,CAAC,KAAK,CAAC,CAAC,EACjC,QAAQ,EAAE,CAAC,GACV,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACrC,KAAK,EAAE,EAAE,KACN,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;AAqBzD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,EACnE,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,CAAC,GACP,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACjC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,GACjC,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EAAE,CAAC;AAGnB,wBAAgB,QAAQ,CAAC,KAAK,CAAC,CAAC,EAC9B,KAAK,EAAE,CAAC,GACP,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACrC,KAAK,EAAE,EAAE,KACN,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACnC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,GACjC,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,CAAC,CAAC,GAChB,SAAS,CAAC,EAAE,CAAC;~~AAoBnB~~;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,EACxE,KAAK,EAAE,EAAE,EACT,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,SAAS;IAClB,KAAK,EAAE,yBAAyB,CAAC,EAAE,CAAC;IACpC,GAAG,EAAE,yBAAyB,CAAC,EAAE,CAAC;CACnC,GACA,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACjC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,GAC9C,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,GAC7B,SAAS,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;AAGlC,wBAAgB,aAAa,CAAC,KAAK,CAAC,CAAC,EACnC,KAAK,EAAE,CAAC,EACR,SAAS,EAAE,SAAS;IAClB,KAAK,EAAE,QAAQ,CAAC,kBAAkB;IAClC,GAAG,EAAE,QAAQ,CAAC,kBAAkB;CACjC,GACA,CAAC,KAAK,CAAC,EAAE,SAAS,SAAS,OAAO,EAAE,EACrC,KAAK,EAAE,EAAE,KACN,iBAAiB,CAAC,EAAE,CAAC,SAAS,IAAI,GACnC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,GAC9C,EAAE,SAAS,aAAa,CAAC,OAAO,CAAC,GAC/B,aAAa,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,GAC7B,SAAS,CAAC,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC"}
1	+ {"version":3,"file":"array-utils-modification.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-modification.mts"],"names":[],"mappings":"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"}

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

@@ -40,106 +40,97 @@ 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);
-    }
+    case 3:
+      return setImpl(...args);
+    case 2:
+      return (array) => setImpl(array, ...args);
   }
 }
+const setImpl = (array, index, newValue) => array.with(index, newValue);
 function toUpdated(...args) {
   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);
-    }
+    case 3:
+      return toUpdatedImpl(...args);
+    case 2:
+      return (array) => toUpdatedImpl(array, ...args);
   }
 }
+const toUpdatedImpl = (array, index, updater) => (
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  array.with(index, updater(array[index]))
+);
 function toInserted(...args) {
   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);
-    }
+    case 3:
+      return toInsertedImpl(...args);
+    case 2:
+      return (array) => toInsertedImpl(array, ...args);
   }
 }
+const toInsertedImpl = (array, index, newValue) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.toSpliced(
+    index,
+    0,
+    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);
-    }
+    case 2:
+      return toRemovedImpl(...args);
+    case 1:
+      return (array) => toRemovedImpl(array, ...args);
   }
 }
+const toRemovedImpl = (array, index) => array.toSpliced(index, 1);
 function toPushed(...args) {
   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);
-    }
+    case 2:
+      return toPushedImpl(...args);
+    case 1:
+      return (array) => toPushedImpl(array, ...args);
   }
 }
+const toPushedImpl = (array, newValue) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.toSpliced(array.length, 0, newValue)
+);
 function toUnshifted(...args) {
   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);
-    }
+    case 2:
+      return toUnshiftedImpl(...args);
+    case 1:
+      return (array) => toUnshiftedImpl(array, ...args);
   }
 }
+const toUnshiftedImpl = (array, newValue) => (
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  array.toSpliced(0, 0, 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);
-    }
+    case 2:
+      return toFilledImpl(...args);
+    case 1:
+      return (array) => toFilledImpl(array, ...args);
   }
 }
+const toFilledImpl = (array, value) => create(asPositiveUint32(array.length), 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);
-    }
+    case 3:
+      return toRangeFilledImpl(...args);
+    case 2:
+      return (array) => toRangeFilledImpl(array, ...args);
   }
 }
+const toRangeFilledImpl = (array, value, fillRange) => {
+  const [start, end] = fillRange;
+  const mut_cp = castMutable(copy(array));
+  mut_cp.fill(value, start, end);
+  return mut_cp;
+};
 export { set, toFilled, toInserted, toPushed, toRangeFilled, toRemoved, toUnshifted, toUpdated };
 //# sourceMappingURL=array-utils-modification.mjs.map