typia 3.5.0-dev.20230213 → 3.5.0-dev.20230214

package/src/transformers/CallExpressionTransformer.ts

@@ -3,16 +3,24 @@ import ts from "typescript";
 
 import { IProject } from "./IProject";
 import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
+import { AssertCloneTransformer } from "./features/miscellaneous/AssertCloneTransformer";
 import { AssertPruneTransformer } from "./features/miscellaneous/AssertPruneTransformer";
 import { CloneTransformer } from "./features/miscellaneous/CloneTransformer";
+import { CreateAssertCloneTransformer } from "./features/miscellaneous/CreateAssertCloneTransformer";
 import { CreateAssertPruneTransformer } from "./features/miscellaneous/CreateAssertPruneTransformer";
 import { CreateCloneTransformer } from "./features/miscellaneous/CreateCloneTransformer";
+import { CreateIsCloneTransformer } from "./features/miscellaneous/CreateIsCloneTransformer";
 import { CreateIsPruneTransformer } from "./features/miscellaneous/CreateIsPruneTransformer";
 import { CreatePruneTransformer } from "./features/miscellaneous/CreatePruneTransformer";
+import { CreateRandomTransformer } from "./features/miscellaneous/CreateRandomGenerator";
+import { CreateValidateCloneTransformer } from "./features/miscellaneous/CreateValidateCloneTransformer";
 import { CreateValidatePruneTransformer } from "./features/miscellaneous/CreateValidatePruneTransformer";
+import { IsCloneTransformer } from "./features/miscellaneous/IsCloneTransformer";
 import { IsPruneTransformer } from "./features/miscellaneous/IsPruneTransformer";
 import { MetadataTransformer } from "./features/miscellaneous/MetadataTransformer";
 import { PruneTransformer } from "./features/miscellaneous/PruneTransformer";
+import { RandomTransformer } from "./features/miscellaneous/RandomTransformer";
+import { ValidateCloneTransformer } from "./features/miscellaneous/ValidateCloneTransformer";
 import { ValidatePruneTransformer } from "./features/miscellaneous/ValidatePruneTransformer";
 import { AssertParseTransformer } from "./features/parsers/AssertParseTransformer";
 import { CreateAssertParseTransformer } from "./features/parsers/CreateAssertParseTransformer";
