typia 3.5.0-dev.20230212 → 3.5.0-dev.20230213

package/lib/transformers/features/miscellaneous/CloneTransformer.js

@@ -0,0 +1,34 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloneTransformer = void 0;
+var typescript_1 = __importDefault(require("typescript"));
+var CloneProgrammer_1 = require("../../../programmers/CloneProgrammer");
+var CloneTransformer;
+(function (CloneTransformer) {
+    function transform(project, modulo, expression) {
+        if (expression.arguments.length !== 1)
+            throw new Error("Error on typia.clone(): no input value.");
+        var type = expression.typeArguments && expression.typeArguments[0]
+            ? project.checker.getTypeFromTypeNode(expression.typeArguments[0])
+            : project.checker.getTypeAtLocation(expression.arguments[0]);
+        if (type.isTypeParameter())
+            throw new Error("Error on typia.clone(): non-specified generic argument.");
+        return typescript_1.default.factory.createCallExpression(CloneProgrammer_1.CloneProgrammer.generate(__assign(__assign({}, project), { options: __assign(__assign({}, project.options), { functional: false, numeric: false }) }), modulo)(type), undefined, [expression.arguments[0]]);
+    }
+    CloneTransformer.transform = transform;
+})(CloneTransformer = exports.CloneTransformer || (exports.CloneTransformer = {}));
+//# sourceMappingURL=CloneTransformer.js.map

package/lib/transformers/features/miscellaneous/CloneTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloneTransformer.js","sourceRoot":"","sources":["../../../../src/transformers/features/miscellaneous/CloneTransformer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,0DAA4B;AAE5B,wEAAuE;AAIvE,IAAiB,gBAAgB,CAkChC;AAlCD,WAAiB,gBAAgB;IAC7B,SAAgB,SAAS,CACrB,OAAiB,EACjB,MAAiC,EACjC,UAA6B;QAE7B,IAAI,UAAU,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;YACjC,MAAM,IAAI,KAAK,2CAA8B,CAAC;QAElD,IAAM,IAAI,GACN,UAAU,CAAC,aAAa,IAAI,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;YACnD,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAC/B,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC,CAC9B;YACH,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAE,CAAC,CAAC;QACtE,IAAI,IAAI,CAAC,eAAe,EAAE;YACtB,MAAM,IAAI,KAAK,2DAAgC,CAAC;QAEpD,OAAO,oBAAE,CAAC,OAAO,CAAC,oBAAoB,CAClC,iCAAe,CAAC,QAAQ,uBAEb,OAAO,KACV,OAAO,wBACA,OAAO,CAAC,OAAO,KAClB,UAAU,EAAE,KAAK,EACjB,OAAO,EAAE,KAAK,QAGtB,MAAM,CACT,CAAC,IAAI,CAAC,EACP,SAAS,EACT,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAE,CAAC,CAC7B,CAAC;IACN,CAAC;IAhCe,0BAAS,YAgCxB,CAAA;AACL,CAAC,EAlCgB,gBAAgB,GAAhB,wBAAgB,KAAhB,wBAAgB,QAkChC"}

package/lib/transformers/features/miscellaneous/CreateCloneTransformer.d.ts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+import { IProject } from "../../IProject";
+export declare namespace CreateCloneTransformer {
+    function transform(project: IProject, modulo: ts.LeftHandSideExpression, expression: ts.CallExpression): ts.Expression;
+}

package/lib/transformers/features/miscellaneous/CreateCloneTransformer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCloneTransformer = void 0;
+var CloneProgrammer_1 = require("../../../programmers/CloneProgrammer");
+var CreateCloneTransformer;
+(function (CreateCloneTransformer) {
+    function transform(project, modulo, expression) {
+        if (!expression.typeArguments || !expression.typeArguments[0])
+            throw new Error("Error on typia.clone(): generic argument is not specified.");
+        var type = project.checker.getTypeFromTypeNode(expression.typeArguments[0]);
+        if (type.isTypeParameter())
+            throw new Error("Error on typia.clone(): non-specified generic argument.");
+        return CloneProgrammer_1.CloneProgrammer.generate(project, modulo)(type);
+    }
+    CreateCloneTransformer.transform = transform;
+})(CreateCloneTransformer = exports.CreateCloneTransformer || (exports.CreateCloneTransformer = {}));
+//# sourceMappingURL=CreateCloneTransformer.js.map

