@rzl-zone/utils-js 3.3.1 → 3.4.0

package/README.md

@@ -101,7 +101,7 @@
 - 📦 Works in **Node.js** & modern browsers
 - ❤️ Simple API, easy to extend
 - 🧬 **Next.js support**: helpers for dynamic routes, building URLs, reading env, extracting client IP
-- 🛠 Additional TypeScript types: `OmitStrict`, `PartialOnly`, etc.
+- 🛠 Additional including TypeScript package **`@rzl-zone/ts-types-plus`** types: `OmitStrict`, `PartialOnly`, etc.
 
 ---
 
@@ -148,7 +148,7 @@
   import { | } from "@rzl-zone/utils-js/tailwind";
   import { | } from "@rzl-zone/utils-js/urls";
 
-  import type { | } from "@rzl-zone/utils-js/types";
+  import type { | } from "@rzl-zone/ts-types-plus";
   ```
   #### Place your cursor inside { } or after "@rzl-zone/utils-js/{{ | }}" then press Ctrl+Space to see all available functions/types with full TSDoc hints.
   ---
@@ -222,7 +222,7 @@ console.log(isServer());
 #### *Example Types Helper Import:*
 
 ```ts
-import type { OmitStrict } from "@rzl-zone/utils-js/types";
+import type { OmitStrict } from "@rzl-zone/ts-types-plus";
 
 type MyType = OmitStrict<OtherType, "omittingProps">;
 // Fully strict TS omit that requires all keys to exist in target

package/dist/assertions/index.d.ts

