ts-data-forge 9.0.0 → 10.0.0

package/dist/functional/ternary-result/impl/variant-name.mjs

@@ -1,15 +1,14 @@
 import { ErrTypeTagName, WarnTypeTagName, OkTypeTagName } from './tag.mjs';
 
-/** @internal Returns the human readable variant label for the given tag. */
 const variantName = (tag) => {
-    switch (tag) {
-        case OkTypeTagName:
-            return 'Ok';
-        case WarnTypeTagName:
-            return 'Warn';
-        case ErrTypeTagName:
-            return 'Err';
-    }
+  switch (tag) {
+    case OkTypeTagName:
+      return "Ok";
+    case WarnTypeTagName:
+      return "Warn";
+    case ErrTypeTagName:
+      return "Err";
+  }
 };
 
 export { variantName };

package/dist/functional/ternary-result/impl/variant-name.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"variant-name.mjs","sources":["../../../../src/functional/ternary-result/impl/variant-name.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;AACO,MAAM,WAAW,GAAG,CACzB,GAAkC,KACT;IACzB,QAAQ,GAAG;AACT,QAAA,KAAK,aAAa;AAChB,YAAA,OAAO,IAAI;AAEb,QAAA,KAAK,eAAe;AAClB,YAAA,OAAO,MAAM;AAEf,QAAA,KAAK,cAAc;AACjB,YAAA,OAAO,KAAK;;AAElB;;;;"}
+{"version":3,"file":"variant-name.mjs","sources":["../../../../src/functional/ternary-result/impl/variant-name.mts"],"sourcesContent":["import { type UnknownTernaryResult } from '../ternary-result.mjs';\nimport { ErrTypeTagName, OkTypeTagName, WarnTypeTagName } from './tag.mjs';\n\n/** @internal Returns the human readable variant label for the given tag. */\nexport const variantName = (\n  tag: UnknownTernaryResult['$$tag'],\n): 'Ok' | 'Warn' | 'Err' => {\n  switch (tag) {\n    case OkTypeTagName:\n      return 'Ok';\n\n    case WarnTypeTagName:\n      return 'Warn';\n\n    case ErrTypeTagName:\n      return 'Err';\n  }\n};\n"],"names":[],"mappings":";;AAIO,MAAM,WAAA,GAAc,CACzB,GAAA,KAC0B;AAC1B,EAAA,QAAQ,GAAA;AAAK,IACX,KAAK,aAAA;AACH,MAAA,OAAO,IAAA;AAAA,IAET,KAAK,eAAA;AACH,MAAA,OAAO,MAAA;AAAA,IAET,KAAK,cAAA;AACH,MAAA,OAAO,KAAA;AAAA;AAEb;;;;"}

package/dist/guard/as-length-bounded-array.d.mts

