ts-data-forge 9.0.1 → 10.0.0

package/dist/array/impl/array-utils-validation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-validation.mjs","sources":["../../../src/array/impl/array-utils-validation.mts"],"sourcesContent":["import {\n  type ArrayAtLeastLen,\n  type ArrayAtMostLen,\n  type ArrayBoundedLen,\n  type ArrayOfLength,\n  type BoolOr,\n  type NonEmptyArray,\n  type TypeEq,\n} from 'ts-type-forge';\nimport { asUint32, Num } from '../../number/index.mjs';\nimport { type ArrayIndex, type SizeType } from '../../types.mjs';\n\n/**\n * Type guard that checks if a value is an array.\n *\n * @example\n *\n * ```ts\n * const maybeArray: unknown = [1, 2, 3] as const;\n *\n * const maybeValue: unknown = 'Ada';\n *\n * assert.isTrue(Arr.isArray(maybeArray));\n *\n * assert.isFalse(Arr.isArray(maybeValue));\n *\n * if (Arr.isArray(maybeArray)) {\n *   assert.deepStrictEqual(maybeArray, [1, 2, 3]);\n * }\n * ```\n */\nexport const isArray = <E,>(value: E): value is FilterArray<E> =>\n  Array.isArray(value);\n\ntype FilterArray<T> = T extends T\n  ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    BoolOr<TypeEq<T, unknown>, TypeEq<T, any>> extends true\n    ? Cast<readonly unknown[], T>\n    : T extends readonly unknown[]\n      ? T\n      : never // Exclude non-array types\n  : never;\n\ntype Cast<A, B> = A extends B ? A : never;\n\n// validation\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 *   assert.deepStrictEqual(emptyNumbers, []);\n * }\n * ```\n */\nexport const isEmpty = <E,>(array: readonly E[]): array is readonly [] =>\n  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 = <E,>(\n  array: readonly E[],\n): array is NonEmptyArray<E> => array.length > 0;\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.isArrayOfLength(pair, 2));\n *\n * assert.isFalse(Arr.isArrayOfLength(triple, 2));\n *\n * if (Arr.isArrayOfLength(pair, 2)) {\n *   assert.deepStrictEqual(pair, [1, 2]);\n * }\n * ```\n */\nexport const isArrayOfLength = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is ArrayOfLength<N, E> => 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.isArrayAtLeastLength(queue, 1));\n *\n * assert.isFalse(Arr.isArrayAtLeastLength(emptyQueue, 1));\n *\n * if (Arr.isArrayAtLeastLength(queue, 1)) {\n *   assert.isTrue(queue[0] === 'task-1');\n * }\n * ```\n */\nexport const isArrayAtLeastLength = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is ArrayAtLeastLen<N, E> => 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.isArrayAtMostLength(pair, 2));\n *\n * assert.isFalse(Arr.isArrayAtMostLength(triple, 2));\n *\n * if (Arr.isArrayAtMostLength(pair, 2)) {\n *   assert.isTrue(pair.length <= 2);\n * }\n * ```\n */\nexport const isArrayAtMostLength = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is ArrayAtMostLen<N, E> => 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.isArrayBoundedLength(pair, 1, 3));\n *\n * assert.isFalse(Arr.isArrayBoundedLength(quad, 1, 3));\n *\n * if (Arr.isArrayBoundedLength(pair, 1, 3)) {\n *   assert.isTrue(pair.length >= 1 && pair.length <= 3);\n * }\n * ```\n */\nexport const isArrayBoundedLength = <\n  E,\n  Min extends SizeType.ArgArr,\n  Max extends SizeType.ArgArr,\n>(\n  array: readonly E[],\n  min: Min,\n  max: Max,\n): array is ArrayBoundedLen<Min, Max, E> =>\n  array.length >= min && array.length <= max;\n\n/**\n * Tests whether all elements in an array pass a test implemented by a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [2, 4, 6] as const;\n *\n * const words = ['Ada', 'Grace'] as const;\n *\n * const allEven = Arr.every(numbers, (value) => value % 2 === 0);\n *\n * const allStartWithA = Arr.every(words, (value) => value.startsWith('A'));\n *\n * assert.isTrue(allEven);\n *\n * assert.isFalse(allStartWithA);\n * ```\n */\n// Type guard overloads - narrow the entire array type\nexport function every<E, S extends E>(\n  array: readonly E[],\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): array is readonly S[];\n\nexport function every<E, S extends E>(\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): (array: readonly E[]) => array is readonly S[];\n\n// Regular boolean predicate overloads\nexport function every<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): boolean;\n\nexport function every<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => boolean;\n\nexport function every<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): boolean | ((array: readonly E[]) => boolean) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.every((a, i) => predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => every(array, predicate);\n    }\n  }\n}\n\n/**\n * Tests whether at least one element in an array passes a test implemented by a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 3, 5] as const;\n *\n * const words = ['Ada', 'Grace'] as const;\n *\n * const hasEven = Arr.some(numbers, (value) => value % 2 === 0);\n *\n * const hasShortName = Arr.some(words, (value) => value.length <= 3);\n *\n * assert.isFalse(hasEven);\n *\n * assert.isTrue(hasShortName);\n * ```\n */\nexport function some<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): boolean;\n\nexport function some<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => boolean;\n\nexport function some<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): boolean | ((array: readonly E[]) => boolean) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.some((a, i) => predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => some(array, predicate);\n    }\n  }\n}\n\n/**\n * Checks if an index is within the valid range of an array.\n *\n * @example\n *\n * ```ts\n * const items = ['Ada', 'Grace', 'Katherine'] as const;\n *\n * assert.isTrue(Arr.indexIsInRange(items, 1));\n *\n * assert.isFalse(Arr.indexIsInRange(items, 3));\n *\n * if (Arr.indexIsInRange(items, 2)) {\n *   assert.isTrue(items[2] === 'Katherine');\n * }\n * ```\n */\nexport const indexIsInRange = <E,>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n): boolean => Num.isInRange(0, array.length)(index);\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BO,MAAM,OAAA,GAAU,CAAK,KAAA,KAC1B,KAAA,CAAM,QAAQ,KAAK;AAkCd,MAAM,OAAA,GAAU,CAAK,KAAA,KAC1B,KAAA,CAAM,MAAA,KAAW;AAqBZ,MAAM,UAAA,GAAa,CACxB,KAAA,KAC8B,KAAA,CAAM,MAAA,GAAS;AAqBxC,MAAM,eAAA,GAAkB,CAC7B,KAAA,EACA,GAAA,KACiC,MAAM,MAAA,KAAW;AAqB7C,MAAM,oBAAA,GAAuB,CAClC,KAAA,EACA,GAAA,KACmC,MAAM,MAAA,IAAU;AAqB9C,MAAM,mBAAA,GAAsB,CACjC,KAAA,EACA,GAAA,KACkC,MAAM,MAAA,IAAU;AAqB7C,MAAM,oBAAA,GAAuB,CAKlC,KAAA,EACA,GAAA,EACA,QAEA,KAAA,CAAM,MAAA,IAAU,GAAA,IAAO,KAAA,CAAM,MAAA,IAAU;AAyClC,SAAS,SACX,IAAA,EAM2C;AAC9C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,SAAS,CAAA,GAAI,IAAA;AAE3B,MAAA,OAAO,KAAA,CAAM,KAAA,CAAM,CAAC,CAAA,EAAG,CAAA,KAAM,UAAU,CAAA,EAAG,QAAA,CAAS,CAAC,CAAC,CAAC,CAAA;AAAA,IACxD;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,KAAA,KAAU,KAAA,CAAM,KAAA,EAAO,SAAS,CAAA;AAAA,IAC1C;AAAA;AAEJ;AA8BO,SAAS,QACX,IAAA,EAM2C;AAC9C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,SAAS,CAAA,GAAI,IAAA;AAE3B,MAAA,OAAO,KAAA,CAAM,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,UAAU,CAAA,EAAG,QAAA,CAAS,CAAC,CAAC,CAAC,CAAA;AAAA,IACvD;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,KAAA,KAAU,IAAA,CAAK,KAAA,EAAO,SAAS,CAAA;AAAA,IACzC;AAAA;AAEJ;AAmBO,MAAM,cAAA,GAAiB,CAC5B,KAAA,EACA,KAAA,KACY,GAAA,CAAI,UAAU,CAAA,EAAG,KAAA,CAAM,MAAM,CAAA,CAAE,KAAK;;;;"}
+{"version":3,"file":"array-utils-validation.mjs","sources":["../../../src/array/impl/array-utils-validation.mts"],"sourcesContent":["import {\n  type BoolOr,\n  type BoundedLengthTuple,\n  type FixedLengthTuple,\n  type MaxLengthTuple,\n  type MinLengthTuple,\n  type NonEmptyArray,\n  type TypeEq,\n} from 'ts-type-forge';\nimport { asUint32, Num } from '../../number/index.mjs';\nimport { type ArrayIndex, type SizeType } from '../../types.mjs';\n\n/**\n * Type guard that checks if a value is an array.\n *\n * @example\n *\n * ```ts\n * const maybeArray: unknown = [1, 2, 3] as const;\n *\n * const maybeValue: unknown = 'Ada';\n *\n * assert.isTrue(Arr.isArray(maybeArray));\n *\n * assert.isFalse(Arr.isArray(maybeValue));\n *\n * if (Arr.isArray(maybeArray)) {\n *   assert.deepStrictEqual(maybeArray, [1, 2, 3]);\n * }\n * ```\n */\nexport const isArray = <E,>(value: E): value is FilterArray<E> =>\n  Array.isArray(value);\n\ntype FilterArray<T> = T extends T\n  ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    BoolOr<TypeEq<T, unknown>, TypeEq<T, any>> extends true\n    ? Cast<readonly unknown[], T>\n    : T extends readonly unknown[]\n      ? T\n      : never // Exclude non-array types\n  : never;\n\ntype Cast<A, B> = A extends B ? A : never;\n\n// validation\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 *   assert.deepStrictEqual(emptyNumbers, []);\n * }\n * ```\n */\nexport const isEmpty = <E,>(array: readonly E[]): array is readonly [] =>\n  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 = <E,>(\n  array: readonly E[],\n): array is NonEmptyArray<E> => array.length > 0;\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(pair, 2));\n *\n * assert.isFalse(Arr.isFixedLengthTuple(triple, 2));\n *\n * if (Arr.isFixedLengthTuple(pair, 2)) {\n *   assert.deepStrictEqual(pair, [1, 2]);\n * }\n * ```\n */\nexport const isFixedLengthTuple = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is FixedLengthTuple<N, E> => 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(queue, 1));\n *\n * assert.isFalse(Arr.isMinLengthTuple(emptyQueue, 1));\n *\n * if (Arr.isMinLengthTuple(queue, 1)) {\n *   assert.isTrue(queue[0] === 'task-1');\n * }\n * ```\n */\nexport const isMinLengthTuple = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is MinLengthTuple<N, E> => 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(pair, 2));\n *\n * assert.isFalse(Arr.isMaxLengthTuple(triple, 2));\n *\n * if (Arr.isMaxLengthTuple(pair, 2)) {\n *   assert.isTrue(pair.length <= 2);\n * }\n * ```\n */\nexport const isMaxLengthTuple = <E, N extends SizeType.ArgArr>(\n  array: readonly E[],\n  len: N,\n): array is MaxLengthTuple<N, E> => 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(pair, 1, 3));\n *\n * assert.isFalse(Arr.isBoundedLengthTuple(quad, 1, 3));\n *\n * if (Arr.isBoundedLengthTuple(pair, 1, 3)) {\n *   assert.isTrue(pair.length >= 1 && pair.length <= 3);\n * }\n * ```\n */\nexport const isBoundedLengthTuple = <\n  E,\n  Min extends SizeType.ArgArr,\n  Max extends SizeType.ArgArr,\n>(\n  array: readonly E[],\n  min: Min,\n  max: Max,\n): array is BoundedLengthTuple<Min, Max, E> =>\n  array.length >= min && array.length <= max;\n\n/**\n * Tests whether all elements in an array pass a test implemented by a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [2, 4, 6] as const;\n *\n * const words = ['Ada', 'Grace'] as const;\n *\n * const allEven = Arr.every(numbers, (value) => value % 2 === 0);\n *\n * const allStartWithA = Arr.every(words, (value) => value.startsWith('A'));\n *\n * assert.isTrue(allEven);\n *\n * assert.isFalse(allStartWithA);\n * ```\n */\n// Type guard overloads - narrow the entire array type\nexport function every<E, S extends E>(\n  array: readonly E[],\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): array is readonly S[];\n\nexport function every<E, S extends E>(\n  predicate: (a: E, index: SizeType.Arr) => a is S,\n): (array: readonly E[]) => array is readonly S[];\n\n// Regular boolean predicate overloads\nexport function every<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): boolean;\n\nexport function every<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => boolean;\n\nexport function every<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): boolean | ((array: readonly E[]) => boolean) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.every((a, i) => predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => every(array, predicate);\n    }\n  }\n}\n\n/**\n * Tests whether at least one element in an array passes a test implemented by a predicate.\n *\n * @example\n *\n * ```ts\n * const numbers = [1, 3, 5] as const;\n *\n * const words = ['Ada', 'Grace'] as const;\n *\n * const hasEven = Arr.some(numbers, (value) => value % 2 === 0);\n *\n * const hasShortName = Arr.some(words, (value) => value.length <= 3);\n *\n * assert.isFalse(hasEven);\n *\n * assert.isTrue(hasShortName);\n * ```\n */\nexport function some<const Ar extends readonly unknown[]>(\n  array: Ar,\n  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,\n): boolean;\n\nexport function some<E>(\n  predicate: (a: E, index: SizeType.Arr) => boolean,\n): (array: readonly E[]) => boolean;\n\nexport function some<E>(\n  ...args:\n    | readonly [\n        array: readonly E[],\n        predicate: (a: E, index: SizeType.Arr) => boolean,\n      ]\n    | readonly [predicate: (a: E, index: SizeType.Arr) => boolean]\n): boolean | ((array: readonly E[]) => boolean) {\n  switch (args.length) {\n    case 2: {\n      const [array, predicate] = args;\n\n      return array.some((a, i) => predicate(a, asUint32(i)));\n    }\n\n    case 1: {\n      const [predicate] = args;\n\n      return (array) => some(array, predicate);\n    }\n  }\n}\n\n/**\n * Checks if an index is within the valid range of an array.\n *\n * @example\n *\n * ```ts\n * const items = ['Ada', 'Grace', 'Katherine'] as const;\n *\n * assert.isTrue(Arr.indexIsInRange(items, 1));\n *\n * assert.isFalse(Arr.indexIsInRange(items, 3));\n *\n * if (Arr.indexIsInRange(items, 2)) {\n *   assert.isTrue(items[2] === 'Katherine');\n * }\n * ```\n */\nexport const indexIsInRange = <E,>(\n  array: readonly E[],\n  index: SizeType.ArgArr,\n): boolean => Num.isInRange(0, array.length)(index);\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BO,MAAM,OAAA,GAAU,CAAK,KAAA,KAC1B,KAAA,CAAM,QAAQ,KAAK;AAkCd,MAAM,OAAA,GAAU,CAAK,KAAA,KAC1B,KAAA,CAAM,MAAA,KAAW;AAqBZ,MAAM,UAAA,GAAa,CACxB,KAAA,KAC8B,KAAA,CAAM,MAAA,GAAS;AAqBxC,MAAM,kBAAA,GAAqB,CAChC,KAAA,EACA,GAAA,KACoC,MAAM,MAAA,KAAW;AAqBhD,MAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,GAAA,KACkC,MAAM,MAAA,IAAU;AAqB7C,MAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,GAAA,KACkC,MAAM,MAAA,IAAU;AAqB7C,MAAM,oBAAA,GAAuB,CAKlC,KAAA,EACA,GAAA,EACA,QAEA,KAAA,CAAM,MAAA,IAAU,GAAA,IAAO,KAAA,CAAM,MAAA,IAAU;AAyClC,SAAS,SACX,IAAA,EAM2C;AAC9C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,SAAS,CAAA,GAAI,IAAA;AAE3B,MAAA,OAAO,KAAA,CAAM,KAAA,CAAM,CAAC,CAAA,EAAG,CAAA,KAAM,UAAU,CAAA,EAAG,QAAA,CAAS,CAAC,CAAC,CAAC,CAAA;AAAA,IACxD;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,KAAA,KAAU,KAAA,CAAM,KAAA,EAAO,SAAS,CAAA;AAAA,IAC1C;AAAA;AAEJ;AA8BO,SAAS,QACX,IAAA,EAM2C;AAC9C,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,KAAA,EAAO,SAAS,CAAA,GAAI,IAAA;AAE3B,MAAA,OAAO,KAAA,CAAM,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,UAAU,CAAA,EAAG,QAAA,CAAS,CAAC,CAAC,CAAC,CAAA;AAAA,IACvD;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,KAAA,KAAU,IAAA,CAAK,KAAA,EAAO,SAAS,CAAA;AAAA,IACzC;AAAA;AAEJ;AAmBO,MAAM,cAAA,GAAiB,CAC5B,KAAA,EACA,KAAA,KACY,GAAA,CAAI,UAAU,CAAA,EAAG,KAAA,CAAM,MAAM,CAAA,CAAE,KAAK;;;;"}

package/dist/array/impl/index.mjs

@@ -9,5 +9,5 @@ export { length, size } from './array-utils-size.mjs';
 export { sliceClamped } from './array-utils-slice-clamped.mjs';
 export { butLast, drop, rest, skip, skipLast, tail, take, takeLast } from './array-utils-slicing.mjs';
 export { cartesianProduct, chunk, concat, filter, filterNot, flat, flatMap, groupBy, map, partition, scan, toReversed, toSorted, toSortedBy, uniq, uniqBy, zip } from './array-utils-transformation.mjs';
-export { every, indexIsInRange, isArray, isArrayAtLeastLength, isArrayAtMostLength, isArrayBoundedLength, isArrayOfLength, isEmpty, isNonEmpty, some } from './array-utils-validation.mjs';
+export { every, indexIsInRange, isArray, isBoundedLengthTuple, isEmpty, isFixedLengthTuple, isMaxLengthTuple, isMinLengthTuple, isNonEmpty, some } from './array-utils-validation.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/entry-point.mjs

@@ -15,7 +15,9 @@ export { ISet } from './collections/iset.mjs';
 export { createQueue } from './collections/queue.mjs';
 export { createStack } from './collections/stack.mjs';
 export { expectType } from './expect-type.mjs';
+export { asBoundedLengthArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray } from './guard/as-length-bounded-array.mjs';
 export { hasKey } from './guard/has-key.mjs';
+export { isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray, isMinLengthArray } from './guard/is-length-bounded-array.mjs';
 export { isBoundedLengthString, isFixedLengthString, isMaxLengthString, isMinLengthString } from './guard/is-length-bounded-string.mjs';
 export { isNonEmptyString } from './guard/is-non-empty-string.mjs';
 export { isNonNullObject } from './guard/is-non-null-object.mjs';

package/dist/entry-point.mjs.map

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

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/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,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,QAAQ,CAAC,MAAM,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,QAAQ,CAAC,MAAM,EACjC,SAAS,SAAS,QAAQ,CAAC,MAAM,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,QAAQ,CAAC,MAAM,KAE3B,CAAC,UACI,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"}

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

@@ -1 +1 @@
-{"version":3,"file":"is-length-bounded-string.mjs","sources":["../../src/guard/is-length-bounded-string.mts"],"sourcesContent":["import {\n  type BoundedLengthString,\n  type FixedLengthString,\n  type MaxLengthString,\n  type MinLengthString,\n} from 'ts-type-forge';\nimport { type SizeType } from '../types.mjs';\n\n/**\n * Type guard that checks if a string has at least `minLength` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MinLengthString<MinLength>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MinLengthString<3>` is assignable to\n *   `MinLengthString<1>` (= `NonEmptyString`).\n *\n * @example\n *\n * ```ts\n * const input: string = 'very-secret-password';\n *\n * assert.isTrue(isMinLengthString(input, 12));\n *\n * assert.isFalse(isMinLengthString('short', 12));\n *\n * if (isMinLengthString(input, 12)) {\n *   const password: MinLengthString<12> = input;\n *\n *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MinLength - The minimum number of characters (inclusive).\n * @param s - The string to check.\n * @param minLength - The minimum number of characters (inclusive).\n * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.\n */\nexport const isMinLengthString = <\n  S extends string,\n  MinLength extends SizeType.ArgStr,\n>(\n  s: S,\n  minLength: MinLength,\n): s is MinLengthString<MinLength> & S => s.length >= minLength;\n\n/**\n * Type guard that checks if a string has at most `maxLength` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MaxLengthString<MaxLength>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MaxLengthString<16>` is assignable to\n *   `MaxLengthString<32>`.\n *\n * @example\n *\n * ```ts\n * const input: string = 'noshiro';\n *\n * assert.isTrue(isMaxLengthString(input, 32));\n *\n * assert.isFalse(isMaxLengthString(input, 3));\n *\n * if (isMaxLengthString(input, 32)) {\n *   const userName: MaxLengthString<32> = input;\n *\n *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MaxLength - The maximum number of characters (inclusive).\n * @param s - The string to check.\n * @param maxLength - The maximum number of characters (inclusive).\n * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.\n */\nexport const isMaxLengthString = <\n  S extends string,\n  MaxLength extends SizeType.ArgStr,\n>(\n  s: S,\n  maxLength: MaxLength,\n): s is MaxLengthString<MaxLength> & S => s.length <= maxLength;\n\n/**\n * Type guard that checks if a string's length is within the inclusive range\n * `[minLength, maxLength]`.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `BoundedLengthString<MinLength, MaxLength>` while\n *   preserving the original string type (e.g. literal types) via intersection.\n * - Since `BoundedLengthString` is the intersection of `MinLengthString` and\n *   `MaxLengthString`, the narrowed value is assignable to both, and both\n *   bounds can be weakened independently.\n *\n * @example\n *\n * ```ts\n * const input: string = 'user-12345678';\n *\n * assert.isTrue(isBoundedLengthString(input, 8, 16));\n *\n * assert.isFalse(isBoundedLengthString('user', 8, 16));\n *\n * if (isBoundedLengthString(input, 8, 16)) {\n *   const userId: BoundedLengthString<8, 16> = input;\n *\n *   const relaxed: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MinLength - The minimum number of characters (inclusive).\n * @template MaxLength - The maximum number of characters (inclusive).\n * @param s - The string to check.\n * @param minLength - The minimum number of characters (inclusive).\n * @param maxLength - The maximum number of characters (inclusive).\n * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`\n *   otherwise. When `true`, TypeScript narrows `s` to\n *   `BoundedLengthString<MinLength, MaxLength> & S`.\n */\nexport const isBoundedLengthString = <\n  S extends string,\n  MinLength extends SizeType.ArgStr,\n  MaxLength extends SizeType.ArgStr,\n>(\n  s: S,\n  minLength: MinLength,\n  maxLength: MaxLength,\n): s is BoundedLengthString<MinLength, MaxLength> & S =>\n  s.length >= minLength && s.length <= maxLength;\n\n/**\n * Type guard that checks if a string has exactly `length` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `FixedLengthString<Length>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - Since `FixedLengthString<Length>` is defined as\n *   `BoundedLengthString<Length, Length>`, the narrowed value is assignable to\n *   any `MinLengthString<N>` with `N <= Length` and any `MaxLengthString<N>`\n *   with `N >= Length`.\n *\n * @example\n *\n * ```ts\n * const input: string = 'JP';\n *\n * assert.isTrue(isFixedLengthString(input, 2));\n *\n * assert.isFalse(isFixedLengthString(input, 3));\n *\n * if (isFixedLengthString(input, 2)) {\n *   const countryCode: FixedLengthString<2> = input;\n *\n *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template Length - The exact number of characters.\n * @param s - The string to check.\n * @param length - The exact number of characters.\n * @returns `true` if `s.length === length`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.\n */\nexport const isFixedLengthString = <\n  S extends string,\n  Length extends SizeType.ArgStr,\n>(\n  s: S,\n  length: Length,\n): s is FixedLengthString<Length> & S => s.length === length;\n"],"names":[],"mappings":"AA8CO,MAAM,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU;AAwC/C,MAAM,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU;AA4C/C,MAAM,qBAAA,GAAwB,CAKnC,CAAA,EACA,SAAA,EACA,cAEA,CAAA,CAAE,MAAA,IAAU,SAAA,IAAa,CAAA,CAAE,MAAA,IAAU;AAyChC,MAAM,mBAAA,GAAsB,CAIjC,CAAA,EACA,MAAA,KACuC,EAAE,MAAA,KAAW;;;;"}
+{"version":3,"file":"is-length-bounded-string.mjs","sources":["../../src/guard/is-length-bounded-string.mts"],"sourcesContent":["import {\n  type BoundedLengthString,\n  type FixedLengthString,\n  type MaxLengthString,\n  type MinLengthString,\n  type SupportedLength,\n} from 'ts-type-forge';\n\n/**\n * Type guard that checks if a string has at least `minLength` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MinLengthString<MinLength>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MinLengthString<3>` is assignable to\n *   `MinLengthString<1>` (= `NonEmptyString`).\n *\n * @example\n *\n * ```ts\n * const input: string = 'very-secret-password';\n *\n * assert.isTrue(isMinLengthString(input, 12));\n *\n * assert.isFalse(isMinLengthString('short', 12));\n *\n * if (isMinLengthString(input, 12)) {\n *   const password: MinLengthString<12> = input;\n *\n *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MinLength - The minimum number of characters (inclusive).\n * @param s - The string to check.\n * @param minLength - The minimum number of characters (inclusive).\n * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.\n */\nexport const isMinLengthString = <\n  S extends string,\n  MinLength extends SupportedLength,\n>(\n  s: S,\n  minLength: MinLength,\n): s is MinLengthString<MinLength> & S => s.length >= minLength;\n\n/**\n * Type guard that checks if a string has at most `maxLength` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MaxLengthString<MaxLength>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MaxLengthString<16>` is assignable to\n *   `MaxLengthString<32>`.\n *\n * @example\n *\n * ```ts\n * const input: string = 'noshiro';\n *\n * assert.isTrue(isMaxLengthString(input, 32));\n *\n * assert.isFalse(isMaxLengthString(input, 3));\n *\n * if (isMaxLengthString(input, 32)) {\n *   const userName: MaxLengthString<32> = input;\n *\n *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MaxLength - The maximum number of characters (inclusive).\n * @param s - The string to check.\n * @param maxLength - The maximum number of characters (inclusive).\n * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.\n */\nexport const isMaxLengthString = <\n  S extends string,\n  MaxLength extends SupportedLength,\n>(\n  s: S,\n  maxLength: MaxLength,\n): s is MaxLengthString<MaxLength> & S => s.length <= maxLength;\n\n/**\n * Type guard that checks if a string's length is within the inclusive range\n * `[minLength, maxLength]`.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `BoundedLengthString<MinLength, MaxLength>` while\n *   preserving the original string type (e.g. literal types) via intersection.\n * - Since `BoundedLengthString` is the intersection of `MinLengthString` and\n *   `MaxLengthString`, the narrowed value is assignable to both, and both\n *   bounds can be weakened independently.\n *\n * @example\n *\n * ```ts\n * const input: string = 'user-12345678';\n *\n * assert.isTrue(isBoundedLengthString(input, 8, 16));\n *\n * assert.isFalse(isBoundedLengthString('user', 8, 16));\n *\n * if (isBoundedLengthString(input, 8, 16)) {\n *   const userId: BoundedLengthString<8, 16> = input;\n *\n *   const relaxed: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MinLength - The minimum number of characters (inclusive).\n * @template MaxLength - The maximum number of characters (inclusive).\n * @param s - The string to check.\n * @param minLength - The minimum number of characters (inclusive).\n * @param maxLength - The maximum number of characters (inclusive).\n * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`\n *   otherwise. When `true`, TypeScript narrows `s` to\n *   `BoundedLengthString<MinLength, MaxLength> & S`.\n */\nexport const isBoundedLengthString = <\n  S extends string,\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  s: S,\n  minLength: MinLength,\n  maxLength: MaxLength,\n): s is BoundedLengthString<MinLength, MaxLength> & S =>\n  s.length >= minLength && s.length <= maxLength;\n\n/**\n * Type guard that checks if a string has exactly `length` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `FixedLengthString<Length>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - Since `FixedLengthString<Length>` is defined as\n *   `BoundedLengthString<Length, Length>`, the narrowed value is assignable to\n *   any `MinLengthString<N>` with `N <= Length` and any `MaxLengthString<N>`\n *   with `N >= Length`.\n *\n * @example\n *\n * ```ts\n * const input: string = 'JP';\n *\n * assert.isTrue(isFixedLengthString(input, 2));\n *\n * assert.isFalse(isFixedLengthString(input, 3));\n *\n * if (isFixedLengthString(input, 2)) {\n *   const countryCode: FixedLengthString<2> = input;\n *\n *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template Length - The exact number of characters.\n * @param s - The string to check.\n * @param length - The exact number of characters.\n * @returns `true` if `s.length === length`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.\n */\nexport const isFixedLengthString = <\n  S extends string,\n  Length extends SupportedLength,\n>(\n  s: S,\n  length: Length,\n): s is FixedLengthString<Length> & S => s.length === length;\n"],"names":[],"mappings":"AA8CO,MAAM,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU;AAwC/C,MAAM,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU;AA4C/C,MAAM,qBAAA,GAAwB,CAKnC,CAAA,EACA,SAAA,EACA,cAEA,CAAA,CAAE,MAAA,IAAU,SAAA,IAAa,CAAA,CAAE,MAAA,IAAU;AAyChC,MAAM,mBAAA,GAAsB,CAIjC,CAAA,EACA,MAAA,KACuC,EAAE,MAAA,KAAW;;;;"}

package/dist/index.mjs

@@ -5,7 +5,9 @@ export { ISet } from './collections/iset.mjs';
 export { createQueue } from './collections/queue.mjs';
 export { createStack } from './collections/stack.mjs';
 export { expectType } from './expect-type.mjs';
+export { asBoundedLengthArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray } from './guard/as-length-bounded-array.mjs';
 export { hasKey } from './guard/has-key.mjs';
+export { isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray, isMinLengthArray } from './guard/is-length-bounded-array.mjs';
 export { isBoundedLengthString, isFixedLengthString, isMaxLengthString, isMinLengthString } from './guard/is-length-bounded-string.mjs';
 export { isNonEmptyString } from './guard/is-non-empty-string.mjs';
 export { isNonNullObject } from './guard/is-non-null-object.mjs';

package/dist/index.mjs.map

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