typia 5.3.5-dev.20231206 → 5.3.5

package/src/Resolved.ts

@@ -1,116 +1,116 @@
-/**
- * Resolved type erased every methods.
- *
- * `Resolved` is a type of TMP (Type Meta Programming) type which converts
- * its argument as a resolved type that erased every method properties.
- *
- * If the target argument is a built-in class which returns its origin primitive type
- * through the `valueOf()` method like the `String` or `Number`, its return type would
- * be the `string` or `number`. Otherwise, the built-in class does not have the
- * `valueOf()` method, the return type would be same with the target argument.
- *
- * Otherwise, the target argument is a type of custom class, all of its custom methods
- * would be erased and its prototype would be changed to the primitive `object`.
- * Therefore, return type of the TMP type finally be the resolved object.
- *
- * Before                  | After
- * ------------------------|----------------------------------------
- * `Boolean`               | `boolean`
- * `Number`                | `number`
- * `BigInt`                | `bigint`
- * `String`                | `string`
- * `Class`                 | `interface`
- * Native Class or Others  | No change
- *
- * @template T Target argument type.
- * @author Jeongho Nam - https://github.com/samchon
- * @author Kyungsu Kang - https://github.com/kakasoo
- */
-export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true
-  ? T
-  : ResolvedMain<T>;
-
-type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
-
-type ResolvedMain<T> = T extends [never]
-  ? never // (special trick for jsonable | null) type
-  : ValueOf<T> extends boolean | number | bigint | string
-  ? ValueOf<T>
-  : T extends Function
-  ? never
-  : T extends object
-  ? ResolvedObject<T>
-  : ValueOf<T>;
-
-type ResolvedObject<T extends object> = T extends Array<infer U>
-  ? IsTuple<T> extends true
-    ? ResolvedTuple<T>
-    : ResolvedMain<U>[]
-  : T extends Set<infer U>
-  ? Set<ResolvedMain<U>>
-  : T extends Map<infer K, infer V>
-  ? Map<ResolvedMain<K>, ResolvedMain<V>>
-  : T extends WeakSet<any> | WeakMap<any, any>
-  ? never
-  : T extends
-      | Date
-      | Uint8Array
-      | Uint8ClampedArray
-      | Uint16Array
-      | Uint32Array
-      | BigUint64Array
-      | Int8Array
-      | Int16Array
-      | Int32Array
-      | BigInt64Array
-      | Float32Array
-      | Float64Array
-      | ArrayBuffer
-      | SharedArrayBuffer
-      | DataView
-  ? T
-  : {
-      [P in keyof T]: ResolvedMain<T[P]>;
-    };
-
-type ResolvedTuple<T extends readonly any[]> = T extends []
-  ? []
-  : T extends [infer F]
-  ? [ResolvedMain<F>]
-  : T extends [infer F, ...infer Rest extends readonly any[]]
-  ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]
-  : T extends [(infer F)?]
-  ? [ResolvedMain<F>?]
-  : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-  ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]
-  : [];
-
-type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
-  never,
-]
-  ? false
-  : T extends readonly any[]
-  ? number extends T["length"]
-    ? false
-    : true
-  : false;
-
-type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
-  ? boolean
-  : IsValueOf<Instance, Number> extends true
-  ? number
-  : IsValueOf<Instance, String> extends true
-  ? string
-  : Instance;
-
-type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
-  ? Object extends IValueOf<infer Primitive>
-    ? Instance extends Primitive
-      ? false
-      : true // not Primitive, but Object
-    : false // cannot be
-  : false;
-
-interface IValueOf<T> {
-  valueOf(): T;
-}
+/**
+ * Resolved type erased every methods.
+ *
+ * `Resolved` is a type of TMP (Type Meta Programming) type which converts
+ * its argument as a resolved type that erased every method properties.
+ *
+ * If the target argument is a built-in class which returns its origin primitive type
+ * through the `valueOf()` method like the `String` or `Number`, its return type would
+ * be the `string` or `number`. Otherwise, the built-in class does not have the
+ * `valueOf()` method, the return type would be same with the target argument.
+ *
+ * Otherwise, the target argument is a type of custom class, all of its custom methods
+ * would be erased and its prototype would be changed to the primitive `object`.
+ * Therefore, return type of the TMP type finally be the resolved object.
+ *
+ * Before                  | After
+ * ------------------------|----------------------------------------
+ * `Boolean`               | `boolean`
+ * `Number`                | `number`
+ * `BigInt`                | `bigint`
+ * `String`                | `string`
+ * `Class`                 | `interface`
+ * Native Class or Others  | No change
+ *
+ * @template T Target argument type.
+ * @author Jeongho Nam - https://github.com/samchon
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ */
+export type Resolved<T> = Equal<T, ResolvedMain<T>> extends true
+  ? T
+  : ResolvedMain<T>;
+
+type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+
+type ResolvedMain<T> = T extends [never]
+  ? never // (special trick for jsonable | null) type
+  : ValueOf<T> extends boolean | number | bigint | string
+  ? ValueOf<T>
+  : T extends Function
+  ? never
+  : T extends object
+  ? ResolvedObject<T>
+  : ValueOf<T>;
+
+type ResolvedObject<T extends object> = T extends Array<infer U>
+  ? IsTuple<T> extends true
+    ? ResolvedTuple<T>
+    : ResolvedMain<U>[]
+  : T extends Set<infer U>
+  ? Set<ResolvedMain<U>>
+  : T extends Map<infer K, infer V>
+  ? Map<ResolvedMain<K>, ResolvedMain<V>>
+  : T extends WeakSet<any> | WeakMap<any, any>
+  ? never
+  : T extends
+      | Date
+      | Uint8Array
+      | Uint8ClampedArray
+      | Uint16Array
+      | Uint32Array
+      | BigUint64Array
+      | Int8Array
+      | Int16Array
+      | Int32Array
+      | BigInt64Array
+      | Float32Array
+      | Float64Array
+      | ArrayBuffer
+      | SharedArrayBuffer
+      | DataView
+  ? T
+  : {
+      [P in keyof T]: ResolvedMain<T[P]>;
+    };
+
+type ResolvedTuple<T extends readonly any[]> = T extends []
+  ? []
+  : T extends [infer F]
+  ? [ResolvedMain<F>]
+  : T extends [infer F, ...infer Rest extends readonly any[]]
+  ? [ResolvedMain<F>, ...ResolvedTuple<Rest>]
+  : T extends [(infer F)?]
+  ? [ResolvedMain<F>?]
+  : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+  ? [ResolvedMain<F>?, ...ResolvedTuple<Rest>]
+  : [];
+
+type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
+  never,
+]
+  ? false
+  : T extends readonly any[]
+  ? number extends T["length"]
+    ? false
+    : true
+  : false;
+
+type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
+  ? boolean
+  : IsValueOf<Instance, Number> extends true
+  ? number
+  : IsValueOf<Instance, String> extends true
+  ? string
+  : Instance;
+
+type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
+  ? Object extends IValueOf<infer Primitive>
+    ? Instance extends Primitive
+      ? false
+      : true // not Primitive, but Object
+    : false // cannot be
+  : false;
+
+interface IValueOf<T> {
+  valueOf(): T;
+}