@@ -0,0 +1,117 @@
+import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, type MinLengthArray, type SupportedLength } from 'ts-type-forge';
+/**
+ * Casts an array to `FixedLengthArray<Length, E>` after checking that it has
+ * exactly `length` elements.
+ *
+ * Use this instead of writing `xs as unknown as FixedLengthArray<N, E>`: the
+ * length is verified at runtime, and the original array type (e.g. tuple
+ * types) is preserved via intersection, so the result also benefits from the
+ * structural tuple prefix (in-range indexed access without `undefined` under
+ * `noUncheckedIndexedAccess`).
+ *
+ * @example
+ *
+ * ```ts
+ * const rgb = asFixedLengthArray([255, 128, 0], 3);
+ *
+ * const atMost5: MaxLengthArray<5, number> = rgb; // OK (3 <= 5)
+ * const red: number = rgb[0]; // OK — no `undefined`
+ *
+ * // asFixedLengthArray([255, 128], 3); // throws TypeError
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @template Length - The exact number of elements.
+ * @param xs - The array to cast.
+ * @param length - The exact number of elements.
+ * @returns `xs` typed as `FixedLengthArray<Length, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs.length !== length`.
+ */
+export declare const asFixedLengthArray: <Xs extends readonly unknown[], Length extends SupportedLength>(xs: Xs, length: Length) => FixedLengthArray<Length, Xs[number]> & Xs;
+/**
+ * Casts an array to `MinLengthArray<MinLength, E>` after checking that it has
+ * at least `minLength` elements.
+ *
+ * Use this instead of writing `xs as unknown as MinLengthArray<N, E>`: the
+ * length is verified at runtime, and the original array type (e.g. tuple
+ * types) is preserved via intersection, so the result also benefits from the
+ * structural tuple prefix (indexed access below `min(N, 10)` without
+ * `undefined` under `noUncheckedIndexedAccess`).
+ *
+ * @example
+ *
+ * ```ts
+ * const history = asMinLengthArray([0, 1, 2, 3], 3);
+ *
+ * const nonEmpty: MinLengthArray<1, number> = history; // OK (3 >= 1)
+ * const first: number = history[0]; // OK — no `undefined`
+ *
+ * // asMinLengthArray([0], 3); // throws TypeError
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @template MinLength - The minimum number of elements (inclusive).
+ * @param xs - The array to cast.
+ * @param minLength - The minimum number of elements (inclusive).
+ * @returns `xs` typed as `MinLengthArray<MinLength, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs.length < minLength`.
+ */
+export declare const asMinLengthArray: <Xs extends readonly unknown[], MinLength extends SupportedLength>(xs: Xs, minLength: MinLength) => MinLengthArray<MinLength, Xs[number]> & Xs;
+/**
+ * Casts an array to `MaxLengthArray<MaxLength, E>` after checking that it has
+ * at most `maxLength` elements.
+ *
+ * Use this instead of writing `xs as unknown as MaxLengthArray<N, E>`: the
+ * length is verified at runtime, and the original array type (e.g. tuple
+ * types) is preserved via intersection.
+ *
+ * @example
+ *
+ * ```ts
+ * const tags = asMaxLengthArray(['a', 'b', 'c'], 8);
+ *
+ * const relaxed: MaxLengthArray<16, string> = tags; // OK (8 <= 16)
+ *
+ * // asMaxLengthArray(['a', 'b', 'c'], 2); // throws TypeError
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @template MaxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to cast.
+ * @param maxLength - The maximum number of elements (inclusive).
+ * @returns `xs` typed as `MaxLengthArray<MaxLength, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs.length > maxLength`.
+ */
+export declare const asMaxLengthArray: <Xs extends readonly unknown[], MaxLength extends SupportedLength>(xs: Xs, maxLength: MaxLength) => MaxLengthArray<MaxLength, Xs[number]> & Xs;
+/**
+ * Casts an array to `BoundedLengthArray<MinLength, MaxLength, E>` after
+ * checking that its length is within the inclusive range
+ * `[minLength, maxLength]`.
+ *
+ * Use this instead of writing
+ * `xs as unknown as BoundedLengthArray<Min, Max, E>`: the length is verified
+ * at runtime, and the original array type (e.g. tuple types) is preserved via
+ * intersection.
+ *
+ * @example
+ *
+ * ```ts
+ * const selection = asBoundedLengthArray([1, 2, 3], 1, 5);
+ *
+ * const relaxed: BoundedLengthArray<0, 100, number> = selection; // OK
+ *
+ * // asBoundedLengthArray([], 1, 5); // throws TypeError
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @template MinLength - The minimum number of elements (inclusive).
+ * @template MaxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to cast.
+ * @param minLength - The minimum number of elements (inclusive).
+ * @param maxLength - The maximum number of elements (inclusive).
+ * @returns `xs` typed as
+ *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs.length < minLength || xs.length > maxLength`.
+ */
+export declare const asBoundedLengthArray: <Xs extends readonly unknown[], MinLength extends SupportedLength, MaxLength extends SupportedLength>(xs: Xs, minLength: MinLength, maxLength: MaxLength) => BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+//# sourceMappingURL=as-length-bounded-array.d.mts.map

package/dist/guard/as-length-bounded-array.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"as-length-bounded-array.d.mts","sourceRoot":"","sources":["../../src/guard/as-length-bounded-array.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAQvB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,kBAAkB,GAC7B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,MAAM,SAAS,eAAe,MAE1B,EAAE,UACE,MAAM,KACb,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAQzC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB,GAC3B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,KACnB,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAQ1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,gBAAgB,GAC3B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,KACnB,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAQ1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,oBAAoB,GAC/B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,EACjC,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,aACT,SAAS,KACnB,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAQzD,CAAC"}

package/dist/guard/as-length-bounded-array.mjs

@@ -0,0 +1,37 @@
+import { isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray, isMinLengthArray } from './is-length-bounded-array.mjs';
+
+const asFixedLengthArray = (xs, length) => {
+  if (!isFixedLengthArray(xs, length)) {
+    throw new TypeError(
+      `Expected an array of length ${length}, got an array of length ${xs.length}`
+    );
+  }
+  return xs;
+};
+const asMinLengthArray = (xs, minLength) => {
+  if (!isMinLengthArray(xs, minLength)) {
+    throw new TypeError(
+      `Expected an array of length >= ${minLength}, got an array of length ${xs.length}`
+    );
+  }
+  return xs;
+};
+const asMaxLengthArray = (xs, maxLength) => {
+  if (!isMaxLengthArray(xs, maxLength)) {
+    throw new TypeError(
+      `Expected an array of length <= ${maxLength}, got an array of length ${xs.length}`
+    );
+  }
+  return xs;
+};
+const asBoundedLengthArray = (xs, minLength, maxLength) => {
+  if (!isBoundedLengthArray(xs, minLength, maxLength)) {
+    throw new TypeError(
+      `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${xs.length}`
+    );
+  }
+  return xs;
+};
+
+export { asBoundedLengthArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray };
+//# sourceMappingURL=as-length-bounded-array.mjs.map

