ts-data-forge 12.2.2 → 14.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"array-utils-length-bounded-tuple-cast.mjs","sources":["../../../src/array/impl/array-utils-length-bounded-tuple-cast.mts"],"sourcesContent":["import {\n  type BoundedLengthTuple,\n  type FixedLengthTuple,\n  type MaxLengthTuple,\n  type MinLengthTuple,\n} from 'ts-type-forge';\nimport { type SizeType } from '../../types.mjs';\nimport {\n  isBoundedLengthTuple,\n  isEmptyTuple,\n  isFixedLengthTuple,\n  isMaxLengthTuple,\n  isMinLengthTuple,\n} from './array-utils-length-bounded-tuple-guard.mjs';\n\n/**\n * Casts an array to `FixedLengthTuple<Length, E>` after checking that it has\n * exactly `length` elements.\n *\n * This is the structural counterpart of `asFixedLengthArray`: it produces a\n * tuple type rather than the branded `FixedLengthArray`. Prefer the branded\n * one unless you specifically need the structural type — the brand keeps\n * type-checking cost independent of the element type and of the bound.\n *\n * The length argument comes first, matching the type-parameter order of\n * `FixedLengthTuple<Length, Elm>`. Omitting the array returns a function that\n * casts one.\n *\n * @example\n *\n * ```ts\n * const rgb = Arr.asFixedLengthTuple(3, [255, 128, 0]);\n *\n * const red: number = rgb[0]; // OK — no `undefined`\n *\n * // curried version\n * const asRgb = Arr.asFixedLengthTuple(3);\n *\n * // Arr.asFixedLengthTuple(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 `FixedLengthTuple<Length, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length !== length`.\n */\nexport function asFixedLengthTuple<\n  Length extends SizeType.ArgArr,\n  Xs extends readonly unknown[],\n>(length: Length, xs: Xs): FixedLengthTuple<Length, Xs[number]> & Xs;\n\n// Curried version\nexport function asFixedLengthTuple<Length extends SizeType.ArgArr>(\n  length: Length,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => FixedLengthTuple<Length, Xs[number]> & Xs;\n\nexport function asFixedLengthTuple(\n  ...args:\n    | readonly [length: SizeType.ArgArr, xs: readonly unknown[]]\n    | readonly [length: SizeType.ArgArr]\n): readonly unknown[] | ((xs: readonly unknown[]) => readonly unknown[]) {\n  switch (args.length) {\n    case 2:\n      return asFixedLengthTupleImpl(...args);\n\n    case 1:\n      return (xs) => asFixedLengthTupleImpl(args[0], xs);\n  }\n}\n\nconst asFixedLengthTupleImpl = (\n  length: SizeType.ArgArr,\n  xs: readonly unknown[],\n): readonly unknown[] => {\n  const actualLength = xs.length;\n\n  if (!isFixedLengthTuple(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 `MinLengthTuple<MinLength, E>` after checking that it has\n * at least `minLength` elements.\n *\n * This is the structural counterpart of `asMinLengthArray`; see\n * {@link asFixedLengthTuple} for when to prefer which.\n *\n * @example\n *\n * ```ts\n * const history = Arr.asMinLengthTuple(3, [0, 1, 2, 3]);\n *\n * const first: number = history[0]; // OK — no `undefined`\n *\n * // curried version\n * const asHistory = Arr.asMinLengthTuple(3);\n *\n * // Arr.asMinLengthTuple(3, [0, 1]); // 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 `MinLengthTuple<MinLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength`.\n */\nexport function asMinLengthTuple<\n  MinLength extends SizeType.ArgArr,\n  Xs extends readonly unknown[],\n>(minLength: MinLength, xs: Xs): MinLengthTuple<MinLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asMinLengthTuple<MinLength extends SizeType.ArgArr>(\n  minLength: MinLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => MinLengthTuple<MinLength, Xs[number]> & Xs;\n\nexport function asMinLengthTuple(\n  ...args:\n    | readonly [minLength: SizeType.ArgArr, xs: readonly unknown[]]\n    | readonly [minLength: SizeType.ArgArr]\n): readonly unknown[] | ((xs: readonly unknown[]) => readonly unknown[]) {\n  switch (args.length) {\n    case 2:\n      return asMinLengthTupleImpl(...args);\n\n    case 1:\n      return (xs) => asMinLengthTupleImpl(args[0], xs);\n  }\n}\n\nconst asMinLengthTupleImpl = (\n  minLength: SizeType.ArgArr,\n  xs: readonly unknown[],\n): readonly unknown[] => {\n  const actualLength = xs.length;\n\n  if (!isMinLengthTuple(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 `MaxLengthTuple<MaxLength, E>` after checking that it has\n * at most `maxLength` elements.\n *\n * This is the structural counterpart of `asMaxLengthArray`; see\n * {@link asFixedLengthTuple} for when to prefer which.\n *\n * @example\n *\n * ```ts\n * const tags = Arr.asMaxLengthTuple(8, ['a', 'b', 'c']);\n *\n * // curried version\n * const asTags = Arr.asMaxLengthTuple(8);\n *\n * // Arr.asMaxLengthTuple(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 `MaxLengthTuple<MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length > maxLength`.\n */\nexport function asMaxLengthTuple<\n  MaxLength extends SizeType.ArgArr,\n  Xs extends readonly unknown[],\n>(maxLength: MaxLength, xs: Xs): MaxLengthTuple<MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asMaxLengthTuple<MaxLength extends SizeType.ArgArr>(\n  maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => MaxLengthTuple<MaxLength, Xs[number]> & Xs;\n\nexport function asMaxLengthTuple(\n  ...args:\n    | readonly [maxLength: SizeType.ArgArr, xs: readonly unknown[]]\n    | readonly [maxLength: SizeType.ArgArr]\n): readonly unknown[] | ((xs: readonly unknown[]) => readonly unknown[]) {\n  switch (args.length) {\n    case 2:\n      return asMaxLengthTupleImpl(...args);\n\n    case 1:\n      return (xs) => asMaxLengthTupleImpl(args[0], xs);\n  }\n}\n\nconst asMaxLengthTupleImpl = (\n  maxLength: SizeType.ArgArr,\n  xs: readonly unknown[],\n): readonly unknown[] => {\n  const actualLength = xs.length;\n\n  if (!isMaxLengthTuple(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 `BoundedLengthTuple<Min, Max, E>` after checking that its\n * length is within the inclusive range `[min, max]`.\n *\n * This is the structural counterpart of `asBoundedLengthArray`; see\n * {@link asFixedLengthTuple} for when to prefer which.\n *\n * @example\n *\n * ```ts\n * const selection = Arr.asBoundedLengthTuple(1, 5, [1, 2, 3]);\n *\n * // curried version\n * const asSelection = Arr.asBoundedLengthTuple(1, 5);\n *\n * // Arr.asBoundedLengthTuple(1, 2, [1, 2, 3]); // throws TypeError\n * ```\n *\n * @template Min - The minimum number of elements (inclusive).\n * @template Max - The maximum number of elements (inclusive).\n * @template Xs - The input array type (tuple types are preserved).\n * @param min - The minimum number of elements (inclusive).\n * @param max - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @returns `xs` typed as `BoundedLengthTuple<Min, Max, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length` is outside `[min, max]`.\n */\nexport function asBoundedLengthTuple<\n  Min extends SizeType.ArgArr,\n  Max extends SizeType.ArgArr,\n  Xs extends readonly unknown[],\n>(min: Min, max: Max, xs: Xs): BoundedLengthTuple<Min, Max, Xs[number]> & Xs;\n\n// Curried version\nexport function asBoundedLengthTuple<\n  Min extends SizeType.ArgArr,\n  Max extends SizeType.ArgArr,\n>(\n  min: Min,\n  max: Max,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => BoundedLengthTuple<Min, Max, Xs[number]> & Xs;\n\nexport function asBoundedLengthTuple(\n  ...args:\n    | readonly [\n        min: SizeType.ArgArr,\n        max: SizeType.ArgArr,\n        xs: readonly unknown[],\n      ]\n    | readonly [min: SizeType.ArgArr, max: SizeType.ArgArr]\n): readonly unknown[] | ((xs: readonly unknown[]) => readonly unknown[]) {\n  switch (args.length) {\n    case 3:\n      return asBoundedLengthTupleImpl(...args);\n\n    case 2:\n      return (xs) => asBoundedLengthTupleImpl(...args, xs);\n  }\n}\n\nconst asBoundedLengthTupleImpl = (\n  min: SizeType.ArgArr,\n  max: SizeType.ArgArr,\n  xs: readonly unknown[],\n): readonly unknown[] => {\n  const actualLength = xs.length;\n\n  if (!isBoundedLengthTuple(min, max, xs)) {\n    throw new TypeError(\n      `Expected an array of length in [${min}, ${max}], got an array of length ${actualLength}`,\n    );\n  }\n\n  return xs;\n};\n\n/**\n * Casts an array to the structural empty tuple after checking that it is\n * empty.\n *\n * This is the structural counterpart of `asEmptyArray`, and the length-0\n * specialization of {@link asFixedLengthTuple}.\n *\n * @example\n *\n * ```ts\n * const nothing = Arr.asEmptyTuple([]);\n *\n * // Arr.asEmptyTuple([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 `readonly [] & Xs`.\n * @throws {TypeError} If `xs` is not empty.\n */\nexport const asEmptyTuple = <Xs extends readonly unknown[]>(\n  xs: Xs,\n): readonly [] & Xs => {\n  if (!isEmptyTuple(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 `MinLengthTuple<1, E>` after checking that it has at least\n * one element.\n *\n * This is the structural counterpart of `asNonEmptyArray`, and the length-1\n * specialization of {@link asMinLengthTuple}.\n *\n * @example\n *\n * ```ts\n * const values = Arr.asNonEmptyTuple([1, 2, 3]);\n *\n * const first: number = values[0]; // OK — no `undefined`\n *\n * // Arr.asNonEmptyTuple([]); // 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 `MinLengthTuple<1, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs` is empty.\n */\nexport const asNonEmptyTuple = <Xs extends readonly unknown[]>(\n  xs: Xs,\n): MinLengthTuple<1, Xs[number]> & Xs => {\n  if (!isMinLengthTuple(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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"}

