@rzl-zone/utils-js 3.1.0-beta.2 → 3.1.0

package/dist/extends-Bk_SBGdT.d.ts

@@ -1,367 +1,367 @@
 import{I as If}from'./if-CvT4R7Kh.js';import{I as IsNever}from'./never-BfayMBF9.js';
 /** -------------------------------------------------------
-* * ***Arrayable.***
-* -------------------------------------------------------
-* Represents a type that can be either:
-* - a single value of type `T`, or
-* - an array of values of type `T`.
-*
-* Useful when a function or API accepts **either one item or multiple items**.
-*
-* @template T - The element type.
-*
-* @example
-* ```ts
-* function toArray<T>(input: Arrayable<T>): T[] {
-*   return Array.isArray(input) ? input : [input];
-* }
-*
-* type A = Arrayable<string>;
-* // ➔ string | string[]
-*
-* const a: A = "foo";
-* const b: A = ["foo", "bar"];
-* ```
-*/
+ * * ***Arrayable.***
+ * -------------------------------------------------------
+ * Represents a type that can be either:
+ * - a single value of type `T`, or
+ * - an array of values of type `T`.
+ *
+ * Useful when a function or API accepts **either one item or multiple items**.
+ *
+ * @template T - The element type.
+ *
+ * @example
+ * ```ts
+ * function toArray<T>(input: Arrayable<T>): T[] {
+ *   return Array.isArray(input) ? input : [input];
+ * }
+ *
+ * type A = Arrayable<string>;
+ * // ➔ string | string[]
+ *
+ * const a: A = "foo";
+ * const b: A = ["foo", "bar"];
+ * ```
+ */
 type Arrayable<T>=T|Array<T>;
 /** -------------------------------------------------------
-* * ***MutableArray.***
-* -------------------------------------------------------
-* Recursively creates a **mutable version** of a readonly array, tuple, or object type.
-*
-* By default, TypeScript infers tuple/array literals as `readonly` (especially with `as const`).
-* This utility removes the `readonly` modifier from all elements recursively,
-* turning a readonly tuple, array, or object into a mutable one.
-*
-* Optionally, if `Widen` is `true`, literal types (`1`, `'foo'`, `true`) are widened to
-* their primitive equivalents (`number`, `string`, `boolean`) for easier assignment.
-*
-* @template T - The readonly array, tuple, or object type to make mutable.
-* @template Widen - Whether to widen literal primitive types to their base types (default: `false`).
-*
-* @example
-* ```ts
-* type A = readonly [1, 2, 3];
-* type B = MutableArray<A>;
-* // ➔ [1, 2, 3]
-*
-* const x: A = [1, 2, 3] as const;
-* // x[0] = 9; // ❌ Error: read-only
-*
-* const y: MutableArray<B,true> = [1, 2, 3];
-* y[0] = 9; // ✅ Allowed
-*
-* // Recursive example with objects
-* type Obj = readonly [{ a: 1, b: readonly [2] }];
-* type MutableObj = MutableArray<Obj, true>;
-* // ➔ [{ a: number; b: [number]; }]
-* ```
-*/
+ * * ***MutableArray.***
+ * -------------------------------------------------------
+ * Recursively creates a **mutable version** of a readonly array, tuple, or object type.
+ *
+ * By default, TypeScript infers tuple/array literals as `readonly` (especially with `as const`).
+ * This utility removes the `readonly` modifier from all elements recursively,
+ * turning a readonly tuple, array, or object into a mutable one.
+ *
+ * Optionally, if `Widen` is `true`, literal types (`1`, `'foo'`, `true`) are widened to
+ * their primitive equivalents (`number`, `string`, `boolean`) for easier assignment.
+ *
+ * @template T - The readonly array, tuple, or object type to make mutable.
+ * @template Widen - Whether to widen literal primitive types to their base types (default: `false`).
+ *
+ * @example
+ * ```ts
+ * type A = readonly [1, 2, 3];
+ * type B = MutableArray<A>;
+ * // ➔ [1, 2, 3]
+ *
+ * const x: A = [1, 2, 3] as const;
+ * // x[0] = 9; // ❌ Error: read-only
+ *
+ * const y: MutableArray<B,true> = [1, 2, 3];
+ * y[0] = 9; // ✅ Allowed
+ *
+ * // Recursive example with objects
+ * type Obj = readonly [{ a: 1, b: readonly [2] }];
+ * type MutableObj = MutableArray<Obj, true>;
+ * // ➔ [{ a: number; b: [number]; }]
+ * ```
+ */
 type MutableArray<T,Widen extends boolean=false>=T extends(...args:any)=>any?T:T extends readonly any[]?{-readonly [K in keyof T]:MutableArray<T[K],Widen>;}:T extends object?{-readonly [K in keyof T]:MutableArray<T[K],Widen>;}:Widen extends true?T extends number?number:T extends string?string:T extends boolean?boolean:T extends bigint?bigint:T extends symbol?symbol:T:T;
 /** --------------------------------------------------
-* * ***GetArrayElementType.***
-* --------------------------------------------------
-* Gets the element type from a readonly array or tuple.
-*
-* ✅ Useful when working with `as const` arrays to extract the union of literal types.
-*
-* @template T - A readonly array or tuple type.
-*
-* @example
-* ```ts
-* const roles = ['admin', 'user'] as const;
-* type Role = GetArrayElementType<typeof roles>;
-* // ➔ "admin" | "user"
-* ```
-*/
+ * * ***GetArrayElementType.***
+ * --------------------------------------------------
+ * Gets the element type from a readonly array or tuple.
+ *
+ * ✅ Useful when working with `as const` arrays to extract the union of literal types.
+ *
+ * @template T - A readonly array or tuple type.
+ *
+ * @example
+ * ```ts
+ * const roles = ['admin', 'user'] as const;
+ * type Role = GetArrayElementType<typeof roles>;
+ * // ➔ "admin" | "user"
+ * ```
+ */
 type GetArrayElementType<T extends readonly any[]>=T extends readonly(infer U)[]?U:never;
 /** -------------------------------------------------------
-* * ***EmptyArray.***
-* -------------------------------------------------------
-* A type-level utility that returns `T` if it is an ***empty array***,
-* otherwise returns `never`.
-*
-* @template T - The array type to check.
-* @example
-* ```ts
-* type A = EmptyArray<[]>;
-* // ➔ []
-* type B = EmptyArray<[1]>;
-* // ➔ never
-* type C = EmptyArray<string[]>;
-* // ➔ string[]
-* type D = EmptyArray<number[]>;
-* // ➔ number[]
-* type E = EmptyArray<readonly []>;
-* // ➔ readonly []
-* ```
-*/
+ * * ***EmptyArray.***
+ * -------------------------------------------------------
+ * A type-level utility that returns `T` if it is an ***empty array***,
+ * otherwise returns `never`.
+ *
+ * @template T - The array type to check.
+ * @example
+ * ```ts
+ * type A = EmptyArray<[]>;
+ * // ➔ []
+ * type B = EmptyArray<[1]>;
+ * // ➔ never
+ * type C = EmptyArray<string[]>;
+ * // ➔ string[]
+ * type D = EmptyArray<number[]>;
+ * // ➔ number[]
+ * type E = EmptyArray<readonly []>;
+ * // ➔ readonly []
+ * ```
+ */
 type EmptyArray<T extends readonly unknown[]>=T extends readonly [ unknown,...unknown[]]?never:T;
 /** -------------------------------------------------------
-* * ***NonEmptyArray.***
-* -------------------------------------------------------
-* A type-level utility that returns `T` if it is a ***non-empty array***,
-* otherwise returns `never`.
-*
-* @template T - The array type to check.
-* @example
-* ```ts
-* type A = NonEmptyArray<[]>;
-* // ➔ never
-* type B = NonEmptyArray<[1]>;
-* // ➔ [1]
-* type C = NonEmptyArray<string[]>;
-* // ➔ never
-* type D = NonEmptyArray<number[]>;
-* // ➔ never
-* type E = NonEmptyArray<readonly []>;
-* // ➔ never
-* ```
-*/
+ * * ***NonEmptyArray.***
+ * -------------------------------------------------------
+ * A type-level utility that returns `T` if it is a ***non-empty array***,
+ * otherwise returns `never`.
+ *
+ * @template T - The array type to check.
+ * @example
+ * ```ts
+ * type A = NonEmptyArray<[]>;
+ * // ➔ never
+ * type B = NonEmptyArray<[1]>;
+ * // ➔ [1]
+ * type C = NonEmptyArray<string[]>;
+ * // ➔ never
+ * type D = NonEmptyArray<number[]>;
+ * // ➔ never
+ * type E = NonEmptyArray<readonly []>;
+ * // ➔ never
+ * ```
+ */
 type NonEmptyArray<T extends readonly unknown[]>=If<IsNever<EmptyArray<T>>,T,never>;
 /** -------------------------------------------------------
-* * ***IsEmptyArray.***
-* -------------------------------------------------------
-* A type-level utility that evaluates to `true` if `T` is an ***empty array.***
-* (or can be empty per this definition), otherwise `false`.
-*
-* @template T - The array type to check.
-* @example
-* ```ts
-* type A = IsEmptyArray<[]>;
-* // ➔ true
-* type B = IsEmptyArray<[1]>;
-* // ➔ false
-* type C = IsEmptyArray<string[]>;
-* // ➔ true
-* type D = IsEmptyArray<number[]>;
-* // ➔ true
-* type E = IsEmptyArray<readonly []>;
-* // ➔ true
-* ```
-*/
+ * * ***IsEmptyArray.***
+ * -------------------------------------------------------
+ * A type-level utility that evaluates to `true` if `T` is an ***empty array.***
+ * (or can be empty per this definition), otherwise `false`.
+ *
+ * @template T - The array type to check.
+ * @example
+ * ```ts
+ * type A = IsEmptyArray<[]>;
+ * // ➔ true
+ * type B = IsEmptyArray<[1]>;
+ * // ➔ false
+ * type C = IsEmptyArray<string[]>;
+ * // ➔ true
+ * type D = IsEmptyArray<number[]>;
+ * // ➔ true
+ * type E = IsEmptyArray<readonly []>;
+ * // ➔ true
+ * ```
+ */
 type IsEmptyArray<T extends readonly unknown[]>=If<IsNever<EmptyArray<T>>,false,true>;
 /** -------------------------------------------------------
-* * ***IsNonEmptyArray.***
-* -------------------------------------------------------
-* A type-level utility that evaluates to `true` if `T` is a ***non-empty array.***
-* (strictly a non-empty tuple), otherwise `false`.
-*
-* @template T - The array type to check.
-* @example
-* ```ts
-* type A = IsNonEmptyArray<[]>;
-* // ➔ false
-* type B = IsNonEmptyArray<[1]>;
-* // ➔ true
-* type C = IsNonEmptyArray<string[]>;
-* // ➔ false
-* type D = IsNonEmptyArray<number[]>;
-* // ➔ false
-* type E = IsNonEmptyArray<readonly []>;
-* // ➔ false
-* ```
-*/
+ * * ***IsNonEmptyArray.***
+ * -------------------------------------------------------
+ * A type-level utility that evaluates to `true` if `T` is a ***non-empty array.***
+ * (strictly a non-empty tuple), otherwise `false`.
+ *
+ * @template T - The array type to check.
+ * @example
+ * ```ts
+ * type A = IsNonEmptyArray<[]>;
+ * // ➔ false
+ * type B = IsNonEmptyArray<[1]>;
+ * // ➔ true
+ * type C = IsNonEmptyArray<string[]>;
+ * // ➔ false
+ * type D = IsNonEmptyArray<number[]>;
+ * // ➔ false
+ * type E = IsNonEmptyArray<readonly []>;
+ * // ➔ false
+ * ```
+ */
 type IsNonEmptyArray<T extends readonly unknown[]>=If<IsNever<EmptyArray<T>>,true,false>;
 /** -------------------------------------------------------
-* * ***IfEmptyArray.***
-* -------------------------------------------------------
-* Returns the second argument if `T` is an ***empty array*** (per this utility),
-* otherwise returns the third argument.
-* - Defaults: `IfTrue = true`, `IfFalse = false`.
-*
-* @template T - The array type to check.
-* @template IfTrue - Returned type if `T` is empty by this definition.
-* @template IfFalse - Returned type if `T` is not empty by this definition.
-* @example
-* ```ts
-* type A = IfEmptyArray<[]>;
-* // ➔ true
-* type B = IfEmptyArray<[1]>;
-* // ➔ false
-* type C = IfEmptyArray<string[]>;
-* // ➔ true
-* type D = IfEmptyArray<readonly []>;
-* // ➔ true
-* type E = IfEmptyArray<[], "yes", "no">;
-* // ➔ "yes"
-* type F = IfEmptyArray<[1], "yes", "no">;
-* // ➔ "no"
-* type G = IfEmptyArray<string[], "yes", "no">;
-* // ➔ "yes"
-* ```
-*/
+ * * ***IfEmptyArray.***
+ * -------------------------------------------------------
+ * Returns the second argument if `T` is an ***empty array*** (per this utility),
+ * otherwise returns the third argument.
+ * - Defaults: `IfTrue = true`, `IfFalse = false`.
+ *
+ * @template T - The array type to check.
+ * @template IfTrue - Returned type if `T` is empty by this definition.
+ * @template IfFalse - Returned type if `T` is not empty by this definition.
+ * @example
+ * ```ts
+ * type A = IfEmptyArray<[]>;
+ * // ➔ true
+ * type B = IfEmptyArray<[1]>;
+ * // ➔ false
+ * type C = IfEmptyArray<string[]>;
+ * // ➔ true
+ * type D = IfEmptyArray<readonly []>;
+ * // ➔ true
+ * type E = IfEmptyArray<[], "yes", "no">;
+ * // ➔ "yes"
+ * type F = IfEmptyArray<[1], "yes", "no">;
+ * // ➔ "no"
+ * type G = IfEmptyArray<string[], "yes", "no">;
+ * // ➔ "yes"
+ * ```
+ */
 type IfEmptyArray<T extends readonly unknown[],IfTrue=true,IfFalse=false>=If<IsEmptyArray<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
