typia 8.0.0 → 8.0.1

package/lib/transformers/CallExpressionTransformer.mjs

@@ -0,0 +1,450 @@
+import path from 'path';
+import { FunctionalAssertFunctionProgrammer } from '../programmers/functional/FunctionalAssertFunctionProgrammer.mjs';
+import { FunctionalAssertParametersProgrammer } from '../programmers/functional/FunctionalAssertParametersProgrammer.mjs';
+import { FunctionAssertReturnProgrammer } from '../programmers/functional/FunctionalAssertReturnProgrammer.mjs';
+import { FunctionalIsFunctionProgrammer } from '../programmers/functional/FunctionalIsFunctionProgrammer.mjs';
+import { FunctionalIsParametersProgrammer } from '../programmers/functional/FunctionalIsParametersProgrammer.mjs';
+import { FunctionalIsReturnProgrammer } from '../programmers/functional/FunctionalIsReturnProgrammer.mjs';
+import { FunctionalValidateFunctionProgrammer } from '../programmers/functional/FunctionalValidateFunctionProgrammer.mjs';
+import { FunctionalValidateParametersProgrammer } from '../programmers/functional/FunctionalValidateParametersProgrammer.mjs';
+import { FunctionalValidateReturnProgrammer } from '../programmers/functional/FunctionalValidateReturnProgrammer.mjs';
+import { FunctionalGenericTransformer } from './features/functional/FunctionalGenericTransformer.mjs';
+import { NamingConvention } from '../utils/NamingConvention.mjs';
+import { AssertTransformer } from './features/AssertTransformer.mjs';
+import { CreateAssertTransformer } from './features/CreateAssertTransformer.mjs';
+import { CreateIsTransformer } from './features/CreateIsTransformer.mjs';
+import { CreateRandomTransformer } from './features/CreateRandomTransformer.mjs';
+import { CreateValidateTransformer } from './features/CreateValidateTransformer.mjs';
+import { IsTransformer } from './features/IsTransformer.mjs';
+import { RandomTransformer } from './features/RandomTransformer.mjs';
+import { ValidateTransformer } from './features/ValidateTransformer.mjs';
+import { CreateHttpAssertFormDataTransformer } from './features/http/CreateHttpAssertFormDataTransformer.mjs';
+import { CreateHttpAssertHeadersTransformer } from './features/http/CreateHttpAssertHeadersTransformer.mjs';
+import { CreateHttpAssertQueryTransformer } from './features/http/CreateHttpAssertQueryTransformer.mjs';
+import { CreateHttpFormDataTransformer } from './features/http/CreateHttpFormDataTransformer.mjs';
+import { CreateHttpHeadersTransformer } from './features/http/CreateHttpHeadersTransformer.mjs';
+import { CreateHttpIsFormDataTransformer } from './features/http/CreateHttpIsFormDataTransformer.mjs';
+import { CreateHttpIsHeadersTransformer } from './features/http/CreateHttpIsHeadersTransformer.mjs';
+import { CreateHttpIsQueryTransformer } from './features/http/CreateHttpIsQueryTransformer.mjs';
+import { CreateHttpParameterTransformer } from './features/http/CreateHttpParameterTransformer.mjs';
+import { CreateHttpQueryTransformer } from './features/http/CreateHttpQueryTransformer.mjs';
+import { CreateHttpValidateFormDataTransformer } from './features/http/CreateHttpValidateFormDataTransformer.mjs';
+import { CreateHttpValidateHeadersTransformer } from './features/http/CreateHttpValidateHeadersTransformer.mjs';
+import { CreateHttpValidateQueryTransformer } from './features/http/CreateHttpValidateQueryTransformer.mjs';
+import { HttpAssertFormDataTransformer } from './features/http/HttpAssertFormDataTransformer.mjs';
+import { HttpAssertHeadersTransformer } from './features/http/HttpAssertHeadersTransformer.mjs';
+import { HttpAssertQueryTransformer } from './features/http/HttpAssertQueryTransformer.mjs';
+import { HttpFormDataTransformer } from './features/http/HttpFormDataTransformer.mjs';
+import { HttpHeadersTransformer } from './features/http/HttpHeadersTransformer.mjs';
+import { HttpIsFormDataTransformer } from './features/http/HttpIsFormDataTransformer.mjs';
+import { HttpIsHeadersTransformer } from './features/http/HttpIsHeadersTransformer.mjs';
+import { HttpIsQueryTransformer } from './features/http/HttpIsQueryTransformer.mjs';
+import { HttpParameterTransformer } from './features/http/HttpParameterTransformer.mjs';
+import { HttpQueryTransformer } from './features/http/HttpQueryTransformer.mjs';
+import { HttpValidateFormDataTransformer } from './features/http/HttpValidateFormDataTransformer.mjs';
+import { HttpValidateHeadersTransformer } from './features/http/HttpValidateHeadersTransformer.mjs';
+import { HttpValidateQueryTransformer } from './features/http/HttpValidateQueryTransformer.mjs';
+import { JsonAssertParseTransformer } from './features/json/JsonAssertParseTransformer.mjs';
+import { JsonAssertStringifyTransformer } from './features/json/JsonAssertStringifyTransformer.mjs';
+import { JsonCreateAssertParseTransformer } from './features/json/JsonCreateAssertParseTransformer.mjs';
+import { JsonCreateAssertStringifyTransformer } from './features/json/JsonCreateAssertStringifyTransformer.mjs';
+import { JsonCreateIsParseTransformer } from './features/json/JsonCreateIsParseTransformer.mjs';
+import { JsonCreateIsStringifyTransformer } from './features/json/JsonCreateIsStringifyTransformer.mjs';
+import { JsonCreateStringifyTransformer } from './features/json/JsonCreateStringifyTransformer.mjs';
+import { JsonCreateValidateParseTransformer } from './features/json/JsonCreateValidateParseTransformer.mjs';
+import { JsonCreateValidateStringifyTransformer } from './features/json/JsonCreateValidateStringifyProgrammer.mjs';
+import { JsonIsParseTransformer } from './features/json/JsonIsParseTransformer.mjs';
+import { JsonIsStringifyTransformer } from './features/json/JsonIsStringifyTransformer.mjs';
+import { JsonSchemasTransformer } from './features/json/JsonSchemasTransformer.mjs';
+import { JsonStringifyTransformer } from './features/json/JsonStringifyTransformer.mjs';
+import { JsonValidateParseTransformer } from './features/json/JsonValidateParseTransformer.mjs';
+import { JsonValidateStringifyTransformer } from './features/json/JsonValidateStringifyTransformer.mjs';
+import { LlmApplicationTransformer } from './features/llm/LlmApplicationTransformer.mjs';
+import { LlmParametersTransformer } from './features/llm/LlmParametersTransformer.mjs';
+import { LlmSchemaTransformer } from './features/llm/LlmSchemaTransformer.mjs';
+import { MiscAssertCloneTransformer } from './features/misc/MiscAssertCloneTransformer.mjs';
+import { MiscAssertPruneTransformer } from './features/misc/MiscAssertPruneTransformer.mjs';
+import { MiscCloneTransformer } from './features/misc/MiscCloneTransformer.mjs';
+import { MiscCreateAssertCloneTransformer } from './features/misc/MiscCreateAssertCloneTransformer.mjs';
+import { MiscCreateAssertPruneTransformer } from './features/misc/MiscCreateAssertPruneTransformer.mjs';
+import { MiscCreateCloneTransformer } from './features/misc/MiscCreateCloneTransformer.mjs';
+import { MiscCreateIsCloneTransformer } from './features/misc/MiscCreateIsCloneTransformer.mjs';
+import { MiscCreateIsPruneTransformer } from './features/misc/MiscCreateIsPruneTransformer.mjs';
+import { MiscCreatePruneTransformer } from './features/misc/MiscCreatePruneTransformer.mjs';
+import { MiscCreateValidateCloneTransformer } from './features/misc/MiscCreateValidateCloneTransformer.mjs';
+import { MiscCreateValidatePruneTransformer } from './features/misc/MiscCreateValidatePruneTransformer.mjs';
+import { MiscIsCloneTransformer } from './features/misc/MiscIsCloneTransformer.mjs';
+import { MiscIsPruneTransformer } from './features/misc/MiscIsPruneTransformer.mjs';
+import { MiscLiteralsTransformer } from './features/misc/MiscLiteralsTransformer.mjs';
+import { MiscPruneTransformer } from './features/misc/MiscPruneTransformer.mjs';
+import { MiscValidateCloneTransformer } from './features/misc/MiscValidateCloneTransformer.mjs';
+import { MiscValidatePruneTransformer } from './features/misc/MiscValidatePruneTransformer.mjs';
+import { NotationAssertGeneralTransformer } from './features/notations/NotationAssertGeneralTransformer.mjs';
+import { NotationCreateAssertGeneralTransformer } from './features/notations/NotationCreateAssertGeneralTransformer.mjs';
+import { NotationCreateGeneralTransformer } from './features/notations/NotationCreateGeneralTransformer.mjs';
+import { NotationCreateIsGeneralTransformer } from './features/notations/NotationCreateIsGeneralTransformer.mjs';
+import { NotationCreateValidateGeneralTransformer } from './features/notations/NotationCreateValidateGeneralTransformer.mjs';
+import { NotationGeneralTransformer } from './features/notations/NotationGeneralTransformer.mjs';
+import { NotationIsGeneralTransformer } from './features/notations/NotationIsGeneralTransformer.mjs';
+import { NotationValidateGeneralTransformer } from './features/notations/NotationValidateGeneralTransformer.mjs';
+import { ProtobufAssertDecodeTransformer } from './features/protobuf/ProtobufAssertDecodeTransformer.mjs';
+import { ProtobufAssertEncodeTransformer } from './features/protobuf/ProtobufAssertEncodeTransformer.mjs';
+import { ProtobufCreateAssertDecodeTransformer } from './features/protobuf/ProtobufCreateAssertDecodeTransformer.mjs';
+import { ProtobufCreateAssertEncodeTransformer } from './features/protobuf/ProtobufCreateAssertEncodeTransformer.mjs';
+import { ProtobufCreateDecodeTransformer } from './features/protobuf/ProtobufCreateDecodeTransformer.mjs';
+import { ProtobufCreateEncodeTransformer } from './features/protobuf/ProtobufCreateEncodeTransformer.mjs';
+import { ProtobufCreateIsDecodeTransformer } from './features/protobuf/ProtobufCreateIsDecodeTransformer.mjs';
+import { ProtobufCreateIsEncodeTransformer } from './features/protobuf/ProtobufCreateIsEncodeTransformer.mjs';
+import { ProtobufCreateValidateDecodeTransformer } from './features/protobuf/ProtobufCreateValidateDecodeTransformer.mjs';
+import { ProtobufCreateValidateEncodeTransformer } from './features/protobuf/ProtobufCreateValidateEncodeTransformer.mjs';
+import { ProtobufDecodeTransformer } from './features/protobuf/ProtobufDecodeTransformer.mjs';
+import { ProtobufEncodeTransformer } from './features/protobuf/ProtobufEncodeTransformer.mjs';
+import { ProtobufIsDecodeTransformer } from './features/protobuf/ProtobufIsDecodeTransformer.mjs';
+import { ProtobufIsEncodeTransformer } from './features/protobuf/ProtobufIsEncodeTransformer.mjs';
+import { ProtobufMessageTransformer } from './features/protobuf/ProtobufMessageTransformer.mjs';
+import { ProtobufValidateDecodeTransformer } from './features/protobuf/ProtobufValidateDecodeTransformer.mjs';
+import { ProtobufValidateEncodeTransformer } from './features/protobuf/ProtobufValidateEncodeTransformer.mjs';
+import { ReflectMetadataTransformer } from './features/reflect/ReflectMetadataTransformer.mjs';
+import { ReflectNameTransformer } from './features/reflect/ReflectNameTransformer.mjs';
+
+var CallExpressionTransformer;
+(function (CallExpressionTransformer) {
+    CallExpressionTransformer.transform = (props) => {
+        //----
+        // VALIDATIONS
+        //----
+        // SIGNATURE DECLARATION
+        const declaration = props.context.checker.getResolvedSignature(props.expression)?.declaration;
+        if (!declaration)
+            return props.expression;
+        // FILE PATH
+        const location = path.resolve(declaration.getSourceFile().fileName);
+        if (isTarget(location) === false)
+            return props.expression;
+        //----
+        // TRANSFORMATION
+        //----
+        // FUNCTION NAME
+        const module = location.split(path.sep).at(-1).split(".")[0];
+        const { name } = props.context.checker.getTypeAtLocation(declaration).symbol;
+        // FIND TRANSFORMER
+        const functor = FUNCTORS[module]?.[name];
+        if (functor === undefined)
+            return props.expression;
+        // RETURNS WITH TRANSFORMATION
+        const result = functor()({
+            context: props.context,
+            modulo: props.expression.expression,
+            expression: props.expression,
+        });
+        return result ?? props.expression;
+    };
+    const isTarget = (location) => {
+        const files = Object.keys(FUNCTORS);
+        return files.some((f) => location.includes(path.join("typia", "lib", `${f}.d.ts`)));
+    };
+})(CallExpressionTransformer || (CallExpressionTransformer = {}));
+const FUNCTORS = {
+    module: {
+        // BASIC
+        assert: () => AssertTransformer.transform({ equals: false, guard: false }),
+        assertGuard: () => AssertTransformer.transform({ equals: false, guard: true }),
+        assertType: () => AssertTransformer.transform({ equals: false, guard: false }),
+        is: () => IsTransformer.transform({ equals: false }),
+        validate: () => ValidateTransformer.transform({ equals: false }),
+        // STRICT
+        assertEquals: () => AssertTransformer.transform({ equals: true, guard: false }),
+        assertGuardEquals: () => AssertTransformer.transform({ equals: true, guard: true }),
+        equals: () => IsTransformer.transform({ equals: true }),
+        validateEquals: () => ValidateTransformer.transform({ equals: true }),
+        // RANDOM + INTERNAL
+        random: () => RandomTransformer.transform,
+        metadata: () => ReflectMetadataTransformer.transform,
+        // FACTORIES
+        createAssert: () => CreateAssertTransformer.transform({ equals: false, guard: false }),
+        createAssertGuard: () => CreateAssertTransformer.transform({ equals: false, guard: true }),
+        createAssertType: () => CreateAssertTransformer.transform({ equals: false, guard: false }),
+        createIs: () => CreateIsTransformer.transform({ equals: false }),
+        createValidate: () => CreateValidateTransformer.transform({ equals: false }),
+        createAssertEquals: () => CreateAssertTransformer.transform({ equals: true, guard: false }),
+        createAssertGuardEquals: () => CreateAssertTransformer.transform({ equals: true, guard: true }),
+        createEquals: () => CreateIsTransformer.transform({ equals: true }),
+        createValidateEquals: () => CreateValidateTransformer.transform({ equals: true }),
+        createRandom: () => CreateRandomTransformer.transform,
+    },
+    functional: {
+        // ASSERTIONS
+        assertFunction: () => FunctionalGenericTransformer.transform({
+            method: "assertFunction",
+            config: {
+                equals: false,
+            },
+            programmer: FunctionalAssertFunctionProgrammer.write,
+        }),
+        assertParameters: () => FunctionalGenericTransformer.transform({
+            method: "assertParameters",
+            config: {
+                equals: false,
+            },
+            programmer: FunctionalAssertParametersProgrammer.write,
+        }),
+        assertReturn: () => FunctionalGenericTransformer.transform({
+            method: "assertReturn",
+            config: {
+                equals: false,
+            },
+            programmer: FunctionAssertReturnProgrammer.write,
+        }),
+        assertEqualsFunction: () => FunctionalGenericTransformer.transform({
+            method: "assertEqualsFunction",
+            config: {
+                equals: true,
+            },
+            programmer: FunctionalAssertFunctionProgrammer.write,
+        }),
+        assertEqualsParameters: () => FunctionalGenericTransformer.transform({
+            method: "assertEqualsParameters",
+            config: {
+                equals: true,
+            },
+            programmer: FunctionalAssertParametersProgrammer.write,
+        }),
+        assertEqualsReturn: () => FunctionalGenericTransformer.transform({
+            method: "assertEqualsReturn",
+            config: {
+                equals: true,
+            },
+            programmer: FunctionAssertReturnProgrammer.write,
+        }),
+        // IS
+        isFunction: () => FunctionalGenericTransformer.transform({
+            method: "isFunction",
+            config: {
+                equals: false,
+            },
+            programmer: FunctionalIsFunctionProgrammer.write,
+        }),
+        isParameters: () => FunctionalGenericTransformer.transform({
+            method: "isParameters",
+            config: {
+                equals: false,
+            },
+            programmer: FunctionalIsParametersProgrammer.write,
+        }),
+        isReturn: () => FunctionalGenericTransformer.transform({
+            method: "isReturn",
+            config: {
+                equals: false,
+            },
+            programmer: FunctionalIsReturnProgrammer.write,
+        }),
+        equalsFunction: () => FunctionalGenericTransformer.transform({
+            method: "equalsFunction",
+            config: {
+                equals: true,
+            },
+            programmer: FunctionalIsFunctionProgrammer.write,
+        }),
+        equalsParameters: () => FunctionalGenericTransformer.transform({
+            method: "equalsParameters",
+            config: {
+                equals: true,
+            },
+            programmer: FunctionalIsParametersProgrammer.write,
+        }),
+        equalsReturn: () => FunctionalGenericTransformer.transform({
+            method: "equalsReturn",
+            config: {
+                equals: true,
+            },
+            programmer: FunctionalIsReturnProgrammer.write,
+        }),
+        // VALIDATIONS
+        validateFunction: () => FunctionalGenericTransformer.transform({
+            method: "validateFunction",
+            config: {
+                equals: false,
+            },
+            programmer: FunctionalValidateFunctionProgrammer.write,
+        }),
+        validateParameters: () => FunctionalGenericTransformer.transform({
+            method: "validateParameters",
+            config: {
+                equals: false,
+            },
+            programmer: FunctionalValidateParametersProgrammer.write,
+        }),
+        validateReturn: () => FunctionalGenericTransformer.transform({
+            method: "validateReturn",
+            config: {
+                equals: false,
+            },
+            programmer: FunctionalValidateReturnProgrammer.write,
+        }),
+        validateEqualsFunction: () => FunctionalGenericTransformer.transform({
+            method: "validateEqualsFunction",
+            config: {
+                equals: true,
+            },
+            programmer: FunctionalValidateFunctionProgrammer.write,
+        }),
+        validateEqualsParameters: () => FunctionalGenericTransformer.transform({
+            method: "validateEqualsParameters",
+            config: {
+                equals: true,
+            },
+            programmer: FunctionalValidateParametersProgrammer.write,
+        }),
+        validateEqualsReturn: () => FunctionalGenericTransformer.transform({
+            method: "validateEqualsReturn",
+            config: {
+                equals: true,
+            },
+            programmer: FunctionalValidateReturnProgrammer.write,
+        }),
+    },
+    http: {
+        // FORM-DATA
+        formData: () => HttpFormDataTransformer.transform,
+        isFormData: () => HttpIsFormDataTransformer.transform,
+        assertFormData: () => HttpAssertFormDataTransformer.transform,
+        validateFormData: () => HttpValidateFormDataTransformer.transform,
+        // HEADERS
+        headers: () => HttpHeadersTransformer.transform,
+        isHeaders: () => HttpIsHeadersTransformer.transform,
+        assertHeaders: () => HttpAssertHeadersTransformer.transform,
+        validateHeaders: () => HttpValidateHeadersTransformer.transform,
+        // PARAMETER
+        parameter: () => HttpParameterTransformer.transform,
+        // QUERY
+        query: () => HttpQueryTransformer.transform,
+        isQuery: () => HttpIsQueryTransformer.transform,
+        assertQuery: () => HttpAssertQueryTransformer.transform,
+        validateQuery: () => HttpValidateQueryTransformer.transform,
+        // FACTORIES
+        createFormData: () => CreateHttpFormDataTransformer.transform,
+        createIsFormData: () => CreateHttpIsFormDataTransformer.transform,
+        createAssertFormData: () => CreateHttpAssertFormDataTransformer.transform,
+        createValidateFormData: () => CreateHttpValidateFormDataTransformer.transform,
+        createHeaders: () => CreateHttpHeadersTransformer.transform,
+        createIsHeaders: () => CreateHttpIsHeadersTransformer.transform,
+        createAssertHeaders: () => CreateHttpAssertHeadersTransformer.transform,
+        createValidateHeaders: () => CreateHttpValidateHeadersTransformer.transform,
+        createParameter: () => CreateHttpParameterTransformer.transform,
+        createQuery: () => CreateHttpQueryTransformer.transform,
+        createIsQuery: () => CreateHttpIsQueryTransformer.transform,
+        createAssertQuery: () => CreateHttpAssertQueryTransformer.transform,
+        createValidateQuery: () => CreateHttpValidateQueryTransformer.transform,
+    },
+    llm: {
+        applicationOfValidate: () => LlmApplicationTransformer.transform,
+        application: () => LlmApplicationTransformer.transform,
+        parameters: () => LlmParametersTransformer.transform,
+        schema: () => LlmSchemaTransformer.transform,
+    },
+    json: {
+        // METADATA
+        // application: () => JsonApplicationTransformer.transform,
+        application: () => JsonSchemasTransformer.transform,
+        schemas: () => JsonSchemasTransformer.transform,
+        // PARSER
+        isParse: () => JsonIsParseTransformer.transform,
+        assertParse: () => JsonAssertParseTransformer.transform,
+        validateParse: () => JsonValidateParseTransformer.transform,
+        // STRINGIFY
+        stringify: () => JsonStringifyTransformer.transform,
+        assertStringify: () => JsonAssertStringifyTransformer.transform,
+        isStringify: () => JsonIsStringifyTransformer.transform,
+        validateStringify: () => JsonValidateStringifyTransformer.transform,
+        // FACTORIES
+        createIsParse: () => JsonCreateIsParseTransformer.transform,
+        createAssertParse: () => JsonCreateAssertParseTransformer.transform,
+        createValidateParse: () => JsonCreateValidateParseTransformer.transform,
+        createStringify: () => JsonCreateStringifyTransformer.transform,
+        createAssertStringify: () => JsonCreateAssertStringifyTransformer.transform,
+        createIsStringify: () => JsonCreateIsStringifyTransformer.transform,
+        createValidateStringify: () => JsonCreateValidateStringifyTransformer.transform,
+    },
+    protobuf: {
+        // SCHEMA
+        message: () => ProtobufMessageTransformer.transform,
+        // ENCODE
+        encode: () => ProtobufEncodeTransformer.transform,
+        assertEncode: () => ProtobufAssertEncodeTransformer.transform,
+        isEncode: () => ProtobufIsEncodeTransformer.transform,
+        validateEncode: () => ProtobufValidateEncodeTransformer.transform,
+        // DECODE
+        decode: () => ProtobufDecodeTransformer.transform,
+        assertDecode: () => ProtobufAssertDecodeTransformer.transform,
+        isDecode: () => ProtobufIsDecodeTransformer.transform,
+        validateDecode: () => ProtobufValidateDecodeTransformer.transform,
+        // FACTORIES
+        createEncode: () => ProtobufCreateEncodeTransformer.transform,
+        createAssertEncode: () => ProtobufCreateAssertEncodeTransformer.transform,
+        createIsEncode: () => ProtobufCreateIsEncodeTransformer.transform,
+        createValidateEncode: () => ProtobufCreateValidateEncodeTransformer.transform,
+        createDecode: () => ProtobufCreateDecodeTransformer.transform,
+        createAssertDecode: () => ProtobufCreateAssertDecodeTransformer.transform,
+        createIsDecode: () => ProtobufCreateIsDecodeTransformer.transform,
+        createValidateDecode: () => ProtobufCreateValidateDecodeTransformer.transform,
+    },
+    reflect: {
+        metadata: () => ReflectMetadataTransformer.transform,
+        name: () => ReflectNameTransformer.transform,
+    },
+    misc: {
+        literals: () => MiscLiteralsTransformer.transform,
+        // CLONE
+        clone: () => MiscCloneTransformer.transform,
+        assertClone: () => MiscAssertCloneTransformer.transform,
+        isClone: () => MiscIsCloneTransformer.transform,
+        validateClone: () => MiscValidateCloneTransformer.transform,
+        // PRUNE
+        prune: () => MiscPruneTransformer.transform,
+        assertPrune: () => MiscAssertPruneTransformer.transform,
+        isPrune: () => MiscIsPruneTransformer.transform,
+        validatePrune: () => MiscValidatePruneTransformer.transform,
+        // FACTORIES
+        createClone: () => MiscCreateCloneTransformer.transform,
+        createAssertClone: () => MiscCreateAssertCloneTransformer.transform,
+        createIsClone: () => MiscCreateIsCloneTransformer.transform,
+        createValidateClone: () => MiscCreateValidateCloneTransformer.transform,
+        createPrune: () => MiscCreatePruneTransformer.transform,
+        createAssertPrune: () => MiscCreateAssertPruneTransformer.transform,
+        createIsPrune: () => MiscCreateIsPruneTransformer.transform,
+        createValidatePrune: () => MiscCreateValidatePruneTransformer.transform,
+    },
+    notations: {
+        // CAMEL
+        camel: () => NotationGeneralTransformer.transform(NamingConvention.camel),
+        assertCamel: () => NotationAssertGeneralTransformer.transform(NamingConvention.camel),
+        isCamel: () => NotationIsGeneralTransformer.transform(NamingConvention.camel),
+        validateCamel: () => NotationValidateGeneralTransformer.transform(NamingConvention.camel),
+        // PASCAL
+        pascal: () => NotationGeneralTransformer.transform(NamingConvention.pascal),
+        assertPascal: () => NotationAssertGeneralTransformer.transform(NamingConvention.pascal),
+        isPascal: () => NotationIsGeneralTransformer.transform(NamingConvention.pascal),
+        validatePascal: () => NotationValidateGeneralTransformer.transform(NamingConvention.pascal),
+        // SNAKE
+        snake: () => NotationGeneralTransformer.transform(NamingConvention.snake),
+        assertSnake: () => NotationAssertGeneralTransformer.transform(NamingConvention.snake),
+        isSnake: () => NotationIsGeneralTransformer.transform(NamingConvention.snake),
+        validateSnake: () => NotationValidateGeneralTransformer.transform(NamingConvention.snake),
+        // FACTORIES
+        createCamel: () => NotationCreateGeneralTransformer.transform(NamingConvention.camel),
+        createAssertCamel: () => NotationCreateAssertGeneralTransformer.transform(NamingConvention.camel),
+        createIsCamel: () => NotationCreateIsGeneralTransformer.transform(NamingConvention.camel),
+        createValidateCamel: () => NotationCreateValidateGeneralTransformer.transform(NamingConvention.camel),
+        createPascal: () => NotationCreateGeneralTransformer.transform(NamingConvention.pascal),
+        createAssertPascal: () => NotationCreateAssertGeneralTransformer.transform(NamingConvention.pascal),
+        createIsPascal: () => NotationCreateIsGeneralTransformer.transform(NamingConvention.pascal),
+        createValidatePascal: () => NotationCreateValidateGeneralTransformer.transform(NamingConvention.pascal),
+        createSnake: () => NotationCreateGeneralTransformer.transform(NamingConvention.snake),
+        createAssertSnake: () => NotationCreateAssertGeneralTransformer.transform(NamingConvention.snake),
+        createIsSnake: () => NotationCreateIsGeneralTransformer.transform(NamingConvention.snake),
+        createValidateSnake: () => NotationCreateValidateGeneralTransformer.transform(NamingConvention.snake),
+    },
+};
+
+export { CallExpressionTransformer };
+//# sourceMappingURL=CallExpressionTransformer.mjs.map