package/dist/guard/as-length-bounded-array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"as-length-bounded-array.mjs","sources":["../../src/guard/as-length-bounded-array.mts"],"sourcesContent":["import {\n  type BoundedLengthArray,\n  type FixedLengthArray,\n  type MaxLengthArray,\n  type MinLengthArray,\n  type SupportedLength,\n} from 'ts-type-forge';\nimport {\n  isBoundedLengthArray,\n  isFixedLengthArray,\n  isMaxLengthArray,\n  isMinLengthArray,\n} from './is-length-bounded-array.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 * @example\n *\n * ```ts\n * const rgb = asFixedLengthArray([255, 128, 0], 3);\n *\n * const atMost5: MaxLengthArray<5, number> = rgb; // OK (3 <= 5)\n * const red: number = rgb[0]; // OK — no `undefined`\n *\n * // asFixedLengthArray([255, 128], 3); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template Length - The exact number of elements.\n * @param xs - The array to cast.\n * @param length - The exact number of elements.\n * @returns `xs` typed as `FixedLengthArray<Length, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length !== length`.\n */\nexport const asFixedLengthArray = <\n  Xs extends readonly unknown[],\n  Length extends SupportedLength,\n>(\n  xs: Xs,\n  length: Length,\n): FixedLengthArray<Length, Xs[number]> & Xs => {\n  if (!isFixedLengthArray(xs, length)) {\n    throw new TypeError(\n      `Expected an array of length ${length}, got an array of length ${xs.length}`,\n    );\n  }\n\n  return xs;\n};\n\n/**\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 * @example\n *\n * ```ts\n * const history = asMinLengthArray([0, 1, 2, 3], 3);\n *\n * const nonEmpty: MinLengthArray<1, number> = history; // OK (3 >= 1)\n * const first: number = history[0]; // OK — no `undefined`\n *\n * // asMinLengthArray([0], 3); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param minLength - The minimum number of elements (inclusive).\n * @returns `xs` typed as `MinLengthArray<MinLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength`.\n */\nexport const asMinLengthArray = <\n  Xs extends readonly unknown[],\n  MinLength extends SupportedLength,\n>(\n  xs: Xs,\n  minLength: MinLength,\n): MinLengthArray<MinLength, Xs[number]> & Xs => {\n  if (!isMinLengthArray(xs, minLength)) {\n    throw new TypeError(\n      `Expected an array of length >= ${minLength}, got an array of length ${xs.length}`,\n    );\n  }\n\n  return xs;\n};\n\n/**\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 * @example\n *\n * ```ts\n * const tags = asMaxLengthArray(['a', 'b', 'c'], 8);\n *\n * const relaxed: MaxLengthArray<16, string> = tags; // OK (8 <= 16)\n *\n * // asMaxLengthArray(['a', 'b', 'c'], 2); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `xs` typed as `MaxLengthArray<MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length > maxLength`.\n */\nexport const asMaxLengthArray = <\n  Xs extends readonly unknown[],\n  MaxLength extends SupportedLength,\n>(\n  xs: Xs,\n  maxLength: MaxLength,\n): MaxLengthArray<MaxLength, Xs[number]> & Xs => {\n  if (!isMaxLengthArray(xs, maxLength)) {\n    throw new TypeError(\n      `Expected an array of length <= ${maxLength}, got an array of length ${xs.length}`,\n    );\n  }\n\n  return xs;\n};\n\n/**\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 * @example\n *\n * ```ts\n * const selection = asBoundedLengthArray([1, 2, 3], 1, 5);\n *\n * const relaxed: BoundedLengthArray<0, 100, number> = selection; // OK\n *\n * // asBoundedLengthArray([], 1, 5); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param minLength - The minimum number of elements (inclusive).\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `xs` typed as\n *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength || xs.length > maxLength`.\n */\nexport const asBoundedLengthArray = <\n  Xs extends readonly unknown[],\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  xs: Xs,\n  minLength: MinLength,\n  maxLength: MaxLength,\n): BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs => {\n  if (!isBoundedLengthArray(xs, minLength, maxLength)) {\n    throw new TypeError(\n      `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${xs.length}`,\n    );\n  }\n\n  return xs;\n};\n"],"names":[],"mappings":";;AA0CO,MAAM,kBAAA,GAAqB,CAIhC,EAAA,EACA,MAAA,KAC8C;AAC9C,EAAA,IAAI,CAAC,kBAAA,CAAmB,EAAA,EAAI,MAAM,CAAA,EAAG;AACnC,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,4BAAA,EAA+B,MAAM,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,KAC5E;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT;AA8BO,MAAM,gBAAA,GAAmB,CAI9B,EAAA,EACA,SAAA,KAC+C;AAC/C,EAAA,IAAI,CAAC,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA,EAAG;AACpC,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,KAClF;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT;AA2BO,MAAM,gBAAA,GAAmB,CAI9B,EAAA,EACA,SAAA,KAC+C;AAC/C,EAAA,IAAI,CAAC,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA,EAAG;AACpC,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,KAClF;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT;AAgCO,MAAM,oBAAA,GAAuB,CAKlC,EAAA,EACA,SAAA,EACA,SAAA,KAC8D;AAC9D,EAAA,IAAI,CAAC,oBAAA,CAAqB,EAAA,EAAI,SAAA,EAAW,SAAS,CAAA,EAAG;AACnD,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,mCAAmC,SAAS,CAAA,EAAA,EAAK,SAAS,CAAA,0BAAA,EAA6B,GAAG,MAAM,CAAA;AAAA,KAClG;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT;;;;"}