package/dist/array/impl/array-utils-length-bounded-tuple-guard.d.mts

@@ -0,0 +1,135 @@
+import { type BoundedLengthTuple, type FixedLengthTuple, type MaxLengthTuple, type MinLengthTuple } from 'ts-type-forge';
+import { type SizeType } from '../../types.mjs';
+/**
+ * Type guard that checks if an array is empty, narrowing it to the structural
+ * empty tuple.
+ *
+ * This is the structural counterpart of `isEmpty`: it narrows to `readonly []`
+ * rather than to the branded `FixedLengthArray<0, E>`. Prefer `isEmpty` unless
+ * you specifically need the structural type.
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly number[] = [] as const;
+ *
+ * assert.isTrue(Arr.isEmptyTuple(values));
+ *
+ * assert.isFalse(Arr.isEmptyTuple([1] as const));
+ * ```
+ *
+ * @template E - The element type.
+ * @param array - The array to check.
+ * @returns `true` if `array.length === 0`. When `true`, TypeScript narrows
+ *   `array` to `readonly []`.
+ */
+export declare const isEmptyTuple: <E>(array: readonly E[]) => array is readonly [];
+/**
+ * Type guard that checks if an array is non-empty, narrowing it to the
+ * structural non-empty tuple.
+ *
+ * This is the structural counterpart of `isNonEmpty`: it narrows to
+ * `MinLengthTuple<1, E>` rather than to the branded `MinLengthArray<1, E>`.
+ * Prefer `isNonEmpty` unless you specifically need the structural type.
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly number[] = [1, 2] as const;
+ *
+ * assert.isTrue(Arr.isNonEmptyTuple(values));
+ *
+ * assert.isFalse(Arr.isNonEmptyTuple([] as const));
+ * ```
+ *
+ * @template E - The element type.
+ * @param array - The array to check.
+ * @returns `true` if `array.length >= 1`. When `true`, TypeScript narrows
+ *   `array` to `MinLengthTuple<1, E>`.
+ */
+export declare const isNonEmptyTuple: <E>(array: readonly E[]) => array is MinLengthTuple<1, E>;
+/**
+ * Checks if an array has a specific length.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const triple: readonly number[] = [1, 2, 3] as const;
+ *
+ * assert.isTrue(Arr.isFixedLengthTuple(2, pair));
+ *
+ * assert.isFalse(Arr.isFixedLengthTuple(2, triple));
+ *
+ * if (Arr.isFixedLengthTuple(2, pair)) {
+ *   assert.deepStrictEqual(pair, [1, 2]);
+ * }
+ * ```
+ */
+export declare function isFixedLengthTuple<N extends SizeType.ArgArr, E>(len: N, array: readonly E[]): array is FixedLengthTuple<N, E>;
+export declare function isFixedLengthTuple<N extends SizeType.ArgArr>(len: N): <E>(array: readonly E[]) => array is FixedLengthTuple<N, E>;
+/**
+ * Checks if an array has at least a specific length.
+ *
+ * @example
+ *
+ * ```ts
+ * const queue: readonly string[] = ['task-1', 'task-2'] as const;
+ *
+ * const emptyQueue: readonly string[] = [] as const;
+ *
+ * assert.isTrue(Arr.isMinLengthTuple(1, queue));
+ *
+ * assert.isFalse(Arr.isMinLengthTuple(1, emptyQueue));
+ *
+ * if (Arr.isMinLengthTuple(1, queue)) {
+ *   assert.isTrue(queue[0] === 'task-1');
+ * }
+ * ```
+ */
+export declare function isMinLengthTuple<N extends SizeType.ArgArr, E>(len: N, array: readonly E[]): array is MinLengthTuple<N, E>;
+export declare function isMinLengthTuple<N extends SizeType.ArgArr>(len: N): <E>(array: readonly E[]) => array is MinLengthTuple<N, E>;
+/**
+ * Checks if an array has at most a specific length.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const triple: readonly number[] = [1, 2, 3] as const;
+ *
+ * assert.isTrue(Arr.isMaxLengthTuple(2, pair));
+ *
+ * assert.isFalse(Arr.isMaxLengthTuple(2, triple));
+ *
+ * if (Arr.isMaxLengthTuple(2, pair)) {
+ *   assert.isTrue(pair.length <= 2);
+ * }
+ * ```
+ */
+export declare function isMaxLengthTuple<N extends SizeType.ArgArr, E>(len: N, array: readonly E[]): array is MaxLengthTuple<N, E>;
+export declare function isMaxLengthTuple<N extends SizeType.ArgArr>(len: N): <E>(array: readonly E[]) => array is MaxLengthTuple<N, E>;
+/**
+ * Checks if an array's length is within a specific inclusive range.
+ *
+ * @example
+ *
+ * ```ts
+ * const pair: readonly number[] = [1, 2] as const;
+ *
+ * const quad: readonly number[] = [1, 2, 3, 4] as const;
+ *
+ * assert.isTrue(Arr.isBoundedLengthTuple(1, 3, pair));
+ *
+ * assert.isFalse(Arr.isBoundedLengthTuple(1, 3, quad));
+ *
+ * if (Arr.isBoundedLengthTuple(1, 3, pair)) {
+ *   assert.isTrue(pair.length >= 1 && pair.length <= 3);
+ * }
+ * ```
+ */
+export declare function isBoundedLengthTuple<Min extends SizeType.ArgArr, Max extends SizeType.ArgArr, E>(min: Min, max: Max, array: readonly E[]): array is BoundedLengthTuple<Min, Max, E>;
+export declare function isBoundedLengthTuple<Min extends SizeType.ArgArr, Max extends SizeType.ArgArr>(min: Min, max: Max): <E>(array: readonly E[]) => array is BoundedLengthTuple<Min, Max, E>;
+//# sourceMappingURL=array-utils-length-bounded-tuple-guard.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array-utils-length-bounded-tuple-guard.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-length-bounded-tuple-guard.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAU,SAAS,CAAC,EAAE,KAAG,KAAK,IAAI,SAAS,EACrD,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,SACxB,SAAS,CAAC,EAAE,KAClB,KAAK,IAAI,cAAc,CAAC,CAAC,EAAE,CAAC,CAAsB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,EAAE,CAAC,EAC7D,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,SAAS,CAAC,EAAE,GAClB,KAAK,IAAI,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAGnC,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,EAC1D,GAAG,EAAE,CAAC,GACL,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,KAAK,IAAI,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAqB/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,EAAE,CAAC,EAC3D,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,SAAS,CAAC,EAAE,GAClB,KAAK,IAAI,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAGjC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,EACxD,GAAG,EAAE,CAAC,GACL,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,KAAK,IAAI,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAqB7D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,EAAE,CAAC,EAC3D,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,SAAS,CAAC,EAAE,GAClB,KAAK,IAAI,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAGjC,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,EACxD,GAAG,EAAE,CAAC,GACL,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,KAAK,IAAI,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAqB7D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,SAAS,QAAQ,CAAC,MAAM,EAC3B,GAAG,SAAS,QAAQ,CAAC,MAAM,EAC3B,CAAC,EAED,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,SAAS,CAAC,EAAE,GAClB,KAAK,IAAI,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;AAG5C,wBAAgB,oBAAoB,CAClC,GAAG,SAAS,QAAQ,CAAC,MAAM,EAC3B,GAAG,SAAS,QAAQ,CAAC,MAAM,EAE3B,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,GAAG,GACP,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,KAAK,KAAK,IAAI,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC"}