package/lib/transformers/CallExpressionTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallExpressionTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/FileTransformer.mjs

@@ -0,0 +1,93 @@
+import ts from 'typescript';
+import { ImportProgrammer } from '../programmers/ImportProgrammer.mjs';
+import { Singleton } from '../utils/Singleton.mjs';
+import { NodeTransformer } from './NodeTransformer.mjs';
+
+var FileTransformer;
+(function (FileTransformer) {
+    FileTransformer.transform = (environments) => (transformer) => (file) => {
+        if (file.isDeclarationFile)
+            return file;
+        const importer = new ImportProgrammer({
+            internalPrefix: "typia_transform_",
+        });
+        const context = {
+            ...environments,
+            transformer,
+            importer,
+        };
+        checkJsDocParsingMode.get(context, file);
+        file = ts.visitEachChild(file, (node) => iterate_node({
+            context,
+            node,
+        }), transformer);
+        const index = find_import_injection_index(file);
+        return ts.factory.updateSourceFile(file, [
+            ...file.statements.slice(0, index),
+            ...importer.toStatements(),
+            ...file.statements.slice(index),
+        ], false, file.referencedFiles, file.typeReferenceDirectives, file.hasNoDefaultLib, file.libReferenceDirectives);
+    };
+    const iterate_node = (props) => ts.visitEachChild(try_transform_node(props) ?? props.node, (node) => iterate_node({
+        context: props.context,
+        node,
+    }), props.context.transformer);
+    const try_transform_node = (props) => {
+        try {
+            return NodeTransformer.transform(props);
+        }
+        catch (exp) {
+            // ONLY ACCEPT TRANSFORMER-ERROR
+            if (!isTransformerError(exp))
+                throw exp;
+            // REPORT DIAGNOSTIC
+            const diagnostic = ts.createDiagnosticForNode(props.node, {
+                key: exp.code,
+                category: ts.DiagnosticCategory.Error,
+                message: exp.message,
+                code: `(${exp.code})`,
+            });
+            props.context.extras.addDiagnostic(diagnostic);
+            return null;
+        }
+    };
+    const find_import_injection_index = (file) => {
+        let i = 0;
+        for (; i < file.statements.length; ++i) {
+            const stmt = file.statements[i];
+            if (ts.isExpressionStatement(stmt) &&
+                ts.isStringLiteralLike(stmt.expression) &&
+                stmt.expression.text.startsWith("use "))
+                continue;
+            break;
+        }
+        return i;
+    };
+})(FileTransformer || (FileTransformer = {}));
+const isTransformerError = (error) => typeof error === "object" &&
+    error !== null &&
+    error.constructor.name === "TransformerError" &&
+    typeof error.code === "string" &&
+    typeof error.message === "string";
+const checkJsDocParsingMode = new Singleton((context, file) => {
+    if (typeof file.jsDocParsingMode === "number" &&
+        file.jsDocParsingMode !== 0) {
+        context.extras.addDiagnostic(ts.createDiagnosticForNode(file, {
+            code: `(typia setup)`,
+            key: "jsDocParsingMode",
+            category: ts.DiagnosticCategory.Warning,
+            message: [
+                `Run "npx typia setup" or "npx typia patch" command again.`,
+                ``,
+                `Since TypeScript v5.3 update, "tsc" no more parses JSDoc comments. Therefore, "typia" also cannot utilize those JSDoc comments too, and it damages on some features of "typia" like "comment tags" or "JSON schema" generator.`,
+                ``,
+                `To solve this problem, run "npx typia setup" or "npx typia patch" command to hack the TypeScript compiler to revive the JSDoc parsing feature.`,
+                ``,
+                `  - reference: https://github.com/microsoft/TypeScript/pull/55739`,
+            ].join("\n"),
+        }));
+    }
+});
+
+export { FileTransformer };
+//# sourceMappingURL=FileTransformer.mjs.map