package/dist/guard/has-key.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"has-key.d.mts","sourceRoot":"","sources":["../../src/guard/has-key.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,CAAC,CAAC,SAAS,aAAa,EAC7B,KAAK,CAAC,CAAC,SAAS,WAAW,EAE3B,KAAK,CAAC,EACN,KAAK,CAAC,KACL,GAAG,IAAI,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAA4B,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,aAAa,EACvB,CAAC,SAAS,WAAW,IACnB,CAAC,SAAS,CAAC,GACX,CAAC,SAAS,MAAM,CAAC,GACf,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,CAAC,GACP,KAAK,GACP,KAAK,CAAC"}
+{"version":3,"file":"has-key.d.mts","sourceRoot":"","sources":["../../src/guard/has-key.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,MAAM,GACjB,KAAK,CAAC,CAAC,SAAS,aAAa,EAC7B,KAAK,CAAC,CAAC,SAAS,WAAW,OAEtB,CAAC,OACD,CAAC,KACL,GAAG,IAAI,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAA4B,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,aAAa,EACvB,CAAC,SAAS,WAAW,IACnB,CAAC,SAAS,CAAC,GACX,CAAC,SAAS,MAAM,CAAC,GACf,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,MAAM,SAAS,MAAM,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,GACjC,CAAC,GACP,KAAK,GACP,KAAK,CAAC"}

package/dist/guard/has-key.mjs

@@ -1,44 +1,3 @@
-/**
- * Type guard function that checks if an object has a specific key as its own
- * property.
- *
- * This function uses `Object.hasOwn()` to check if the given object has the
- * specified key as its own property (not inherited). It acts as a type guard
- * that narrows the type of the object to guarantee the key exists, enabling
- * type-safe property access.
- *
- * **Type Narrowing Behavior:**
- *
- * - When the guard returns `true`, TypeScript narrows the object type to include
- *   the checked key
- * - For union types, only union members that contain the key are preserved
- * - The key's value type is preserved from the original object type when possible
- *
- * @example
- *
- * ```ts
- * const maybeUser: Readonly<{ id?: number; name?: string }> = {
- *   id: 42,
- * } as const;
- *
- * if (hasKey(maybeUser, 'id')) {
- *   // `maybeUser` is now known to have an `id` property.
- *   assert.isTrue(maybeUser.id === 42);
- * } else {
- *   assert.fail();
- * }
- * ```
- *
- * @template R - The type of the input object, must extend UnknownRecord
- * @template K - The type of the key to check for, must extend PropertyKey
- *   (string | number | symbol)
- * @param obj - The object to check for the presence of the key
- * @param key - The key to check for in the object
- * @returns `true` if the object has the specified key as its own property,
- *   `false` otherwise. When `true`, TypeScript narrows the object type to
- *   guarantee the key exists.
- * @see {@link keyIsIn} - Similar function that narrows the key type instead of the object type
- */
 const hasKey = (obj, key) => Object.hasOwn(obj, key);
 
 export { hasKey };

package/dist/guard/has-key.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"has-key.mjs","sources":["../../src/guard/has-key.mts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCG;AACI,MAAM,MAAM,GAAG,CAIpB,GAAM,EACN,GAAM,KAC4B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG;;;;"}
+{"version":3,"file":"has-key.mjs","sources":["../../src/guard/has-key.mts"],"sourcesContent":["import { type ReadonlyRecord, type UnknownRecord } from 'ts-type-forge';\n\n/**\n * Type guard function that checks if an object has a specific key as its own\n * property.\n *\n * This function uses `Object.hasOwn()` to check if the given object has the\n * specified key as its own property (not inherited). It acts as a type guard\n * that narrows the type of the object to guarantee the key exists, enabling\n * type-safe property access.\n *\n * **Type Narrowing Behavior:**\n *\n * - When the guard returns `true`, TypeScript narrows the object type to include\n *   the checked key\n * - For union types, only union members that contain the key are preserved\n * - The key's value type is preserved from the original object type when possible\n *\n * @example\n *\n * ```ts\n * const maybeUser: Readonly<{ id?: number; name?: string }> = {\n *   id: 42,\n * } as const;\n *\n * if (hasKey(maybeUser, 'id')) {\n *   // `maybeUser` is now known to have an `id` property.\n *   assert.isTrue(maybeUser.id === 42);\n * } else {\n *   assert.fail();\n * }\n * ```\n *\n * @template R - The type of the input object, must extend UnknownRecord\n * @template K - The type of the key to check for, must extend PropertyKey\n *   (string | number | symbol)\n * @param obj - The object to check for the presence of the key\n * @param key - The key to check for in the object\n * @returns `true` if the object has the specified key as its own property,\n *   `false` otherwise. When `true`, TypeScript narrows the object type to\n *   guarantee the key exists.\n * @see {@link keyIsIn} - Similar function that narrows the key type instead of the object type\n */\nexport const hasKey = <\n  const R extends UnknownRecord,\n  const K extends PropertyKey,\n>(\n  obj: R,\n  key: K,\n): obj is HasKeyReturnType<R, K> => Object.hasOwn(obj, key);\n\n/**\n * @internal\n * When R is a union type (including the case with only one element), if any element in the union\n * contains K as a key, returns a type that narrows the union to only those elements that contain K as a key.\n * If none of the elements in the union contain K as a key, returns `ReadonlyRecord<K, unknown>`.\n * The result is made readonly.\n */\nexport type HasKeyReturnType<\n  R extends UnknownRecord,\n  K extends PropertyKey,\n> = R extends R // union distribution\n  ? K extends keyof R\n    ? string extends keyof R\n      ? ReadonlyRecord<K, R[keyof R]> & R\n      : number extends keyof R\n        ? ReadonlyRecord<K, R[keyof R]> & R\n        : symbol extends keyof R\n          ? ReadonlyRecord<K, R[keyof R]> & R\n          : R\n    : never // omit union member that does not have key K\n  : never; // dummy case for union distribution\n"],"names":[],"mappings":"AA2CO,MAAM,SAAS,CAIpB,GAAA,EACA,QACkC,MAAA,CAAO,MAAA,CAAO,KAAK,GAAG;;;;"}

package/dist/guard/index.d.mts

@@ -1,4 +1,6 @@
+export * from './as-length-bounded-array.mjs';
 export * from './has-key.mjs';
+export * from './is-length-bounded-array.mjs';
 export * from './is-length-bounded-string.mjs';
 export * from './is-non-empty-string.mjs';
 export * from './is-non-null-object.mjs';

package/dist/guard/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/guard/index.mts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/guard/index.mts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/dist/guard/index.mjs

@@ -1,4 +1,6 @@
+export { asBoundedLengthArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray } from './as-length-bounded-array.mjs';
 export { hasKey } from './has-key.mjs';
+export { isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray, isMinLengthArray } from './is-length-bounded-array.mjs';
 export { isBoundedLengthString, isFixedLengthString, isMaxLengthString, isMinLengthString } from './is-length-bounded-string.mjs';
 export { isNonEmptyString } from './is-non-empty-string.mjs';
 export { isNonNullObject } from './is-non-null-object.mjs';

package/dist/guard/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}

