typia 3.6.0 → 3.6.2

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

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

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

@@ -10,15 +10,18 @@ export namespace RandomTransformer {
         modulo: ts.LeftHandSideExpression,
         expression: ts.CallExpression,
     ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
         if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
-        const type: ts.Type | undefined = project.checker.getTypeFromTypeNode(
-            expression.typeArguments[0],
-        );
+        // GET TYPE INFO
+        const node: ts.TypeNode = expression.typeArguments[0];
+        const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
         if (type.isTypeParameter())
             throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
 
+        // DO TRANSFORM
         return ts.factory.createCallExpression(
             RandomProgrammer.generate(
                 {
@@ -30,7 +33,7 @@ export namespace RandomTransformer {
                     },
                 },
                 modulo,
-            )(type),
+            )(type, node.getText()),
             undefined,
             expression.arguments.length
                 ? [expression.arguments[0]!]

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

@@ -1,38 +1,9 @@
-import ts from "typescript";
-
 import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 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.",
+    export const transform = GenericTransformer.scalar("validatClone")(
+        (project, modulo) => ValidateCloneProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,38 +1,9 @@
-import ts from "typescript";
-
 import { ValidatePruneProgrammer } from "../../../programmers/ValidatePruneProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ValidatePruneTransformer {
-    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(
-            ValidatePruneProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NO_INPUT_VALUE = "Error on typia.validatePrune(): no input value.",
-    GENERIC_ARGUMENT = "Error on typia.validatePrune(): non-specified generic argument.",
+    export const transform = GenericTransformer.scalar("validatPrune")(
+        (project, modulo) => ValidatePruneProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,36 +1,9 @@
-import ts from "typescript";
-
 import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        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 ts.factory.createCallExpression(
-            AssertParseProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.assertParse(): generic argument is not specified",
-    GENERIC_ARGUMENT = "Error on typia.assertParse(): non-specified generic argument.",
+    export const transform = GenericTransformer.scalar("assertParse")(
+        (project, modulo) => AssertParseProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,32 +1,9 @@
-import ts from "typescript";
-
 import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXASSERTTENCE
-        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 AssertParseProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.assertParse(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.assertParse(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory("createAssertParse")(
+        (project, modulo) => AssertParseProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,32 +1,9 @@
-import ts from "typescript";
-
 import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsParseTransformer {
-    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 IsParseProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.isParse(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.isParse(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory("createIsParse")(
+        (project, modulo) => IsParseProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,32 +1,9 @@
-import ts from "typescript";
-
 import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateValidateParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        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 ValidateParseProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.validateParse(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.validateParse(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory("createValidateParse")(
+        (project, modulo) => ValidateParseProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,36 +1,9 @@
-import ts from "typescript";
-
 import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace IsParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        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 ts.factory.createCallExpression(
-            IsParseProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.isParse(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.isParse(): non-specified generic argument.",
+    export const transform = GenericTransformer.scalar("isParse")(
+        (project, modulo) => IsParseProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,36 +1,9 @@
-import ts from "typescript";
-
 import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ValidateParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        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 ts.factory.createCallExpression(
-            ValidateParseProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.validateParse(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.validateParse(): non-specified generic argument.",
+    export const transform = GenericTransformer.scalar("validatParse")(
+        (project, modulo) => ValidateParseProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,38 +1,10 @@
-import ts from "typescript";
-
 import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertStringifyTransformer {
-    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(
-            AssertStringifyProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NO_INPUT_VALUE = "Error on typia.assertStringify(): no input value.",
-    GENERIC_ARGUMENT = "Error on typia.assertStringify(): non-specified generic argument.",
+    export const transform = GenericTransformer.scalar("assertStringify")(
+        (project, modulo) =>
+            AssertStringifyProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,32 +1,9 @@
-import ts from "typescript";
-
 import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertStringifyTransformer {
-    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 AssertStringifyProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.assertStringify(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.assertStringify(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory(
+        "createAssertStringify",
+    )((project, modulo) => AssertStringifyProgrammer.generate(project, modulo));
 }

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

@@ -1,32 +1,9 @@
-import ts from "typescript";
-
 import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsStringifyTransformer {
-    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 IsStringifyProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.isStringify(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.isStringify(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory("createIsStringify")(
+        (project, modulo) => IsStringifyProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,31 +1,9 @@
-import ts from "typescript";
-
 import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateStringifyTransformer {
-    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);
-
-        return StringifyProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.stringify(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.stringify(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory("createStringify")(
+        (project, modulo) => StringifyProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,32 +1,11 @@
-import ts from "typescript";
-
 import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateValidateStringifyTransformer {
-    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 ValidateStringifyProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.validateStringify(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.validateStringify(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory(
+        "createValidateStringify",
+    )((project, modulo) =>
+        ValidateStringifyProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,38 +1,9 @@
-import ts from "typescript";
-
 import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace IsStringifyTransformer {
-    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(
-            IsStringifyProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NO_INPUT_VALUE = "Error on typia.isStringify(): no input value.",
-    GENERIC_ARGUMENT = "Error on typia.isStringify(): non-specified generic argument.",
+    export const transform = GenericTransformer.scalar("isStringify")(
+        (project, modulo) => IsStringifyProgrammer.generate(project, modulo),
+    );
 }