package/lib/transformers/FileTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/IProgrammerProps.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=IProgrammerProps.mjs.map

package/lib/transformers/IProgrammerProps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IProgrammerProps.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/ITransformOptions.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=ITransformOptions.mjs.map

package/lib/transformers/ITransformOptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITransformOptions.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/ITransformProps.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=ITransformProps.mjs.map

package/lib/transformers/ITransformProps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITransformProps.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/ITypiaContext.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=ITypiaContext.mjs.map

package/lib/transformers/ITypiaContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ITypiaContext.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/ImportTransformer.mjs

@@ -0,0 +1,51 @@
+import path from 'path';
+import ts from 'typescript';
+
+var ImportTransformer;
+(function (ImportTransformer) {
+    ImportTransformer.transform = (props) => (context) => (file) => transform_file({
+        top: props.from,
+        to: props.to,
+        context,
+        file,
+    });
+    const transform_file = (props) => {
+        if (props.file.isDeclarationFile)
+            return props.file;
+        const from = get_directory_path(path.resolve(props.file.getSourceFile().fileName));
+        const to = from.replace(props.top, props.to);
+        return ts.visitEachChild(props.file, (node) => transform_node({
+            top: props.top,
+            from,
+            to,
+            node,
+        }), props.context);
+    };
+    const transform_node = (props) => {
+        if (!ts.isImportDeclaration(props.node) ||
+            !ts.isStringLiteral(props.node.moduleSpecifier))
+            return props.node;
+        const text = props.node.moduleSpecifier.text;
+        if (text[0] !== ".")
+            return props.node;
+        const location = path.resolve(props.from, text);
+        if (location.indexOf(props.top) === 0)
+            return props.node;
+        const replaced = (() => {
+            const simple = path
+                .relative(props.to, location)
+                .split(path.sep)
+                .join("/");
+            return simple[0] === "." ? simple : `./${simple}`;
+        })();
+        return ts.factory.createImportDeclaration(undefined, props.node.importClause, ts.factory.createStringLiteral(replaced), props.node.assertClause);
+    };
+})(ImportTransformer || (ImportTransformer = {}));
+const get_directory_path = (file) => {
+    const split = path.resolve(file).split(path.sep);
+    split.pop();
+    return path.resolve(split.join(path.sep));
+};
+
+export { ImportTransformer };
+//# sourceMappingURL=ImportTransformer.mjs.map

package/lib/transformers/ImportTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportTransformer.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/transformers/NodeTransformer.mjs

@@ -0,0 +1,15 @@
+import ts from 'typescript';
+import { CallExpressionTransformer } from './CallExpressionTransformer.mjs';
+
+var NodeTransformer;
+(function (NodeTransformer) {
+    NodeTransformer.transform = (props) => ts.isCallExpression(props.node) && props.node.parent
+        ? CallExpressionTransformer.transform({
+            context: props.context,
+            expression: props.node,
+        })
+        : props.node;
+})(NodeTransformer || (NodeTransformer = {}));
+
+export { NodeTransformer };
+//# sourceMappingURL=NodeTransformer.mjs.map