package/dist/array/impl/array-utils-length-bounded-tuple-guard.mjs

@@ -0,0 +1,41 @@
+const isEmptyTuple = (array) => array.length === 0;
+const isNonEmptyTuple = (array) => array.length >= 1;
+function isFixedLengthTuple(...args) {
+  switch (args.length) {
+    case 2:
+      return hasFixedLength(args[0], args[1]);
+    case 1:
+      return (array) => hasFixedLength(args[0], array);
+  }
+}
+const hasFixedLength = (len, array) => array.length === len;
+function isMinLengthTuple(...args) {
+  switch (args.length) {
+    case 2:
+      return hasMinLength(args[0], args[1]);
+    case 1:
+      return (array) => hasMinLength(args[0], array);
+  }
+}
+const hasMinLength = (len, array) => array.length >= len;
+function isMaxLengthTuple(...args) {
+  switch (args.length) {
+    case 2:
+      return hasMaxLength(args[0], args[1]);
+    case 1:
+      return (array) => hasMaxLength(args[0], array);
+  }
+}
+const hasMaxLength = (len, array) => array.length <= len;
+function isBoundedLengthTuple(...args) {
+  switch (args.length) {
+    case 3:
+      return isWithinBounds(args[0], args[1], args[2]);
+    case 2:
+      return (array) => isWithinBounds(args[0], args[1], array);
+  }
+}
+const isWithinBounds = (min, max, array) => array.length >= min && array.length <= max;
+
+export { isBoundedLengthTuple, isEmptyTuple, isFixedLengthTuple, isMaxLengthTuple, isMinLengthTuple, isNonEmptyTuple };
+//# sourceMappingURL=array-utils-length-bounded-tuple-guard.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array-utils-length-bounded-tuple-guard.mjs","sources":["../../../src/array/impl/array-utils-length-bounded-tuple-guard.mts"],"sourcesContent":["import {\n  type BoundedLengthTuple,\n  type FixedLengthTuple,\n  type MaxLengthTuple,\n  type MinLengthTuple,\n} from 'ts-type-forge';\nimport { type SizeType } from '../../types.mjs';\n\n/**\n * Type guard that checks if an array is empty, narrowing it to the structural\n * empty tuple.\n *\n * This is the structural counterpart of `isEmpty`: it narrows to `readonly []`\n * rather than to the branded `FixedLengthArray<0, E>`. Prefer `isEmpty` unless\n * you specifically need the structural type.\n *\n * @example\n *\n * ```ts\n * const values: readonly number[] = [] as const;\n *\n * assert.isTrue(Arr.isEmptyTuple(values));\n *\n * assert.isFalse(Arr.isEmptyTuple([1] as const));\n * ```\n *\n * @template E - The element type.\n * @param array - The array to check.\n * @returns `true` if `array.length === 0`. When `true`, TypeScript narrows\n *   `array` to `readonly []`.\n */\nexport const isEmptyTuple = <E,>(array: readonly E[]): array is readonly [] =>\n  array.length === 0;\n\n/**\n * Type guard that checks if an array is non-empty, narrowing it to the\n * structural non-empty tuple.\n *\n * This is the structural counterpart of `isNonEmpty`: it narrows to\n * `MinLengthTuple<1, E>` rather than to the branded `MinLengthArray<1, E>`.\n * Prefer `isNonEmpty` unless you specifically need the structural type.\n *\n * @example\n *\n * ```ts\n * const values: readonly number[] = [1, 2] as const;\n *\n * assert.isTrue(Arr.isNonEmptyTuple(values));\n *\n * assert.isFalse(Arr.isNonEmptyTuple([] as const));\n * ```\n *\n * @template E - The element type.\n * @param array - The array to check.\n * @returns `true` if `array.length >= 1`. When `true`, TypeScript narrows\n *   `array` to `MinLengthTuple<1, E>`.\n */\nexport const isNonEmptyTuple = <E,>(\n  array: readonly E[],\n): array is MinLengthTuple<1, E> => array.length >= 1;\n\n/**\n * Checks if an array has a specific length.\n *\n * @example\n *\n * ```ts\n * const pair: readonly number[] = [1, 2] as const;\n *\n * const triple: readonly number[] = [1, 2, 3] as const;\n *\n * assert.isTrue(Arr.isFixedLengthTuple(2, pair));\n *\n * assert.isFalse(Arr.isFixedLengthTuple(2, triple));\n *\n * if (Arr.isFixedLengthTuple(2, pair)) {\n *   assert.deepStrictEqual(pair, [1, 2]);\n * }\n * ```\n */\nexport function isFixedLengthTuple<N extends SizeType.ArgArr, E>(\n  len: N,\n  array: readonly E[],\n): array is FixedLengthTuple<N, E>;\n\n// Curried version\nexport function isFixedLengthTuple<N extends SizeType.ArgArr>(\n  len: N,\n): <E>(array: readonly E[]) => array is FixedLengthTuple<N, E>;\n\nexport function isFixedLengthTuple(\n  ...args:\n    | readonly [len: SizeType.ArgArr, array: readonly unknown[]]\n    | readonly [len: SizeType.ArgArr]\n): boolean | ((array: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return hasFixedLength(args[0], args[1]);\n\n    case 1:\n      return (array) => hasFixedLength(args[0], array);\n  }\n}\n\nconst hasFixedLength = (\n  len: SizeType.ArgArr,\n  array: readonly unknown[],\n): boolean => array.length === len;\n\n/**\n * Checks if an array has at least a specific length.\n *\n * @example\n *\n * ```ts\n * const queue: readonly string[] = ['task-1', 'task-2'] as const;\n *\n * const emptyQueue: readonly string[] = [] as const;\n *\n * assert.isTrue(Arr.isMinLengthTuple(1, queue));\n *\n * assert.isFalse(Arr.isMinLengthTuple(1, emptyQueue));\n *\n * if (Arr.isMinLengthTuple(1, queue)) {\n *   assert.isTrue(queue[0] === 'task-1');\n * }\n * ```\n */\nexport function isMinLengthTuple<N extends SizeType.ArgArr, E>(\n  len: N,\n  array: readonly E[],\n): array is MinLengthTuple<N, E>;\n\n// Curried version\nexport function isMinLengthTuple<N extends SizeType.ArgArr>(\n  len: N,\n): <E>(array: readonly E[]) => array is MinLengthTuple<N, E>;\n\nexport function isMinLengthTuple(\n  ...args:\n    | readonly [len: SizeType.ArgArr, array: readonly unknown[]]\n    | readonly [len: SizeType.ArgArr]\n): boolean | ((array: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return hasMinLength(args[0], args[1]);\n\n    case 1:\n      return (array) => hasMinLength(args[0], array);\n  }\n}\n\nconst hasMinLength = (\n  len: SizeType.ArgArr,\n  array: readonly unknown[],\n): boolean => array.length >= len;\n\n/**\n * Checks if an array has at most a specific length.\n *\n * @example\n *\n * ```ts\n * const pair: readonly number[] = [1, 2] as const;\n *\n * const triple: readonly number[] = [1, 2, 3] as const;\n *\n * assert.isTrue(Arr.isMaxLengthTuple(2, pair));\n *\n * assert.isFalse(Arr.isMaxLengthTuple(2, triple));\n *\n * if (Arr.isMaxLengthTuple(2, pair)) {\n *   assert.isTrue(pair.length <= 2);\n * }\n * ```\n */\nexport function isMaxLengthTuple<N extends SizeType.ArgArr, E>(\n  len: N,\n  array: readonly E[],\n): array is MaxLengthTuple<N, E>;\n\n// Curried version\nexport function isMaxLengthTuple<N extends SizeType.ArgArr>(\n  len: N,\n): <E>(array: readonly E[]) => array is MaxLengthTuple<N, E>;\n\nexport function isMaxLengthTuple(\n  ...args:\n    | readonly [len: SizeType.ArgArr, array: readonly unknown[]]\n    | readonly [len: SizeType.ArgArr]\n): boolean | ((array: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return hasMaxLength(args[0], args[1]);\n\n    case 1:\n      return (array) => hasMaxLength(args[0], array);\n  }\n}\n\nconst hasMaxLength = (\n  len: SizeType.ArgArr,\n  array: readonly unknown[],\n): boolean => array.length <= len;\n\n/**\n * Checks if an array's length is within a specific inclusive range.\n *\n * @example\n *\n * ```ts\n * const pair: readonly number[] = [1, 2] as const;\n *\n * const quad: readonly number[] = [1, 2, 3, 4] as const;\n *\n * assert.isTrue(Arr.isBoundedLengthTuple(1, 3, pair));\n *\n * assert.isFalse(Arr.isBoundedLengthTuple(1, 3, quad));\n *\n * if (Arr.isBoundedLengthTuple(1, 3, pair)) {\n *   assert.isTrue(pair.length >= 1 && pair.length <= 3);\n * }\n * ```\n */\nexport function isBoundedLengthTuple<\n  Min extends SizeType.ArgArr,\n  Max extends SizeType.ArgArr,\n  E,\n>(\n  min: Min,\n  max: Max,\n  array: readonly E[],\n): array is BoundedLengthTuple<Min, Max, E>;\n\n// Curried version\nexport function isBoundedLengthTuple<\n  Min extends SizeType.ArgArr,\n  Max extends SizeType.ArgArr,\n>(\n  min: Min,\n  max: Max,\n): <E>(array: readonly E[]) => array is BoundedLengthTuple<Min, Max, E>;\n\nexport function isBoundedLengthTuple(\n  ...args:\n    | readonly [\n        min: SizeType.ArgArr,\n        max: SizeType.ArgArr,\n        array: readonly unknown[],\n      ]\n    | readonly [min: SizeType.ArgArr, max: SizeType.ArgArr]\n): boolean | ((array: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 3:\n      return isWithinBounds(args[0], args[1], args[2]);\n\n    case 2:\n      return (array) => isWithinBounds(args[0], args[1], array);\n  }\n}\n\nconst isWithinBounds = (\n  min: SizeType.ArgArr,\n  max: SizeType.ArgArr,\n  array: readonly unknown[],\n): boolean => array.length >= min && array.length <= max;\n"],"names":[],"mappings":"AA+BO,MAAM,YAAA,GAAe,CAAK,KAAA,KAC/B,KAAA,CAAM,MAAA,KAAW;AAyBZ,MAAM,eAAA,GAAkB,CAC7B,KAAA,KACkC,KAAA,CAAM,MAAA,IAAU;AA+B7C,SAAS,sBACX,IAAA,EAGiD;AACpD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,eAAe,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AAAA,IAExC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,cAAA,CAAe,IAAA,CAAK,CAAC,GAAG,KAAK,CAAA;AAAA;AAErD;AAEA,MAAM,cAAA,GAAiB,CACrB,GAAA,EACA,KAAA,KACY,MAAM,MAAA,KAAW,GAAA;AA+BxB,SAAS,oBACX,IAAA,EAGiD;AACpD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,aAAa,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AAAA,IAEtC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,YAAA,CAAa,IAAA,CAAK,CAAC,GAAG,KAAK,CAAA;AAAA;AAEnD;AAEA,MAAM,YAAA,GAAe,CACnB,GAAA,EACA,KAAA,KACY,MAAM,MAAA,IAAU,GAAA;AA+BvB,SAAS,oBACX,IAAA,EAGiD;AACpD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,aAAa,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AAAA,IAEtC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,KAAA,KAAU,YAAA,CAAa,IAAA,CAAK,CAAC,GAAG,KAAK,CAAA;AAAA;AAEnD;AAEA,MAAM,YAAA,GAAe,CACnB,GAAA,EACA,KAAA,KACY,MAAM,MAAA,IAAU,GAAA;AAwCvB,SAAS,wBACX,IAAA,EAOiD;AACpD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,cAAA,CAAe,KAAK,CAAC,CAAA,EAAG,KAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AAAA,IAEjD,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,UAAU,cAAA,CAAe,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAA,EAAG,KAAK,CAAA;AAAA;AAE9D;AAEA,MAAM,cAAA,GAAiB,CACrB,GAAA,EACA,GAAA,EACA,UACY,KAAA,CAAM,MAAA,IAAU,GAAA,IAAO,KAAA,CAAM,MAAA,IAAU,GAAA;;;;"}

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

