typia 3.6.2 → 3.6.3

package/src/functional/$string.ts

@@ -1,37 +1,37 @@
-/**
- * @internal
- */
-export function $string(str: string): string {
-    if (str.length > 41) return JSON.stringify(str);
-
-    const length = str.length;
-    let result = "";
-    let last = 0;
-    let found = false;
-    let surrogateFound = false;
-    let point = 255;
-
-    // eslint-disable-next-line
-    for (let i = 0; i < length && point >= 32; i++) {
-        point = str.charCodeAt(i);
-        if (0xd800 <= point && point <= 0xdfff) {
-            // The current character is a surrogate.
-            surrogateFound = true;
-            break;
-        }
-        if (point === 34 || point === 92) {
-            result += str.slice(last, i) + "\\";
-            last = i;
-            found = true;
-        }
-    }
-
-    if (!found) {
-        result = str;
-    } else {
-        result += str.slice(last);
-    }
-    return point < 32 || surrogateFound === true
-        ? JSON.stringify(str)
-        : `"${result}"`;
-}
+/**
+ * @internal
+ */
+export function $string(str: string): string {
+    if (str.length > 41) return JSON.stringify(str);
+
+    const length = str.length;
+    let result = "";
+    let last = 0;
+    let found = false;
+    let surrogateFound = false;
+    let point = 255;
+
+    // eslint-disable-next-line
+    for (let i = 0; i < length && point >= 32; i++) {
+        point = str.charCodeAt(i);
+        if (0xd800 <= point && point <= 0xdfff) {
+            // The current character is a surrogate.
+            surrogateFound = true;
+            break;
+        }
+        if (point === 34 || point === 92) {
+            result += str.slice(last, i) + "\\";
+            last = i;
+            found = true;
+        }
+    }
+
+    if (!found) {
+        result = str;
+    } else {
+        result += str.slice(last);
+    }
+    return point < 32 || surrogateFound === true
+        ? JSON.stringify(str)
+        : `"${result}"`;
+}

package/src/functional/$tail.ts

@@ -1,6 +1,6 @@
-/**
- * @internal
- */
-export function $tail(str: string): string {
-    return str[str.length - 1] === "," ? str.substring(0, str.length - 1) : str;
-}
+/**
+ * @internal
+ */
+export function $tail(str: string): string {
+    return str[str.length - 1] === "," ? str.substring(0, str.length - 1) : str;
+}

package/src/functional/Namespace.ts