package/dist/guard/is-length-bounded-array.d.mts

@@ -0,0 +1,159 @@
+import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, type MinLengthArray, type SupportedLength } from 'ts-type-forge';
+/**
+ * Type guard that checks if an array has at least `minLength` elements.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `MinLengthArray<MinLength, E>` while preserving the
+ *   original array type (e.g. tuple types) via intersection.
+ * - The length constraint lives only in the brand, so this stays cheap for the
+ *   type checker even when the element type is large — unlike
+ *   `isMinLengthTuple`, which narrows to a structural tuple type.
+ * - The result participates in the length-constraint subtyping relation: for
+ *   example, a value narrowed to `MinLengthArray<3, E>` is assignable to
+ *   `MinLengthArray<1, E>`.
+ *
+ * @example
+ *
+ * ```ts
+ * const input: readonly number[] = [0, 1, 2, 3];
+ *
+ * assert.isTrue(isMinLengthArray(input, 3));
+ *
+ * assert.isFalse(isMinLengthArray([0], 3));
+ *
+ * if (isMinLengthArray(input, 3)) {
+ *   const history: MinLengthArray<3, number> = input;
+ *
+ *   const nonEmpty: MinLengthArray<1, number> = input; // OK (3 >= 1)
+ * }
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @template MinLength - The minimum number of elements (inclusive).
+ * @param xs - The array to check.
+ * @param minLength - The minimum number of elements (inclusive).
+ * @returns `true` if `xs.length >= minLength`, `false` otherwise. When `true`,
+ *   TypeScript narrows `xs` to `MinLengthArray<MinLength, Xs[number]> & Xs`.
+ */
+export declare const isMinLengthArray: <Xs extends readonly unknown[], MinLength extends SupportedLength>(xs: Xs, minLength: MinLength) => xs is MinLengthArray<MinLength, Xs[number]> & Xs;
+/**
+ * Type guard that checks if an array has at most `maxLength` elements.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `MaxLengthArray<MaxLength, E>` while preserving the
+ *   original array type (e.g. tuple types) via intersection.
+ * - The length constraint lives only in the brand, so this stays cheap for the
+ *   type checker even when the element type is large — unlike
+ *   `isMaxLengthTuple`, which narrows to a union of tuple types.
+ * - The result participates in the length-constraint subtyping relation: for
+ *   example, a value narrowed to `MaxLengthArray<8, E>` is assignable to
+ *   `MaxLengthArray<16, E>`.
+ *
+ * @example
+ *
+ * ```ts
+ * const input: readonly string[] = ['a', 'b', 'c'];
+ *
+ * assert.isTrue(isMaxLengthArray(input, 8));
+ *
+ * assert.isFalse(isMaxLengthArray(input, 2));
+ *
+ * if (isMaxLengthArray(input, 8)) {
+ *   const tags: MaxLengthArray<8, string> = input;
+ *
+ *   const relaxed: MaxLengthArray<16, string> = input; // OK (8 <= 16)
+ * }
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @template MaxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to check.
+ * @param maxLength - The maximum number of elements (inclusive).
+ * @returns `true` if `xs.length <= maxLength`, `false` otherwise. When `true`,
+ *   TypeScript narrows `xs` to `MaxLengthArray<MaxLength, Xs[number]> & Xs`.
+ */
+export declare const isMaxLengthArray: <Xs extends readonly unknown[], MaxLength extends SupportedLength>(xs: Xs, maxLength: MaxLength) => xs is MaxLengthArray<MaxLength, Xs[number]> & Xs;
+/**
+ * Type guard that checks if an array's length is within the inclusive range
+ * `[minLength, maxLength]`.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `BoundedLengthArray<MinLength, MaxLength, E>` while
+ *   preserving the original array type (e.g. tuple types) via intersection.
+ * - Since `BoundedLengthArray` is the intersection of `MinLengthArray` and
+ *   `MaxLengthArray`, the narrowed value is assignable to both, and both
+ *   bounds can be weakened independently.
+ * - The length constraint lives only in the brand, so this stays cheap for the
+ *   type checker even when the element type is large — unlike
+ *   `isBoundedLengthTuple`, which narrows to a union of tuple types.
+ *
+ * @example
+ *
+ * ```ts
+ * const input: readonly number[] = [1, 2, 3];
+ *
+ * assert.isTrue(isBoundedLengthArray(input, 1, 5));
+ *
+ * assert.isFalse(isBoundedLengthArray([], 1, 5));
+ *
+ * if (isBoundedLengthArray(input, 1, 5)) {
+ *   const selection: BoundedLengthArray<1, 5, number> = input;
+ *
+ *   const relaxed: BoundedLengthArray<0, 100, number> = input; // OK ([1, 5] ⊆ [0, 100])
+ * }
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @template MinLength - The minimum number of elements (inclusive).
+ * @template MaxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to check.
+ * @param minLength - The minimum number of elements (inclusive).
+ * @param maxLength - The maximum number of elements (inclusive).
+ * @returns `true` if `minLength <= xs.length && xs.length <= maxLength`,
+ *   `false` otherwise. When `true`, TypeScript narrows `xs` to
+ *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.
+ */
+export declare const isBoundedLengthArray: <Xs extends readonly unknown[], MinLength extends SupportedLength, MaxLength extends SupportedLength>(xs: Xs, minLength: MinLength, maxLength: MaxLength) => xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+/**
+ * Type guard that checks if an array has exactly `length` elements.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input to `FixedLengthArray<Length, E>` while preserving the
+ *   original array type (e.g. tuple types) via intersection.
+ * - Since `FixedLengthArray<Length, E>` is defined as
+ *   `BoundedLengthArray<Length, Length, E>`, the narrowed value is assignable
+ *   to any `MinLengthArray<N, E>` with `N <= Length` and any
+ *   `MaxLengthArray<N, E>` with `N >= Length`.
+ * - The length constraint lives only in the brand, so this stays cheap for the
+ *   type checker even when the element type is large — unlike
+ *   `isFixedLengthTuple`, which narrows to a structural tuple type.
+ *
+ * @example
+ *
+ * ```ts
+ * const input: readonly number[] = [255, 128, 0];
+ *
+ * assert.isTrue(isFixedLengthArray(input, 3));
+ *
+ * assert.isFalse(isFixedLengthArray(input, 4));
+ *
+ * if (isFixedLengthArray(input, 3)) {
+ *   const rgb: FixedLengthArray<3, number> = input;
+ *
+ *   const atMost5: MaxLengthArray<5, number> = input; // OK (3 <= 5)
+ * }
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @template Length - The exact number of elements.
+ * @param xs - The array to check.
+ * @param length - The exact number of elements.
+ * @returns `true` if `xs.length === length`, `false` otherwise. When `true`,
+ *   TypeScript narrows `xs` to `FixedLengthArray<Length, Xs[number]> & Xs`.
+ */
+export declare const isFixedLengthArray: <Xs extends readonly unknown[], Length extends SupportedLength>(xs: Xs, length: Length) => xs is FixedLengthArray<Length, Xs[number]> & Xs;
+//# sourceMappingURL=is-length-bounded-array.d.mts.map