@@ -1,4 +1,4 @@
-import { type FixedLengthTuple, type Increment, type IsFixedLengthList, type NonEmptyArray, type NonEmptyTuple } from 'ts-type-forge';
+import { type ChangeArrayElement, type ConstrainedList, type FixedLengthTuple, type HasLengthConstraint, type Increment, type IsFixedLengthList, type NonEmptyArray, type NonEmptyTuple } from 'ts-type-forge';
 import { type ArgArrayIndex, type ArgArrayIndexWithNegative, type SizeType } from '../../types.mjs';
 /**
  * Returns a new array with an element at the specified index replaced.
@@ -13,12 +13,8 @@ import { type ArgArrayIndex, type ArgArrayIndexWithNegative, type SizeType } fro
  * assert.deepStrictEqual(updated, [10, 25, 30]);
  * ```
  */
-export declare function set<const Ar extends readonly unknown[], const V = Ar[number]>(array: Ar, index: ArgArrayIndex<Ar>, newValue: V): IsFixedLengthList<Ar> extends true ? Readonly<{
-    [K in keyof Ar]: Ar[K] | V;
-}> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<Ar[number] | V> : readonly (Ar[number] | V)[];
-export declare function set<const V>(index: SizeType.ArgArr, newValue: V): <const Ar extends readonly unknown[]>(array: Ar) => IsFixedLengthList<Ar> extends true ? Readonly<{
-    [K in keyof Ar]: Ar[K] | V;
-}> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<Ar[number] | V> : readonly (Ar[number] | V)[];
+export declare function set<const Ar extends readonly unknown[], const I extends ArgArrayIndex<Ar>, const V = Ar[number]>(array: Ar, index: I, newValue: V): ReplacedAt<Ar, I, V>;
+export declare function set<const I extends SizeType.ArgArr, const V>(index: I, newValue: V): <const Ar extends readonly unknown[]>(array: Ar) => ReplacedAt<Ar, I, V>;
 /**
  * Returns a new array with an element at the specified index updated by applying a function.
  *
@@ -29,7 +25,7 @@ export declare function set<const V>(index: SizeType.ArgArr, newValue: V): <cons
  *
  * const increased = Arr.toUpdated(temperatures, 1, (value) => value + 5);
  *
- * const incrementLast = Arr.toUpdated<number>(
+ * const incrementLast = Arr.toUpdated<2, number>(
  *   2,
  *   (value) => value + 1,
  * )(temperatures);
@@ -39,12 +35,8 @@ export declare function set<const V>(index: SizeType.ArgArr, newValue: V): <cons
  * assert.deepStrictEqual(incrementLast, [20, 21, 23]);
  * ```
  */