package/lib/transformers/features/miscellaneous/CreateCloneTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateCloneTransformer.js","sourceRoot":"","sources":["../../../../src/transformers/features/miscellaneous/CreateCloneTransformer.ts"],"names":[],"mappings":";;;AAEA,wEAAuE;AAIvE,IAAiB,sBAAsB,CAmBtC;AAnBD,WAAiB,sBAAsB;IACnC,SAAgB,SAAS,CACrB,OAAiB,EACjB,MAAiC,EACjC,UAA6B;QAG7B,IAAI,CAAC,UAAU,CAAC,aAAa,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;YACzD,MAAM,IAAI,KAAK,8DAA6B,CAAC;QAGjD,IAAM,IAAI,GAAY,OAAO,CAAC,OAAO,CAAC,mBAAmB,CACrD,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC,CAC9B,CAAC;QACF,IAAI,IAAI,CAAC,eAAe,EAAE;YACtB,MAAM,IAAI,KAAK,2DAAgC,CAAC;QAEpD,OAAO,iCAAe,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;IAC3D,CAAC;IAjBe,gCAAS,YAiBxB,CAAA;AACL,CAAC,EAnBgB,sBAAsB,GAAtB,8BAAsB,KAAtB,8BAAsB,QAmBtC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "3.5.0-dev.20230212",
+  "version": "3.5.0-dev.20230213",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/module.ts

@@ -1105,6 +1105,28 @@ export function metadata(): never {
     halt("metadata");
 }
 
+export function clone<T>(input: T): T;
+export function clone(): never {
+    halt("clone");
+}
+export namespace clone {
+    export const is_uuid = $is_uuid;
+    export const is_email = $is_email;
+    export const is_url = $is_url;
+    export const is_ipv4 = $is_ipv4;
+    export const is_ipv6 = $is_ipv6;
+    export const is_between = $is_between;
+
+    export function throws(
+        props: Pick<TypeGuardError.IProps, "expected" | "value">,
+    ): void {
+        throw new TypeGuardError({
+            ...props,
+            method: "typia.clone",
+        });
+    }
+}
+
 /**
  * Prune, erase superfluous properties.
  *
@@ -1764,6 +1786,17 @@ Object.assign(createValidateStringify, validateStringify);
 /* -----------------------------------------------------------
     MISCELLANEOUS
 ----------------------------------------------------------- */
