ts-data-forge 13.0.0 → 14.0.0

package/README.md

@@ -381,7 +381,7 @@ const sum = Arr.sum(numbers);
 assert.isTrue(sum === 20);
 
 // Type-safe length checking
-if (Arr.isMinLengthTuple(numbers, 2)) {
+if (Arr.isMinLengthTuple(2, numbers)) {
     // numbers is now guaranteed to have at least 2 elements
     expectType<typeof numbers, readonly [number, number, ...number[]]>('=');
 

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

@@ -1,4 +1,4 @@
-import { type BoolOr, type FixedLengthTuple, type Index, type IsUnion, type List, type Min, type NonEmptyArray, type NonZeroSafeIntWithSmallInt, type PositiveSafeIntWithSmallInt, type RelaxedExclude, type SafeInt, type SafeIntWithSmallInt, type SafeUint, type SafeUintWithSmallInt, type Seq, type SmallUint, type StructuralPrefixLength } from 'ts-type-forge';
+import { type BoolOr, type FixedLengthArray, type FixedLengthTuple, type Index, type IsUnion, type List, type Min, type NonEmptyArray, type NonZeroSafeIntWithSmallInt, type PositiveSafeIntWithSmallInt, type RelaxedExclude, type SafeInt, type SafeIntWithSmallInt, type SafeUint, type SafeUintWithSmallInt, type Seq, type SmallUint, type StructuralPrefixLength, type SupportedLength } from 'ts-type-forge';
 import { type SizeType } from '../../types.mjs';
 /**
  * Creates an array of zeros with the specified length.
@@ -47,7 +47,7 @@ export declare const seq: <N extends SizeType.ArgArr>(len: N) => N extends Small
  * assert.deepStrictEqual(emptyStrings, []);
  * ```
  */
-export declare const create: <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 create: <N extends SizeType.ArgArr, const V>(len: N, init: V) => N extends StructuralPrefixLength ? FixedLengthTuple<N, V> : N extends SupportedLength ? FixedLengthArray<N, V> : N extends SizeType.ArgArrPositive ? NonEmptyArray<V> : readonly V[];
 /**
  * Alias for `create`.
  *

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":"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"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-creation.mjs","sources":["../../../src/array/impl/array-utils-creation.mts"],"sourcesContent":["import {\n  type BoolOr,\n  type FixedLengthTuple,\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  type StructuralPrefixLength,\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  ? FixedLengthTuple<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 StructuralPrefixLength\n  ? FixedLengthTuple<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":";;AAsCO,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;;;;"}
+{"version":3,"file":"array-utils-creation.mjs","sources":["../../../src/array/impl/array-utils-creation.mts"],"sourcesContent":["import {\n  type BoolOr,\n  type FixedLengthArray,\n  type FixedLengthTuple,\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  type StructuralPrefixLength,\n  type SupportedLength,\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  ? FixedLengthTuple<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 StructuralPrefixLength\n  ? FixedLengthTuple<N, V>\n  : N extends SupportedLength\n    ? FixedLengthArray<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":";;AAwCO,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,EASA,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-length-bounded-array-cast.d.mts

@@ -9,13 +9,14 @@ import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, ty
  * structural tuple prefix (in-range indexed access without `undefined` under
  * `noUncheckedIndexedAccess`).
  *
- * Supports a curried overload: calling it with only `length` returns a
- * function that casts an array, which is convenient for `pipe`/`map`.
+ * The length argument comes first, matching the type-parameter order of
+ * `FixedLengthArray<Length, Elm>`. Omitting the array returns a function that
+ * casts one, which is convenient for `pipe`/`map`.
  *
  * @example
  *
  * ```ts
- * const rgb = Arr.asFixedLengthArray([255, 128, 0], 3);
+ * const rgb = Arr.asFixedLengthArray(3, [255, 128, 0]);
  *
  * const atMost5: MaxLengthArray<5, number> = rgb; // OK (3 <= 5)
  * const red: number = rgb[0]; // OK — no `undefined`
@@ -24,17 +25,17 @@ import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, ty
  * const asRgb = Arr.asFixedLengthArray(3);
  * const green = asRgb([0, 255, 0]);
  *
- * // Arr.asFixedLengthArray([255, 128], 3); // throws TypeError
+ * // Arr.asFixedLengthArray(3, [255, 128]); // throws TypeError
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template Length - The exact number of elements.
- * @param xs - The array to cast.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param length - The exact number of elements.
+ * @param xs - The array to cast.
  * @returns `xs` typed as `FixedLengthArray<Length, Xs[number]> & Xs`.
  * @throws {TypeError} If `xs.length !== length`.
  */
-export declare function asFixedLengthArray<Xs extends readonly unknown[], Length extends SupportedLength>(xs: Xs, length: Length): FixedLengthArray<Length, Xs[number]> & Xs;
+export declare function asFixedLengthArray<Length extends SupportedLength, Xs extends readonly unknown[]>(length: Length, xs: Xs): FixedLengthArray<Length, Xs[number]> & Xs;
 export declare function asFixedLengthArray<Length extends SupportedLength>(length: Length): <Xs extends readonly unknown[]>(xs: Xs) => FixedLengthArray<Length, Xs[number]> & Xs;
 /**
  * Casts an array to `MinLengthArray<MinLength, E>` after checking that it has
@@ -46,13 +47,14 @@ export declare function asFixedLengthArray<Length extends SupportedLength>(lengt
  * structural tuple prefix (indexed access below `min(N, 10)` without
  * `undefined` under `noUncheckedIndexedAccess`).
  *
- * Supports a curried overload: calling it with only `minLength` returns a
- * function that casts an array, which is convenient for `pipe`/`map`.
+ * The length argument comes first, matching the type-parameter order of
+ * `MinLengthArray<MinLength, Elm>`. Omitting the array returns a function that
+ * casts one, which is convenient for `pipe`/`map`.
  *
  * @example
  *
  * ```ts
- * const history = Arr.asMinLengthArray([0, 1, 2, 3], 3);
+ * const history = Arr.asMinLengthArray(3, [0, 1, 2, 3]);
  *
  * const nonEmpty: MinLengthArray<1, number> = history; // OK (3 >= 1)
  * const first: number = history[0]; // OK — no `undefined`
@@ -61,17 +63,17 @@ export declare function asFixedLengthArray<Length extends SupportedLength>(lengt
  * const asHistory = Arr.asMinLengthArray(3);
  * const next = asHistory([4, 5, 6, 7]);
  *
- * // Arr.asMinLengthArray([0], 3); // throws TypeError
+ * // Arr.asMinLengthArray(3, [0]); // throws TypeError
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template MinLength - The minimum number of elements (inclusive).
- * @param xs - The array to cast.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param minLength - The minimum number of elements (inclusive).
+ * @param xs - The array to cast.
  * @returns `xs` typed as `MinLengthArray<MinLength, Xs[number]> & Xs`.
  * @throws {TypeError} If `xs.length < minLength`.
  */
-export declare function asMinLengthArray<Xs extends readonly unknown[], MinLength extends SupportedLength>(xs: Xs, minLength: MinLength): MinLengthArray<MinLength, Xs[number]> & Xs;
+export declare function asMinLengthArray<MinLength extends SupportedLength, Xs extends readonly unknown[]>(minLength: MinLength, xs: Xs): MinLengthArray<MinLength, Xs[number]> & Xs;
 export declare function asMinLengthArray<MinLength extends SupportedLength>(minLength: MinLength): <Xs extends readonly unknown[]>(xs: Xs) => MinLengthArray<MinLength, Xs[number]> & Xs;
 /**
  * Casts an array to `MaxLengthArray<MaxLength, E>` after checking that it has
@@ -81,13 +83,14 @@ export declare function asMinLengthArray<MinLength extends SupportedLength>(minL
  * length is verified at runtime, and the original array type (e.g. tuple
  * types) is preserved via intersection.
  *
- * Supports a curried overload: calling it with only `maxLength` returns a
- * function that casts an array, which is convenient for `pipe`/`map`.
+ * The length argument comes first, matching the type-parameter order of
+ * `MaxLengthArray<MaxLength, Elm>`. Omitting the array returns a function that
+ * casts one, which is convenient for `pipe`/`map`.
  *
  * @example
  *
  * ```ts
- * const tags = Arr.asMaxLengthArray(['a', 'b', 'c'], 8);
+ * const tags = Arr.asMaxLengthArray(8, ['a', 'b', 'c']);
  *
  * const relaxed: MaxLengthArray<16, string> = tags; // OK (8 <= 16)
  *
@@ -95,17 +98,17 @@ export declare function asMinLengthArray<MinLength extends SupportedLength>(minL
  * const asTags = Arr.asMaxLengthArray(8);
  * const more = asTags(['d', 'e']);
  *
- * // Arr.asMaxLengthArray(['a', 'b', 'c'], 2); // throws TypeError
+ * // Arr.asMaxLengthArray(2, ['a', 'b', 'c']); // throws TypeError
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template MaxLength - The maximum number of elements (inclusive).
- * @param xs - The array to cast.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param maxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to cast.
  * @returns `xs` typed as `MaxLengthArray<MaxLength, Xs[number]> & Xs`.
  * @throws {TypeError} If `xs.length > maxLength`.
  */
-export declare function asMaxLengthArray<Xs extends readonly unknown[], MaxLength extends SupportedLength>(xs: Xs, maxLength: MaxLength): MaxLengthArray<MaxLength, Xs[number]> & Xs;
+export declare function asMaxLengthArray<MaxLength extends SupportedLength, Xs extends readonly unknown[]>(maxLength: MaxLength, xs: Xs): MaxLengthArray<MaxLength, Xs[number]> & Xs;
 export declare function asMaxLengthArray<MaxLength extends SupportedLength>(maxLength: MaxLength): <Xs extends readonly unknown[]>(xs: Xs) => MaxLengthArray<MaxLength, Xs[number]> & Xs;
 /**
  * Casts an array to `BoundedLengthArray<MinLength, MaxLength, E>` after
@@ -117,14 +120,14 @@ export declare function asMaxLengthArray<MaxLength extends SupportedLength>(maxL
  * at runtime, and the original array type (e.g. tuple types) is preserved via
  * intersection.
  *
- * Supports a curried overload: calling it with only `minLength` and
- * `maxLength` returns a function that casts an array, which is convenient for
- * `pipe`/`map`.
+ * The length arguments come first, matching the type-parameter order of
+ * `BoundedLengthArray<MinLength, MaxLength, Elm>`. Omitting the array returns a
+ * function that casts one, which is convenient for `pipe`/`map`.
  *
  * @example
  *
  * ```ts
- * const selection = Arr.asBoundedLengthArray([1, 2, 3], 1, 5);
+ * const selection = Arr.asBoundedLengthArray(1, 5, [1, 2, 3]);
  *
  * const relaxed: BoundedLengthArray<0, 100, number> = selection; // OK
  *
@@ -132,21 +135,45 @@ export declare function asMaxLengthArray<MaxLength extends SupportedLength>(maxL
  * const asSelection = Arr.asBoundedLengthArray(1, 5);
  * const next = asSelection([4, 5]);
  *
- * // Arr.asBoundedLengthArray([], 1, 5); // throws TypeError
+ * // Arr.asBoundedLengthArray(1, 5, []); // throws TypeError
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template MinLength - The minimum number of elements (inclusive).
  * @template MaxLength - The maximum number of elements (inclusive).
- * @param xs - The array to cast.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param minLength - The minimum number of elements (inclusive).
  * @param maxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to cast.
  * @returns `xs` typed as
  *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.
  * @throws {TypeError} If `xs.length < minLength || xs.length > maxLength`.
  */
-export declare function asBoundedLengthArray<Xs extends readonly unknown[], MinLength extends SupportedLength, MaxLength extends SupportedLength>(xs: Xs, minLength: MinLength, maxLength: MaxLength): BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+export declare function asBoundedLengthArray<MinLength extends SupportedLength, MaxLength extends SupportedLength, Xs extends readonly unknown[]>(minLength: MinLength, maxLength: MaxLength, xs: Xs): BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
 export declare function asBoundedLengthArray<MinLength extends SupportedLength, MaxLength extends SupportedLength>(minLength: MinLength, maxLength: MaxLength): <Xs extends readonly unknown[]>(xs: Xs) => BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+/**
+ * Casts an array to `FixedLengthArray<0, E>` after checking that it is empty.
+ *
+ * `Arr.isEmpty` narrows to that same type, so this is its cast counterpart —
+ * the length-0 specialization of {@link asFixedLengthArray}. Use this instead
+ * of writing `xs as unknown as FixedLengthArray<0, E>`: the length is verified
+ * at runtime, and the original array type is preserved via intersection.
+ *
+ * @example
+ *
+ * ```ts
+ * const nothing = Arr.asEmptyArray([]);
+ *
+ * const atMost5: MaxLengthArray<5, never> = nothing; // OK (0 <= 5)
+ *
+ * // Arr.asEmptyArray([1]); // throws TypeError
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @param xs - The array to cast.
+ * @returns `xs` typed as `FixedLengthArray<0, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs` is not empty.
+ */
+export declare const asEmptyArray: <Xs extends readonly unknown[]>(xs: Xs) => FixedLengthArray<0, Xs[number]> & Xs;
 /**
  * Casts an array to `NonEmptyArray<E>` after checking that it has at least one
  * element.

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

@@ -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":"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"}
+{"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

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

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

@@ -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      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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"}
+{"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 * The length argument comes first, matching the type-parameter order of\n * `FixedLengthArray<Length, Elm>`. Omitting the array returns a function that\n * casts one, which is convenient for `pipe`/`map`.\n *\n * @example\n *\n * ```ts\n * const rgb = Arr.asFixedLengthArray(3, [255, 128, 0]);\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(3, [255, 128]); // throws TypeError\n * ```\n *\n * @template Length - The exact number of elements.\n * @template Xs - The input array type (tuple types are preserved).\n * @param length - The exact number of elements.\n * @param xs - The array to cast.\n * @returns `xs` typed as `FixedLengthArray<Length, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length !== length`.\n */\nexport function asFixedLengthArray<\n  Length extends SupportedLength,\n  Xs extends readonly unknown[],\n>(length: Length, xs: Xs): 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 [length: SupportedLength, xs: readonly E[]]\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(args[0], xs);\n  }\n}\n\nconst asFixedLengthArrayImpl = <E,>(\n  length: SupportedLength,\n  xs: readonly E[],\n): readonly E[] => {\n  const actualLength = xs.length;\n\n  if (!isFixedLengthArray(length, xs)) {\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 * The length argument comes first, matching the type-parameter order of\n * `MinLengthArray<MinLength, Elm>`. Omitting the array returns a function that\n * casts one, which is convenient for `pipe`/`map`.\n *\n * @example\n *\n * ```ts\n * const history = Arr.asMinLengthArray(3, [0, 1, 2, 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(3, [0]); // throws TypeError\n * ```\n *\n * @template MinLength - The minimum number of elements (inclusive).\n * @template Xs - The input array type (tuple types are preserved).\n * @param minLength - The minimum number of elements (inclusive).\n * @param xs - The array to cast.\n * @returns `xs` typed as `MinLengthArray<MinLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength`.\n */\nexport function asMinLengthArray<\n  MinLength extends SupportedLength,\n  Xs extends readonly unknown[],\n>(minLength: MinLength, xs: Xs): 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 [minLength: SupportedLength, xs: readonly E[]]\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(args[0], xs);\n  }\n}\n\nconst asMinLengthArrayImpl = <E,>(\n  minLength: SupportedLength,\n  xs: readonly E[],\n): readonly E[] => {\n  const actualLength = xs.length;\n\n  if (!isMinLengthArray(minLength, xs)) {\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 * The length argument comes first, matching the type-parameter order of\n * `MaxLengthArray<MaxLength, Elm>`. Omitting the array returns a function that\n * casts one, which is convenient for `pipe`/`map`.\n *\n * @example\n *\n * ```ts\n * const tags = Arr.asMaxLengthArray(8, ['a', 'b', 'c']);\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(2, ['a', 'b', 'c']); // throws TypeError\n * ```\n *\n * @template MaxLength - The maximum number of elements (inclusive).\n * @template Xs - The input array type (tuple types are preserved).\n * @param maxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @returns `xs` typed as `MaxLengthArray<MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length > maxLength`.\n */\nexport function asMaxLengthArray<\n  MaxLength extends SupportedLength,\n  Xs extends readonly unknown[],\n>(maxLength: MaxLength, xs: Xs): 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 [maxLength: SupportedLength, xs: readonly E[]]\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(args[0], xs);\n  }\n}\n\nconst asMaxLengthArrayImpl = <E,>(\n  maxLength: SupportedLength,\n  xs: readonly E[],\n): readonly E[] => {\n  const actualLength = xs.length;\n\n  if (!isMaxLengthArray(maxLength, xs)) {\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 * The length arguments come first, matching the type-parameter order of\n * `BoundedLengthArray<MinLength, MaxLength, Elm>`. Omitting the array returns a\n * function that casts one, which is convenient for `pipe`/`map`.\n *\n * @example\n *\n * ```ts\n * const selection = Arr.asBoundedLengthArray(1, 5, [1, 2, 3]);\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 MinLength - The minimum number of elements (inclusive).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @template Xs - The input array type (tuple types are preserved).\n * @param minLength - The minimum number of elements (inclusive).\n * @param maxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\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  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n  Xs extends readonly unknown[],\n>(\n  minLength: MinLength,\n  maxLength: MaxLength,\n  xs: Xs,\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        minLength: SupportedLength,\n        maxLength: SupportedLength,\n        xs: readonly E[],\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(args[0], args[1], xs);\n  }\n}\n\nconst asBoundedLengthArrayImpl = <E,>(\n  minLength: SupportedLength,\n  maxLength: SupportedLength,\n  xs: readonly E[],\n): readonly E[] => {\n  const actualLength = xs.length;\n\n  if (!isBoundedLengthArray(minLength, maxLength, xs)) {\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 `FixedLengthArray<0, E>` after checking that it is empty.\n *\n * `Arr.isEmpty` narrows to that same type, so this is its cast counterpart —\n * the length-0 specialization of {@link asFixedLengthArray}. Use this instead\n * of writing `xs as unknown as FixedLengthArray<0, E>`: the length is verified\n * at runtime, and the original array type is preserved via intersection.\n *\n * @example\n *\n * ```ts\n * const nothing = Arr.asEmptyArray([]);\n *\n * const atMost5: MaxLengthArray<5, never> = nothing; // OK (0 <= 5)\n *\n * // Arr.asEmptyArray([1]); // 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 `FixedLengthArray<0, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs` is not empty.\n */\nexport const asEmptyArray = <Xs extends readonly unknown[]>(\n  xs: Xs,\n): FixedLengthArray<0, Xs[number]> & Xs => {\n  if (!isFixedLengthArray(0, xs)) {\n    throw new TypeError(\n      `Expected an empty array, got an array of length ${xs.length}`,\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(1, xs)) {\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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"}