-export declare function toUpdated<const Ar extends readonly unknown[], const V = Ar[number]>(array: Ar, index: ArgArrayIndex<Ar>, updater: (prev: Ar[number]) => V): IsFixedLengthList<Ar> extends true ? Readonly<{
-    [K in keyof Ar]: Ar[K] | V;
-}> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<Ar[number] | V> : readonly (Ar[number] | V)[];
-export declare function toUpdated<E, const V = E>(index: SizeType.ArgArr, updater: (prev: E) => V): <const Ar extends readonly E[]>(array: Ar) => IsFixedLengthList<Ar> extends true ? Readonly<{
-    [K in keyof Ar]: Ar[K] | V;
-}> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<Ar[number] | V> : readonly (Ar[number] | V)[];
+export declare function toUpdated<const Ar extends readonly unknown[], const I extends ArgArrayIndex<Ar>, const V = Ar[number]>(array: Ar, index: I, updater: (prev: Ar[number]) => V): ReplacedAt<Ar, I, V>;
+export declare function toUpdated<const I extends SizeType.ArgArr, E, const V = E>(index: I, updater: (prev: E) => V): <const Ar extends readonly E[]>(array: Ar) => ReplacedAt<Ar, I, V>;
 /**
  * Returns a new array with a value inserted at the specified index.
  *
@@ -149,8 +141,8 @@ export declare function toUnshifted<const V>(newValue: V): <const Ar extends rea
  * assert.deepStrictEqual(filledCurried, ['x', 'x', 'x']);
  * ```
  */
-export declare function toFilled<const Ar extends readonly unknown[], const V>(array: Ar, value: V): IsFixedLengthList<Ar> extends true ? FixedLengthTuple<Ar['length'], V> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<V> : readonly V[];
-export declare function toFilled<const V>(value: V): <const Ar extends readonly unknown[]>(array: Ar) => IsFixedLengthList<Ar> extends true ? FixedLengthTuple<Ar['length'], V> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<V> : readonly V[];
+export declare function toFilled<const Ar extends readonly unknown[], const V>(array: Ar, value: V): HasLengthConstraint<Ar> extends true ? ChangeArrayElement<Ar, V> : IsFixedLengthList<Ar> extends true ? FixedLengthTuple<Ar['length'], V> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<V> : readonly V[];
+export declare function toFilled<const V>(value: V): <const Ar extends readonly unknown[]>(array: Ar) => HasLengthConstraint<Ar> extends true ? ChangeArrayElement<Ar, V> : IsFixedLengthList<Ar> extends true ? FixedLengthTuple<Ar['length'], V> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<V> : readonly V[];
 /**
  * Returns a new array with elements in the specified range replaced by the specified value.
  *
@@ -171,10 +163,32 @@ export declare function toFilled<const V>(value: V): <const Ar extends readonly
 export declare function toRangeFilled<const Ar extends readonly unknown[], const V>(array: Ar, value: V, fillRange: readonly [
     start: ArgArrayIndexWithNegative<Ar>,
     end: ArgArrayIndexWithNegative<Ar>
-]): IsFixedLengthList<Ar> extends true ? FixedLengthTuple<Ar['length'], V | Ar[number]> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<V | Ar[number]> : readonly (V | Ar[number])[];
+]): HasLengthConstraint<Ar> extends true ? ChangeArrayElement<Ar, V | Ar[number]> : IsFixedLengthList<Ar> extends true ? FixedLengthTuple<Ar['length'], V | Ar[number]> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<V | Ar[number]> : readonly (V | Ar[number])[];
 export declare function toRangeFilled<const V>(value: V, fillRange: readonly [
     start: SizeType.ArgArrWithNegative,
     end: SizeType.ArgArrWithNegative
-]): <const Ar extends readonly unknown[]>(array: Ar) => IsFixedLengthList<Ar> extends true ? FixedLengthTuple<Ar['length'], V | Ar[number]> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<V | Ar[number]> : readonly (V | Ar[number])[];
+]): <const Ar extends readonly unknown[]>(array: Ar) => HasLengthConstraint<Ar> extends true ? ChangeArrayElement<Ar, V | Ar[number]> : IsFixedLengthList<Ar> extends true ? FixedLengthTuple<Ar['length'], V | Ar[number]> : Ar extends NonEmptyTuple<unknown> ? NonEmptyArray<V | Ar[number]> : readonly (V | Ar[number])[];
+/**
+ * The result of replacing the element at `I` of `Ar` with a `V`.
+ *
+ * `ConstrainedList.SetAt` replaces exactly one position when the index pins
+ * one, which is what makes `Arr.set(xs, 1, v)` report `readonly [a, V, c]`
+ * instead of widening every position to `a | V`.
+ *
+ * A union index needs the weaker answer, and this used to guard for it here:
+ * `ArgArrayIndex<Ar>` for a tuple is the union of its indices, so
+ * `Arr.set(tuple, someIndex, v)` with `someIndex: 0 | 2` binds `I = 0 | 2`, and
+ * the upstream `List.SetAt` used to answer `readonly [V, b, V]` — a type that
+ * *neither* possible runtime result satisfies, since the call replaces one
+ * position or the other and never both.
+ *
+ * ts-type-forge 9.1.1 fixes that at the source and widens the candidate
+ * positions itself, so the guard is gone. Upstream is the more precise of the
+ * two: it widens only the positions the index can name, where the guard here
+ * widened all of them — `Arr.set(t, i, 'x')` with `i: 0 | 2` on
+ * `readonly [1, 2, 3]` now keeps the middle element at `2` rather than
+ * reporting `2 | 'x'`.
+ */
+type ReplacedAt<Ar extends readonly unknown[], I extends number, V> = ConstrainedList.SetAt<I, V, Ar>;
 export {};
 //# sourceMappingURL=array-utils-modification.d.mts.map

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

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