+export function createClone(): never;
+export function createClone<T>(): (input: T) => T;
+
+/**
+ * @internal
+ */
+export function createClone(): never {
+    halt("createClone");
+}
+Object.assign(createClone, clone);
+
 /**
  * Creates a reusable {@link prune} function.
  *

package/src/programmers/CloneProgrammer.ts

@@ -0,0 +1,357 @@
+import ts from "typescript";
+
+import { ExpressionFactory } from "../factories/ExpressionFactory";
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { MetadataFactory } from "../factories/MetadataFactory";
+
+import { Metadata } from "../metadata/Metadata";
+
+import { IProject } from "../transformers/IProject";
+
+import { FeatureProgrammer } from "./FeatureProgrammer";
+import { IsProgrammer } from "./IsProgrammer";
+import { CloneJoiner } from "./helpers/CloneJoiner";
+import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { UnionExplorer } from "./helpers/UnionExplorer";
+import { decode_union_object } from "./internal/decode_union_object";
+
+export namespace CloneProgrammer {
+    export function generate(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+    ) {
+        const importer: FunctionImporter = new FunctionImporter();
+        return FeatureProgrammer.generate(
+            project,
+            CONFIG(project, importer),
+            importer,
+            (collection) => {
+                const isFunctors = IsProgrammer.generate_functors(
+                    project,
+                    importer,
+                )(collection);
+                const isUnioners = IsProgrammer.generate_unioners(
+                    project,
+                    importer,
+                )(collection);
+
+                return [
+                    ...importer.declare(modulo),
+                    ...isFunctors,
+                    ...isUnioners,
+                ];
+            },
+        );
+    }
+
+    /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+    const decode =
+        (project: IProject, importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            meta: Metadata,
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression => {
+            // ANY TYPE
+            if (
+                meta.any ||
+                meta.arrays.some((a) => a.any) ||
+                meta.tuples.some((t) => t.every((e) => e.any))
+            )
+                return ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("JSON.parse"),
+                    undefined,
+                    [
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("JSON.stringify"),
+                            undefined,
+                            [input],
+                        ),
+                    ],
+                );
+
+            interface IUnion {
+                type: string;
+                is: () => ts.Expression;
+                value: () => ts.Expression;
+            }
+            const unions: IUnion[] = [];
+
+            //----
+            // LIST UP UNION TYPES
+            //----
+            // toJSON() METHOD
+            if (meta.resolved !== null)
+                unions.push({
+                    type: "resolved",
+                    is: () => IsProgrammer.decode_to_json(input),
+                    value: () =>
+                        decode_to_json(project, importer)(
+                            input,
+                            meta.resolved!,
+                            explore,
+                        ),
+                });
+
+            // TUPLES
+            for (const tuple of meta.tuples)
+                unions.push({
+                    type: "tuple",
+                    is: () =>
+                        IsProgrammer.decode(project, importer)(
+                            input,
+                            (() => {
+                                const partial = Metadata.initialize();
+                                partial.tuples.push(tuple);
+                                return partial;
+                            })(),
+                            explore,
+                            [],
+                        ),
+                    value: () =>
+                        decode_tuple(project, importer)(input, tuple, explore),
+                });
+
+            // ARRAYS
+            if (meta.arrays.length)
+                unions.push({
+                    type: "array",
+                    is: () => ExpressionFactory.isArray(input),
+                    value: () =>
+                        explore_arrays(project, importer)(
+                            input,
+                            meta.arrays,
+                            {
+                                ...explore,
+                                from: "array",
+                            },
+                            [],
+                        ),
+                });
+
+            // NATIVE TYPES
+            if (meta.sets.length)
+                unions.push({
+                    type: "set",
+                    is: () => ExpressionFactory.isInstanceOf(input, "Set"),
+                    value: () => ts.factory.createIdentifier("{}"),
+                });
+            if (meta.maps.length)
+                unions.push({
+                    type: "map",
+                    is: () => ExpressionFactory.isInstanceOf(input, "Map"),
+                    value: () => ts.factory.createIdentifier("{}"),
+                });
+            for (const native of meta.natives)
+                unions.push({
+                    type: "native",
+                    is: () => ExpressionFactory.isInstanceOf(input, native),
+                    value: () => ts.factory.createIdentifier("{}"),
+                });
+
+            // OBJECTS
+            if (meta.objects.length)
+                unions.push({
+                    type: "object",
+                    is: () =>
+                        ExpressionFactory.isObject(input, {
+                            checkNull: true,
+                            checkArray: false,
+                        }),
+                    value: () =>
+                        explore_objects(input, meta, {
+                            ...explore,
+                            from: "object",
+                        }),
+                });
+
+            // COMPOSITION
+            let last: ts.Expression = input;
+            for (const u of unions.reverse())
+                last = ts.factory.createConditionalExpression(
+                    u.is(),
+                    undefined,
+                    u.value(),
+                    undefined,
+                    last,
+                );
+            return last;
+        };
+
+    const decode_to_json =
+        (project: IProject, importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            resolved: Metadata,
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression => {
+            return decode(project, importer)(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.join(input, "toJSON"),
+                    undefined,
+                    [],
+                ),
+                resolved,
+                explore,
+            );
+        };
+
+    const decode_tuple =
+        (project: IProject, importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            tuple: Metadata[],
+            explore: FeatureProgrammer.IExplore,
+        ): ts.Expression => {
+            const children: ts.Expression[] = tuple
+                .filter((m) => m.rest === null)
+                .map((elem, index) =>
+                    decode(project, importer)(
+                        ts.factory.createElementAccessExpression(input, index),
+                        elem,
+                        {
+                            ...explore,
+                            from: "array",
+                        },
+                    ),
+                );
+            const rest = (() => {
+                if (tuple.length === 0) return null;
+
+                const last: Metadata = tuple[tuple.length - 1]!;
+                const rest: Metadata | null = last.rest;
+                if (rest === null) return null;
+
+                return decode(project, importer)(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.join(input, "slice"),
+                        undefined,
+                        [ts.factory.createNumericLiteral(tuple.length - 1)],
+                    ),
+                    (() => {
+                        const wrapper: Metadata = Metadata.initialize();
+                        wrapper.arrays.push(rest);
+                        return wrapper;
+                    })(),
+                    {
+                        ...explore,
+                        start: tuple.length - 1,
+                    },
+                );
+            })();
+            return CloneJoiner.tuple(children, rest);
+        };
+
+    const decode_array = (project: IProject, importer: FunctionImporter) =>
+        FeatureProgrammer.decode_array(
+            CONFIG(project, importer),
+            importer,
+            CloneJoiner.array,
+        );
+
+    const decode_object = () =>
+        FeatureProgrammer.decode_object({
+            trace: false,
+            path: false,
+            functors: FUNCTORS,
+        });
+
+    const explore_arrays = (project: IProject, importer: FunctionImporter) =>
+        UnionExplorer.array({
+            checker: IsProgrammer.decode(project, importer),
+            decoder: decode_array(project, importer),
+            empty: ts.factory.createReturnStatement(),
+            success: ts.factory.createTrue(),
+            failure: (input, expected) =>
+                create_throw_error(importer, input, expected),
+        });
+
+    const explore_objects = (
+        input: ts.Expression,
+        meta: Metadata,
+        explore: FeatureProgrammer.IExplore,
+    ) => {
+        if (meta.objects.length === 1)
+            return decode_object()(input, meta.objects[0]!, explore);
+
+        return ts.factory.createCallExpression(
+            ts.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
+            undefined,
+            [input],
+        );
+    };
+
+    /* -----------------------------------------------------------
+        CONFIGURATIONS
+    ----------------------------------------------------------- */
+    const FUNCTORS = "$co";
+    const UNIONERS = "$cu";
+
+    const CONFIG = (
+        project: IProject,
+        importer: FunctionImporter,
+    ): FeatureProgrammer.IConfig => ({
+        functors: FUNCTORS,
+        unioners: UNIONERS,
+        trace: false,
+        path: false,
+        initializer,
+        decoder: decode(project, importer),
+        objector: OBJECTOR(project, importer),
+    });
+
+    const OBJECTOR = (
+        project: IProject,
+        importer: FunctionImporter,
+    ): FeatureProgrammer.IConfig.IObjector => ({
+        checker: IsProgrammer.decode(project, importer),
+        decoder: decode_object(),
+        joiner: CloneJoiner.object,
+        unionizer: decode_union_object(IsProgrammer.decode_object(importer))(
+            decode_object(),
+        )((exp) => exp)((value, expected) =>
+            create_throw_error(importer, value, expected),
+        ),
+        failure: (input, expected) =>
+            create_throw_error(importer, input, expected),
+    });
+
+    const initializer: FeatureProgrammer.IConfig["initializer"] = (
+        { checker },
+        type,
+    ) => {
+        const collection = new MetadataCollection();
+        const meta = MetadataFactory.generate(checker, collection, type, {
+            resolve: true,
+            constant: true,
+        });
+        return [collection, meta];
+    };
+
+    const create_throw_error = (
+        importer: FunctionImporter,
+        value: ts.Expression,
+        expected: string,
+    ) =>
+        ts.factory.createExpressionStatement(
+            ts.factory.createCallExpression(
+                importer.use("throws"),
+                [],
+                [
+                    ts.factory.createObjectLiteralExpression(
+                        [
+                            ts.factory.createPropertyAssignment(
+                                "expected",
+                                ts.factory.createStringLiteral(expected),
+                            ),
+                            ts.factory.createPropertyAssignment("value", value),
+                        ],
+                        true,
+                    ),
+                ],
+            ),
+        );
+}