package/dist/guard/is-length-bounded-array.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-length-bounded-array.d.mts","sourceRoot":"","sources":["../../src/guard/is-length-bounded-array.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,gBAAgB,GAC3B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,KACnB,EAAE,IAAI,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAA4B,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,gBAAgB,GAC3B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,KACnB,EAAE,IAAI,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAA4B,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,oBAAoB,GAC/B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,EACjC,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,aACT,SAAS,KACnB,EAAE,IAAI,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EACd,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,kBAAkB,GAC7B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,MAAM,SAAS,eAAe,MAE1B,EAAE,UACE,MAAM,KACb,EAAE,IAAI,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAA0B,CAAC"}

package/dist/guard/is-length-bounded-array.mjs

@@ -0,0 +1,7 @@
+const isMinLengthArray = (xs, minLength) => xs.length >= minLength;
+const isMaxLengthArray = (xs, maxLength) => xs.length <= maxLength;
+const isBoundedLengthArray = (xs, minLength, maxLength) => xs.length >= minLength && xs.length <= maxLength;
+const isFixedLengthArray = (xs, length) => xs.length === length;
+
+export { isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray, isMinLengthArray };
+//# sourceMappingURL=is-length-bounded-array.mjs.map

package/dist/guard/is-length-bounded-array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-length-bounded-array.mjs","sources":["../../src/guard/is-length-bounded-array.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 * @example\n *\n * ```ts\n * const input: readonly number[] = [0, 1, 2, 3];\n *\n * assert.isTrue(isMinLengthArray(input, 3));\n *\n * assert.isFalse(isMinLengthArray([0], 3));\n *\n * if (isMinLengthArray(input, 3)) {\n *   const history: MinLengthArray<3, number> = input;\n *\n *   const nonEmpty: MinLengthArray<1, number> = input; // OK (3 >= 1)\n * }\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @param xs - The array to check.\n * @param minLength - The minimum number of elements (inclusive).\n * @returns `true` if `xs.length >= minLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `MinLengthArray<MinLength, Xs[number]> & Xs`.\n */\nexport const isMinLengthArray = <\n  Xs extends readonly unknown[],\n  MinLength extends SupportedLength,\n>(\n  xs: Xs,\n  minLength: MinLength,\n): xs is MinLengthArray<MinLength, Xs[number]> & Xs => 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 * @example\n *\n * ```ts\n * const input: readonly string[] = ['a', 'b', 'c'];\n *\n * assert.isTrue(isMaxLengthArray(input, 8));\n *\n * assert.isFalse(isMaxLengthArray(input, 2));\n *\n * if (isMaxLengthArray(input, 8)) {\n *   const tags: MaxLengthArray<8, string> = input;\n *\n *   const relaxed: MaxLengthArray<16, string> = input; // OK (8 <= 16)\n * }\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to check.\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `true` if `xs.length <= maxLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `MaxLengthArray<MaxLength, Xs[number]> & Xs`.\n */\nexport const isMaxLengthArray = <\n  Xs extends readonly unknown[],\n  MaxLength extends SupportedLength,\n>(\n  xs: Xs,\n  maxLength: MaxLength,\n): xs is MaxLengthArray<MaxLength, Xs[number]> & Xs => 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 * @example\n *\n * ```ts\n * const input: readonly number[] = [1, 2, 3];\n *\n * assert.isTrue(isBoundedLengthArray(input, 1, 5));\n *\n * assert.isFalse(isBoundedLengthArray([], 1, 5));\n *\n * if (isBoundedLengthArray(input, 1, 5)) {\n *   const selection: BoundedLengthArray<1, 5, number> = input;\n *\n *   const relaxed: BoundedLengthArray<0, 100, number> = input; // OK ([1, 5] ⊆ [0, 100])\n * }\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to check.\n * @param minLength - The minimum number of elements (inclusive).\n * @param maxLength - The maximum number of elements (inclusive).\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 const isBoundedLengthArray = <\n  Xs extends readonly unknown[],\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  xs: Xs,\n  minLength: MinLength,\n  maxLength: MaxLength,\n): xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs =>\n  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 * @example\n *\n * ```ts\n * const input: readonly number[] = [255, 128, 0];\n *\n * assert.isTrue(isFixedLengthArray(input, 3));\n *\n * assert.isFalse(isFixedLengthArray(input, 4));\n *\n * if (isFixedLengthArray(input, 3)) {\n *   const rgb: FixedLengthArray<3, number> = input;\n *\n *   const atMost5: MaxLengthArray<5, number> = input; // OK (3 <= 5)\n * }\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template Length - The exact number of elements.\n * @param xs - The array to check.\n * @param length - The exact number of elements.\n * @returns `true` if `xs.length === length`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `FixedLengthArray<Length, Xs[number]> & Xs`.\n */\nexport const isFixedLengthArray = <\n  Xs extends readonly unknown[],\n  Length extends SupportedLength,\n>(\n  xs: Xs,\n  length: Length,\n): xs is FixedLengthArray<Length, Xs[number]> & Xs => xs.length === length;\n"],"names":[],"mappings":"AA6CO,MAAM,gBAAA,GAAmB,CAI9B,EAAA,EACA,SAAA,KACqD,GAAG,MAAA,IAAU;AAuC7D,MAAM,gBAAA,GAAmB,CAI9B,EAAA,EACA,SAAA,KACqD,GAAG,MAAA,IAAU;AA2C7D,MAAM,oBAAA,GAAuB,CAKlC,EAAA,EACA,SAAA,EACA,cAEA,EAAA,CAAG,MAAA,IAAU,SAAA,IAAa,EAAA,CAAG,MAAA,IAAU;AAwClC,MAAM,kBAAA,GAAqB,CAIhC,EAAA,EACA,MAAA,KACoD,GAAG,MAAA,KAAW;;;;"}

package/dist/guard/is-length-bounded-string.d.mts

@@ -1,5 +1,4 @@
-import { type BoundedLengthString, type FixedLengthString, type MaxLengthString, type MinLengthString } from 'ts-type-forge';
-import { type SizeType } from '../types.mjs';
+import { type BoundedLengthString, type FixedLengthString, type MaxLengthString, type MinLengthString, type SupportedLength } from 'ts-type-forge';
 /**
  * Type guard that checks if a string has at least `minLength` characters.
  *
@@ -38,7 +37,7 @@ import { type SizeType } from '../types.mjs';
  * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,
  *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.
  */
-export declare const isMinLengthString: <S extends string, MinLength extends SizeType.ArgStr>(s: S, minLength: MinLength) => s is MinLengthString<MinLength> & S;
+export declare const isMinLengthString: <S extends string, MinLength extends SupportedLength>(s: S, minLength: MinLength) => s is MinLengthString<MinLength> & S;
 /**
  * Type guard that checks if a string has at most `maxLength` characters.
  *
@@ -77,7 +76,7 @@ export declare const isMinLengthString: <S extends string, MinLength extends Siz
  * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,
  *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.
  */
-export declare const isMaxLengthString: <S extends string, MaxLength extends SizeType.ArgStr>(s: S, maxLength: MaxLength) => s is MaxLengthString<MaxLength> & S;
+export declare const isMaxLengthString: <S extends string, MaxLength extends SupportedLength>(s: S, maxLength: MaxLength) => s is MaxLengthString<MaxLength> & S;
 /**
  * Type guard that checks if a string's length is within the inclusive range
  * `[minLength, maxLength]`.
@@ -120,7 +119,7 @@ export declare const isMaxLengthString: <S extends string, MaxLength extends Siz
  *   otherwise. When `true`, TypeScript narrows `s` to
  *   `BoundedLengthString<MinLength, MaxLength> & S`.
  */
-export declare const isBoundedLengthString: <S extends string, MinLength extends SizeType.ArgStr, MaxLength extends SizeType.ArgStr>(s: S, minLength: MinLength, maxLength: MaxLength) => s is BoundedLengthString<MinLength, MaxLength> & S;
+export declare const isBoundedLengthString: <S extends string, MinLength extends SupportedLength, MaxLength extends SupportedLength>(s: S, minLength: MinLength, maxLength: MaxLength) => s is BoundedLengthString<MinLength, MaxLength> & S;
 /**
  * Type guard that checks if a string has exactly `length` characters.
  *
@@ -160,5 +159,5 @@ export declare const isBoundedLengthString: <S extends string, MinLength extends
  * @returns `true` if `s.length === length`, `false` otherwise. When `true`,
  *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.
  */
-export declare const isFixedLengthString: <S extends string, Length extends SizeType.ArgStr>(s: S, length: Length) => s is FixedLengthString<Length> & S;
+export declare const isFixedLengthString: <S extends string, Length extends SupportedLength>(s: S, length: Length) => s is FixedLengthString<Length> & S;
 //# sourceMappingURL=is-length-bounded-string.d.mts.map

package/dist/guard/is-length-bounded-string.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"is-length-bounded-string.d.mts","sourceRoot":"","sources":["../../src/guard/is-length-bounded-string.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,QAAQ,CAAC,MAAM,EAEjC,GAAG,CAAC,EACJ,WAAW,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,QAAQ,CAAC,MAAM,EAEjC,GAAG,CAAC,EACJ,WAAW,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,qBAAqB,GAChC,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,QAAQ,CAAC,MAAM,EACjC,SAAS,SAAS,QAAQ,CAAC,MAAM,EAEjC,GAAG,CAAC,EACJ,WAAW,SAAS,EACpB,WAAW,SAAS,KACnB,CAAC,IAAI,mBAAmB,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,CACJ,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,mBAAmB,GAC9B,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,QAAQ,CAAC,MAAM,EAE9B,GAAG,CAAC,EACJ,QAAQ,MAAM,KACb,CAAC,IAAI,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAwB,CAAC"}
+{"version":3,"file":"is-length-bounded-string.d.mts","sourceRoot":"","sources":["../../src/guard/is-length-bounded-string.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,qBAAqB,GAChC,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,EACjC,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,aACT,SAAS,KACnB,CAAC,IAAI,mBAAmB,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,CACJ,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,mBAAmB,GAC9B,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,eAAe,KAE3B,CAAC,UACI,MAAM,KACb,CAAC,IAAI,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAwB,CAAC"}