typia 8.0.0 → 8.0.2-dev.20250314

package/lib/tags/internal/FormatCheatSheet.mjs

@@ -0,0 +1,35 @@
+const RegexCall = (text) => `${text}.test($input)`;
+/**
+ * @reference https://github.dev/ajv-validator/ajv-formats/blob/master/src/formats.ts
+ */
+const FormatCheatSheet = {
+    // SPECIAL CHARACTERS
+    byte: RegexCall(`/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm`),
+    password: `true`,
+    regex: `(() => { try { new RegExp($input); return true; } catch { return false; } })()`,
+    uuid: RegexCall(`/^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i`),
+    // ADDRESSES
+    email: RegexCall(`/^[a-z0-9!#$%&'*+/=?^_\`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_\`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i`),
+    hostname: RegexCall(`/^(?=.{1,253}\\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\\.?$/i`),
+    "idn-email": RegexCall(`/^(([^<>()[\\]\\.,;:\\s@\\"]+(\\.[^<>()[\\]\\.,;:\\s@\\"]+)*)|(\\".+\\"))@(([^<>()[\\]\\.,;:\\s@\\"]+\\.)+[^<>()[\\]\\.,;:\\s@\\"]{2,})$/i`),
+    "idn-hostname": RegexCall(`/^([a-z0-9\\u00a1-\\uffff0-9]+(-[a-z0-9\\u00a1-\\uffff0-9]+)*\\.)+[a-z\\u00a1-\\uffff]{2,}$/i`),
+    iri: RegexCall(`/^[A-Za-z][\\d+-.A-Za-z]*:[^\\u0000-\\u0020"<>\\\\^\`{|}]*$/u`),
+    "iri-reference": RegexCall(`/^[A-Za-z][\\d+-.A-Za-z]*:[^\\u0000-\\u0020"<>\\\\^\`{|}]*$/u`),
+    ipv4: RegexCall(`/^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)$/`),
+    ipv6: RegexCall(`/^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i`),
+    uri: `${RegexCall(`/\\/|:/`)} && ${RegexCall(`/^(?:[a-z][a-z0-9+\\-.]*:)(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\\?(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i`)}`,
+    "uri-reference": RegexCall(`/^(?:[a-z][a-z0-9+\\-.]*:)?(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\\?(?:[a-z0-9\\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i`),
+    "uri-template": RegexCall(`/^(?:(?:[^\\x00-\\x20"'<>%\\\\^\`{|}]|%[0-9a-f]{2})|\\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?)*\\})*$/i`),
+    url: RegexCall(`/^(?:https?|ftp):\\/\\/(?:\\S+(?::\\S*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z0-9\\u{00a1}-\\u{ffff}]+-)*[a-z0-9\\u{00a1}-\\u{ffff}]+)(?:\\.(?:[a-z0-9\\u{00a1}-\\u{ffff}]+-)*[a-z0-9\\u{00a1}-\\u{ffff}]+)*(?:\\.(?:[a-z\\u{00a1}-\\u{ffff}]{2,})))(?::\\d{2,5})?(?:\\/[^\\s]*)?$/iu`),
+    // TIMESTAMPS
+    "date-time": RegexCall(`/^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])(T|\\s)([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]{1,9})?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9])$/i`),
+    date: RegexCall(`/^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/`),
+    time: RegexCall(`/^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]{1,9})?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9])$/i`),
+    duration: RegexCall(`/^P(?!$)((\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+S)?)?|(\\d+W)?)$/`),
+    // POINTERS
+    "json-pointer": RegexCall(`/^(?:\\/(?:[^~/]|~0|~1)*)*$/`),
+    "relative-json-pointer": RegexCall(`/^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~/]|~0|~1)*)*)$/`),
+};
+
+export { FormatCheatSheet };
+//# sourceMappingURL=FormatCheatSheet.mjs.map

package/lib/tags/internal/FormatCheatSheet.mjs.map

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

package/lib/transform.mjs

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+import { FileTransformer } from './transformers/FileTransformer.mjs';
+
+const transform = (program, options, extras) => {
+    const compilerOptions = program.getCompilerOptions();
+    const strict = compilerOptions.strictNullChecks !== undefined
+        ? !!compilerOptions.strictNullChecks
+        : !!compilerOptions.strict;
+    if (strict === false)
+        extras.addDiagnostic({
+            category: ts.DiagnosticCategory.Error,
+            code: "(typia)",
+            file: undefined,
+            start: undefined,
+            length: undefined,
+            messageText: "strict mode is required.",
+        });
+    return FileTransformer.transform({
+        program,
+        compilerOptions,
+        checker: program.getTypeChecker(),
+        printer: ts.createPrinter(),
+        options: options ?? {},
+        extras,
+    });
+};
+
+export { transform as default, transform };
+//# sourceMappingURL=transform.mjs.map

package/lib/transform.mjs.map

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

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":""}