typia 4.0.0-dev.20230502 → 4.0.0-dev.20230519

package/src/transformers/CallExpressionTransformer.ts

@@ -1,5 +1,7 @@
 import path from "path";
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
+
+import { TsNodeUtil } from "../utils/TsNodeUtil";
 
 import { IProject } from "./IProject";
 import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
@@ -29,7 +31,6 @@ import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransf
 import { CreateValidateParseTransformer } from "./features/parsers/CreateValidateParseTransformer";
 import { IsParseTransformer } from "./features/parsers/IsParseTransformer";
 import { ValidateParseTransformer } from "./features/parsers/ValidateParseTransformer";
-import { MessageTransformer } from "./features/protocols/MessageTransformer";
 import { AssertStringifyTransformer } from "./features/stringifiers/AssertStringifyTransformer";
 import { CreateAssertStringifyTransformer } from "./features/stringifiers/CreateAssertStringifyTransformer";
 import { CreateIsStringifyTransformer } from "./features/stringifiers/CreateIsStringifyTransformer";
@@ -59,8 +60,9 @@ export namespace CallExpressionTransformer {
 
             // FILE PATH
             const file: string = path.resolve(
-                declaration.getSourceFile().fileName,
+                TsNodeUtil.getSourceFile(project.tsc)(declaration).fileName,
             );
+
             if (
                 file.indexOf(LIB_PATH) === -1 &&
                 file !== SRC_PATH &&
@@ -72,11 +74,12 @@ export namespace CallExpressionTransformer {
             // TRANSFORMATION
             //----
             // FUNCTION NAME
-            const { name } =
+            const { escapedName } =
                 project.checker.getTypeAtLocation(declaration).symbol;
 
             // FIND TRANSFORMER
-            const functor: (() => Task) | undefined = FUNCTORS[name];
+            const functor: (() => Task) | undefined =
+                FUNCTORS[escapedName.toString()];
             if (functor === undefined) return expression;
 
             // RETURNS WITH TRANSFORMATION
@@ -91,14 +94,16 @@ type Task = (
 ) => (expression: ts.CallExpression) => ts.Expression;
 
 const LIB_PATH = path.join("node_modules", "typia", "lib", "module.d.ts");
-const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
+const SRC_PATH = path.resolve(
+    path.join(__dirname, "..", "..", "src", "module.ts"),
+);
 const CLI_PATH = path.resolve(
     path.join(__dirname, "..", "..", "..", "src", "module.ts"),
 );
 
 const FUNCTORS: Record<string, () => Task> = {
     //----
-    // VALIDATORS
+    // SINGLE FUNCTIONS
     //----
     // BASIC VALIDATORS
     assert: () => AssertTransformer.transform(false),
@@ -111,24 +116,14 @@ const FUNCTORS: Record<string, () => Task> = {
     equals: () => IsTransformer.transform(true),
     validateEquals: () => ValidateTransformer.transform(true),
 
-    //----
-    // PROTOCOL BUFFER
-    //----
-    message: () => MessageTransformer.transform,
-
-    //----
-    // JSON FUNCTIONS
-    //----
-    // SCHEMA DEFINITION
-    application: () => (project) => () =>
-        ApplicationTransformer.transform(project),
-
-    // PARSER FUNCTIONS
+    // PARSE FUNCTIONS
     isParse: () => IsParseTransformer.transform,
     assertParse: () => AssertParseTransformer.transform,
     validateParse: () => ValidateParseTransformer.transform,
 
     // STRINGIFY FUNCTIONS
+    application: () => (project) => () =>
+        ApplicationTransformer.transform(project),
     stringify: () => StringifyTransformer.transform,
     assertStringify: () => AssertStringifyTransformer.transform,
     isStringify: () => IsStringifyTransformer.transform,
@@ -152,19 +147,23 @@ const FUNCTORS: Record<string, () => Task> = {
     //----
     // FACTORY FUNCTIONS
     //----
-    // VALIDATORS
+    // BASIC VALIDATORS
     createAssert: () => CreateAssertTransformer.transform(false),
     createAssertType: () => CreateAssertTransformer.transform(false),
     createIs: () => CreateIsTransformer.transform(false),
     createValidate: () => CreateValidateTransformer.transform(false),
+
+    // STRICT VALIDATORS
     createAssertEquals: () => CreateAssertTransformer.transform(true),
     createEquals: () => CreateIsTransformer.transform(true),
     createValidateEquals: () => CreateValidateTransformer.transform(true),
 
-    // JSON FUNCTIONS
+    // PARSE FUNCTIONS
     createIsParse: () => CreateIsParseTransformer.transform,
     createAssertParse: () => CreateAssertParseTransformer.transform,
     createValidateParse: () => CreateValidateParseTransformer.transform,
+
+    // STRINGIFY FUNCTIONS
     createStringify: () => CreateStringifyTransformer.transform,
     createAssertStringify: () => CreateAssertStringifyTransformer.transform,
     createIsStringify: () => CreateIsStringifyTransformer.transform,

package/src/transformers/FileTransformer.ts

@@ -1,4 +1,6 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
+
+import { TsNodeUtil } from "../utils/TsNodeUtil";
 
 import { IProject } from "./IProject";
 import { NodeTransformer } from "./NodeTransformer";
@@ -10,7 +12,7 @@ export namespace FileTransformer {
         (file: ts.SourceFile): ts.SourceFile =>
             file.isDeclarationFile
                 ? file
-                : ts.visitEachChild(
+                : project.tsc.visitEachChild(
                       file,
                       (node) => iterate_node(project)(context)(node),
                       context,
@@ -20,7 +22,7 @@ export namespace FileTransformer {
         (project: IProject) =>
         (context: ts.TransformationContext) =>
         (node: ts.Node): ts.Node =>
-            ts.visitEachChild(
+            project.tsc.visitEachChild(
                 try_transform_node(project)(node),
                 (child) => iterate_node(project)(context)(child),
                 context,
@@ -34,10 +36,11 @@ export namespace FileTransformer {
             } catch (exp) {
                 if (!(exp instanceof Error)) throw exp;
 
-                const file: ts.SourceFile = node.getSourceFile();
-                const { line, character } = file.getLineAndCharacterOfPosition(
-                    node.pos,
-                );
+                const file: ts.SourceFile = TsNodeUtil.getSourceFile(
+                    project.tsc,
+                )(node);
+                const { line, character } =
+                    project.tsc.getLineAndCharacterOfPosition(file, node.pos);
                 exp.message += ` - ${file.fileName}:${line + 1}:${
                     character + 1
                 }`;

package/src/transformers/IProject.ts

@@ -1,11 +1,18 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { ITransformOptions } from "./ITransformOptions";
 
 export interface IProject {
+    tsc: typeof ts;
     program: ts.Program;
     compilerOptions: ts.CompilerOptions;
     checker: ts.TypeChecker;
     printer: ts.Printer;
     options: ITransformOptions;
 }
+export namespace IProject {
+    export interface IModule {
+        tsc: typeof ts;
+        checker: ts.TypeChecker;
+    }
+}

package/src/transformers/ImportTransformer.ts

@@ -1,15 +1,19 @@
 import path from "path";
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
+
+import { TsNodeUtil } from "../utils/TsNodeUtil";
 
 export namespace ImportTransformer {
     export const transform =
+        (tsc: typeof ts) =>
         (from: string) =>
         (to: string) =>
         (context: ts.TransformationContext) =>
         (file: ts.SourceFile) =>
-            transform_file(from)(to)(context)(file);
+            transform_file(tsc)(from)(to)(context)(file);
 
     const transform_file =
+        (tsc: typeof ts) =>
         (top: string) =>
         (to: string) =>
         (context: ts.TransformationContext) =>
@@ -17,22 +21,26 @@ export namespace ImportTransformer {
             if (file.isDeclarationFile) return file;
 
             const from: string = get_directory_path(
-                path.resolve(file.getSourceFile().fileName),
+                path.resolve(TsNodeUtil.getSourceFile(tsc)(file).fileName),
             );
             to = from.replace(top, to);
 
-            return ts.visitEachChild(
+            return tsc.visitEachChild(
                 file,
-                (node) => transform_node(top)(from)(to)(node),
+                (node) => transform_node(tsc)(top)(from)(to)(node),
                 context,
             );
         };
 
     const transform_node =
-        (top: string) => (from: string) => (to: string) => (node: ts.Node) => {
+        (tsc: typeof ts) =>
+        (top: string) =>
+        (from: string) =>
+        (to: string) =>
+        (node: ts.Node) => {
             if (
-                !ts.isImportDeclaration(node) ||
-                !ts.isStringLiteral(node.moduleSpecifier)
+                !tsc.isImportDeclaration(node) ||
+                !tsc.isStringLiteral(node.moduleSpecifier)
             )
                 return node;
 
@@ -50,10 +58,10 @@ export namespace ImportTransformer {
                 return simple[0] === "." ? simple : `./${simple}`;
             })();
 
-            return ts.factory.createImportDeclaration(
+            return tsc.factory.createImportDeclaration(
                 undefined,
                 node.importClause,
-                ts.factory.createStringLiteral(replaced),
+                tsc.factory.createStringLiteral(replaced),
                 node.assertClause,
             );
         };

package/src/transformers/NodeTransformer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { CallExpressionTransformer } from "./CallExpressionTransformer";
 import { IProject } from "./IProject";
@@ -7,7 +7,7 @@ export namespace NodeTransformer {
     export const transform =
         (project: IProject) =>
         (expression: ts.Node): ts.Node =>
-            ts.isCallExpression(expression)
+            project.tsc.isCallExpression(expression)
                 ? CallExpressionTransformer.transform(project)(expression)
                 : expression;
 }

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

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { LiteralFactory } from "../../../factories/LiteralFactory";
 import { MetadataCollection } from "../../../factories/MetadataCollection";
@@ -9,11 +9,13 @@ import { IJsonApplication } from "../../../schemas/IJsonApplication";
 
 import { ApplicationProgrammer } from "../../../programmers/ApplicationProgrammer";
 
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
 import { IProject } from "../../IProject";
 
 export namespace ApplicationTransformer {
     export const transform =
-        ({ checker }: IProject) =>
+        (p: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
                 throw new Error(NO_GENERIC_ARGUMENT);
@@ -23,43 +25,37 @@ export namespace ApplicationTransformer {
             //----
             // VALIDATE TUPLE ARGUMENTS
             const top: ts.Node = expression.typeArguments[0]!;
-            if (!ts.isTupleTypeNode(top)) return expression;
-            else if (top.elements.some((child) => !ts.isTypeNode(child)))
+            if (!p.tsc.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !p.tsc.isTypeNode(child)))
                 return expression;
 
             // GET TYPES
-            const types: ts.Type[] = top.elements.map((child) =>
-                checker.getTypeFromTypeNode(child as ts.TypeNode),
+            const typeList: ts.Type[] = top.elements.map((child) =>
+                p.checker.getTypeFromTypeNode(child as ts.TypeNode),
             );
-            if (types.some((t) => t.isTypeParameter()))
+            if (
+                typeList.some((type) => TsTypeUtil.isTypeParameter(p.tsc)(type))
+            )
                 throw new Error(GENERIC_ARGUMENT);
 
             // ADDITIONAL PARAMETERS
             const purpose: "swagger" | "ajv" = get_parameter(
-                checker,
+                p,
                 "Purpose",
                 expression.typeArguments[1],
                 (str) => str === "swagger" || str === "ajv",
                 () => "swagger",
             );
-            const prefix: string = get_parameter(
-                checker,
-                "Prefix",
-                expression.typeArguments[2],
-                () => true,
-                () =>
-                    purpose === "swagger"
-                        ? "#/components/schemas"
-                        : "components#/schemas",
-            );
 
             //----
             // GENERATORS
             //----
             // METADATA
-            const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
+            const collection: MetadataCollection = new MetadataCollection({
+                replace: MetadataCollection.replace,
+            });
+            const metadatas: Array<Metadata> = typeList.map((type) =>
+                MetadataFactory.analyze(p)({
                     resolve: true,
                     constant: true,
                     validate: (meta) => {
@@ -72,15 +68,14 @@ export namespace ApplicationTransformer {
             // APPLICATION
             const app: IJsonApplication = ApplicationProgrammer.write({
                 purpose,
-                prefix,
             })(metadatas);
 
             // RETURNS WITH LITERAL EXPRESSION
-            return LiteralFactory.generate(app);
+            return LiteralFactory.generate(p.tsc)(app);
         };
 
     const get_parameter = <T extends string>(
-        checker: ts.TypeChecker,
+        p: IProject.IModule,
         name: string,
         node: ts.TypeNode | undefined,
         predicator: (value: string) => boolean,
@@ -89,8 +84,8 @@ export namespace ApplicationTransformer {
         if (!node) return defaulter();
 
         // CHECK LITERAL TYPE
-        const type: ts.Type = checker.getTypeFromTypeNode(node);
-        if (!type.isLiteral())
+        const type: ts.Type = p.checker.getTypeFromTypeNode(node);
+        if (!TsTypeUtil.isLiteral(p.tsc)(type))
             throw new Error(
                 `Error on typia.application(): generic argument "${name}" must be constant.`,
             );

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

@@ -1,12 +1,15 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
 
+import { TsNodeUtil } from "../../../utils/TsNodeUtil";
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
 import { IProject } from "../../IProject";
 
 export namespace CreateRandomTransformer {
     export const transform =
-        (project: IProject) =>
+        (p: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
@@ -14,21 +17,22 @@ export namespace CreateRandomTransformer {
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+            const type: ts.Type = p.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
+                throw new Error(NO_GENERIC_ARGUMENT);
 
             // DO TRANSFORM
             return RandomProgrammer.write({
-                ...project,
+                ...p,
                 options: {
-                    ...project.options,
+                    ...p.options,
                     functional: false,
                     numeric: false,
                 },
             })(modulo)(expression.arguments?.[0])(
                 type,
-                node.getFullText().trim(),
+                TsNodeUtil.getFullText(p.tsc)(node).trim(),
             );
         };
 }

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

@@ -1,24 +1,27 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { LiteralsProgrammer } from "../../../programmers/LiteralsProgrammer";
 
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
 import { IProject } from "../../IProject";
 
 export namespace LiteralsTransformer {
     export const transform =
-        (project: IProject) =>
+        (p: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
             if (!expression.typeArguments?.[0]) throw new Error(NOT_SPECIFIED);
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+            const type: ts.Type = p.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
+                throw new Error(NO_GENERIC_ARGUMENT);
 
             // DO TRANSFORM
-            return LiteralsProgrammer.write(project)(type);
+            return LiteralsProgrammer.write(p)(type);
         };
 }
 

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

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { LiteralFactory } from "../../../factories/LiteralFactory";
 import { MetadataCollection } from "../../../factories/MetadataCollection";
@@ -7,32 +7,36 @@ import { MetadataFactory } from "../../../factories/MetadataFactory";
 import { IMetadataApplication } from "../../../metadata/IMetadataApplication";
 import { Metadata } from "../../../metadata/Metadata";
 
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
 import { IProject } from "../../IProject";
 
 export namespace MetadataTransformer {
     export const transform =
-        ({ checker }: IProject) =>
+        (p: IProject) =>
         (expression: ts.CallExpression): ts.Expression => {
             if (!expression.typeArguments?.length)
                 throw new Error(NO_GENERIC_ARGUMENT);
 
             // VALIDATE TUPLE ARGUMENTS
             const top: ts.Node = expression.typeArguments[0]!;
-            if (!ts.isTupleTypeNode(top)) return expression;
-            else if (top.elements.some((child) => !ts.isTypeNode(child)))
+            if (!p.tsc.isTupleTypeNode(top)) return expression;
+            else if (top.elements.some((child) => !p.tsc.isTypeNode(child)))
                 return expression;
 
             // GET TYPES
-            const types: ts.Type[] = top.elements.map((child) =>
-                checker.getTypeFromTypeNode(child as ts.TypeNode),
+            const typeList: ts.Type[] = top.elements.map((child) =>
+                p.checker.getTypeFromTypeNode(child as ts.TypeNode),
             );
-            if (types.some((t) => t.isTypeParameter()))
+            if (
+                typeList.some((type) => TsTypeUtil.isTypeParameter(p.tsc)(type))
+            )
                 throw new Error(GENERIC_ARGUMENT);
 
             // METADATA
             const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
+            const metadatas: Array<Metadata> = typeList.map((type) =>
+                MetadataFactory.analyze(p)({
                     resolve: false,
                     constant: true,
                 })(collection)(type),
@@ -43,7 +47,7 @@ export namespace MetadataTransformer {
                 metadatas: metadatas.map((metadata) => metadata.toJSON()),
                 collection: collection.objects().map((obj) => obj.toJSON()),
             };
-            return LiteralFactory.generate(app);
+            return LiteralFactory.generate(p.tsc)(app);
         };
 }
 

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

@@ -1,12 +1,15 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
 
+import { TsNodeUtil } from "../../../utils/TsNodeUtil";
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
 import { IProject } from "../../IProject";
 
 export namespace RandomTransformer {
     export const transform =
-        (project: IProject) =>
+        (p: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression): ts.Expression => {
             // CHECK GENERIC ARGUMENT EXISTENCE
@@ -14,20 +17,21 @@ export namespace RandomTransformer {
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+            const type: ts.Type = p.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
+            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
+                throw new Error(NO_GENERIC_ARGUMENT);
 
             // DO TRANSFORM
-            return ts.factory.createCallExpression(
+            return p.tsc.factory.createCallExpression(
                 RandomProgrammer.write({
-                    ...project,
+                    ...p,
                     options: {
-                        ...project.options,
+                        ...p.options,
                         functional: false,
                         numeric: false,
                     },
-                })(modulo)()(type, node.getFullText().trim()),
+                })(modulo)()(type, TsNodeUtil.getFullText(p.tsc)(node).trim()),
                 undefined,
                 expression.arguments.length
                     ? [expression.arguments[0]!]

package/src/transformers/internal/GenericTransformer.ts

@@ -1,4 +1,7 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
+
+import { TsNodeUtil } from "../../utils/TsNodeUtil";
+import { TsTypeUtil } from "../../utils/TsTypeUtil";
 
 import { IProject } from "../IProject";
 
@@ -12,7 +15,7 @@ export namespace GenericTransformer {
                 modulo: ts.LeftHandSideExpression,
             ) => (type: ts.Type, name: string) => ts.ArrowFunction,
         ) =>
-        (project: IProject) =>
+        (p: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression) => {
             // CHECK PARAMETER
@@ -23,31 +26,29 @@ export namespace GenericTransformer {
             const [type, node, generic]: [ts.Type, ts.Node, boolean] =
                 expression.typeArguments && expression.typeArguments[0]
                     ? [
-                          project.checker.getTypeFromTypeNode(
+                          p.checker.getTypeFromTypeNode(
                               expression.typeArguments[0],
                           ),
                           expression.typeArguments[0],
                           true,
                       ]
                     : [
-                          project.checker.getTypeAtLocation(
-                              expression.arguments[0]!,
-                          ),
+                          p.checker.getTypeAtLocation(expression.arguments[0]!),
                           expression.arguments[0]!,
                           false,
                       ];
-            if (type.isTypeParameter())
+            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
                 throw new Error(
                     `Error on typia.${method}(): non-specified generic argument.`,
                 );
 
             // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                programmer(project)(modulo)(
+            return p.tsc.factory.createCallExpression(
+                programmer(p)(modulo)(
                     type,
                     generic
-                        ? node.getFullText().trim()
-                        : name(project.checker)(type)(node),
+                        ? TsNodeUtil.getFullText(p.tsc)(node).trim()
+                        : name(p)(type)(node),
                 ),
                 undefined,
                 [expression.arguments[0]!],
@@ -63,7 +64,7 @@ export namespace GenericTransformer {
                 modulo: ts.LeftHandSideExpression,
             ) => (type: ts.Type, name: string) => ts.ArrowFunction,
         ) =>
-        (project: IProject) =>
+        (p: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (expression: ts.CallExpression) => {
             // CHECK GENERIC ARGUMENT EXISTENCE
@@ -74,24 +75,27 @@ export namespace GenericTransformer {
 
             // GET TYPE INFO
             const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+            const type: ts.Type = p.checker.getTypeFromTypeNode(node);
 
-            if (type.isTypeParameter())
+            if (TsTypeUtil.isTypeParameter(p.tsc)(type))
                 throw new Error(
                     `Error on typia.${method}(): non-specified generic argument.`,
                 );
 
             // DO TRANSFORM
-            return programmer(project)(modulo)(type, node.getFullText().trim());
+            return programmer(p)(modulo)(
+                type,
+                TsNodeUtil.getFullText(p.tsc)(node).trim(),
+            );
         };
 
     const name =
-        (checker: ts.TypeChecker) =>
+        (project: IProject) =>
         (type: ts.Type) =>
         (node: ts.Node): string =>
-            checker.typeToString(
+            project.checker.typeToString(
                 type,
                 node,
-                ts.TypeFormatFlags.NodeBuilderFlagsMask,
+                project.tsc.TypeFormatFlags.NodeBuilderFlagsMask,
             );
 }