@@ -1,121 +1,121 @@
-import { RandomGenerator } from "../utils/RandomGenerator";
-
-import { IValidation } from "../IValidation";
-import { TypeGuardError } from "../TypeGuardError";
-import { $any } from "./$any";
-import { $every } from "./$every";
-import { $guard } from "./$guard";
-import { $is_between } from "./$is_between";
-import { $is_email } from "./$is_email";
-import { $is_ipv4 } from "./$is_ipv4";
-import { $is_ipv6 } from "./$is_ipv6";
-import { $is_url } from "./$is_url";
-import { $is_uuid } from "./$is_uuid";
-import { $join } from "./$join";
-import { $number } from "./$number";
-import { $report } from "./$report";
-import { $rest } from "./$rest";
-import { $string } from "./$string";
-import { $tail } from "./$tail";
-
-/**
- * @internal
- */
-export namespace Namespace {
-    export const is = () => ({
-        is_uuid: $is_uuid,
-        is_email: $is_email,
-        is_url: $is_url,
-        is_ipv4: $is_ipv4,
-        is_ipv6: $is_ipv6,
-        is_between: $is_between,
-    });
-
-    export const assert = (method: string) => ({
-        ...is(),
-        join: $join,
-        every: $every,
-        guard: $guard(`typia.${method}`),
-        predicate: (
-            matched: boolean,
-            exceptionable: boolean,
-            closure: () => Omit<TypeGuardError.IProps, "method">,
-        ): boolean => {
-            if (matched === false && exceptionable === true)
-                throw new TypeGuardError({
-                    ...closure(),
-                    method: `typia.${method}`,
-                });
-            return matched;
-        },
-    });
-
-    export const validate = () => ({
-        ...is(),
-        join: $join,
-        report: $report,
-        predicate:
-            (res: IValidation) =>
-            (
-                matched: boolean,
-                exceptionable: boolean,
-                closure: () => IValidation.IError,
-            ) => {
-                // CHECK FAILURE
-                if (matched === false && exceptionable === true)
-                    (() => {
-                        res.success &&= false;
-                        const errorList = (res as IValidation.IFailure).errors;
-
-                        // TRACE ERROR
-                        const error = closure();
-                        if (errorList.length) {
-                            const last = errorList[errorList.length - 1]!.path;
-                            if (
-                                last.length >= error.path.length &&
-                                last.substring(0, error.path.length) ===
-                                    error.path
-                            )
-                                return;
-                        }
-                        errorList.push(error);
-                        return;
-                    })();
-                return matched;
-            },
-    });
-
-    export const stringify = (method: string) => ({
-        ...is(),
-        number: $number,
-        string: $string,
-        tail: $tail,
-        rest: $rest,
-        throws: $throws(method),
-    });
-
-    export const clone = (method: string) => ({
-        ...is(),
-        throws: $throws(method),
-        any: $any,
-    });
-
-    export const prune = (method: string) => ({
-        ...is(),
-        throws: $throws(method),
-    });
-
-    export const random = () => ({
-        generator: RandomGenerator,
-        pick: RandomGenerator.pick,
-    });
-
-    const $throws =
-        (method: string) =>
-        (props: Pick<TypeGuardError.IProps, "expected" | "value">) => {
-            throw new TypeGuardError({
-                ...props,
-                method: `typia.${method}`,
-            });
-        };
-}
+import { RandomGenerator } from "../utils/RandomGenerator";
+
+import { IValidation } from "../IValidation";
+import { TypeGuardError } from "../TypeGuardError";
+import { $any } from "./$any";
+import { $every } from "./$every";
+import { $guard } from "./$guard";
+import { $is_between } from "./$is_between";
+import { $is_email } from "./$is_email";
+import { $is_ipv4 } from "./$is_ipv4";
+import { $is_ipv6 } from "./$is_ipv6";
+import { $is_url } from "./$is_url";
+import { $is_uuid } from "./$is_uuid";
+import { $join } from "./$join";
+import { $number } from "./$number";
+import { $report } from "./$report";
+import { $rest } from "./$rest";
+import { $string } from "./$string";
+import { $tail } from "./$tail";
+
+/**
+ * @internal
+ */
+export namespace Namespace {
+    export const is = () => ({
+        is_uuid: $is_uuid,
+        is_email: $is_email,
+        is_url: $is_url,
+        is_ipv4: $is_ipv4,
+        is_ipv6: $is_ipv6,
+        is_between: $is_between,
+    });
+
+    export const assert = (method: string) => ({
+        ...is(),
+        join: $join,
+        every: $every,
+        guard: $guard(`typia.${method}`),
+        predicate: (
+            matched: boolean,
+            exceptionable: boolean,
+            closure: () => Omit<TypeGuardError.IProps, "method">,
+        ): boolean => {
+            if (matched === false && exceptionable === true)
+                throw new TypeGuardError({
+                    ...closure(),
+                    method: `typia.${method}`,
+                });
+            return matched;
+        },
+    });
+
+    export const validate = () => ({
+        ...is(),
+        join: $join,
+        report: $report,
+        predicate:
+            (res: IValidation) =>
+            (
+                matched: boolean,
+                exceptionable: boolean,
+                closure: () => IValidation.IError,
+            ) => {
+                // CHECK FAILURE
+                if (matched === false && exceptionable === true)
+                    (() => {
+                        res.success &&= false;
+                        const errorList = (res as IValidation.IFailure).errors;
+
+                        // TRACE ERROR
+                        const error = closure();
+                        if (errorList.length) {
+                            const last = errorList[errorList.length - 1]!.path;
+                            if (
+                                last.length >= error.path.length &&
+                                last.substring(0, error.path.length) ===
+                                    error.path
+                            )
+                                return;
+                        }
+                        errorList.push(error);
+                        return;
+                    })();
+                return matched;
+            },
+    });
+
+    export const stringify = (method: string) => ({
+        ...is(),
+        number: $number,
+        string: $string,
+        tail: $tail,
+        rest: $rest,
+        throws: $throws(method),
+    });
+
+    export const clone = (method: string) => ({
+        ...is(),
+        throws: $throws(method),
+        any: $any,
+    });
+
+    export const prune = (method: string) => ({
+        ...is(),
+        throws: $throws(method),
+    });
+
+    export const random = () => ({
+        generator: RandomGenerator,
+        pick: RandomGenerator.pick,
+    });
+
+    const $throws =
+        (method: string) =>
+        (props: Pick<TypeGuardError.IProps, "expected" | "value">) => {
+            throw new TypeGuardError({
+                ...props,
+                method: `typia.${method}`,
+            });
+        };
+}

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as typia from "./module";
-
-export default typia;
-export * from "./module";
+import * as typia from "./module";
+
+export default typia;
+export * from "./module";

package/src/metadata/IJsDocTagInfo.ts

@@ -1,10 +1,10 @@
-export interface IJsDocTagInfo {
-    name: string;
-    text?: IJsDocTagInfo.IText[];
-}
-export namespace IJsDocTagInfo {
-    export interface IText {
-        text: string;
-        kind: string;
-    }
-}
+export interface IJsDocTagInfo {
+    name: string;
+    text?: IJsDocTagInfo.IText[];
+}
+export namespace IJsDocTagInfo {
+    export interface IText {
+        text: string;
+        kind: string;
+    }
+}

package/src/metadata/IMetadata.ts