-* * ***IfNonEmptyArray.***
-* -------------------------------------------------------
-* Returns the second argument if `T` is a ***non-empty array*** (strict tuple),
-* otherwise returns the third argument.
-* - Defaults: `IfTrue = true`, `IfFalse = false`.
-*
-* @template T - The array type to check.
-* @template IfTrue - Returned type if `T` is non-empty by this definition.
-* @template IfFalse - Returned type if `T` is not non-empty by this definition.
-* @example
-* ```ts
-* type A = IfNonEmptyArray<[]>;
-* // ➔ false
-* type B = IfNonEmptyArray<[1]>;
-* // ➔ true
-* type C = IfNonEmptyArray<string[]>;
-* // ➔ false
-* type D = IfNonEmptyArray<readonly []>;
-* // ➔ false
-* type E = IfNonEmptyArray<[1], "yes", "no">;
-* // ➔ "yes"
-* type F = IfNonEmptyArray<[], "yes", "no">;
-* // ➔ "no"
-* type G = IfNonEmptyArray<string[], "yes", "no">;
-* // ➔ "no"
-* ```
-*/
+ * * ***IfNonEmptyArray.***
+ * -------------------------------------------------------
+ * Returns the second argument if `T` is a ***non-empty array*** (strict tuple),
+ * otherwise returns the third argument.
+ * - Defaults: `IfTrue = true`, `IfFalse = false`.
+ *
+ * @template T - The array type to check.
+ * @template IfTrue - Returned type if `T` is non-empty by this definition.
+ * @template IfFalse - Returned type if `T` is not non-empty by this definition.
+ * @example
+ * ```ts
+ * type A = IfNonEmptyArray<[]>;
+ * // ➔ false
+ * type B = IfNonEmptyArray<[1]>;
+ * // ➔ true
+ * type C = IfNonEmptyArray<string[]>;
+ * // ➔ false
+ * type D = IfNonEmptyArray<readonly []>;
+ * // ➔ false
+ * type E = IfNonEmptyArray<[1], "yes", "no">;
+ * // ➔ "yes"
+ * type F = IfNonEmptyArray<[], "yes", "no">;
+ * // ➔ "no"
+ * type G = IfNonEmptyArray<string[], "yes", "no">;
+ * // ➔ "no"
+ * ```
+ */
 type IfNonEmptyArray<T extends readonly unknown[],IfTrue=true,IfFalse=false>=If<IsNonEmptyArray<T>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