package/src/SnakeCase.ts

@@ -1,156 +1,156 @@
-/**
- * Snake case type.
- *
- * `SnakeCase` type is a type that all keys of an object are converted to snake case.
- *
- * It also erase every method properties like {@link Resolved} type.
- *
- * @template T Target type to be snake cased
- * @author Jeongho Nam - https://github.com/samchon
- */
-export type SnakeCase<T> = Equal<T, SnakageMain<T>> extends true
-  ? T
-  : SnakageMain<T>;
-
-/* -----------------------------------------------------------
-    OBJECT CONVERSION
------------------------------------------------------------ */
-type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
-
-type SnakageMain<T> = T extends [never]
-  ? never // special trick for (jsonable | null) type
-  : T extends { valueOf(): boolean | bigint | number | string }
-  ? ValueOf<T>
-  : T extends Function
-  ? never
-  : T extends object
-  ? SnakageObject<T>
-  : T;
-
-type SnakageObject<T extends object> = T extends Array<infer U>
-  ? IsTuple<T> extends true
-    ? SnakageTuple<T>
-    : SnakageMain<U>[]
-  : T extends Set<infer U>
-  ? Set<SnakageMain<U>>
-  : T extends Map<infer K, infer V>
-  ? Map<SnakageMain<K>, SnakageMain<V>>
-  : T extends WeakSet<any> | WeakMap<any, any>
-  ? never
-  : T extends
-      | Date
-      | Uint8Array
-      | Uint8ClampedArray
-      | Uint16Array
-      | Uint32Array
-      | BigUint64Array
-      | Int8Array
-      | Int16Array
-      | Int32Array
-      | BigInt64Array
-      | Float32Array
-      | Float64Array
-      | ArrayBuffer
-      | SharedArrayBuffer
-      | DataView
-  ? T
-  : {
-      [Key in keyof T as SnakageString<Key & string>]: SnakageMain<T[Key]>;
-    };
-
-/* -----------------------------------------------------------
-    SPECIAL CASES
------------------------------------------------------------ */
-type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
-  never,
-]
-  ? false
-  : T extends readonly any[]
-  ? number extends T["length"]
-    ? false
-    : true
-  : false;
-type SnakageTuple<T extends readonly any[]> = T extends []
-  ? []
-  : T extends [infer F]
-  ? [SnakageMain<F>]
-  : T extends [infer F, ...infer Rest extends readonly any[]]
-  ? [SnakageMain<F>, ...SnakageTuple<Rest>]
-  : T extends [(infer F)?]
-  ? [SnakageMain<F>?]
-  : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-  ? [SnakageMain<F>?, ...SnakageTuple<Rest>]
-  : [];
-
-type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
-  ? boolean
-  : IsValueOf<Instance, Number> extends true
-  ? number
-  : IsValueOf<Instance, String> extends true
-  ? string
-  : Instance;
-
-type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
-  ? Object extends IValueOf<infer Primitive>
-    ? Instance extends Primitive
-      ? false
-      : true // not Primitive, but Object
-    : false // cannot be
-  : false;
-
-interface IValueOf<T> {
-  valueOf(): T;
-}
-
-/* -----------------------------------------------------------
-    STRING CONVERTER
------------------------------------------------------------ */
-type SnakageString<Key extends string> = Key extends `${infer _}`
-  ? SnakageStringRepeatedly<Key, "">
-  : Key;
-type SnakageStringRepeatedly<
-  S extends string,
-  Previous extends string,
-> = S extends `${infer First}${infer Second}${infer Rest}`
-  ? `${Underscore<Previous, First>}${Lowercase<First>}${Underscore<
-      First,
-      Second
-    >}${Lowercase<Second>}${SnakageStringRepeatedly<Rest, Second>}`
-  : S extends `${infer First}`
-  ? `${Underscore<Previous, First>}${Lowercase<First>}`
-  : "";
-type Underscore<First extends string, Second extends string> = First extends
-  | UpperAlphabetic
-  | ""
-  | "_"
-  ? ""
-  : Second extends UpperAlphabetic
-  ? "_"
-  : "";
-type UpperAlphabetic =
-  | "A"
-  | "B"
-  | "C"
-  | "D"
-  | "E"
-  | "F"
-  | "G"
-  | "H"
-  | "I"
-  | "J"
-  | "K"
-  | "L"
-  | "M"
-  | "N"
-  | "O"
-  | "P"
-  | "Q"
-  | "R"
-  | "S"
-  | "T"
-  | "U"
-  | "V"
-  | "W"
-  | "X"
-  | "Y"
-  | "Z";
+/**
+ * Snake case type.
+ *
+ * `SnakeCase` type is a type that all keys of an object are converted to snake case.
+ *
+ * It also erase every method properties like {@link Resolved} type.
+ *
+ * @template T Target type to be snake cased
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type SnakeCase<T> = Equal<T, SnakageMain<T>> extends true
+  ? T
+  : SnakageMain<T>;
+
+/* -----------------------------------------------------------
+    OBJECT CONVERSION
+----------------------------------------------------------- */
+type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+
+type SnakageMain<T> = T extends [never]
+  ? never // special trick for (jsonable | null) type
+  : T extends { valueOf(): boolean | bigint | number | string }
+  ? ValueOf<T>
+  : T extends Function
+  ? never
+  : T extends object
+  ? SnakageObject<T>
+  : T;
+
+type SnakageObject<T extends object> = T extends Array<infer U>
+  ? IsTuple<T> extends true
+    ? SnakageTuple<T>
+    : SnakageMain<U>[]
+  : T extends Set<infer U>
+  ? Set<SnakageMain<U>>
+  : T extends Map<infer K, infer V>
+  ? Map<SnakageMain<K>, SnakageMain<V>>
+  : T extends WeakSet<any> | WeakMap<any, any>
+  ? never
+  : T extends
+      | Date
+      | Uint8Array
+      | Uint8ClampedArray
+      | Uint16Array
+      | Uint32Array
+      | BigUint64Array
+      | Int8Array
+      | Int16Array
+      | Int32Array
+      | BigInt64Array
+      | Float32Array
+      | Float64Array
+      | ArrayBuffer
+      | SharedArrayBuffer
+      | DataView
+  ? T
+  : {
+      [Key in keyof T as SnakageString<Key & string>]: SnakageMain<T[Key]>;
+    };
+
+/* -----------------------------------------------------------
+    SPECIAL CASES
+----------------------------------------------------------- */
+type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
+  never,
+]
+  ? false
+  : T extends readonly any[]
+  ? number extends T["length"]
+    ? false
+    : true
+  : false;
+type SnakageTuple<T extends readonly any[]> = T extends []
+  ? []
+  : T extends [infer F]
+  ? [SnakageMain<F>]
+  : T extends [infer F, ...infer Rest extends readonly any[]]
+  ? [SnakageMain<F>, ...SnakageTuple<Rest>]
+  : T extends [(infer F)?]
+  ? [SnakageMain<F>?]
+  : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+  ? [SnakageMain<F>?, ...SnakageTuple<Rest>]
+  : [];
+
+type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
+  ? boolean
+  : IsValueOf<Instance, Number> extends true
+  ? number
+  : IsValueOf<Instance, String> extends true
+  ? string
+  : Instance;
+
+type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
+  ? Object extends IValueOf<infer Primitive>
+    ? Instance extends Primitive
+      ? false
+      : true // not Primitive, but Object
+    : false // cannot be
+  : false;
+
+interface IValueOf<T> {
+  valueOf(): T;
+}
+
+/* -----------------------------------------------------------
+    STRING CONVERTER
+----------------------------------------------------------- */
+type SnakageString<Key extends string> = Key extends `${infer _}`
+  ? SnakageStringRepeatedly<Key, "">
+  : Key;
+type SnakageStringRepeatedly<
+  S extends string,
+  Previous extends string,
+> = S extends `${infer First}${infer Second}${infer Rest}`
+  ? `${Underscore<Previous, First>}${Lowercase<First>}${Underscore<
+      First,
+      Second
+    >}${Lowercase<Second>}${SnakageStringRepeatedly<Rest, Second>}`
+  : S extends `${infer First}`
+  ? `${Underscore<Previous, First>}${Lowercase<First>}`
+  : "";
+type Underscore<First extends string, Second extends string> = First extends
+  | UpperAlphabetic
+  | ""
+  | "_"
+  ? ""
+  : Second extends UpperAlphabetic
+  ? "_"
+  : "";
+type UpperAlphabetic =
+  | "A"
+  | "B"
+  | "C"
+  | "D"
+  | "E"
+  | "F"
+  | "G"
+  | "H"
+  | "I"
+  | "J"
+  | "K"
+  | "L"
+  | "M"
+  | "N"
+  | "O"
+  | "P"
+  | "Q"
+  | "R"
+  | "S"
+  | "T"
+  | "U"
+  | "V"
+  | "W"
+  | "X"
+  | "Y"
+  | "Z";