package/src/programmers/helpers/CloneJoiner.ts

@@ -0,0 +1,126 @@
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace CloneJoiner {
+    export const object = (
+        input: ts.Expression,
+        entries: IExpressionEntry<ts.Expression>[],
+        _obj: MetadataObject,
+    ): ts.ConciseBody => {
+        const regular = entries.filter((e) => e.key.isSoleLiteral());
+        const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+
+        if (regular.length === 0 && dynamic.length === 0)
+            return ts.factory.createIdentifier("{}");
+
+        const literal = ts.factory.createObjectLiteralExpression(
+            regular.map((entry) => {
+                const str: string = entry.key.getSoleLiteral()!;
+                return ts.factory.createPropertyAssignment(
+                    Escaper.variable(str)
+                        ? str
+                        : ts.factory.createStringLiteral(str),
+                    entry.expression,
+                );
+            }),
+            true,
+        );
+        if (dynamic.length === 0) return literal;
+
+        const key = ts.factory.createIdentifier("key");
+        const value = ts.factory.createIdentifier("value");
+        const output = ts.factory.createIdentifier("output");
+
+        const statements: ts.Statement[] = dynamic.map((entry) =>
+            ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        `RegExp(/${metadata_to_pattern(true)(
+                            entry.key,
+                        )}/).test`,
+                    ),
+                    undefined,
+                    [key],
+                ),
+                ts.factory.createBlock([
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createBinaryExpression(
+                            ts.factory.createElementAccessExpression(
+                                output,
+                                key,
+                            ),
+                            ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+                            entry.expression,
+                        ),
+                    ),
+                    ts.factory.createContinueStatement(),
+                ]),
+            ),
+        );
+
+        return ts.factory.createBlock([
+            StatementFactory.constant("output", literal),
+            ts.factory.createForOfStatement(
+                undefined,
+                ts.factory.createVariableDeclarationList(
+                    [
+                        ts.factory.createVariableDeclaration(
+                            ts.factory.createArrayBindingPattern([
+                                ts.factory.createBindingElement(
+                                    undefined,
+                                    undefined,
+                                    key,
+                                    undefined,
+                                ),
+                                ts.factory.createBindingElement(
+                                    undefined,
+                                    undefined,
+                                    value,
+                                    undefined,
+                                ),
+                            ]),
+                            undefined,
+                            undefined,
+                            undefined,
+                        ),
+                    ],
+                    ts.NodeFlags.Const,
+                ),
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("Object.entries"),
+                    undefined,
+                    [input],
+                ),
+                ts.factory.createBlock(statements),
+            ),
+            ts.factory.createReturnStatement(output),
+        ]);
+    };
+
+    export const tuple = (
+        children: ts.Expression[],
+        rest: ts.Expression | null,
+    ): ts.Expression => {
+        if (rest === null)
+            return ts.factory.createArrayLiteralExpression(children, true);
+        return ts.factory.createArrayLiteralExpression(
+            [...children, ts.factory.createSpreadElement(rest)],
+            true,
+        );
+    };
+
+    export const array = (input: ts.Expression, arrow: ts.Expression) =>
+        ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(input, "map"),
+            undefined,
+            [arrow],
+        );
+}