@@ -1 +1 @@
-{"version":3,"file":"array-utils-modification.mjs","sources":["../../../src/array/impl/array-utils-modification.mts"],"sourcesContent":["import {\n  type FixedLengthTuple,\n  type Increment,\n  type IsFixedLengthList,\n  type NonEmptyArray,\n  type NonEmptyTuple,\n} from 'ts-type-forge';\nimport { asPositiveUint32 } from '../../number/index.mjs';\nimport { castMutable } from '../../others/index.mjs';\nimport {\n  type ArgArrayIndex,\n  type ArgArrayIndexWithNegative,\n  type SizeType,\n} from '../../types.mjs';\nimport { copy, create } from './array-utils-creation.mjs';\n\n/**\n * Returns a new array with an element at the specified index replaced.\n *\n * @example\n *\n * ```ts\n * const scores: readonly number[] = [10, 20, 30] as const;\n *\n * const updated = Arr.set(scores, 1, 25);\n *\n * assert.deepStrictEqual(updated, [10, 25, 30]);\n * ```\n */\nexport function set<const Ar extends readonly unknown[], const V = Ar[number]>(\n  array: Ar,\n  index: ArgArrayIndex<Ar>,\n  newValue: V,\n): IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\n// curried version\nexport function set<const V>(\n  index: SizeType.ArgArr,\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\nexport function set<E, const V = E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArr, newValue: V]\n    | readonly [index: SizeType.ArgArr, newValue: V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3:\n      return setImpl(...args);\n\n    case 2:\n      return (array) => setImpl(array, ...args);\n  }\n}\n\nconst setImpl = <E, const V = E>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n  newValue: V,\n): readonly (E | V)[] => (array as readonly (E | V)[]).with(index, newValue);\n\n/**\n * Returns a new array with an element at the specified index updated by applying a function.\n *\n * @example\n *\n * ```ts\n * const temperatures: readonly number[] = [20, 21, 22] as const;\n *\n * const increased = Arr.toUpdated(temperatures, 1, (value) => value + 5);\n *\n * const incrementLast = Arr.toUpdated<number>(\n *   2,\n *   (value) => value + 1,\n * )(temperatures);\n *\n * assert.deepStrictEqual(increased, [20, 26, 22]);\n *\n * assert.deepStrictEqual(incrementLast, [20, 21, 23]);\n * ```\n */\nexport function toUpdated<\n  const Ar extends readonly unknown[],\n  const V = Ar[number],\n>(\n  array: Ar,\n  index: ArgArrayIndex<Ar>,\n  updater: (prev: Ar[number]) => V,\n): IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\n// curried version\nexport function toUpdated<E, const V = E>(\n  index: SizeType.ArgArr,\n  updater: (prev: E) => V,\n): <const Ar extends readonly E[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? Readonly<{ [K in keyof Ar]: Ar[K] | V }>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<Ar[number] | V>\n    : readonly (Ar[number] | V)[];\n\nexport function toUpdated<E, V = E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        index: SizeType.ArgArr,\n        updater: (prev: E) => V,\n      ]\n    | readonly [index: SizeType.ArgArr, updater: (prev: E) => V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3:\n      return toUpdatedImpl(...args);\n\n    case 2:\n      return (array) => toUpdatedImpl(array, ...args);\n  }\n}\n\nconst toUpdatedImpl = <E, V = E>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n  updater: (prev: E) => V,\n): readonly (E | V)[] =>\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  (array as readonly (E | V)[]).with(index, updater(array[index]!));\n\n/**\n * Returns a new array with a value inserted at the specified index.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 4] as const;\n *\n * const withThree = Arr.toInserted(numbers, 2, 3);\n *\n * const appendFive = Arr.toInserted(3, 5)(numbers);\n *\n * assert.deepStrictEqual(withThree, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(appendFive, [1, 2, 4, 5]);\n * ```\n */\nexport function toInserted<\n  const Ar extends readonly unknown[],\n  const V = Ar[number],\n>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n  newValue: V,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n  : NonEmptyArray<Ar[number] | V>;\n\n// curried version\nexport function toInserted<const V>(\n  index: SizeType.ArgArrWithNegative,\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n  : NonEmptyArray<Ar[number] | V>;\n\nexport function toInserted<E, const V = E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        index: SizeType.ArgArrWithNegative,\n        newValue: V,\n      ]\n    | readonly [index: SizeType.ArgArrWithNegative, newValue: V]\n): NonEmptyArray<E | V> | ((array: readonly E[]) => NonEmptyArray<E | V>) {\n  switch (args.length) {\n    case 3:\n      return toInsertedImpl(...args);\n\n    case 2:\n      return (array) => toInsertedImpl(array, ...args);\n  }\n}\n\nconst toInsertedImpl = <E, const V = E>(\n  array: readonly E[],\n  index: SizeType.ArgArrWithNegative,\n  newValue: V,\n): NonEmptyArray<E | V> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  (array as readonly (E | V)[]).toSpliced(\n    index,\n    0,\n    newValue,\n  ) as unknown as NonEmptyArray<E | V>;\n\ntype CastToNumber<T> = T extends number ? T : never;\n\n/**\n * Returns a new array with the element at the specified index removed.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'd'] as const;\n *\n * const withoutSecond = Arr.toRemoved(letters, 1);\n *\n * const withoutFirstCurried = Arr.toRemoved(0)(letters);\n *\n * assert.deepStrictEqual(withoutSecond, ['a', 'c', 'd']);\n *\n * assert.deepStrictEqual(withoutFirstCurried, ['b', 'c', 'd']);\n * ```\n */\nexport function toRemoved<const Ar extends readonly unknown[]>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n): readonly Ar[number][];\n\nexport function toRemoved(\n  index: SizeType.ArgArrWithNegative,\n): <E>(array: readonly E[]) => readonly E[];\n\nexport function toRemoved<E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArrWithNegative]\n    | readonly [index: SizeType.ArgArrWithNegative]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2:\n      return toRemovedImpl(...args);\n\n    case 1:\n      return (array) => toRemovedImpl(array, ...args);\n  }\n}\n\nconst toRemovedImpl = <E,>(\n  array: readonly E[],\n  index: SizeType.ArgArrWithNegative,\n): readonly E[] => array.toSpliced(index, 1);\n\n/**\n * Returns a new array with a value appended to the end.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2] as const;\n *\n * const appended = Arr.toPushed(base, 3);\n *\n * const appendedCurried = Arr.toPushed(4)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = appended;\n *\n * assert.deepStrictEqual<readonly number[]>(appended, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(appendedCurried, [1, 2, 4]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const V>(\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n  ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [...Ar, V] | ((array: Ar) => readonly [...Ar, V]) {\n  switch (args.length) {\n    case 2:\n      return toPushedImpl(...args);\n\n    case 1:\n      return (array) => toPushedImpl(array, ...args);\n  }\n}\n\nconst toPushedImpl = <const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [...Ar, V] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toSpliced(array.length, 0, newValue) as unknown as readonly [...Ar, V];\n\n/**\n * Returns a new array with a value prepended to the beginning.\n *\n * @example\n *\n * ```ts\n * const base = [2, 3] as const;\n *\n * const prefixed = Arr.toUnshifted(base, 1);\n *\n * const prefixedCurried = Arr.toUnshifted(0)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = prefixed;\n *\n * assert.deepStrictEqual<readonly number[]>(prefixed, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(prefixedCurried, [0, 2, 3]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toUnshifted<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<const V>(\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<Ar extends readonly unknown[], const V>(\n  ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [V, ...Ar] | ((array: Ar) => readonly [V, ...Ar]) {\n  switch (args.length) {\n    case 2:\n      return toUnshiftedImpl(...args);\n\n    case 1:\n      return (array) => toUnshiftedImpl(array, ...args);\n  }\n}\n\nconst toUnshiftedImpl = <Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [V, ...Ar] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];\n\n/**\n * Returns a new array with all elements replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2, 3] as const;\n *\n * const filled = Arr.toFilled(base, 0);\n *\n * const filledCurried = Arr.toFilled('x')(base);\n *\n * assert.deepStrictEqual(filled, [0, 0, 0]);\n *\n * assert.deepStrictEqual(filledCurried, ['x', 'x', 'x']);\n * ```\n */\nexport function toFilled<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  value: V,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V>\n    : readonly V[];\n\n// curried version\nexport function toFilled<const V>(\n  value: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V>\n    : readonly V[];\n\nexport function toFilled<E>(\n  ...args: readonly [array: readonly E[], value: E] | readonly [value: E]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2:\n      return toFilledImpl(...args);\n\n    case 1:\n      return (array) => toFilledImpl(array, ...args);\n  }\n}\n\nconst toFilledImpl = <E,>(array: readonly E[], value: E): readonly E[] =>\n  create(asPositiveUint32(array.length), value);\n\n/**\n * Returns a new array with elements in the specified range replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [0, 1, 2, 3, 4] as const;\n *\n * const filledMiddle = Arr.toRangeFilled(base, 9, [1, 4]);\n *\n * const filledPrefix = Arr.toRangeFilled(8, [0, 2])(base);\n *\n * assert.deepStrictEqual(filledMiddle, [0, 9, 9, 9, 4]);\n *\n * assert.deepStrictEqual(filledPrefix, [8, 8, 2, 3, 4]);\n * ```\n */\nexport function toRangeFilled<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  value: V,\n  fillRange: readonly [\n    start: ArgArrayIndexWithNegative<Ar>,\n    end: ArgArrayIndexWithNegative<Ar>,\n  ],\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V | Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V | Ar[number]>\n    : readonly (V | Ar[number])[];\n\n// curried version\nexport function toRangeFilled<const V>(\n  value: V,\n  fillRange: readonly [\n    start: SizeType.ArgArrWithNegative,\n    end: SizeType.ArgArrWithNegative,\n  ],\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<Ar['length'], V | Ar[number]>\n  : Ar extends NonEmptyTuple<unknown>\n    ? NonEmptyArray<V | Ar[number]>\n    : readonly (V | Ar[number])[];\n\nexport function toRangeFilled<E, const V>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        value: V,\n        fillRange: readonly [\n          start: SizeType.ArgArrWithNegative,\n          end: SizeType.ArgArrWithNegative,\n        ],\n      ]\n    | readonly [\n        value: V,\n        fillRange: readonly [\n          start: SizeType.ArgArrWithNegative,\n          end: SizeType.ArgArrWithNegative,\n        ],\n      ]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3:\n      return toRangeFilledImpl(...args);\n\n    case 2:\n      return (array) => toRangeFilledImpl(array, ...args);\n  }\n}\n\nconst toRangeFilledImpl = <E, const V>(\n  array: readonly E[],\n  value: V,\n  fillRange: readonly [\n    start: SizeType.ArgArrWithNegative,\n    end: SizeType.ArgArrWithNegative,\n  ],\n): readonly (E | V)[] => {\n  const [start, end] = fillRange;\n\n  const mut_cp: (E | V)[] = castMutable(copy(array));\n\n  mut_cp.fill(value, start, end);\n\n  return mut_cp;\n};\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"array-utils-modification.mjs","sources":["../../../src/array/impl/array-utils-modification.mts"],"sourcesContent":["import {\n  type ChangeArrayElement,\n  type ConstrainedList,\n  type FixedLengthTuple,\n  type HasLengthConstraint,\n  type Increment,\n  type IsFixedLengthList,\n  type NonEmptyArray,\n  type NonEmptyTuple,\n} from 'ts-type-forge';\nimport { asPositiveUint32 } from '../../number/index.mjs';\nimport { castMutable } from '../../others/index.mjs';\nimport {\n  type ArgArrayIndex,\n  type ArgArrayIndexWithNegative,\n  type SizeType,\n} from '../../types.mjs';\nimport { copy, create } from './array-utils-creation.mjs';\n\n/**\n * Returns a new array with an element at the specified index replaced.\n *\n * @example\n *\n * ```ts\n * const scores: readonly number[] = [10, 20, 30] as const;\n *\n * const updated = Arr.set(scores, 1, 25);\n *\n * assert.deepStrictEqual(updated, [10, 25, 30]);\n * ```\n */\nexport function set<\n  const Ar extends readonly unknown[],\n  const I extends ArgArrayIndex<Ar>,\n  const V = Ar[number],\n>(array: Ar, index: I, newValue: V): ReplacedAt<Ar, I, V>;\n\n// curried version\nexport function set<const I extends SizeType.ArgArr, const V>(\n  index: I,\n  newValue: V,\n): <const Ar extends readonly unknown[]>(array: Ar) => ReplacedAt<Ar, I, V>;\n\nexport function set<E, const V = E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArr, newValue: V]\n    | readonly [index: SizeType.ArgArr, newValue: V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3:\n      return setImpl(...args);\n\n    case 2:\n      return (array) => setImpl(array, ...args);\n  }\n}\n\nconst setImpl = <E, const V = E>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n  newValue: V,\n): readonly (E | V)[] => (array as readonly (E | V)[]).with(index, newValue);\n\n/**\n * Returns a new array with an element at the specified index updated by applying a function.\n *\n * @example\n *\n * ```ts\n * const temperatures: readonly number[] = [20, 21, 22] as const;\n *\n * const increased = Arr.toUpdated(temperatures, 1, (value) => value + 5);\n *\n * const incrementLast = Arr.toUpdated<2, number>(\n *   2,\n *   (value) => value + 1,\n * )(temperatures);\n *\n * assert.deepStrictEqual(increased, [20, 26, 22]);\n *\n * assert.deepStrictEqual(incrementLast, [20, 21, 23]);\n * ```\n */\nexport function toUpdated<\n  const Ar extends readonly unknown[],\n  const I extends ArgArrayIndex<Ar>,\n  const V = Ar[number],\n>(array: Ar, index: I, updater: (prev: Ar[number]) => V): ReplacedAt<Ar, I, V>;\n\n// curried version\nexport function toUpdated<const I extends SizeType.ArgArr, E, const V = E>(\n  index: I,\n  updater: (prev: E) => V,\n): <const Ar extends readonly E[]>(array: Ar) => ReplacedAt<Ar, I, V>;\n\nexport function toUpdated<E, V = E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        index: SizeType.ArgArr,\n        updater: (prev: E) => V,\n      ]\n    | readonly [index: SizeType.ArgArr, updater: (prev: E) => V]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3:\n      return toUpdatedImpl(...args);\n\n    case 2:\n      return (array) => toUpdatedImpl(array, ...args);\n  }\n}\n\nconst toUpdatedImpl = <E, V = E>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n  updater: (prev: E) => V,\n): readonly (E | V)[] =>\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  (array as readonly (E | V)[]).with(index, updater(array[index]!));\n\n/**\n * Returns a new array with a value inserted at the specified index.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 2, 4] as const;\n *\n * const withThree = Arr.toInserted(numbers, 2, 3);\n *\n * const appendFive = Arr.toInserted(3, 5)(numbers);\n *\n * assert.deepStrictEqual(withThree, [1, 2, 3, 4]);\n *\n * assert.deepStrictEqual(appendFive, [1, 2, 4, 5]);\n * ```\n */\nexport function toInserted<\n  const Ar extends readonly unknown[],\n  const V = Ar[number],\n>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n  newValue: V,\n): IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n  : NonEmptyArray<Ar[number] | V>;\n\n// curried version\nexport function toInserted<const V>(\n  index: SizeType.ArgArrWithNegative,\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => IsFixedLengthList<Ar> extends true\n  ? FixedLengthTuple<CastToNumber<Increment<Ar['length']>>, Ar[number] | V>\n  : NonEmptyArray<Ar[number] | V>;\n\nexport function toInserted<E, const V = E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        index: SizeType.ArgArrWithNegative,\n        newValue: V,\n      ]\n    | readonly [index: SizeType.ArgArrWithNegative, newValue: V]\n): NonEmptyArray<E | V> | ((array: readonly E[]) => NonEmptyArray<E | V>) {\n  switch (args.length) {\n    case 3:\n      return toInsertedImpl(...args);\n\n    case 2:\n      return (array) => toInsertedImpl(array, ...args);\n  }\n}\n\nconst toInsertedImpl = <E, const V = E>(\n  array: readonly E[],\n  index: SizeType.ArgArrWithNegative,\n  newValue: V,\n): NonEmptyArray<E | V> =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  (array as readonly (E | V)[]).toSpliced(\n    index,\n    0,\n    newValue,\n  ) as unknown as NonEmptyArray<E | V>;\n\ntype CastToNumber<T> = T extends number ? T : never;\n\n/**\n * Returns a new array with the element at the specified index removed.\n *\n * @example\n *\n * ```ts\n * const letters = ['a', 'b', 'c', 'd'] as const;\n *\n * const withoutSecond = Arr.toRemoved(letters, 1);\n *\n * const withoutFirstCurried = Arr.toRemoved(0)(letters);\n *\n * assert.deepStrictEqual(withoutSecond, ['a', 'c', 'd']);\n *\n * assert.deepStrictEqual(withoutFirstCurried, ['b', 'c', 'd']);\n * ```\n */\nexport function toRemoved<const Ar extends readonly unknown[]>(\n  array: Ar,\n  index: ArgArrayIndexWithNegative<Ar>,\n): readonly Ar[number][];\n\nexport function toRemoved(\n  index: SizeType.ArgArrWithNegative,\n): <E>(array: readonly E[]) => readonly E[];\n\nexport function toRemoved<E>(\n  ...args:\n    | readonly [array: readonly E[], index: SizeType.ArgArrWithNegative]\n    | readonly [index: SizeType.ArgArrWithNegative]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2:\n      return toRemovedImpl(...args);\n\n    case 1:\n      return (array) => toRemovedImpl(array, ...args);\n  }\n}\n\nconst toRemovedImpl = <E,>(\n  array: readonly E[],\n  index: SizeType.ArgArrWithNegative,\n): readonly E[] => array.toSpliced(index, 1);\n\n/**\n * Returns a new array with a value appended to the end.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2] as const;\n *\n * const appended = Arr.toPushed(base, 3);\n *\n * const appendedCurried = Arr.toPushed(4)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = appended;\n *\n * assert.deepStrictEqual<readonly number[]>(appended, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(appendedCurried, [1, 2, 4]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const V>(\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly [...Ar, V] & NonEmptyArray<Ar[number] | V>;\n\nexport function toPushed<const Ar extends readonly unknown[], const V>(\n  ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [...Ar, V] | ((array: Ar) => readonly [...Ar, V]) {\n  switch (args.length) {\n    case 2:\n      return toPushedImpl(...args);\n\n    case 1:\n      return (array) => toPushedImpl(array, ...args);\n  }\n}\n\nconst toPushedImpl = <const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [...Ar, V] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toSpliced(array.length, 0, newValue) as unknown as readonly [...Ar, V];\n\n/**\n * Returns a new array with a value prepended to the beginning.\n *\n * @example\n *\n * ```ts\n * const base = [2, 3] as const;\n *\n * const prefixed = Arr.toUnshifted(base, 1);\n *\n * const prefixedCurried = Arr.toUnshifted(0)(base);\n *\n * // The result is guaranteed non-empty, so it is assignable to NonEmptyArray.\n * const nonEmpty: NonEmptyArray<number> = prefixed;\n *\n * assert.deepStrictEqual<readonly number[]>(prefixed, [1, 2, 3]);\n *\n * assert.deepStrictEqual<readonly number[]>(prefixedCurried, [0, 2, 3]);\n *\n * assert.isTrue(nonEmpty.length >= 1);\n * ```\n */\nexport function toUnshifted<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<const V>(\n  newValue: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => readonly [V, ...Ar] & NonEmptyArray<V | Ar[number]>;\n\nexport function toUnshifted<Ar extends readonly unknown[], const V>(\n  ...args: readonly [array: Ar, newValue: V] | readonly [newValue: V]\n): readonly [V, ...Ar] | ((array: Ar) => readonly [V, ...Ar]) {\n  switch (args.length) {\n    case 2:\n      return toUnshiftedImpl(...args);\n\n    case 1:\n      return (array) => toUnshiftedImpl(array, ...args);\n  }\n}\n\nconst toUnshiftedImpl = <Ar extends readonly unknown[], const V>(\n  array: Ar,\n  newValue: V,\n): readonly [V, ...Ar] =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  array.toSpliced(0, 0, newValue) as unknown as readonly [V, ...Ar];\n\n/**\n * Returns a new array with all elements replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [1, 2, 3] as const;\n *\n * const filled = Arr.toFilled(base, 0);\n *\n * const filledCurried = Arr.toFilled('x')(base);\n *\n * assert.deepStrictEqual(filled, [0, 0, 0]);\n *\n * assert.deepStrictEqual(filledCurried, ['x', 'x', 'x']);\n * ```\n */\nexport function toFilled<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  value: V,\n): HasLengthConstraint<Ar> extends true\n  ? ChangeArrayElement<Ar, V>\n  : IsFixedLengthList<Ar> extends true\n    ? FixedLengthTuple<Ar['length'], V>\n    : Ar extends NonEmptyTuple<unknown>\n      ? NonEmptyArray<V>\n      : readonly V[];\n\n// curried version\nexport function toFilled<const V>(\n  value: V,\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => HasLengthConstraint<Ar> extends true\n  ? ChangeArrayElement<Ar, V>\n  : IsFixedLengthList<Ar> extends true\n    ? FixedLengthTuple<Ar['length'], V>\n    : Ar extends NonEmptyTuple<unknown>\n      ? NonEmptyArray<V>\n      : readonly V[];\n\nexport function toFilled<E>(\n  ...args: readonly [array: readonly E[], value: E] | readonly [value: E]\n): readonly E[] | ((array: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2:\n      return toFilledImpl(...args);\n\n    case 1:\n      return (array) => toFilledImpl(array, ...args);\n  }\n}\n\nconst toFilledImpl = <E,>(array: readonly E[], value: E): readonly E[] =>\n  create(asPositiveUint32(array.length), value);\n\n/**\n * Returns a new array with elements in the specified range replaced by the specified value.\n *\n * @example\n *\n * ```ts\n * const base = [0, 1, 2, 3, 4] as const;\n *\n * const filledMiddle = Arr.toRangeFilled(base, 9, [1, 4]);\n *\n * const filledPrefix = Arr.toRangeFilled(8, [0, 2])(base);\n *\n * assert.deepStrictEqual(filledMiddle, [0, 9, 9, 9, 4]);\n *\n * assert.deepStrictEqual(filledPrefix, [8, 8, 2, 3, 4]);\n * ```\n */\nexport function toRangeFilled<const Ar extends readonly unknown[], const V>(\n  array: Ar,\n  value: V,\n  fillRange: readonly [\n    start: ArgArrayIndexWithNegative<Ar>,\n    end: ArgArrayIndexWithNegative<Ar>,\n  ],\n): HasLengthConstraint<Ar> extends true\n  ? ChangeArrayElement<Ar, V | Ar[number]>\n  : IsFixedLengthList<Ar> extends true\n    ? FixedLengthTuple<Ar['length'], V | Ar[number]>\n    : Ar extends NonEmptyTuple<unknown>\n      ? NonEmptyArray<V | Ar[number]>\n      : readonly (V | Ar[number])[];\n\n// curried version\nexport function toRangeFilled<const V>(\n  value: V,\n  fillRange: readonly [\n    start: SizeType.ArgArrWithNegative,\n    end: SizeType.ArgArrWithNegative,\n  ],\n): <const Ar extends readonly unknown[]>(\n  array: Ar,\n) => HasLengthConstraint<Ar> extends true\n  ? ChangeArrayElement<Ar, V | Ar[number]>\n  : IsFixedLengthList<Ar> extends true\n    ? FixedLengthTuple<Ar['length'], V | Ar[number]>\n    : Ar extends NonEmptyTuple<unknown>\n      ? NonEmptyArray<V | Ar[number]>\n      : readonly (V | Ar[number])[];\n\nexport function toRangeFilled<E, const V>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        value: V,\n        fillRange: readonly [\n          start: SizeType.ArgArrWithNegative,\n          end: SizeType.ArgArrWithNegative,\n        ],\n      ]\n    | readonly [\n        value: V,\n        fillRange: readonly [\n          start: SizeType.ArgArrWithNegative,\n          end: SizeType.ArgArrWithNegative,\n        ],\n      ]\n): readonly (E | V)[] | ((array: readonly E[]) => readonly (E | V)[]) {\n  switch (args.length) {\n    case 3:\n      return toRangeFilledImpl(...args);\n\n    case 2:\n      return (array) => toRangeFilledImpl(array, ...args);\n  }\n}\n\nconst toRangeFilledImpl = <E, const V>(\n  array: readonly E[],\n  value: V,\n  fillRange: readonly [\n    start: SizeType.ArgArrWithNegative,\n    end: SizeType.ArgArrWithNegative,\n  ],\n): readonly (E | V)[] => {\n  const [start, end] = fillRange;\n\n  const mut_cp: (E | V)[] = castMutable(copy(array));\n\n  mut_cp.fill(value, start, end);\n\n  return mut_cp;\n};\n\n/**\n * The result of replacing the element at `I` of `Ar` with a `V`.\n *\n * `ConstrainedList.SetAt` replaces exactly one position when the index pins\n * one, which is what makes `Arr.set(xs, 1, v)` report `readonly [a, V, c]`\n * instead of widening every position to `a | V`.\n *\n * A union index needs the weaker answer, and this used to guard for it here:\n * `ArgArrayIndex<Ar>` for a tuple is the union of its indices, so\n * `Arr.set(tuple, someIndex, v)` with `someIndex: 0 | 2` binds `I = 0 | 2`, and\n * the upstream `List.SetAt` used to answer `readonly [V, b, V]` — a type that\n * *neither* possible runtime result satisfies, since the call replaces one\n * position or the other and never both.\n *\n * ts-type-forge 9.1.1 fixes that at the source and widens the candidate\n * positions itself, so the guard is gone. Upstream is the more precise of the\n * two: it widens only the positions the index can name, where the guard here\n * widened all of them — `Arr.set(t, i, 'x')` with `i: 0 | 2` on\n * `readonly [1, 2, 3]` now keeps the middle element at `2` rather than\n * reporting `2 | 'x'`.\n */\ntype ReplacedAt<\n  Ar extends readonly unknown[],\n  I extends number,\n  V,\n> = ConstrainedList.SetAt<I, V, Ar>;\n"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-reducing-value.d.mts

@@ -234,9 +234,9 @@ export declare function sum(array: readonly number[]): number;
  * ```
  */
 export declare function sumBy(array: readonly [], mapFn: (item: unknown) => number): 0;
-export declare function sumBy<N extends Uint, E>(array: readonly E[], mapFn: (item: E) => N): Uint;
-export declare function sumBy<N extends Int, E>(array: readonly E[], mapFn: (item: E) => N): Int;
-export declare function sumBy<N extends number, E>(array: readonly E[], mapFn: (item: E) => N): number;
+export declare function sumBy<E, N extends Uint>(array: readonly E[], mapFn: (item: E) => N): Uint;
+export declare function sumBy<E, N extends Int>(array: readonly E[], mapFn: (item: E) => N): Int;
+export declare function sumBy<E, N extends number>(array: readonly E[], mapFn: (item: E) => N): number;
 /**
  * Joins array elements into a string.
  *

package/dist/array/impl/array-utils-reducing-value.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-reducing-value.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-reducing-value.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"array-utils-reducing-value.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-reducing-value.mts"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-reducing-value.mjs

@@ -45,7 +45,7 @@ import '../../number/enum/int8.mjs';
 import '../../number/enum/uint8.mjs';
 import { Num } from '../../number/num.mjs';
 import '../../number/refined-number-utils.mjs';
-import { isNonEmpty } from './array-utils-validation.mjs';
+import { isNonEmpty } from './array-utils-length-bounded-array-guard.mjs';
 
 function min(array, comparator) {
   if (!isNonEmpty(array)) {