package/src/TypeGuardError.ts

@@ -1,36 +1,36 @@
-export class TypeGuardError extends Error {
-  public readonly method: string;
-  public readonly path: string | undefined;
-  public readonly expected: string;
-  public readonly value: any;
-
-  public constructor(props: TypeGuardError.IProps) {
-    // MESSAGE CONSTRUCTION
-    super(
-      props.message ||
-        `Error on ${props.method}(): invalid type${
-          props.path ? ` on ${props.path}` : ""
-        }, expect to be ${props.expected}`,
-    );
-
-    // INHERITANCE POLYFILL
-    const proto = new.target.prototype;
-    if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
-    else (this as any).__proto__ = proto;
-
-    // ASSIGN MEMBERS
-    this.method = props.method;
-    this.path = props.path;
-    this.expected = props.expected;
-    this.value = props.value;
-  }
-}
-export namespace TypeGuardError {
-  export interface IProps {
-    method: string;
-    path?: undefined | string;
-    expected: string;
-    value: any;
-    message?: undefined | string;
-  }
-}
+export class TypeGuardError extends Error {
+  public readonly method: string;
+  public readonly path: string | undefined;
+  public readonly expected: string;
+  public readonly value: any;
+
+  public constructor(props: TypeGuardError.IProps) {
+    // MESSAGE CONSTRUCTION
+    super(
+      props.message ||
+        `Error on ${props.method}(): invalid type${
+          props.path ? ` on ${props.path}` : ""
+        }, expect to be ${props.expected}`,
+    );
+
+    // INHERITANCE POLYFILL
+    const proto = new.target.prototype;
+    if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
+    else (this as any).__proto__ = proto;
+
+    // ASSIGN MEMBERS
+    this.method = props.method;
+    this.path = props.path;
+    this.expected = props.expected;
+    this.value = props.value;
+  }
+}
+export namespace TypeGuardError {
+  export interface IProps {
+    method: string;
+    path?: undefined | string;
+    expected: string;
+    value: any;
+    message?: undefined | string;
+  }
+}