package/src/transformers/CallExpressionTransformer.ts

@@ -4,7 +4,9 @@ import ts from "typescript";
 import { IProject } from "./IProject";
 import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
 import { AssertPruneTransformer } from "./features/miscellaneous/AssertPruneTransformer";
+import { CloneTransformer } from "./features/miscellaneous/CloneTransformer";
 import { CreateAssertPruneTransformer } from "./features/miscellaneous/CreateAssertPruneTransformer";
+import { CreateCloneTransformer } from "./features/miscellaneous/CreateCloneTransformer";
 import { CreateIsPruneTransformer } from "./features/miscellaneous/CreateIsPruneTransformer";
 import { CreatePruneTransformer } from "./features/miscellaneous/CreatePruneTransformer";
 import { CreateValidatePruneTransformer } from "./features/miscellaneous/CreateValidatePruneTransformer";
@@ -96,14 +98,15 @@ const FUNCTORS: Record<string, () => Task> = {
     validateParse: () => ValidateParseTransformer.transform,
 
     // STRINGIFY FUNCTIONS
+    application: () => ApplicationTransformer.transform,
     stringify: () => StringifyTransformer.transform,
     assertStringify: () => AssertStringifyTransformer.transform,
     isStringify: () => IsStringifyTransformer.transform,
     validateStringify: () => ValidateStringifyTransformer.transform,
 
     // MISC
-    application: () => ApplicationTransformer.transform,
     metadata: () => MetadataTransformer.transform,
+    clone: () => CloneTransformer.transform,
     prune: () => PruneTransformer.transform,
     assertPrune: () => AssertPruneTransformer.transform,
     isPrune: () => IsPruneTransformer.transform,
@@ -135,6 +138,7 @@ const FUNCTORS: Record<string, () => Task> = {
     createValidateStringify: () => CreateValidateStringifyTransformer.transform,
 
     // MISC
+    createClone: () => CreateCloneTransformer.transform,
     createPrune: () => CreatePruneTransformer.transform,
     createAssertPrune: () => CreateAssertPruneTransformer.transform,
     createIsPrune: () => CreateIsPruneTransformer.transform,

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

@@ -0,0 +1,46 @@
+import ts from "typescript";
+
+import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CloneTransformer {
+    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);
+
+        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);
+
+        return ts.factory.createCallExpression(
+            CloneProgrammer.generate(
+                {
+                    ...project,
+                    options: {
+                        ...project.options,
+                        functional: false,
+                        numeric: false,
+                    },
+                },
+                modulo,
+            )(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.clone(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.clone(): non-specified generic argument.",
+}