@@ -106,7 +114,13 @@ const FUNCTORS: Record<string, () => Task> = {
 
     // MISC
     metadata: () => MetadataTransformer.transform,
+    random: () => RandomTransformer.transform,
+
     clone: () => CloneTransformer.transform,
+    assertClone: () => AssertCloneTransformer.transform,
+    isClone: () => IsCloneTransformer.transform,
+    validateClone: () => ValidateCloneTransformer.transform,
+
     prune: () => PruneTransformer.transform,
     assertPrune: () => AssertPruneTransformer.transform,
     isPrune: () => IsPruneTransformer.transform,
@@ -138,7 +152,12 @@ const FUNCTORS: Record<string, () => Task> = {
     createValidateStringify: () => CreateValidateStringifyTransformer.transform,
 
     // MISC
+    createRandom: () => CreateRandomTransformer.transform,
     createClone: () => CreateCloneTransformer.transform,
+    createAssertClone: () => CreateAssertCloneTransformer.transform,
+    createIsClone: () => CreateIsCloneTransformer.transform,
+    createValidateClone: () => CreateValidateCloneTransformer.transform,
+
     createPrune: () => CreatePruneTransformer.transform,
     createAssertPrune: () => CreateAssertPruneTransformer.transform,
     createIsPrune: () => CreateIsPruneTransformer.transform,

package/src/transformers/features/miscellaneous/AssertCloneTransformer.ts

@@ -0,0 +1,38 @@
+import ts from "typescript";
+
+import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace AssertCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (expression.arguments.length !== 1)
+            throw new Error(ErrorMessages.NO_INPUT_VALUE);
+
+        // GET TYPE INFO
+        const type: ts.Type =
+            expression.typeArguments && expression.typeArguments[0]
+                ? project.checker.getTypeFromTypeNode(
+                      expression.typeArguments[0],
+                  )
+                : project.checker.getTypeAtLocation(expression.arguments[0]!);
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            AssertCloneProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.assertClone(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.assertClone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateAssertCloneTransformer.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateAssertCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return AssertCloneProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.assertClone(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.assertClone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateAssertPruneTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateAssertPruneTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/miscellaneous/CreateCloneTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateCloneTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/miscellaneous/CreateIsCloneTransformer.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateIsCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return IsCloneProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.isClone(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.isClone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateIsPruneTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateIsPruneTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/miscellaneous/CreatePruneTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreatePruneTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/miscellaneous/CreateRandomGenerator.ts

@@ -0,0 +1,39 @@
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateRandomTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        const type: ts.Type | undefined = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
+
+        return RandomProgrammer.generate(
+            {
+                ...project,
+                options: {
+                    ...project.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            modulo,
+        )(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.createRandom(): generic argument is not specified.",
+    NO_GENERIC_ARGUMENT = "Error on typia.createRandom(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateValidateCloneTransformer.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateValidateCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ValidateCloneProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.validateClone(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.validateClone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateValidatePruneTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateValidatePruneTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/miscellaneous/IsCloneTransformer.ts

@@ -0,0 +1,38 @@
+import ts from "typescript";
+
+import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace IsCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (expression.arguments.length !== 1)
+            throw new Error(ErrorMessages.NO_INPUT_VALUE);
+
+        // GET TYPE INFO
+        const type: ts.Type =
+            expression.typeArguments && expression.typeArguments[0]
+                ? project.checker.getTypeFromTypeNode(
+                      expression.typeArguments[0],
+                  )
+                : project.checker.getTypeAtLocation(expression.arguments[0]!);
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            IsCloneProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.isClone(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.isClone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/RandomTransformer.ts

@@ -0,0 +1,45 @@
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace RandomTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        const type: ts.Type | undefined = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
+
+        return ts.factory.createCallExpression(
+            RandomProgrammer.generate(
+                {
+                    ...project,
+                    options: {
+                        ...project.options,
+                        functional: false,
+                        numeric: false,
+                    },
+                },
+                modulo,
+            )(type),
+            undefined,
+            expression.arguments.length
+                ? [expression.arguments[0]!]
+                : undefined,
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.random(): generic argument is not specified.",
+    NO_GENERIC_ARGUMENT = "Error on typia.random(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/ValidateCloneTransformer.ts

@@ -0,0 +1,38 @@
+import ts from "typescript";
+
+import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace ValidateCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (expression.arguments.length !== 1)
+            throw new Error(ErrorMessages.NO_INPUT_VALUE);
+
+        // GET TYPE INFO
+        const type: ts.Type =
+            expression.typeArguments && expression.typeArguments[0]
+                ? project.checker.getTypeFromTypeNode(
+                      expression.typeArguments[0],
+                  )
+                : project.checker.getTypeAtLocation(expression.arguments[0]!);
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            ValidateCloneProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.validateClone(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.validateClone(): non-specified generic argument.",
+}

package/src/transformers/features/parsers/AssertParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace AssertParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/parsers/CreateAssertParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateAssertParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXASSERTTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/parsers/CreateIsParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateIsParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/parsers/CreateValidateParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateValidateParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/parsers/IsParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace IsParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/parsers/ValidateParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace ValidateParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/stringifiers/CreateAssertStringifyTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateAssertStringifyTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/stringifiers/CreateIsStringifyTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateIsStringifyTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/stringifiers/CreateStringifyTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateStringifyTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/stringifiers/CreateValidateStringifyProgrammer.ts

@@ -11,7 +11,7 @@ export namespace CreateValidateStringifyTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/validators/CreateAssertTransformer.ts

@@ -18,7 +18,7 @@ export namespace CreateAssertTransformer {
             expression: ts.CallExpression,
         ): ts.Expression {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
+            if (!expression.typeArguments?.[0])
                 throw new Error(MESSAGES.NOT_SPECIFIED);
 
             // GET TYPE INFO

package/src/transformers/features/validators/CreateIsTransformer.ts

@@ -18,7 +18,7 @@ export namespace CreateIsTransformer {
             expression: ts.CallExpression,
         ): ts.Expression {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
+            if (!expression.typeArguments?.[0])
                 throw new Error(MESSAGES.NOT_SPECIFIED);
 
             // GET TYPE INFO

package/src/transformers/features/validators/CreateValidateTransformer.ts

@@ -18,7 +18,7 @@ export namespace CreateValidateTransformer {
             expression: ts.CallExpression,
         ): ts.Expression {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
+            if (!expression.typeArguments?.[0])
                 throw new Error(MESSAGES.NOT_SPECIFIED);
 
             // GET TYPE INFO

package/src/utils/RandomGenerator.ts

@@ -0,0 +1,90 @@
+import RandExp from "randexp";
+
+/**
+ * @internal
+ */
+export namespace RandomGenerator {
+    const ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
+
+    /* -----------------------------------------------------------
+        REGULAR
+    ----------------------------------------------------------- */
+    export function boolean(): boolean {
+        return Math.random() < 0.5;
+    }
+
+    export function integer(min?: number, max?: number): number {
+        min ??= 0;
+        max ??= 100;
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+
+    export function bigint(min?: bigint, max?: bigint): bigint {
+        min ??= BigInt(0);
+        max ??= BigInt(100);
+        return BigInt(integer(Number(min), Number(max)));
+    }
+
+    export function number(min?: number, max?: number): number {
+        min ??= 0;
+        max ??= 100;
+        return Math.random() * (max - min) + min;
+    }
+
+    export function string(length?: number): string {
+        return new Array(length ?? integer(5, 10))
+            .fill(0)
+            .map(() => ALPHABETS[integer(0, ALPHABETS.length - 1)])
+            .join("");
+    }
+
+    export function array<T>(
+        closure: (index: number) => T,
+        count?: number,
+    ): T[] {
+        return new Array(count ?? integer(0, 3))
+            .fill(0)
+            .map((_e, index) => closure(index));
+    }
+
+    export function pick<T>(array: T[]): T {
+        return array[integer(0, array.length - 1)]!;
+    }
+
+    /* -----------------------------------------------------------
+        SECIAL FORMATS
+    ----------------------------------------------------------- */
+    export function uuid(): string {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+
+    export function email(): string {
+        return `${string(10)}@${string(10)}.${string(3)}`;
+    }
+
+    export function url(): string {
+        return `https://${string(10)}.${string(3)}`;
+    }
+
+    export function ipv4(): string {
+        return array(() => integer(0, 255), 4).join(".");
+    }
+
+    export function ipv6(): string {
+        return array(() => integer(0, 65535).toString(16), 8).join(":");
+    }
+
+    export function pattern(regex: RegExp): string {
+        return new RandExp(regex).gen();
+    }
+
+    export function date(min?: number, max?: number): string {
+        min ??= 0;
+        max ??= Date.now();
+        return new Date(number(min, max)).toString();
+    }
+}

package/lib/programmers/internal/check_length.js

@@ -1,28 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.check_length = void 0;
-var typescript_1 = __importDefault(require("typescript"));
-function check_length(conditions, length, tag) {
-    if (tag.minimum !== undefined &&
-        tag.maximum !== undefined &&
-        tag.minimum.value === tag.maximum.value &&
-        tag.minimum.include === true &&
-        tag.maximum.include === true) {
-        conditions.push(typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createNumericLiteral(tag.minimum.value), length));
-    }
-    else {
-        if (tag.minimum !== undefined)
-            conditions.push((tag.minimum.include
-                ? typescript_1.default.factory.createLessThanEquals
-                : typescript_1.default.factory.createLessThan)(typescript_1.default.factory.createNumericLiteral(tag.minimum.value), length));
-        if (tag.maximum !== undefined)
-            conditions.push((tag.maximum.include
-                ? typescript_1.default.factory.createGreaterThanEquals
-                : typescript_1.default.factory.createGreaterThan)(typescript_1.default.factory.createNumericLiteral(tag.maximum.value), length));
-    }
-}
-exports.check_length = check_length;
-//# sourceMappingURL=check_length.js.map