@@ -1,4 +1,4 @@
-import{P as Prettify}from'../prettify-3o8_Kw6b.js';import{P as PickStrict}from'../pick-BSMX6Xe2.js';import{G as GetPreciseTypeOptions,I as IsNumberOptions,a as IsPlainObjectResult}from'../isPlainObject-DGJkcFYw.js';import'../if-ChM35c_q.js';import'../never-D89PbPh5.js';
+import{Prettify,PickStrict}from'@rzl-zone/ts-types-plus';import{G as GetPreciseTypeOptions,I as IsNumberOptions,a as IsPlainObjectResult}from'../isPlainObject-CEPWPiXh.js';
 /** -------------------------------------------------------
  * * ***Shape of the object passed to custom error message functions.***
  * -------------------------------------------------------

package/dist/conversions/index.d.ts

@@ -1,4 +1,4 @@
-import{h as Nullish,a as KeepNull,b as KeepUndef}from'../nils-CO8zLHSB.js';import{A as AnyFunction,P as Prettify,T as TypedArray,W as WebApiObjects,j as IntlObjects}from'../prettify-3o8_Kw6b.js';import{N as NormalizeEmptyArraysRecursive,R as RemoveEmptyArrayElements,F as FixNeverArrayRecursive}from'../arrays-normalize-recursive-BqmVuFlD.js';import{I as IsAny}from'../any-v4TsK9ES.js';import{i as IfNotExtends,I as IfExtends,E as Extends}from'../extends-DtdRjDyU.js';import{N as NumberRangeUnion}from'../NumberRangeUnion-B6bhM2s7.js';import{O as OrArr,a as AndArr}from'../or-C6qzKt2I.js';import'../if-ChM35c_q.js';import'../never-D89PbPh5.js';type NormalizeInputToNumberArrayUnRecursive<T>=T extends string|bigint|boolean|number|Nullish?T:HasNonNumberLikeNonNullish<T>;
+import{Nullish,KeepNull,KeepUndef,AnyFunction,NormalizeEmptyArraysRecursive,RemoveEmptyArrayElements,FixNeverArrayRecursive,IfNotExtends,IfExtends,IsAny,NumberRangeUnion,Prettify,OrArr,Extends,AndArr,TypedArray,WebApiObjects,IntlObjects}from'@rzl-zone/ts-types-plus';type NormalizeInputToNumberArrayUnRecursive<T>=T extends string|bigint|boolean|number|Nullish?T:HasNonNumberLikeNonNullish<T>;
 /** Detects whether `T` contains any number-like type (`string | number | bigint`).
  *
  * @template T Input type.

package/dist/formatters/index.d.ts

@@ -1,4 +1,4 @@
-import{NumberFormat,CountryCode}from'libphonenumber-js';import{a as OverrideTypes,E as ExtractStrict,O as OmitStrict}from'../override-CL2olHE5.js';import{P as Prettify}from'../prettify-3o8_Kw6b.js';import{FormatOptions,Locale}from'date-fns';import{A as AnyString}from'../string-B1jlOnws.js';import'../if-ChM35c_q.js';import'../never-D89PbPh5.js';type NegativeFormatOptionCustom={
+import{NumberFormat,CountryCode}from'libphonenumber-js';import{OverrideTypes,ExtractStrict,Prettify,OmitStrict,AnyString}from'@rzl-zone/ts-types-plus';import{FormatOptions,Locale}from'date-fns';type NegativeFormatOptionCustom={
 /** Custom formatter function for the final formatted negative string.
  *  If provided, it ***OVERRIDES*** style & space entirely. */
 custom:(formatted:string)=>string;style?:never;space?:never;};type NegativeFormatOptionUnCustom={custom?:never;

package/dist/generators/index.d.ts

@@ -1,4 +1,4 @@
-import{f as IfNonEmptyArray,E as Extends}from'../extends-DtdRjDyU.js';import{F as FixNeverArrayRecursive}from'../arrays-normalize-recursive-BqmVuFlD.js';import{g as NullToUndefined}from'../nils-CO8zLHSB.js';import'../if-ChM35c_q.js';import'../never-D89PbPh5.js';
+import{NullToUndefined,FixNeverArrayRecursive,IfNonEmptyArray,Extends}from'@rzl-zone/ts-types-plus';
 /** ---------------------------------
  * * ***Utility: `getRandomItem`.***
  * ---------------------------------

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 /// <reference path="./urls/index.d.ts" />
-/// <reference path="./types/index.d.ts" />
 /// <reference path="./tailwind/index.d.ts" />
 /// <reference path="./strings/index.d.ts" />
 /// <reference path="./promises/index.d.ts" />

package/dist/{isPlainObject-DGJkcFYw.d.ts → isPlainObject-CEPWPiXh.d.ts}

@@ -1,4 +1,4 @@
-import{N as NonPlainObject}from'./prettify-3o8_Kw6b.js';
+import{NonPlainObject}from'@rzl-zone/ts-types-plus';
 /** ---------------------------------------------------------------------------
  * * ***Type Options for {@link getPreciseType | `getPreciseType`}.***
  * ---------------------------------------------------------------------------

package/dist/next/index.d.ts

@@ -1,4 +1,4 @@
-import{I as IsAny}from'../any-v4TsK9ES.js';import'../if-ChM35c_q.js';
+import{IsAny}from'@rzl-zone/ts-types-plus';
 /** ---------------------------------------------------------
  * * ***Extracts dynamic route parameters from a given route string.***
  * ---------------------------------------------------------

package/dist/operations/index.d.ts

@@ -1,4 +1,4 @@
-import{N as NumberRangeUnion}from'../NumberRangeUnion-B6bhM2s7.js';
+import{NumberRangeUnion}from'@rzl-zone/ts-types-plus';
 /** ----------------------------------------------------------------------
  * * ***Utility: `findDuplicates`.***
  * ----------------------------------------------------------------------

package/dist/predicates/index.d.ts

@@ -1,4 +1,4 @@
-import{h as IsPositive,P as ParseNumber,I as IsStringLiteral,C as CharAt,c as IsUnknown,j as IsReadonlyArray,l as IsArray}from'../is-array-BJeHxPM3.js';import{A as AnyString,a as IsEmptyString,T as Trim}from'../string-B1jlOnws.js';import{I as IsAny}from'../any-v4TsK9ES.js';import{P as Prettify,A as AnyFunction,g as AnObjectNonArray,T as TypedArray}from'../prettify-3o8_Kw6b.js';import{E as Extends}from'../extends-DtdRjDyU.js';import{N as NumberRangeUnion}from'../NumberRangeUnion-B6bhM2s7.js';import{a as IsPlainObjectResult}from'../isPlainObject-DGJkcFYw.js';export{G as GetPreciseTypeOptions,I as IsNumberOptions,g as getPreciseType,i as isNumber,b as isPlainObject}from'../isPlainObject-DGJkcFYw.js';import{I as IsNever}from'../never-D89PbPh5.js';import{O as OrArr}from'../or-C6qzKt2I.js';import'../if-ChM35c_q.js';
+import{NumberRangeUnion,Prettify,IsPositive,ParseNumber,Extends,IsStringLiteral,CharAt,AnyString,AnyFunction,IsEmptyString,Trim,IsAny,IsUnknown,IsNever,IsReadonlyArray,IsArray,AnObjectNonArray,OrArr,TypedArray}from'@rzl-zone/ts-types-plus';import{a as IsPlainObjectResult}from'../isPlainObject-CEPWPiXh.js';export{G as GetPreciseTypeOptions,I as IsNumberOptions,g as getPreciseType,i as isNumber,b as isPlainObject}from'../isPlainObject-CEPWPiXh.js';
 /** ----------------------------------------------------------
  * * ***Predicate: `areArraysEqual`.***
  * ----------------------------------------------------------

package/dist/promises/index.d.ts

@@ -1,4 +1,4 @@
-import{C as CustomPromiseType}from'../promises-LU7K00H0.js';
+import{CustomPromiseType}from'@rzl-zone/ts-types-plus';
 /** -------------------------------------------------------------
  * * ***Utility Class: `CustomPromise`.***
  * -------------------------------------------------------------

package/dist/strings/index.d.ts

@@ -1,4 +1,4 @@
-import{c as Nilable}from'../nils-CO8zLHSB.js';import{E as Extends}from'../extends-DtdRjDyU.js';import'../if-ChM35c_q.js';import'../never-D89PbPh5.js';type CapitalizeFirstOptions={
+import{Nilable,Extends}from'@rzl-zone/ts-types-plus';type CapitalizeFirstOptions={
 /** If true **(default)**, the rest of the string will be converted to lowercase after capitalizing the first letter.
  *
  * @default true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rzl-zone/utils-js",
-  "version": "3.3.1",
+  "version": "3.4.0",
   "type": "module",
   "sideEffects": false,
   "engineStrict": true,
@@ -18,6 +18,7 @@
     "url": "https://github.com/rzl-zone/utils-js/issues"
   },
   "dependencies": {
+    "@rzl-zone/ts-types-plus": "latest",
     "date-fns": "^4.1.0",
     "libphonenumber-js": "^1.12.17",
     "server-only": "^0.0.1",
@@ -201,9 +202,6 @@
         "types": "./dist/urls/index.d.ts",
         "default": "./dist/urls/index.cjs"
       }
-    },
-    "./types": {
-      "types": "./dist/types/index.d.ts"
     }
   },
   "typesVersions": {
@@ -252,9 +250,6 @@
       ],
       "urls": [
         "dist/urls/index.d.ts"
-      ],
-      "types": [
-        "dist/types/index.d.ts"
       ]
     }
   },

package/dist/NumberRangeUnion-B6bhM2s7.d.ts

@@ -1,33 +0,0 @@
-/** --------------------------------------------------
- * * ***Internal Utility Type for: {@link NumberRangeUnion | `NumberRangeUnion`}.***
- * --------------------------------------------------
- * @template N - Starting/Ending number of the range (inclusive).
- * @template Acc - Internal accumulator for recursion (do not set manually).
- */
-type Enumerate<N extends number,Acc extends number[]=[]>=Acc["length"] extends N?Acc[number]:Enumerate<N,[...Acc,Acc["length"]]>;
-/** --------------------------------------------------
- * * ***Utility Type: `NumberRangeUnion`.***
- * --------------------------------------------------
- * **Generate a union type of numbers from `From` to `To` using enumeration.**
- * @description
- * Produces a **numeric union type** from `From` to `To` (inclusive),
- * using a simpler approach based on `Enumerate<N>` helper type.
- * - ✅ Straightforward & easy to reason about.
- * - ⚠️ Still limited by TypeScript recursion depth (safe up to `999`).
- * - ⚙️ Best used for **smaller ranges** (`≤ 100`) or when readability matters.
- * - ℹ️ For **larger ranges** (`≥ 101`) use {@link NumberRangeLimit | `NumberRangeLimit`} instead.
- * @template From - Starting number of the range (inclusive).
- * @template To - Ending number of the range (inclusive).
- * @example
- * ```ts
- * type RangeA = NumberRangeUnion<3, 6>;
- * // ➔ 3 | 4 | 5 | 6
- * type RangeB = NumberRangeUnion<0, 2>;
- * // ➔ 0 | 1 | 2
- * type RangeC = NumberRangeUnion<8, 8>;
- * // ➔ 8
- * type RangeD = NumberRangeUnion<20, 10>;
- * // ➔ 10
- * ```
- */
-type NumberRangeUnion<From extends number,To extends number>=From extends To?From:Exclude<Enumerate<To>,Enumerate<From>>extends never?To:Exclude<Enumerate<To>,Enumerate<From>>|To;export type{NumberRangeUnion as N};

package/dist/any-v4TsK9ES.d.ts

@@ -1,66 +0,0 @@
-import{I as If}from'./if-ChM35c_q.js';
-/** -------------------------------------------------------
- * * ***Utility Type: `IsAny`.***
- * -------------------------------------------------------
- * **A type-level utility that checks whether a type is ***`any`***.**
- * - **Behavior:**
- *    - Returns `true` if `T` is `any`.
- *    - Returns `false` for otherwise.
- * @template T - The type to evaluate.
- * @example
- * ```ts
- * type A = IsAny<any>;     // ➔ true
- * type B = IsAny<string>;  // ➔ false
- * type C = IsAny<unknown>; // ➔ false
- * type D = IsAny<never>;   // ➔ false
- * ```
- */
-type IsAny<T>=0 extends 1 & T?true:false;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfAny`.***
- * -------------------------------------------------------
- * **A type-level conditional utility that returns one type if ***`T` is `any`***,
- * and another type otherwise.**
- * - **Behavior:**
- *    - Defaults to `true` when `T` is `any`.
- *    - Defaults to `false` for otherwise.
- * @template T - The type to check.
- * @template IfTrue - The type to return if `T` is `any`, *(default: `true`)*.
- * @template IfFalse - The type to return if `T` is not `any`, *(default: `false`)*.
- * @example
- * ```ts
- * type A = IfAny<any, string, number>;
- * // ➔ string
- * type B = IfAny<string, string, number>;
- * // ➔ number
- * ```
- */
-type IfAny<T,IfTrue=true,IfFalse=false>=If<IsAny<T>,IfTrue,IfFalse>;
-/** * ***Configuration options for a type-level utility for
- * {@link AnifyProperties | `AnifyProperties`}.***
- */
-type AnifyPropertiesOptions={
-/** If `makeOptional: true`, all properties become optional, otherwise, all properties are required and typed as `any`, defaultValue: `false`.
- *
- * @default false
- */
-makeOptional:boolean;};
-/** -------------------------------------------------------
- * * ***Utility Type: `AnifyProperties`.***
- * -------------------------------------------------------
- * **A type-level utility that transforms all properties of an object
- * into ***`any`***.**
- * - **Behavior:**
- *    - If `makeOptional: true`, all properties become optional.
- *    - Otherwise, all properties are required and typed as `any`.
- * @template T The object type to transform.
- * @template Options Configuration options, defaults to `{ makeOptional: false }`.
- * @example
- * ```ts
- * type A = AnifyProperties<{a: string; b: number}>;
- * // ➔ { a: any; b: any }
- * type B = AnifyProperties<{a: string; b: number}, { makeOptional: true }>;
- * // ➔ { a?: any; b?: any }
- * ```
- */
-type AnifyProperties<T extends object,Options extends AnifyPropertiesOptions={makeOptional:false;}>={[K in keyof T]:any;}extends infer Result?If<Options["makeOptional"],Partial<Result>,Result>:never;export type{AnifyProperties as A,IsAny as I,AnifyPropertiesOptions as a,IfAny as b};

package/dist/arrays-normalize-recursive-BqmVuFlD.d.ts

@@ -1,72 +0,0 @@
-/** -------------------------------------------------------
- * * ***Utility Type: `FixNeverArrayRecursive`.***
- * -------------------------------------------------------
- * **A type-level utility that **recursively transforms arrays of type `never[]` into empty arrays**.**
- * - **Behavior:**
- *    - Preserves `readonly` modifiers.
- *    - Applies recursively for nested arrays.
- *    - Leaves other types unchanged.
- * @template T - The input type to recursively fix.
- * @example
- * ```ts
- * type A = FixNeverArrayRecursive<never[]>;
- * // ➔ []
- * type B = FixNeverArrayRecursive<readonly never[]>;
- * // ➔ readonly []
- * type C = FixNeverArrayRecursive<string[]>;
- * // ➔ string[]
- * type D = FixNeverArrayRecursive<(never | string)[]>;
- * // ➔ (never | string)[]
- * type E = FixNeverArrayRecursive<(never[])[]>;
- * // ➔ [][]
- * ```
- */
-type FixNeverArrayRecursive<T>=T extends readonly never[]?T extends never[]?[]:readonly []:T extends(infer U)[]?FixNeverArrayRecursive<U>[]:T extends readonly(infer U)[]?readonly FixNeverArrayRecursive<U>[]:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `NormalizeEmptyArraysRecursive`.***
- * -------------------------------------------------------
- * **A type-level utility that **recursively normalizes empty array types** by converting arrays whose element type is `never`, `null`, or `undefined` into empty tuple types (`[]`).**
- * - **Behavior:**
- *    - Preserves `readonly` modifiers.
- *    - Recurses into nested arrays.
- *    - Leaves other array types unchanged.
- * @template T - The input type to normalize.
- * @example
- * ```ts
- * type A = NormalizeEmptyArraysRecursive<never[]>;
- * // ➔ []
- * type B = NormalizeEmptyArraysRecursive<readonly never[]>;
- * // ➔ readonly []
- * type C = NormalizeEmptyArraysRecursive<null[]>;
- * // ➔ []
- * type D = NormalizeEmptyArraysRecursive<(null[] | string[])[]>;
- * // ➔ ([] | string[])[]
- * type E = NormalizeEmptyArraysRecursive<string[]>;
- * // ➔ string[]
- * ```
- */
-type NormalizeEmptyArraysRecursive<T>=T extends readonly(infer U)[]?U extends never|null|undefined?T extends readonly unknown[]?T extends(infer E)[]?[]:readonly []:never:T extends(infer E)[]?NormalizeEmptyArraysRecursive<U>[]:readonly NormalizeEmptyArraysRecursive<U>[]:T;
-/** -------------------------------------------------------
- * * ***Utility Type: `RemoveEmptyArrayElements`.***
- * -------------------------------------------------------
- * **A type-level utility that **recursively removes empty array elements (`[]`) from a tuple type**.**
- * - **Behavior:**
- *    - If `T` is a tuple, checks the first element:
- *        - If `Head` is an empty array type (`[]`), it is removed.
- *        - Otherwise, `Head` is preserved.
- *    - Repeats recursively on the rest of the tuple.
- *    - Leaves non-tuple types unchanged.
- * @template T - The tuple type to process.
- * @example
- * ```ts
- * type A = RemoveEmptyArrayElements<[[], 1, [], 2]>;
- * // ➔ [1, 2]
- * type B = RemoveEmptyArrayElements<[]>;
- * // ➔ []
- * type C = RemoveEmptyArrayElements<[[], [], []]>;
- * // ➔ []
- * type D = RemoveEmptyArrayElements<[1, 2, 3]>;
- * // ➔ [1, 2, 3]
- * ```
- */
-type RemoveEmptyArrayElements<T>=T extends [infer Head,...infer Tail]?Head extends []?RemoveEmptyArrayElements<Tail>:[Head,...RemoveEmptyArrayElements<Tail>]:T extends []?[]:T;export type{FixNeverArrayRecursive as F,NormalizeEmptyArraysRecursive as N,RemoveEmptyArrayElements as R};

package/dist/extends-DtdRjDyU.d.ts

@@ -1,343 +0,0 @@
-import{I as If}from'./if-ChM35c_q.js';import{I as IsNever}from'./never-D89PbPh5.js';
-/** -------------------------------------------------------
- * * ***Utility Type: `Arrayable`.***
- * -------------------------------------------------------
- * **Useful when a function or API accepts **either one item or multiple items**.**
- * - **Represents a type that can be either:**
- *    - a single value of type `T`, or an array of values of type `T`.
- * @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>;
-/** -------------------------------------------------------
- * * ***Utility Type: `MutableArray`.***
- * -------------------------------------------------------
- * **Recursively creates a **mutable version** of a readonly array, tuple, or object type.**
- * @description
- * 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.
- * - **Behavior:**
- *    - 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;
-/** --------------------------------------------------
- * * ***Utility Type: `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;
-/** -------------------------------------------------------
- * * ***Utility Type: `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;
-/** -------------------------------------------------------
- * * ***Utility Type: `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>;
-/** -------------------------------------------------------
- * * ***Utility Type: `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>;
-/** -------------------------------------------------------
- * * ***Utility Type: `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>;
-/** -------------------------------------------------------
- * * ***Utility Type: `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>;
-/** -------------------------------------------------------
- * * ***Utility Type: `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>;
-/** -------------------------------------------------------
- * * ***Utility Type: `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;
-/** ---------------------------------------------------------------------------
- * * ***Options for {@link Pop|`Pop`}.***
- * ---------------------------------------------------------------------------
- * **Configuration options for the {@link Pop | **`Pop`**} type utility.**
- */
-type PopOptions={
-/**
- * If `true`, {@link Pop | **`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;};
-/** -------------------------------------------------------
- * * ***Utility Type: `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;
-/** -------------------------------------------------------
- * * ***Utility Type: `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;
-/** -------------------------------------------------------
- * * ***Utility Type: `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>>;
-/** -------------------------------------------------------
- * * ***Utility Type: `IfExtends`.***
- * -------------------------------------------------------
- * - **Conditional:**
- *    - Returns the third argument if the first argument ***extends*** the secon
- *      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>;
-/** -------------------------------------------------------
- * * ***Utility Type: `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>;
-/** -------------------------------------------------------
- * * ***Utility Type: `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};