ts-data-forge 14.6.1 → 14.6.2

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 * 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":";;AA+DO,SAAS,sBACX,IAAA,EAGkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,sBAAA,CAAuB,GAAG,IAAI,CAAA;AAAA,IAEvC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,EAAA,KAAO,sBAAA,CAAuB,IAAA,CAAK,CAAC,GAAG,EAAE,CAAA;AAAA;AAEvD;AAEA,MAAM,sBAAA,GAAyB,CAC7B,MAAA,EACA,EAAA,KACiB;AACjB,EAAA,MAAM,eAAe,EAAA,CAAG,MAAA;AAExB,EAAA,IAAI,CAAC,kBAAA,CAAmB,MAAA,EAAQ,EAAE,CAAA,EAAG;AACnC,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,4BAAA,EAA+B,MAAM,CAAA,yBAAA,EAA4B,YAAY,CAAA;AAAA,KAC/E;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT,CAAA;AAkDO,SAAS,oBACX,IAAA,EAGkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,oBAAA,CAAqB,GAAG,IAAI,CAAA;AAAA,IAErC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,EAAA,KAAO,oBAAA,CAAqB,IAAA,CAAK,CAAC,GAAG,EAAE,CAAA;AAAA;AAErD;AAEA,MAAM,oBAAA,GAAuB,CAC3B,SAAA,EACA,EAAA,KACiB;AACjB,EAAA,MAAM,eAAe,EAAA,CAAG,MAAA;AAExB,EAAA,IAAI,CAAC,gBAAA,CAAiB,SAAA,EAAW,EAAE,CAAA,EAAG;AACpC,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,YAAY,CAAA;AAAA,KACrF;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT,CAAA;AA+CO,SAAS,oBACX,IAAA,EAGkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,oBAAA,CAAqB,GAAG,IAAI,CAAA;AAAA,IAErC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,EAAA,KAAO,oBAAA,CAAqB,IAAA,CAAK,CAAC,GAAG,EAAE,CAAA;AAAA;AAErD;AAEA,MAAM,oBAAA,GAAuB,CAC3B,SAAA,EACA,EAAA,KACiB;AACjB,EAAA,MAAM,eAAe,EAAA,CAAG,MAAA;AAExB,EAAA,IAAI,CAAC,gBAAA,CAAiB,SAAA,EAAW,EAAE,CAAA,EAAG;AACpC,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,YAAY,CAAA;AAAA,KACrF;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT,CAAA;AA6DO,SAAS,wBACX,IAAA,EAOkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,wBAAA,CAAyB,GAAG,IAAI,CAAA;AAAA,IAEzC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,OAAO,wBAAA,CAAyB,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAA,EAAG,EAAE,CAAA;AAAA;AAElE;AAEA,MAAM,wBAAA,GAA2B,CAC/B,SAAA,EACA,SAAA,EACA,EAAA,KACiB;AACjB,EAAA,MAAM,eAAe,EAAA,CAAG,MAAA;AAExB,EAAA,IAAI,CAAC,oBAAA,CAAqB,SAAA,EAAW,SAAA,EAAW,EAAE,CAAA,EAAG;AACnD,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,gCAAA,EAAmC,SAAS,CAAA,EAAA,EAAK,SAAS,6BAA6B,YAAY,CAAA;AAAA,KACrG;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT,CAAA;AAyBO,MAAM,YAAA,GAAe,CAC1B,EAAA,KACyC;AACzC,EAAA,IAAI,CAAC,kBAAA,CAAmB,CAAA,EAAG,EAAE,CAAA,EAAG;AAC9B,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,gDAAA,EAAmD,GAAG,MAAM,CAAA;AAAA,KAC9D;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT;AA4BO,MAAM,eAAA,GAAkB,CAC7B,EAAA,KACmC;AACnC,EAAA,IAAI,CAAC,gBAAA,CAAiB,CAAA,EAAG,EAAE,CAAA,EAAG;AAC5B,IAAA,MAAM,IAAI,UAAU,gDAAgD,CAAA;AAAA,EACtE;AAEA,EAAA,OAAO,EAAA;AACT;;;;"}
+{"version":3,"file":"array-utils-length-bounded-array-cast.mjs","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-guard.mjs

@@ -1,41 +1,79 @@
-function isMinLengthArray(...args) {
-  switch (args.length) {
-    case 2:
-      return hasMinLength(...args);
-    case 1:
-      return (xs) => hasMinLength(args[0], xs);
-  }
+export function isMinLengthArray(...args) {
+    switch (args.length) {
+        case 2:
+            return hasMinLength(...args);
+        case 1:
+            return (xs) => hasMinLength(args[0], xs);
+    }
 }
 const hasMinLength = (minLength, xs) => xs.length >= minLength;
-function isMaxLengthArray(...args) {
-  switch (args.length) {
-    case 2:
-      return hasMaxLength(...args);
-    case 1:
-      return (xs) => hasMaxLength(args[0], xs);
-  }
+export function isMaxLengthArray(...args) {
+    switch (args.length) {
+        case 2:
+            return hasMaxLength(...args);
+        case 1:
+            return (xs) => hasMaxLength(args[0], xs);
+    }
 }
 const hasMaxLength = (maxLength, xs) => xs.length <= maxLength;
-function isBoundedLengthArray(...args) {
-  switch (args.length) {
-    case 3:
-      return hasBoundedLength(...args);
-    case 2:
-      return (xs) => hasBoundedLength(args[0], args[1], xs);
-  }
+export function isBoundedLengthArray(...args) {
+    switch (args.length) {
+        case 3:
+            return hasBoundedLength(...args);
+        case 2:
+            return (xs) => hasBoundedLength(args[0], args[1], xs);
+    }
 }
 const hasBoundedLength = (minLength, maxLength, xs) => xs.length >= minLength && xs.length <= maxLength;
-function isFixedLengthArray(...args) {
-  switch (args.length) {
-    case 2:
-      return hasFixedLength(...args);
-    case 1:
-      return (xs) => hasFixedLength(args[0], xs);
-  }
+export function isFixedLengthArray(...args) {
+    switch (args.length) {
+        case 2:
+            return hasFixedLength(...args);
+        case 1:
+            return (xs) => hasFixedLength(args[0], xs);
+    }
 }
 const hasFixedLength = (length, xs) => xs.length === length;
-const isEmpty = (array) => array.length === 0;
-const isNonEmpty = (array) => array.length > 0;
-
-export { isBoundedLengthArray, isEmpty, isFixedLengthArray, isMaxLengthArray, isMinLengthArray, isNonEmpty };
-//# sourceMappingURL=array-utils-length-bounded-array-guard.mjs.map
+/**
+ * Type guard that checks if an array is empty.
+ *
+ * @example
+ *
+ * ```ts
+ * const emptyNumbers: readonly number[] = [] as const;
+ *
+ * const words = ['Ada', 'Lovelace'] as const;
+ *
+ * assert.isTrue(Arr.isEmpty(emptyNumbers));
+ *
+ * assert.isFalse(Arr.isEmpty(words));
+ *
+ * if (Arr.isEmpty(emptyNumbers)) {
+ *   // `isEmpty` narrows to the branded `FixedLengthArray<0, number>`, so the
+ *   // expected value is annotated with the unbranded type.
+ *   assert.deepStrictEqual<readonly number[]>(emptyNumbers, []);
+ * }
+ * ```
+ */
+export const isEmpty = (array) => array.length === 0;
+/**
+ * Type guard that checks if an array is non-empty.
+ *
+ * @example
+ *
+ * ```ts
+ * const users: readonly Readonly<{ id: number }>[] = [{ id: 1 }] as const;
+ *
+ * const emptyUsers: readonly Readonly<{ id: number }>[] = [] as const;
+ *
+ * assert.isTrue(Arr.isNonEmpty(users));
+ *
+ * assert.isFalse(Arr.isNonEmpty(emptyUsers));
+ *
+ * if (Arr.isNonEmpty(users)) {
+ *   assert.deepStrictEqual(users[0], { id: 1 });
+ * }
+ * ```
+ */
+export const isNonEmpty = (array) => array.length > 0;
+//# sourceMappingURL=array-utils-length-bounded-array-guard.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"array-utils-length-bounded-array-guard.mjs","sources":["../../../src/array/impl/array-utils-length-bounded-array-guard.mts"],"sourcesContent":["import {\n  type BoundedLengthArray,\n  type FixedLengthArray,\n  type MaxLengthArray,\n  type MinLengthArray,\n  type SupportedLength,\n} from 'ts-type-forge';\n\n/**\n * Type guard that checks if an array has at least `minLength` elements.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MinLengthArray<MinLength, E>` while preserving the\n *   original array type (e.g. tuple types) via intersection.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isMinLengthTuple`, which narrows to a structural tuple type.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MinLengthArray<3, E>` is assignable to\n *   `MinLengthArray<1, E>`.\n *\n * The length argument comes first, matching the type-parameter order of\n * `MinLengthArray<MinLength, Elm>`. Omitting the array returns a reusable type\n * guard, which is convenient for `filter`/`pipe`.\n *\n * @example\n *\n * ```ts\n * const input: readonly number[] = [0, 1, 2, 3] as const;\n *\n * assert.isTrue(Arr.isMinLengthArray(3, input));\n *\n * assert.isFalse(Arr.isMinLengthArray(3, [0]));\n *\n * if (Arr.isMinLengthArray(3, input)) {\n *   const history: MinLengthArray<3, number> = input;\n *\n *   const nonEmpty: MinLengthArray<1, number> = input; // OK (3 >= 1)\n *\n *   assert.deepStrictEqual(history[0], 0);\n *\n *   assert.deepStrictEqual(nonEmpty[0], 0);\n * }\n *\n * // curried version\n * const hasThree = Arr.isMinLengthArray(3);\n *\n * assert.isTrue(hasThree(input));\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 check.\n * @returns `true` if `xs.length >= minLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `MinLengthArray<MinLength, Xs[number]> & Xs`.\n */\nexport function isMinLengthArray<\n  MinLength extends SupportedLength,\n  Xs extends readonly unknown[],\n>(\n  minLength: MinLength,\n  xs: Xs,\n): xs is MinLengthArray<MinLength, Xs[number]> & Xs;\n\n// Curried version\nexport function isMinLengthArray<MinLength extends SupportedLength>(\n  minLength: MinLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => xs is MinLengthArray<MinLength, Xs[number]> & Xs;\n\nexport function isMinLengthArray(\n  ...args:\n    | readonly [minLength: SupportedLength, xs: readonly unknown[]]\n    | readonly [minLength: SupportedLength]\n): boolean | ((xs: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return hasMinLength(...args);\n\n    case 1:\n      return (xs) => hasMinLength(args[0], xs);\n  }\n}\n\nconst hasMinLength = (\n  minLength: SupportedLength,\n  xs: readonly unknown[],\n): boolean => xs.length >= minLength;\n\n/**\n * Type guard that checks if an array has at most `maxLength` elements.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MaxLengthArray<MaxLength, E>` while preserving the\n *   original array type (e.g. tuple types) via intersection.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isMaxLengthTuple`, which narrows to a union of tuple types.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MaxLengthArray<8, E>` is assignable to\n *   `MaxLengthArray<16, E>`.\n *\n * The length argument comes first, matching the type-parameter order of\n * `MaxLengthArray<MaxLength, Elm>`. Omitting the array returns a reusable type\n * guard, which is convenient for `filter`/`pipe`.\n *\n * @example\n *\n * ```ts\n * const input: readonly string[] = ['a', 'b', 'c'] as const;\n *\n * assert.isTrue(Arr.isMaxLengthArray(8, input));\n *\n * assert.isFalse(Arr.isMaxLengthArray(2, input));\n *\n * if (Arr.isMaxLengthArray(8, input)) {\n *   const tags: MaxLengthArray<8, string> = input;\n *\n *   const relaxed: MaxLengthArray<16, string> = input; // OK (8 <= 16)\n *\n *   assert.deepStrictEqual(tags.length, 3);\n *\n *   assert.deepStrictEqual(relaxed.length, 3);\n * }\n *\n * // curried version\n * const fitsInEight = Arr.isMaxLengthArray(8);\n *\n * assert.isTrue(fitsInEight(input));\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 check.\n * @returns `true` if `xs.length <= maxLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `MaxLengthArray<MaxLength, Xs[number]> & Xs`.\n */\nexport function isMaxLengthArray<\n  MaxLength extends SupportedLength,\n  Xs extends readonly unknown[],\n>(\n  maxLength: MaxLength,\n  xs: Xs,\n): xs is MaxLengthArray<MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function isMaxLengthArray<MaxLength extends SupportedLength>(\n  maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => xs is MaxLengthArray<MaxLength, Xs[number]> & Xs;\n\nexport function isMaxLengthArray(\n  ...args:\n    | readonly [maxLength: SupportedLength, xs: readonly unknown[]]\n    | readonly [maxLength: SupportedLength]\n): boolean | ((xs: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return hasMaxLength(...args);\n\n    case 1:\n      return (xs) => hasMaxLength(args[0], xs);\n  }\n}\n\nconst hasMaxLength = (\n  maxLength: SupportedLength,\n  xs: readonly unknown[],\n): boolean => xs.length <= maxLength;\n\n/**\n * Type guard that checks if an array's length is within the inclusive range\n * `[minLength, maxLength]`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `BoundedLengthArray<MinLength, MaxLength, E>` while\n *   preserving the original array type (e.g. tuple types) via intersection.\n * - Since `BoundedLengthArray` is the intersection of `MinLengthArray` and\n *   `MaxLengthArray`, the narrowed value is assignable to both, and both\n *   bounds can be weakened independently.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isBoundedLengthTuple`, which narrows to a union of tuple types.\n *\n * The length arguments come first, matching the type-parameter order of\n * `BoundedLengthArray<MinLength, MaxLength, Elm>`. Omitting the array returns a\n * reusable type guard, which is convenient for `filter`/`pipe`.\n *\n * @example\n *\n * ```ts\n * const input: readonly number[] = [1, 2, 3] as const;\n *\n * assert.isTrue(Arr.isBoundedLengthArray(1, 5, input));\n *\n * assert.isFalse(Arr.isBoundedLengthArray(1, 5, []));\n *\n * if (Arr.isBoundedLengthArray(1, 5, input)) {\n *   const selection: BoundedLengthArray<1, 5, number> = input;\n *\n *   const relaxed: BoundedLengthArray<0, 100, number> = input; // OK ([1, 5] ⊆ [0, 100])\n *\n *   assert.deepStrictEqual(selection[0], 1);\n *\n *   assert.deepStrictEqual(relaxed.length, 3);\n * }\n *\n * // curried version\n * const isSmallSelection = Arr.isBoundedLengthArray(1, 5);\n *\n * assert.isTrue(isSmallSelection(input));\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 check.\n * @returns `true` if `minLength <= xs.length && xs.length <= maxLength`,\n *   `false` otherwise. When `true`, TypeScript narrows `xs` to\n *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.\n */\nexport function isBoundedLengthArray<\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n  Xs extends readonly unknown[],\n>(\n  minLength: MinLength,\n  maxLength: MaxLength,\n  xs: Xs,\n): xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function isBoundedLengthArray<\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  minLength: MinLength,\n  maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;\n\nexport function isBoundedLengthArray(\n  ...args:\n    | readonly [\n        minLength: SupportedLength,\n        maxLength: SupportedLength,\n        xs: readonly unknown[],\n      ]\n    | readonly [minLength: SupportedLength, maxLength: SupportedLength]\n): boolean | ((xs: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 3:\n      return hasBoundedLength(...args);\n\n    case 2:\n      return (xs) => hasBoundedLength(args[0], args[1], xs);\n  }\n}\n\nconst hasBoundedLength = (\n  minLength: SupportedLength,\n  maxLength: SupportedLength,\n  xs: readonly unknown[],\n): boolean => xs.length >= minLength && xs.length <= maxLength;\n\n/**\n * Type guard that checks if an array has exactly `length` elements.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `FixedLengthArray<Length, E>` while preserving the\n *   original array type (e.g. tuple types) via intersection.\n * - Since `FixedLengthArray<Length, E>` is defined as\n *   `BoundedLengthArray<Length, Length, E>`, the narrowed value is assignable\n *   to any `MinLengthArray<N, E>` with `N <= Length` and any\n *   `MaxLengthArray<N, E>` with `N >= Length`.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isFixedLengthTuple`, which narrows to a structural tuple type.\n *\n * The length argument comes first, matching the type-parameter order of\n * `FixedLengthArray<Length, Elm>`. Omitting the array returns a reusable type\n * guard, which is convenient for `filter`/`pipe`.\n *\n * @example\n *\n * ```ts\n * const input: readonly number[] = [255, 128, 0] as const;\n *\n * assert.isTrue(Arr.isFixedLengthArray(3, input));\n *\n * assert.isFalse(Arr.isFixedLengthArray(4, input));\n *\n * if (Arr.isFixedLengthArray(3, input)) {\n *   const rgb: FixedLengthArray<3, number> = input;\n *\n *   const atMost5: MaxLengthArray<5, number> = input; // OK (3 <= 5)\n *\n *   assert.deepStrictEqual(rgb[0], 255);\n *\n *   assert.deepStrictEqual(atMost5.length, 3);\n * }\n *\n * // curried version\n * const isRgb = Arr.isFixedLengthArray(3);\n *\n * assert.isTrue(isRgb(input));\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 check.\n * @returns `true` if `xs.length === length`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `FixedLengthArray<Length, Xs[number]> & Xs`.\n */\nexport function isFixedLengthArray<\n  Length extends SupportedLength,\n  Xs extends readonly unknown[],\n>(length: Length, xs: Xs): xs is FixedLengthArray<Length, Xs[number]> & Xs;\n\n// Curried version\nexport function isFixedLengthArray<Length extends SupportedLength>(\n  length: Length,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => xs is FixedLengthArray<Length, Xs[number]> & Xs;\n\nexport function isFixedLengthArray(\n  ...args:\n    | readonly [length: SupportedLength, xs: readonly unknown[]]\n    | readonly [length: SupportedLength]\n): boolean | ((xs: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return hasFixedLength(...args);\n\n    case 1:\n      return (xs) => hasFixedLength(args[0], xs);\n  }\n}\n\nconst hasFixedLength = (\n  length: SupportedLength,\n  xs: readonly unknown[],\n): boolean => xs.length === length;\n\n/**\n * Type guard that checks if an array is empty.\n *\n * @example\n *\n * ```ts\n * const emptyNumbers: readonly number[] = [] as const;\n *\n * const words = ['Ada', 'Lovelace'] as const;\n *\n * assert.isTrue(Arr.isEmpty(emptyNumbers));\n *\n * assert.isFalse(Arr.isEmpty(words));\n *\n * if (Arr.isEmpty(emptyNumbers)) {\n *   // `isEmpty` narrows to the branded `FixedLengthArray<0, number>`, so the\n *   // expected value is annotated with the unbranded type.\n *   assert.deepStrictEqual<readonly number[]>(emptyNumbers, []);\n * }\n * ```\n */\nexport const isEmpty = <Xs extends readonly unknown[]>(\n  array: Xs,\n): array is FixedLengthArray<0, Xs[number]> & Xs => array.length === 0;\n\n/**\n * Type guard that checks if an array is non-empty.\n *\n * @example\n *\n * ```ts\n * const users: readonly Readonly<{ id: number }>[] = [{ id: 1 }] as const;\n *\n * const emptyUsers: readonly Readonly<{ id: number }>[] = [] as const;\n *\n * assert.isTrue(Arr.isNonEmpty(users));\n *\n * assert.isFalse(Arr.isNonEmpty(emptyUsers));\n *\n * if (Arr.isNonEmpty(users)) {\n *   assert.deepStrictEqual(users[0], { id: 1 });\n * }\n * ```\n */\nexport const isNonEmpty = <Xs extends readonly unknown[]>(\n  array: Xs,\n): array is MinLengthArray<1, Xs[number]> & Xs => array.length > 0;\n"],"names":[],"mappings":"AAyEO,SAAS,oBACX,IAAA,EAG8C;AACjD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,YAAA,CAAa,GAAG,IAAI,CAAA;AAAA,IAE7B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,EAAA,KAAO,YAAA,CAAa,IAAA,CAAK,CAAC,GAAG,EAAE,CAAA;AAAA;AAE7C;AAEA,MAAM,YAAA,GAAe,CACnB,SAAA,EACA,EAAA,KACY,GAAG,MAAA,IAAU,SAAA;AAmEpB,SAAS,oBACX,IAAA,EAG8C;AACjD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,YAAA,CAAa,GAAG,IAAI,CAAA;AAAA,IAE7B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,EAAA,KAAO,YAAA,CAAa,IAAA,CAAK,CAAC,GAAG,EAAE,CAAA;AAAA;AAE7C;AAEA,MAAM,YAAA,GAAe,CACnB,SAAA,EACA,EAAA,KACY,GAAG,MAAA,IAAU,SAAA;AA6EpB,SAAS,wBACX,IAAA,EAO8C;AACjD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,gBAAA,CAAiB,GAAG,IAAI,CAAA;AAAA,IAEjC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,OAAO,gBAAA,CAAiB,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAA,EAAG,EAAE,CAAA;AAAA;AAE1D;AAEA,MAAM,gBAAA,GAAmB,CACvB,SAAA,EACA,SAAA,EACA,OACY,EAAA,CAAG,MAAA,IAAU,SAAA,IAAa,EAAA,CAAG,MAAA,IAAU,SAAA;AAiE9C,SAAS,sBACX,IAAA,EAG8C;AACjD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,cAAA,CAAe,GAAG,IAAI,CAAA;AAAA,IAE/B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,EAAA,KAAO,cAAA,CAAe,IAAA,CAAK,CAAC,GAAG,EAAE,CAAA;AAAA;AAE/C;AAEA,MAAM,cAAA,GAAiB,CACrB,MAAA,EACA,EAAA,KACY,GAAG,MAAA,KAAW,MAAA;AAuBrB,MAAM,OAAA,GAAU,CACrB,KAAA,KACkD,KAAA,CAAM,MAAA,KAAW;AAqB9D,MAAM,UAAA,GAAa,CACxB,KAAA,KACgD,KAAA,CAAM,MAAA,GAAS;;;;"}
+{"version":3,"file":"array-utils-length-bounded-array-guard.mjs","sourceRoot":"","sources":["../../../src/array/impl/array-utils-length-bounded-array-guard.mts"],"names":[],"mappings":"AAyEA,MAAM,UAAU,gBAAgB,CAC9B,GAAG,IAEsC;IAEzC,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC;YACJ,OAAO,YAAY,CAAC,GAAG,IAAI,CAAC,CAAC;QAE/B,KAAK,CAAC;YACJ,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC7C,CAAC;AACH,CAAC;AAED,MAAM,YAAY,GAAG,CACnB,SAA0B,EAC1B,EAAsB,EACb,EAAE,CAAC,EAAE,CAAC,MAAM,IAAI,SAAS,CAAC;AAmErC,MAAM,UAAU,gBAAgB,CAC9B,GAAG,IAEsC;IAEzC,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC;YACJ,OAAO,YAAY,CAAC,GAAG,IAAI,CAAC,CAAC;QAE/B,KAAK,CAAC;YACJ,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC7C,CAAC;AACH,CAAC;AAED,MAAM,YAAY,GAAG,CACnB,SAA0B,EAC1B,EAAsB,EACb,EAAE,CAAC,EAAE,CAAC,MAAM,IAAI,SAAS,CAAC;AA6ErC,MAAM,UAAU,oBAAoB,CAClC,GAAG,IAMkE;IAErE,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC;YACJ,OAAO,gBAAgB,CAAC,GAAG,IAAI,CAAC,CAAC;QAEnC,KAAK,CAAC;YACJ,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC;AAED,MAAM,gBAAgB,GAAG,CACvB,SAA0B,EAC1B,SAA0B,EAC1B,EAAsB,EACb,EAAE,CAAC,EAAE,CAAC,MAAM,IAAI,SAAS,IAAI,EAAE,CAAC,MAAM,IAAI,SAAS,CAAC;AAiE/D,MAAM,UAAU,kBAAkB,CAChC,GAAG,IAEmC;IAEtC,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC;YACJ,OAAO,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;QAEjC,KAAK,CAAC;YACJ,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC;AAED,MAAM,cAAc,GAAG,CACrB,MAAuB,EACvB,EAAsB,EACb,EAAE,CAAC,EAAE,CAAC,MAAM,KAAK,MAAM,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,KAAS,EACsC,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,KAAS,EACoC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC"}

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

@@ -1,87 +1,116 @@
-import { isEmptyTuple, isMinLengthTuple, isBoundedLengthTuple, isFixedLengthTuple, isMaxLengthTuple } from './array-utils-length-bounded-tuple-guard.mjs';
-
-function asFixedLengthTuple(...args) {
-  switch (args.length) {
-    case 2:
-      return asFixedLengthTupleImpl(...args);
-    case 1:
-      return (xs) => asFixedLengthTupleImpl(args[0], xs);
-  }
+import { isBoundedLengthTuple, isEmptyTuple, isFixedLengthTuple, isMaxLengthTuple, isMinLengthTuple, } from './array-utils-length-bounded-tuple-guard.mjs';
+export function asFixedLengthTuple(...args) {
+    switch (args.length) {
+        case 2:
+            return asFixedLengthTupleImpl(...args);
+        case 1:
+            return (xs) => asFixedLengthTupleImpl(args[0], xs);
+    }
 }
 const asFixedLengthTupleImpl = (length, xs) => {
-  const actualLength = xs.length;
-  if (!isFixedLengthTuple(length, xs)) {
-    throw new TypeError(
-      `Expected an array of length ${length}, got an array of length ${actualLength}`
-    );
-  }
-  return xs;
+    const actualLength = xs.length;
+    if (!isFixedLengthTuple(length, xs)) {
+        throw new TypeError(`Expected an array of length ${length}, got an array of length ${actualLength}`);
+    }
+    return xs;
 };
-function asMinLengthTuple(...args) {
-  switch (args.length) {
-    case 2:
-      return asMinLengthTupleImpl(...args);
-    case 1:
-      return (xs) => asMinLengthTupleImpl(args[0], xs);
-  }
+export function asMinLengthTuple(...args) {
+    switch (args.length) {
+        case 2:
+            return asMinLengthTupleImpl(...args);
+        case 1:
+            return (xs) => asMinLengthTupleImpl(args[0], xs);
+    }
 }
 const asMinLengthTupleImpl = (minLength, xs) => {
-  const actualLength = xs.length;
-  if (!isMinLengthTuple(minLength, xs)) {
-    throw new TypeError(
-      `Expected an array of length >= ${minLength}, got an array of length ${actualLength}`
-    );
-  }
-  return xs;
+    const actualLength = xs.length;
+    if (!isMinLengthTuple(minLength, xs)) {
+        throw new TypeError(`Expected an array of length >= ${minLength}, got an array of length ${actualLength}`);
+    }
+    return xs;
 };
-function asMaxLengthTuple(...args) {
-  switch (args.length) {
-    case 2:
-      return asMaxLengthTupleImpl(...args);
-    case 1:
-      return (xs) => asMaxLengthTupleImpl(args[0], xs);
-  }
+export function asMaxLengthTuple(...args) {
+    switch (args.length) {
+        case 2:
+            return asMaxLengthTupleImpl(...args);
+        case 1:
+            return (xs) => asMaxLengthTupleImpl(args[0], xs);
+    }
 }
 const asMaxLengthTupleImpl = (maxLength, xs) => {
-  const actualLength = xs.length;
-  if (!isMaxLengthTuple(maxLength, xs)) {
-    throw new TypeError(
-      `Expected an array of length <= ${maxLength}, got an array of length ${actualLength}`
-    );
-  }
-  return xs;
+    const actualLength = xs.length;
+    if (!isMaxLengthTuple(maxLength, xs)) {
+        throw new TypeError(`Expected an array of length <= ${maxLength}, got an array of length ${actualLength}`);
+    }
+    return xs;
 };
-function asBoundedLengthTuple(...args) {
-  switch (args.length) {
-    case 3:
-      return asBoundedLengthTupleImpl(...args);
-    case 2:
-      return (xs) => asBoundedLengthTupleImpl(...args, xs);
-  }
+export function asBoundedLengthTuple(...args) {
+    switch (args.length) {
+        case 3:
+            return asBoundedLengthTupleImpl(...args);
+        case 2:
+            return (xs) => asBoundedLengthTupleImpl(...args, xs);
+    }
 }
 const asBoundedLengthTupleImpl = (min, max, xs) => {
-  const actualLength = xs.length;
-  if (!isBoundedLengthTuple(min, max, xs)) {
-    throw new TypeError(
-      `Expected an array of length in [${min}, ${max}], got an array of length ${actualLength}`
-    );
-  }
-  return xs;
+    const actualLength = xs.length;
+    if (!isBoundedLengthTuple(min, max, xs)) {
+        throw new TypeError(`Expected an array of length in [${min}, ${max}], got an array of length ${actualLength}`);
+    }
+    return xs;
 };
-const asEmptyTuple = (xs) => {
-  if (!isEmptyTuple(xs)) {
-    throw new TypeError(
-      `Expected an empty array, got an array of length ${xs.length}`
-    );
-  }
-  return xs;
+/**
+ * Casts an array to the structural empty tuple after checking that it is
+ * empty.
+ *
+ * This is the structural counterpart of `asEmptyArray`, and the length-0
+ * specialization of {@link asFixedLengthTuple}.
+ *
+ * @example
+ *
+ * ```ts
+ * const nothing = Arr.asEmptyTuple([]);
+ *
+ * // Arr.asEmptyTuple([1]); // throws TypeError
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @param xs - The array to cast.
+ * @returns `xs` typed as `readonly [] & Xs`.
+ * @throws {TypeError} If `xs` is not empty.
+ */
+export const asEmptyTuple = (xs) => {
+    if (!isEmptyTuple(xs)) {
+        throw new TypeError(`Expected an empty array, got an array of length ${xs.length}`);
+    }
+    return xs;
 };
-const asNonEmptyTuple = (xs) => {
-  if (!isMinLengthTuple(1, xs)) {
-    throw new TypeError("Expected a non-empty array, got an empty array");
-  }
-  return xs;
+/**
+ * Casts an array to `MinLengthTuple<1, E>` after checking that it has at least
+ * one element.
+ *
+ * This is the structural counterpart of `asNonEmptyArray`, and the length-1
+ * specialization of {@link asMinLengthTuple}.
+ *
+ * @example
+ *
+ * ```ts
+ * const values = Arr.asNonEmptyTuple([1, 2, 3]);
+ *
+ * const first: number = values[0]; // OK — no `undefined`
+ *
+ * // Arr.asNonEmptyTuple([]); // throws TypeError
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @param xs - The array to cast.
+ * @returns `xs` typed as `MinLengthTuple<1, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs` is empty.
+ */
+export const asNonEmptyTuple = (xs) => {
+    if (!isMinLengthTuple(1, xs)) {
+        throw new TypeError('Expected a non-empty array, got an empty array');
+    }
+    return xs;
 };
-
-export { asBoundedLengthTuple, asEmptyTuple, asFixedLengthTuple, asMaxLengthTuple, asMinLengthTuple, asNonEmptyTuple };
-//# sourceMappingURL=array-utils-length-bounded-tuple-cast.mjs.map
+//# sourceMappingURL=array-utils-length-bounded-tuple-cast.mjs.map

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

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

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

@@ -1,41 +1,85 @@
-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);
-  }
+/**
+ * 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 const isEmptyTuple = (array) => array.length === 0;
+/**
+ * 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 const isNonEmptyTuple = (array) => array.length >= 1;
+export 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);
-  }
+export 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);
-  }
+export 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);
-  }
+export 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
+//# sourceMappingURL=array-utils-length-bounded-tuple-guard.mjs.map

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

@@ -1 +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;;;;"}
+{"version":3,"file":"array-utils-length-bounded-tuple-guard.mjs","sourceRoot":"","sources":["../../../src/array/impl/array-utils-length-bounded-tuple-guard.mts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAK,KAAmB,EAAwB,EAAE,CAC5E,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,KAAmB,EACY,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;AA+BtD,MAAM,UAAU,kBAAkB,CAChC,GAAG,IAEgC;IAEnC,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC;YACJ,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAE1C,KAAK,CAAC;YACJ,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACrD,CAAC;AACH,CAAC;AAED,MAAM,cAAc,GAAG,CACrB,GAAoB,EACpB,KAAyB,EAChB,EAAE,CAAC,KAAK,CAAC,MAAM,KAAK,GAAG,CAAC;AA+BnC,MAAM,UAAU,gBAAgB,CAC9B,GAAG,IAEgC;IAEnC,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC;YACJ,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAExC,KAAK,CAAC;YACJ,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACnD,CAAC;AACH,CAAC;AAED,MAAM,YAAY,GAAG,CACnB,GAAoB,EACpB,KAAyB,EAChB,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,GAAG,CAAC;AA+BlC,MAAM,UAAU,gBAAgB,CAC9B,GAAG,IAEgC;IAEnC,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC;YACJ,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAExC,KAAK,CAAC;YACJ,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IACnD,CAAC;AACH,CAAC;AAED,MAAM,YAAY,GAAG,CACnB,GAAoB,EACpB,KAAyB,EAChB,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,GAAG,CAAC;AAwClC,MAAM,UAAU,oBAAoB,CAClC,GAAG,IAMsD;IAEzD,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;QACpB,KAAK,CAAC;YACJ,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAEnD,KAAK,CAAC;YACJ,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAC9D,CAAC;AACH,CAAC;AAED,MAAM,cAAc,GAAG,CACrB,GAAoB,EACpB,GAAoB,EACpB,KAAyB,EAChB,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,MAAM,IAAI,GAAG,CAAC"}