@rzl-zone/utils-js 3.0.0-beta.0 → 3.0.0

package/dist/prettify-C4xLcYOP.d.ts

@@ -1,353 +1,353 @@
 import{I as If}from'./if-CvT4R7Kh.js';import{A as AnyFunction,N as NonPlainObject}from'./type-data-DDs-u2kq.js';import{I as IsNever}from'./never-BfayMBF9.js';
 /** -------------------------------------------------------
-* * ***IsArrayOrTuple.***
-* -------------------------------------------------------
-* Checks if a given type `T` is an array or tuple type.
-* This includes both mutable (`T[]`) and readonly (`readonly T[]`) arrays.
-*
-* @template T - The type to check.
-* @example
-* // truthy
-* type A = IsArrayOrTuple<string[]>;
-* // ➔ true
-* type B = IsArrayOrTuple<readonly [string, number]>;
-* // ➔ true
-*
-* // falsy
-* type C = IsArrayOrTuple<string>; // ➔ false
-*/
+ * * ***IsArrayOrTuple.***
+ * -------------------------------------------------------
+ * Checks if a given type `T` is an array or tuple type.
+ * This includes both mutable (`T[]`) and readonly (`readonly T[]`) arrays.
+ *
+ * @template T - The type to check.
+ * @example
+ * // truthy
+ * type A = IsArrayOrTuple<string[]>;
+ * // ➔ true
+ * type B = IsArrayOrTuple<readonly [string, number]>;
+ * // ➔ true
+ *
+ * // falsy
+ * type C = IsArrayOrTuple<string>; // ➔ false
+ */
 type IsArrayOrTuple<T>=T extends readonly any[]?true:false;
 /** -------------------------------------------------------
-* * ***IsConstructor.***
-* -------------------------------------------------------
-* Checks if a given type `T` is a constructor type (`new () => any`).
-*
-* @template T - The type to check.
-* @returns `true` if `T` is a constructor, otherwise `false`.
-* @example
-* class MyClass {}
-* type A = IsConstructor<typeof MyClass>;
-* // ➔ true
-* type B = IsConstructor<() => void>;
-* // ➔ false
-*/
+ * * ***IsConstructor.***
+ * -------------------------------------------------------
+ * Checks if a given type `T` is a constructor type (`new () => any`).
+ *
+ * @template T - The type to check.
+ * @returns `true` if `T` is a constructor, otherwise `false`.
+ * @example
+ * class MyClass {}
+ * type A = IsConstructor<typeof MyClass>;
+ * // ➔ true
+ * type B = IsConstructor<() => void>;
+ * // ➔ false
+ */
 type IsConstructor<T>=T extends abstract new(...args:any[])=>any?true:false;
 /** -------------------------------------------------------
-* * ***IsFunction.***
-* -------------------------------------------------------
-* Checks if a given type `T` is a callable function type.
-*
-* @template T - The type to check.
-* @example
-* type A = IsFunction<() => void>;  // ➔ true
-* type B = IsFunction<string>;      // ➔ false
-*/
+ * * ***IsFunction.***
+ * -------------------------------------------------------
+ * Checks if a given type `T` is a callable function type.
+ *
+ * @template T - The type to check.
+ * @example
+ * type A = IsFunction<() => void>;  // ➔ true
+ * type B = IsFunction<string>;      // ➔ false
+ */
 type IsFunction<T>=T extends AnyFunction?true:false;
 /** -------------------------------------------------------
-* * ***Primitive.***
-* -------------------------------------------------------
-*
-* Represents **all primitive types in JavaScript/TypeScript**,
-* including their literal variants.
-*
-* This type matches:
-* - Core primitive types: `string`, `number`, `boolean`, `bigint`, `symbol`, `null`, `undefined`
-* - Literal counterparts: `"foo"`, `42`, `true`, etc.
-*
-* ⚠️ Note:
-* - Unlike some definitions, this does **not** include `void` or `never`,
-*   since they are TypeScript-specific keywords, not runtime primitives.
-*
-* @example
-* ```ts
-* type A = Primitive; // any strict primitive type
-* type B = "hello" extends Primitive ? true : false; // true
-* type C = void extends Primitive ? true : false;    // false
-* ```
-*/
+ * * ***Primitive.***
+ * -------------------------------------------------------
+ *
+ * Represents **all primitive types in JavaScript/TypeScript**,
+ * including their literal variants.
+ *
+ * This type matches:
+ * - Core primitive types: `string`, `number`, `boolean`, `bigint`, `symbol`, `null`, `undefined`
+ * - Literal counterparts: `"foo"`, `42`, `true`, etc.
+ *
+ * ⚠️ Note:
+ * - Unlike some definitions, this does **not** include `void` or `never`,
+ *   since they are TypeScript-specific keywords, not runtime primitives.
+ *
+ * @example
+ * ```ts
+ * type A = Primitive; // any strict primitive type
+ * type B = "hello" extends Primitive ? true : false; // true
+ * type C = void extends Primitive ? true : false;    // false
+ * ```
+ */
 type Primitive=string|number|bigint|boolean|symbol|null|undefined;
 /** -------------------------------------------------------
-* * ***IsPrimitive.***
-* -------------------------------------------------------
-*
-* Checks if a given type `T` is a **strict primitive type** in JavaScript/TypeScript,
-* including literal variants.
-* This excludes `void` and `never`.
-*
-* Includes:
-* - `string`, `number`, `bigint`, `boolean`, `symbol`, `null`, `undefined`.
-* - Literal types like `"foo"`, `42`, `true`.
-*
-* Excludes:
-* - `void` (absence of value)
-* - `never` (impossible type)
-* - `object`, `unknown`, `Date`, `arrays`, `functions`, etc.
-*
-* @template T - The type to check
-*
-* @example
-* ```ts
-* type A = IsPrimitive<"foo">;      // true
-* type B = IsPrimitive<null>;       // true
-* type C = IsPrimitive<number>;     // true
-* type D = IsPrimitive<undefined>;  // true
-* type E = IsPrimitive<{}>;         // false
-* type F = IsPrimitive<void>;       // false
-* type G = IsPrimitive<never>;      // false
-* type H = IsPrimitive<unknown>;    // false
-* type I = IsPrimitive<object>;     // false
-* type J = IsPrimitive<Date>;       // false
-* type K = IsPrimitive<[]>;         // false
-* type L = IsPrimitive<() => void>; // false
-* ```
-*/
+ * * ***IsPrimitive.***
+ * -------------------------------------------------------
+ *
+ * Checks if a given type `T` is a **strict primitive type** in JavaScript/TypeScript,
+ * including literal variants.
+ * This excludes `void` and `never`.
+ *
+ * Includes:
+ * - `string`, `number`, `bigint`, `boolean`, `symbol`, `null`, `undefined`.
+ * - Literal types like `"foo"`, `42`, `true`.
+ *
+ * Excludes:
+ * - `void` (absence of value)
+ * - `never` (impossible type)
+ * - `object`, `unknown`, `Date`, `arrays`, `functions`, etc.
+ *
+ * @template T - The type to check
+ *
+ * @example
+ * ```ts
+ * type A = IsPrimitive<"foo">;      // true
+ * type B = IsPrimitive<null>;       // true
+ * type C = IsPrimitive<number>;     // true
+ * type D = IsPrimitive<undefined>;  // true
+ * type E = IsPrimitive<{}>;         // false
+ * type F = IsPrimitive<void>;       // false
+ * type G = IsPrimitive<never>;      // false
+ * type H = IsPrimitive<unknown>;    // false
+ * type I = IsPrimitive<object>;     // false
+ * type J = IsPrimitive<Date>;       // false
+ * type K = IsPrimitive<[]>;         // false
+ * type L = IsPrimitive<() => void>; // false
+ * ```
+ */
 type IsPrimitive<T>=IsNever<T>extends true?false:T extends Primitive?true:false;
 /** -------------------------------------------------------
-* * ***IsRealPrimitive.***
-* -------------------------------------------------------
-*
-* Checks if a given type `T` is a **real primitive type** in JavaScript/TypeScript,
-* based on runtime behavior, **excluding `null`** but including `undefined`.
-*
-* Includes:
-* - `string`, `number`, `bigint`, `boolean`, `symbol`, `undefined`
-* - Literal types like `"foo"`, `42`, `true`
-*
-* Excludes:
-* - `null`
-* - `never` (impossible type)
-* - Objects, arrays, functions, `Date`, `unknown`, etc.
-*
-* ⚠️ Note:
-* - This aligns with runtime `typeof` checks in JS: `typeof null === "object"`,
-*   so `null` is excluded from **“real primitives”**.
-*
-* @template T - The type to check.
-*
-* @example
-* ```ts
-* type A = IsRealPrimitive<42>;        // true
-* type B = IsRealPrimitive<string>;    // true
-* type C = IsRealPrimitive<boolean>;   // true
-* type D = IsRealPrimitive<undefined>; // true
-* type E = IsRealPrimitive<{}>;        // false
-* type F = IsRealPrimitive<[]>;        // false
-* type G = IsRealPrimitive<null>;      // false
-* type H = IsRealPrimitive<Date>;      // false
-* type I = IsRealPrimitive<() => void>; // false
-* ```
-*/
+ * * ***IsRealPrimitive.***
+ * -------------------------------------------------------
+ *
+ * Checks if a given type `T` is a **real primitive type** in JavaScript/TypeScript,
+ * based on runtime behavior, **excluding `null`** but including `undefined`.
+ *
+ * Includes:
+ * - `string`, `number`, `bigint`, `boolean`, `symbol`, `undefined`
+ * - Literal types like `"foo"`, `42`, `true`
+ *
+ * Excludes:
+ * - `null`
+ * - `never` (impossible type)
+ * - Objects, arrays, functions, `Date`, `unknown`, etc.
+ *
+ * ⚠️ Note:
+ * - This aligns with runtime `typeof` checks in JS: `typeof null === "object"`,
+ *   so `null` is excluded from **“real primitives”**.
+ *
+ * @template T - The type to check.
+ *
+ * @example
+ * ```ts
+ * type A = IsRealPrimitive<42>;        // true
+ * type B = IsRealPrimitive<string>;    // true
+ * type C = IsRealPrimitive<boolean>;   // true
+ * type D = IsRealPrimitive<undefined>; // true
+ * type E = IsRealPrimitive<{}>;        // false
+ * type F = IsRealPrimitive<[]>;        // false
+ * type G = IsRealPrimitive<null>;      // false
+ * type H = IsRealPrimitive<Date>;      // false
+ * type I = IsRealPrimitive<() => void>; // false
+ * ```
+ */
 type IsRealPrimitive<T>=T extends Exclude<Primitive,null>?true:false;
 /**
-* Applies readonly behavior according to mode.
-*/
+ * Applies readonly behavior according to mode.
+ */
 type ApplyReadonlyMode<T,Mode extends PrettifyOptions["readonlyMode"]>=Mode extends"remove"?{-readonly [K in keyof T]:T[K];}:Mode extends"preserve"?{readonly [K in keyof T]:T[K];}:{[K in keyof T]:T[K];};
 /** -------------------------------------------------------
-* * ***PrettifyOptions***
-* -------------------------------------------------------
-*
-* Options for customizing the behavior of the {@link Prettify} type.
-*/
+ * * ***PrettifyOptions***
+ * -------------------------------------------------------
+ *
+ * Options for customizing the behavior of the {@link Prettify} type.
+ */
 type PrettifyOptions={
 /** -------------------------------------------------------
-* * ***recursive***
-* -------------------------------------------------------
-*
-* Enables **deep prettification** of types when set to `true`.
-*
-* By default (`false`), {@link Prettify} only flattens the **top-level shape**
-* of objects and intersections. Nested objects, arrays, and tuples remain as-is
-* unless this option is enabled.
-*
-* ⚡ Behavior when `true`:
-* - **Plain objects**: Nested intersections are expanded recursively.
-* - **Arrays & tuples**: Each element type is recursively prettified.
-* - **Readonly handling**: Nested properties respect the `readonlyMode` option.
-* - **Functions, constructors, and built-in objects** (Set, Map, Date, Promise, etc.)
-*   are **not** affected or expanded.
-* - **Nested intersections**: Combined properties are flattened recursively.
-*
-* ⚠️ Notes:
-* - Recursive mode only applies to **plain objects**, **arrays**, and **tuples**.
-* - Readonly modifiers on nested properties follow the `readonlyMode` rules:
-*   - `"auto"` → keep as-is
-*   - `"remove"` → strip readonly
-*   - `"preserve"` → make readonly
-* - Arrays and tuples maintain `readonly` if the original type is `readonly` and `readonlyMode` is `"auto"` or `"preserve"`.
-*
-* @default false
-*
-* @example
-* ```ts
-* type Nested = {
-*   a: {
-*     readonly b: { c: number } & { d: string }
-*   } & { e: boolean };
-*   list: readonly ({ id: number } & { name: string })[];
-*   set: Set<{ x: number } & { y: string }>;
-* };
-*
-* // Top-level only (default)
-* type Shallow = Prettify<Nested>;
-* // ➔ {
-* //      a: { readonly b: { c: number } & { d: string } } & { e: boolean };
-* //      list: readonly ({ id: number } & { name: string })[];
-* //      set: Set<{ x: number } & { y: string }>;
-* //    }
-*
-* // Fully recursive flatten
-* type Deep = Prettify<Nested, { recursive: true }>;
-* // ➔ {
-* //      a: { readonly b: { c: number; d: string }; e: boolean };
-* //      list: readonly { id: number; name: string }[];
-* //      set: Set<{ x: number } & { y: string }>; // built-in ignored
-* //    }
-* ```
-*/
+ * * ***recursive***
+ * -------------------------------------------------------
+ *
+ * Enables **deep prettification** of types when set to `true`.
+ *
+ * By default (`false`), {@link Prettify} only flattens the **top-level shape**
+ * of objects and intersections. Nested objects, arrays, and tuples remain as-is
+ * unless this option is enabled.
+ *
+ * ⚡ Behavior when `true`:
+ * - **Plain objects**: Nested intersections are expanded recursively.
+ * - **Arrays & tuples**: Each element type is recursively prettified.
+ * - **Readonly handling**: Nested properties respect the `readonlyMode` option.
+ * - **Functions, constructors, and built-in objects** (Set, Map, Date, Promise, etc.)
+ *   are **not** affected or expanded.
+ * - **Nested intersections**: Combined properties are flattened recursively.
+ *
+ * ⚠️ Notes:
+ * - Recursive mode only applies to **plain objects**, **arrays**, and **tuples**.
+ * - Readonly modifiers on nested properties follow the `readonlyMode` rules:
+ *   - `"auto"` → keep as-is
+ *   - `"remove"` → strip readonly
+ *   - `"preserve"` → make readonly
+ * - Arrays and tuples maintain `readonly` if the original type is `readonly` and `readonlyMode` is `"auto"` or `"preserve"`.
+ *
+ * @default false
+ *
+ * @example
+ * ```ts
+ * type Nested = {
+ *   a: {
+ *     readonly b: { c: number } & { d: string }
+ *   } & { e: boolean };
+ *   list: readonly ({ id: number } & { name: string })[];
+ *   set: Set<{ x: number } & { y: string }>;
+ * };
+ *
+ * // Top-level only (default)
+ * type Shallow = Prettify<Nested>;
+ * // ➔ {
+ * //      a: { readonly b: { c: number } & { d: string } } & { e: boolean };
+ * //      list: readonly ({ id: number } & { name: string })[];
+ * //      set: Set<{ x: number } & { y: string }>;
+ * //    }
+ *
+ * // Fully recursive flatten
+ * type Deep = Prettify<Nested, { recursive: true }>;
+ * // ➔ {
+ * //      a: { readonly b: { c: number; d: string }; e: boolean };
+ * //      list: readonly { id: number; name: string }[];
+ * //      set: Set<{ x: number } & { y: string }>; // built-in ignored
+ * //    }
+ * ```
+ */
 recursive?:boolean;
 /** -------------------------------------------------------
-* * ***readonlyMode***
-* -------------------------------------------------------
-*
-* Determines how `readonly` modifiers are applied to properties
-* when using {@link Prettify}.
-*
-* Modes:
-* - `"auto"` → Keep `readonly` exactly as in the original type (default).
-* - `"remove"` → Remove all `readonly` modifiers.
-* - `"preserve"` → Make all properties `readonly`.
-*
-* ⚡ Behavior:
-* - Applies to both **top-level** and **nested properties** (if `recursive` is `true`).
-* - Arrays and tuples preserve or adjust `readonly` according to the selected mode:
-*   - `"auto"` → preserve array/tuple readonly as-is.
-*   - `"remove"` → array/tuple becomes mutable.
-*   - `"preserve"` → array/tuple becomes readonly.
-* - Functions, constructors, and built-in objects (Set, Map, Date, Promise, etc.) are **not affected**.
-* - Nested intersections respect `readonlyMode` recursively if `recursive` is enabled.
-*
-* ⚠️ Notes:
-* - For nested objects, `readonly` behavior only changes if `recursive: true`.
-* - `readonlyMode` does **not** override `readonly` on function parameters, methods, or constructors.
-*
-* @default "auto"
-*
-* @example
-* ```ts
-* type T = { readonly a: number; b: string };
-*
-* // Default: auto
-* type Auto = Prettify<T, { readonlyMode: "auto" }>;
-* // ➔ { readonly a: number; b: string }
-*
-* // Remove readonly
-* type Remove = Prettify<T, { readonlyMode: "remove" }>;
-* // ➔ { a: number; b: string }
-*
-* // Force all readonly
-* type Preserve = Prettify<T, { readonlyMode: "preserve" }>;
-* // ➔ { readonly a: number; readonly b: string }
-*
-* // Recursive + preserve
-* type Nested = {
-*   config: { readonly port: number } & { host: string }
-* };
-* type RecursivePreserve = Prettify<Nested, { recursive: true; readonlyMode: "preserve" }>;
-* // ➔ { readonly config: { readonly port: number; readonly host: string } }
-* ```
-*/
+ * * ***readonlyMode***
+ * -------------------------------------------------------
+ *
+ * Determines how `readonly` modifiers are applied to properties
+ * when using {@link Prettify}.
+ *
+ * Modes:
+ * - `"auto"` → Keep `readonly` exactly as in the original type (default).
+ * - `"remove"` → Remove all `readonly` modifiers.
+ * - `"preserve"` → Make all properties `readonly`.
+ *
+ * ⚡ Behavior:
+ * - Applies to both **top-level** and **nested properties** (if `recursive` is `true`).
+ * - Arrays and tuples preserve or adjust `readonly` according to the selected mode:
+ *   - `"auto"` → preserve array/tuple readonly as-is.
+ *   - `"remove"` → array/tuple becomes mutable.
+ *   - `"preserve"` → array/tuple becomes readonly.
+ * - Functions, constructors, and built-in objects (Set, Map, Date, Promise, etc.) are **not affected**.
+ * - Nested intersections respect `readonlyMode` recursively if `recursive` is enabled.
+ *
+ * ⚠️ Notes:
+ * - For nested objects, `readonly` behavior only changes if `recursive: true`.
+ * - `readonlyMode` does **not** override `readonly` on function parameters, methods, or constructors.
+ *
+ * @default "auto"
+ *
+ * @example
+ * ```ts
+ * type T = { readonly a: number; b: string };
+ *
+ * // Default: auto
+ * type Auto = Prettify<T, { readonlyMode: "auto" }>;
+ * // ➔ { readonly a: number; b: string }
+ *
+ * // Remove readonly
+ * type Remove = Prettify<T, { readonlyMode: "remove" }>;
+ * // ➔ { a: number; b: string }
+ *
+ * // Force all readonly
+ * type Preserve = Prettify<T, { readonlyMode: "preserve" }>;
+ * // ➔ { readonly a: number; readonly b: string }
+ *
+ * // Recursive + preserve
+ * type Nested = {
+ *   config: { readonly port: number } & { host: string }
+ * };
+ * type RecursivePreserve = Prettify<Nested, { recursive: true; readonlyMode: "preserve" }>;
+ * // ➔ { readonly config: { readonly port: number; readonly host: string } }
+ * ```
+ */
 readonlyMode?:Extract<"auto"|"remove"|"preserve",string>;};
 /** -------------------------------------------------------
-* * ***DefaultPrettifyOptions***
-* -------------------------------------------------------
-*
-* Default options {@link Prettify} used when no custom options are provided.
-*/
+ * * ***DefaultPrettifyOptions***
+ * -------------------------------------------------------
+ *
+ * Default options {@link Prettify} used when no custom options are provided.
+ */
 type DefaultPrettifyOptions={recursive:false;readonlyMode:"auto";};type MergeReadonlyIntersection<T>=T extends readonly any[]?T:T extends object?{[K in keyof T]:T[K];}:T;
 /** -------------------------------------------------------
-* * ***Prettify.***
-* -------------------------------------------------------
-* Flattens and simplifies complex TypeScript types into a more
-* human-readable form, by forcing the compiler to expand intersections.
-*
-* By default, only the **top-level shape** of an object is flattened.
-* To also prettify **nested objects**, set the `recursive` option.
-*
-* ⚠️ Note:
-* - `recursive: true` only affects **plain objects** and **arrays/tuples**.
-* - Built-in objects like `Set`, `Map`, `Date`, `Promise`, etc.
-*   will **not** be recursively prettified.
-* - `readonly` handling is controlled via the `readonlyMode` option.
-*
-* ℹ️ Options:
-*  - `recursive?: boolean` (default: `false`)
-*     - Whether to recursively expand nested objects and intersections.
-*  - `readonlyMode?: "auto" | "remove" | "preserve"` (default: `"auto"`)
-*     - How `readonly` modifiers are treated:
-*         - `"auto"`     → preserve `readonly` as-is (default).
-*         - `"remove"`   → strip all `readonly`.
-*         - `"preserve"` → enforce `readonly` everywhere.
-* @template T - The type to prettify.
-* @template Options - Configuration options.
-*
-* @example
-* ```ts
-* // --- Top-level only (default) ---
-* type T0 = Prettify<{ a: number } & { b: string }>;
-* // ➔ { a: number; b: string }
-*
-* // --- Recursive expansion of nested objects ---
-* type T1 = Prettify<
-*   { a: { x: number } & { y: string } } & { b: boolean },
-*   { recursive: true }
-* >;
-* // ➔ { a: { x: number; y: string }; b: boolean }
-*
-* // --- Readonly handling modes ---
-* type T2 = { readonly id: number; name: string };
-*
-* type R1 = Prettify<T2>;
-* // (default: readonlyMode = "auto")
-* // ➔ { readonly id: number; name: string }
-*
-* type R2 = Prettify<T2, { readonlyMode: "remove" }>;
-* // ➔ { id: number; name: string }
-*
-* type R3 = Prettify<T2, { readonlyMode: "preserve" }>;
-* // ➔ { readonly id: number; readonly name: string }
-*
-* // --- Readonly + mutable intersection ---
-* type T3 = Prettify<{ readonly a: number } & { a: number; b: boolean }>;
-* // ➔ { a: number; b: boolean }
-* // (in "auto" mode, readonly lose over mutable)
-*
-* // --- Nested readonly with recursive ---
-* type T4 = Prettify<
-*   { config: { readonly port: number } & { host: string } },
-*   { recursive: true }
-* >;
-* // ➔ { config: { readonly port: number; host: string } }
-*
-* // --- Arrays with readonly ---
-* type T5 = Prettify<
-*   { list: readonly ({ id: number } & { name: string })[] },
-*   { recursive: true }
-* >;
-* // (readonly on array is preserved in "auto" mode)
-* // ➔ { list: readonly { id: number; name: string }[] }
-*
-* type T6 = Prettify<
-*   { list: readonly ({ id: number } & { name: string })[] },
-*   { recursive: true; readonlyMode: "remove" }
-* >;
-* // ➔ { list: { id: number; name: string }[] }
-*
-* // --- Built-in objects are ignored (not expanded) ---
-* type T7 = Prettify<
-*   { s: Set<{ a: number } & { b: string }> },
-*   { recursive: true }
-* >;
-* // ➔ { s: Set<{ a: number } & { b: string }> }
-* ```
-*/
+ * * ***Prettify.***
+ * -------------------------------------------------------
+ * Flattens and simplifies complex TypeScript types into a more
+ * human-readable form, by forcing the compiler to expand intersections.
+ *
+ * By default, only the **top-level shape** of an object is flattened.
+ * To also prettify **nested objects**, set the `recursive` option.
+ *
+ * ⚠️ Note:
+ * - `recursive: true` only affects **plain objects** and **arrays/tuples**.
+ * - Built-in objects like `Set`, `Map`, `Date`, `Promise`, etc.
+ *   will **not** be recursively prettified.
+ * - `readonly` handling is controlled via the `readonlyMode` option.
+ *
+ * ℹ️ Options:
+ *  - `recursive?: boolean` (default: `false`)
+ *     - Whether to recursively expand nested objects and intersections.
+ *  - `readonlyMode?: "auto" | "remove" | "preserve"` (default: `"auto"`)
+ *     - How `readonly` modifiers are treated:
+ *         - `"auto"`     → preserve `readonly` as-is (default).
+ *         - `"remove"`   → strip all `readonly`.
+ *         - `"preserve"` → enforce `readonly` everywhere.
+ * @template T - The type to prettify.
+ * @template Options - Configuration options.
+ *
+ * @example
+ * ```ts
+ * // --- Top-level only (default) ---
+ * type T0 = Prettify<{ a: number } & { b: string }>;
+ * // ➔ { a: number; b: string }
+ *
+ * // --- Recursive expansion of nested objects ---
+ * type T1 = Prettify<
+ *   { a: { x: number } & { y: string } } & { b: boolean },
+ *   { recursive: true }
+ * >;
+ * // ➔ { a: { x: number; y: string }; b: boolean }
+ *
+ * // --- Readonly handling modes ---
+ * type T2 = { readonly id: number; name: string };
+ *
+ * type R1 = Prettify<T2>;
+ * // (default: readonlyMode = "auto")
+ * // ➔ { readonly id: number; name: string }
+ *
+ * type R2 = Prettify<T2, { readonlyMode: "remove" }>;
+ * // ➔ { id: number; name: string }
+ *
+ * type R3 = Prettify<T2, { readonlyMode: "preserve" }>;
+ * // ➔ { readonly id: number; readonly name: string }
+ *
+ * // --- Readonly + mutable intersection ---
+ * type T3 = Prettify<{ readonly a: number } & { a: number; b: boolean }>;
+ * // ➔ { a: number; b: boolean }
+ * // (in "auto" mode, readonly lose over mutable)
+ *
+ * // --- Nested readonly with recursive ---
+ * type T4 = Prettify<
+ *   { config: { readonly port: number } & { host: string } },
+ *   { recursive: true }
+ * >;
+ * // ➔ { config: { readonly port: number; host: string } }
+ *
+ * // --- Arrays with readonly ---
+ * type T5 = Prettify<
+ *   { list: readonly ({ id: number } & { name: string })[] },
+ *   { recursive: true }
+ * >;
+ * // (readonly on array is preserved in "auto" mode)
+ * // ➔ { list: readonly { id: number; name: string }[] }
+ *
+ * type T6 = Prettify<
+ *   { list: readonly ({ id: number } & { name: string })[] },
+ *   { recursive: true; readonlyMode: "remove" }
+ * >;
+ * // ➔ { list: { id: number; name: string }[] }
+ *
+ * // --- Built-in objects are ignored (not expanded) ---
+ * type T7 = Prettify<
+ *   { s: Set<{ a: number } & { b: string }> },
+ *   { recursive: true }
+ * >;
+ * // ➔ { s: Set<{ a: number } & { b: string }> }
+ * ```
+ */
 type Prettify<T,Options extends PrettifyOptions=DefaultPrettifyOptions>=IsPrimitive<T>extends true?T:IsFunction<T>extends true?T:IsConstructor<T>extends true?T:IsArrayOrTuple<T>extends true?ApplyReadonlyMode<{[K in keyof T]:If<Options["recursive"],Prettify<T[K],Options>,T[K]>;},Options["readonlyMode"]>:T extends NonPlainObject?T:T extends object?ApplyReadonlyMode<MergeReadonlyIntersection<{[K in keyof T]:If<Options["recursive"],Prettify<T[K],Options>,T[K]>;}>,Options["readonlyMode"]>:T;export type{DefaultPrettifyOptions as D,IsArrayOrTuple as I,Prettify as P,PrettifyOptions as a,IsConstructor as b,IsFunction as c,IsPrimitive as d,IsRealPrimitive as e,Primitive as f};