@@ -1,25 +1,25 @@
-import { Atomic } from "../typings/Atomic";
-
-import { IMetadataConstant } from "./IMetadataConstant";
-import { IMetadataEntry } from "./IMetadataEntry";
-
-export interface IMetadata {
-    any: boolean;
-    required: boolean;
-    nullable: boolean;
-    functional: boolean;
-
-    atomics: Atomic.Literal[];
-    constants: IMetadataConstant[];
-    templates: IMetadata[][];
-    resolved: IMetadata | null;
-
-    rest: IMetadata | null;
-    arrays: IMetadata[];
-    tuples: IMetadata[][];
-    objects: string[];
-
-    natives: string[];
-    sets: IMetadata[];
-    maps: IMetadataEntry[];
-}
+import { Atomic } from "../typings/Atomic";
+
+import { IMetadataConstant } from "./IMetadataConstant";
+import { IMetadataEntry } from "./IMetadataEntry";
+
+export interface IMetadata {
+    any: boolean;
+    required: boolean;
+    nullable: boolean;
+    functional: boolean;
+
+    atomics: Atomic.Literal[];
+    constants: IMetadataConstant[];
+    templates: IMetadata[][];
+    resolved: IMetadata | null;
+
+    rest: IMetadata | null;
+    arrays: IMetadata[];
+    tuples: IMetadata[][];
+    objects: string[];
+
+    natives: string[];
+    sets: IMetadata[];
+    maps: IMetadataEntry[];
+}

package/src/metadata/IMetadataApplication.ts

@@ -1,7 +1,7 @@
-import { IMetadata } from "./IMetadata";
-import { IMetadataObject } from "./IMetadataObject";
-
-export interface IMetadataApplication {
-    metadatas: IMetadata[];
-    collection: IMetadataObject[];
-}
+import { IMetadata } from "./IMetadata";
+import { IMetadataObject } from "./IMetadataObject";
+
+export interface IMetadataApplication {
+    metadatas: IMetadata[];
+    collection: IMetadataObject[];
+}

package/src/metadata/IMetadataConstant.ts

@@ -1,16 +1,16 @@
-import { Atomic } from "../typings/Atomic";
-
-export type IMetadataConstant =
-    | IMetadataConstant.IBase<"boolean", boolean>
-    | IMetadataConstant.IBase<"number", number>
-    | IMetadataConstant.IBase<"string", string>
-    | IMetadataConstant.IBase<"bigint", bigint>;
-export namespace IMetadataConstant {
-    export interface IBase<
-        Type extends Atomic.Literal,
-        Value extends Atomic.Type,
-    > {
-        type: Type;
-        values: Value[];
-    }
-}
+import { Atomic } from "../typings/Atomic";
+
+export type IMetadataConstant =
+    | IMetadataConstant.IBase<"boolean", boolean>
+    | IMetadataConstant.IBase<"number", number>
+    | IMetadataConstant.IBase<"string", string>
+    | IMetadataConstant.IBase<"bigint", bigint>;
+export namespace IMetadataConstant {
+    export interface IBase<
+        Type extends Atomic.Literal,
+        Value extends Atomic.Type,
+    > {
+        type: Type;
+        values: Value[];
+    }
+}

package/src/metadata/IMetadataEntry.ts

@@ -1,6 +1,6 @@
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataEntry {
-    key: IMetadata;
-    value: IMetadata;
-}
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataEntry {
+    key: IMetadata;
+    value: IMetadata;
+}

package/src/metadata/IMetadataObject.ts

@@ -1,29 +1,29 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataProperty } from "./IMetadataProperty";
-
-export interface IMetadataObject {
-    name: string;
-    properties: IMetadataProperty[];
-    description?: string;
-    jsDocTags: IJsDocTagInfo[];
-
-    /**
-     * @internal
-     */
-    index: number;
-
-    /**
-     * @internal
-     */
-    validated: boolean;
-
-    /**
-     * @internal
-     */
-    recursive: boolean;
-
-    /**
-     * @internal
-     */
-    nullables: boolean[];
-}
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataProperty } from "./IMetadataProperty";
+
+export interface IMetadataObject {
+    name: string;
+    properties: IMetadataProperty[];
+    description?: string;
+    jsDocTags: IJsDocTagInfo[];
+
+    /**
+     * @internal
+     */
+    index: number;
+
+    /**
+     * @internal
+     */
+    validated: boolean;
+
+    /**
+     * @internal
+     */
+    recursive: boolean;
+
+    /**
+     * @internal
+     */
+    nullables: boolean[];
+}

package/src/metadata/IMetadataProperty.ts

@@ -1,11 +1,11 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadata } from "./IMetadata";
-import { IMetadataTag } from "./IMetadataTag";
-
-export interface IMetadataProperty {
-    key: IMetadata;
-    value: IMetadata;
-    description?: string;
-    tags: IMetadataTag[];
-    jsDocTags: IJsDocTagInfo[];
-}
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+import { IMetadataTag } from "./IMetadataTag";
+
+export interface IMetadataProperty {
+    key: IMetadata;
+    value: IMetadata;
+    description?: string;
+    tags: IMetadataTag[];
+    jsDocTags: IJsDocTagInfo[];
+}