-* * ***Not.***
-* -------------------------------------------------------
-* Accepts a boolean type `T` and returns its negation.
-*
-* @template T - Boolean type to negate.
-*
-* @example
-* ```ts
-* type A = Not<true>;  // ➔ false
-* type B = Not<false>; // ➔ true
-* ```
-*/
+ * * ***Not.***
+ * -------------------------------------------------------
+ * Accepts a boolean type `T` and returns its negation.
+ *
+ * @template T - Boolean type to negate.
+ *
+ * @example
+ * ```ts
+ * type A = Not<true>;  // ➔ false
+ * type B = Not<false>; // ➔ true
+ * ```
+ */
 type Not<T extends boolean>=T extends true?false:true;
 /** -------------------------------------------------------
-* * ***PopOptions.***
-* -------------------------------------------------------
-*
-* Configuration options for the {@link Pop} type utility.
-*/
+ * * ***PopOptions.***
+ * -------------------------------------------------------
+ *
+ * Configuration options for the {@link Pop} type utility.
+ */
 type PopOptions={
 /**
-* If `true`, {@link Pop} will return a tuple `[Rest, Removed]`
-* instead of just the remaining array.
-*
-* Default: `false`.
-*
-* @example
-* ```ts
-* type Options = { includeRemoved: true };
-* type Result = Pop<[1, 2, 3], Options>; // ➔ [[1, 2], 3]
-* ```
-*/
+ * If `true`, {@link Pop} will return a tuple `[Rest, Removed]`
+ * instead of just the remaining array.
+ *
+ * Default: `false`.
+ *
+ * @example
+ * ```ts
+ * type Options = { includeRemoved: true };
+ * type Result = Pop<[1, 2, 3], Options>; // ➔ [[1, 2], 3]
+ * ```
+ */
 includeRemoved:boolean;};
 /** -------------------------------------------------------
-* * ***Pop.***
-* -------------------------------------------------------
-*
-* Removes the last element from a tuple/array type.
-*
-* If the `includeRemoved` option is `true`, it returns a tuple `[Rest, Removed]`
-* where `Rest` is the array without the last element, and `Removed` is the last element.
-*
-* @template T - The tuple or array to pop from.
-* @template Options - Configuration object. Default `{ includeRemoved: false }`.
-*
-* @example
-* ```ts
-* // Removes last element
-* type Case1 = Pop<[1, 2, 3]>
-* // ➔ [1, 2]
-*
-* // Removes last element and includes the removed value
-* type Case2 = Pop<[1, 2, 3], { includeRemoved: true }>
-* // ➔ [[1, 2], 3]
-*
-* // Edge case: empty array
-* type Case3 = Pop<[]>
-* // ➔ never
-* ```
-*/
+ * * ***Pop.***
+ * -------------------------------------------------------
+ *
+ * Removes the last element from a tuple/array type.
+ *
+ * If the `includeRemoved` option is `true`, it returns a tuple `[Rest, Removed]`
+ * where `Rest` is the array without the last element, and `Removed` is the last element.
+ *
+ * @template T - The tuple or array to pop from.
+ * @template Options - Configuration object. Default `{ includeRemoved: false }`.
+ *
+ * @example
+ * ```ts
+ * // Removes last element
+ * type Case1 = Pop<[1, 2, 3]>
+ * // ➔ [1, 2]
+ *
+ * // Removes last element and includes the removed value
+ * type Case2 = Pop<[1, 2, 3], { includeRemoved: true }>
+ * // ➔ [[1, 2], 3]
+ *
+ * // Edge case: empty array
+ * type Case3 = Pop<[]>
+ * // ➔ never
+ * ```
+ */
 type Pop<T extends readonly unknown[],Options extends PopOptions={includeRemoved:false;}>=IsEmptyArray<T>extends true?never:T extends readonly [...infer Rest extends readonly unknown[],infer Removed]?If<Options["includeRemoved"],[Rest,Removed],Rest>:never;
 /** -------------------------------------------------------
-* * ***Extends.***
-* -------------------------------------------------------
-* Returns a boolean indicating whether the first argument ***extends*** the second argument.
-*
-* @template T - The type to check.
-* @template Base - The type to compare against.
-* @example
-* ```ts
-* type A = Extends<1, number>;  // ➔ true
-* type B = Extends<number, 1>;  // ➔ false
-* ```
-*/
+ * * ***Extends.***
+ * -------------------------------------------------------
+ * Returns a boolean indicating whether the first argument ***extends*** the second argument.
+ *
+ * @template T - The type to check.
+ * @template Base - The type to compare against.
+ * @example
+ * ```ts
+ * type A = Extends<1, number>;  // ➔ true
+ * type B = Extends<number, 1>;  // ➔ false
+ * ```
+ */
 type Extends<T,Base>=[T] extends [Base]?true:false;
 /** -------------------------------------------------------
-* * ***NotExtends.***
-* -------------------------------------------------------
-* Returns a boolean indicating whether the first argument does ***not extend*** the second argument.
-*
-* @template T - The type to check.
-* @template Base - The type to compare against.
-* @example
-* ```ts
-* type A = NotExtends<1, number>; // ➔ false
-* type B = NotExtends<number, 1>; // ➔ true
-* ```
-*/
+ * * ***NotExtends.***
+ * -------------------------------------------------------
+ * Returns a boolean indicating whether the first argument does ***not extend*** the second argument.
+ *
+ * @template T - The type to check.
+ * @template Base - The type to compare against.
+ * @example
+ * ```ts
+ * type A = NotExtends<1, number>; // ➔ false
+ * type B = NotExtends<number, 1>; // ➔ true
+ * ```
+ */
 type NotExtends<T,Base>=Not<Extends<T,Base>>;
 /** -------------------------------------------------------
-* * ***IfExtends.***
-* -------------------------------------------------------
-* Conditional: returns the third argument if the first argument ***extends*** the second argument, otherwise returns the fourth argument.
-* - Defaults: `IfTrue = true`, `IfFalse = false`.
-*
-* @template T - The type to check.
-* @template Base - The type to compare against.
-* @template IfTrue - The branch type if condition is met. (default: `true`)
-* @template IfFalse - The branch type if condition is not met. (default: `false`)
-* @example
-* ```ts
-* type A = IfExtends<1, number, "valid">;
-* // ➔ "valid"
-* type B = IfExtends<1, string, "valid", "invalid">;
-* // ➔ "invalid"
-* ```
-*/
+ * * ***IfExtends.***
+ * -------------------------------------------------------
+ * Conditional: returns the third argument if the first argument ***extends*** the second argument, otherwise returns the fourth argument.
+ * - Defaults: `IfTrue = true`, `IfFalse = false`.
+ *
+ * @template T - The type to check.
+ * @template Base - The type to compare against.
+ * @template IfTrue - The branch type if condition is met. (default: `true`)
+ * @template IfFalse - The branch type if condition is not met. (default: `false`)
+ * @example
+ * ```ts
+ * type A = IfExtends<1, number, "valid">;
+ * // ➔ "valid"
+ * type B = IfExtends<1, string, "valid", "invalid">;
+ * // ➔ "invalid"
+ * ```
+ */
 type IfExtends<T,Base,IfTrue=true,IfFalse=false>=If<Extends<T,Base>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
-* * ***IfNotExtends.***
-* -------------------------------------------------------
-* Conditional: returns the third argument if the first argument does ***not extend*** the second argument, otherwise returns the fourth argument.
-* - Defaults: `IfTrue = true`, `IfFalse = false`.
-*
-* @template T - The type to check.
-* @template Base - The type to compare against.
-* @template IfTrue - The branch type if condition is met. (default: `true`)
-* @template IfFalse - The branch type if condition is not met. (default: `false`)
-* @example
-* ```ts
-* type A = IfNotExtends<1, string, "valid">;
-* // ➔ "valid"
-* type B = IfNotExtends<1, number, "valid", "invalid">;
-* // ➔ "invalid"
-* ```
-*/
+ * * ***IfNotExtends.***
+ * -------------------------------------------------------
+ * Conditional: returns the third argument if the first argument does ***not extend*** the second argument, otherwise returns the fourth argument.
+ * - Defaults: `IfTrue = true`, `IfFalse = false`.
+ *
+ * @template T - The type to check.
+ * @template Base - The type to compare against.
+ * @template IfTrue - The branch type if condition is met. (default: `true`)
+ * @template IfFalse - The branch type if condition is not met. (default: `false`)
+ * @example
+ * ```ts
+ * type A = IfNotExtends<1, string, "valid">;
+ * // ➔ "valid"
+ * type B = IfNotExtends<1, number, "valid", "invalid">;
+ * // ➔ "invalid"
+ * ```
+ */
 type IfNotExtends<T,Base,IfTrue=true,IfFalse=false>=If<NotExtends<T,Base>,IfTrue,IfFalse>;
 /** -------------------------------------------------------
-* * ***ExtendsArr.***
-* -------------------------------------------------------
-* Returns a boolean indicating whether every element of the first array argument ***extends*** the second argument.
-*
-* @template T - The array to check.
-* @template Base - The type to compare each element against.
-* @example
-* ```ts
-* type A = ExtendsArr<[1, 2, 3], number>;
-* // ➔ true
-* type B = ExtendsArr<[1, "2", 3], number>;
-* // ➔ false
-* ```
-*/
+ * * ***ExtendsArr.***
+ * -------------------------------------------------------
+ * Returns a boolean indicating whether every element of the first array argument ***extends*** the second argument.
+ *
+ * @template T - The array to check.
+ * @template Base - The type to compare each element against.
+ * @example
+ * ```ts
+ * type A = ExtendsArr<[1, 2, 3], number>;
+ * // ➔ true
+ * type B = ExtendsArr<[1, "2", 3], number>;
+ * // ➔ false
+ * ```
+ */
 type ExtendsArr<T extends readonly unknown[],Base>=IsEmptyArray<T>extends true?true:Pop<T,{includeRemoved:true;}>extends readonly [infer Rest extends readonly unknown[],infer Removed]?Extends<Removed,Base>extends true?ExtendsArr<Rest,Base>:false:false;export type{Arrayable as A,Extends as E,GetArrayElementType as G,IfExtends as I,MutableArray as M,Not as N,Pop as P,NotExtends as a,IsEmptyArray as b,ExtendsArr as c,IfEmptyArray as d,EmptyArray as e,IfNonEmptyArray as f,IsNonEmptyArray as g,NonEmptyArray as h,IfNotExtends as i,PopOptions as j};