typia 8.0.0 → 8.0.1

package/lib/programmers/functional/FunctionalIsParametersProgrammer.mjs

@@ -0,0 +1,51 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { IsProgrammer } from '../IsProgrammer.mjs';
+import { FunctionalIsFunctionProgrammer } from './FunctionalIsFunctionProgrammer.mjs';
+import { FunctionalGeneralProgrammer } from './internal/FunctionalGeneralProgrammer.mjs';
+
+var FunctionalIsParametersProgrammer;
+(function (FunctionalIsParametersProgrammer) {
+    FunctionalIsParametersProgrammer.write = (props) => {
+        const { async } = FunctionalGeneralProgrammer.getReturnType({
+            checker: props.context.checker,
+            declaration: props.declaration,
+        });
+        const result = FunctionalIsParametersProgrammer.decompose(props);
+        return ExpressionFactory.selfCall(ts.factory.createBlock([
+            ...result.functions,
+            ts.factory.createReturnStatement(ts.factory.createArrowFunction(async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined, undefined, props.declaration.parameters, FunctionalIsFunctionProgrammer.getReturnTypeNode({
+                declaration: props.declaration,
+                async,
+            }), undefined, ts.factory.createBlock([
+                ...result.statements,
+                ts.factory.createReturnStatement(ts.factory.createCallExpression(props.expression, undefined, props.declaration.parameters.map((p) => ts.factory.createIdentifier(p.name.getText())))),
+            ], true))),
+        ], true));
+    };
+    FunctionalIsParametersProgrammer.decompose = (props) => ({
+        functions: props.declaration.parameters.map((p, i) => StatementFactory.constant({
+            name: `__is_param_${i}`,
+            value: IsProgrammer.write({
+                context: props.context,
+                modulo: props.modulo,
+                config: props.config,
+                type: props.context.checker.getTypeFromTypeNode(p.type ?? TypeFactory.keyword("any")),
+                init: undefined,
+                name: undefined,
+            }),
+        })),
+        statements: props.declaration.parameters
+            .map((p, i) => [
+            ts.factory.createIfStatement(ts.factory.createStrictEquality(ts.factory.createFalse(), ts.factory.createCallExpression(ts.factory.createIdentifier(`__is_param_${i}`), undefined, [ts.factory.createIdentifier(p.name.getText())])), ts.factory.createReturnStatement(ts.factory.createNull())),
+        ])
+            .flat(),
+    });
+})(FunctionalIsParametersProgrammer || (FunctionalIsParametersProgrammer = {}));
+
+export { FunctionalIsParametersProgrammer };
+//# sourceMappingURL=FunctionalIsParametersProgrammer.mjs.map

package/lib/programmers/functional/FunctionalIsParametersProgrammer.mjs.map

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

package/lib/programmers/functional/FunctionalIsReturnProgrammer.mjs

@@ -0,0 +1,58 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { StringUtil } from '../../utils/StringUtil.mjs';
+import { IsProgrammer } from '../IsProgrammer.mjs';
+import { FunctionalIsFunctionProgrammer } from './FunctionalIsFunctionProgrammer.mjs';
+import { FunctionalGeneralProgrammer } from './internal/FunctionalGeneralProgrammer.mjs';
+
+var FunctionalIsReturnProgrammer;
+(function (FunctionalIsReturnProgrammer) {
+    FunctionalIsReturnProgrammer.write = (props) => {
+        const result = FunctionalIsReturnProgrammer.decompose(props);
+        return ExpressionFactory.selfCall(ts.factory.createBlock([
+            ...result.functions,
+            ts.factory.createReturnStatement(ts.factory.createArrowFunction(result.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined, undefined, props.declaration.parameters, FunctionalIsFunctionProgrammer.getReturnTypeNode({
+                declaration: props.declaration,
+                async: result.async,
+            }), undefined, ts.factory.createBlock(result.statements, true))),
+        ], true));
+    };
+    FunctionalIsReturnProgrammer.decompose = (props) => {
+        const { type, async } = FunctionalGeneralProgrammer.getReturnType({
+            checker: props.context.checker,
+            declaration: props.declaration,
+        });
+        const caller = ts.factory.createCallExpression(props.expression, undefined, props.declaration.parameters.map((p) => ts.factory.createIdentifier(p.name.getText())));
+        const name = StringUtil.escapeDuplicate({
+            keep: props.declaration.parameters.map((p) => p.name.getText()),
+            input: "result",
+        });
+        return {
+            async,
+            functions: [
+                StatementFactory.constant({
+                    name: "__is_return",
+                    value: IsProgrammer.write({
+                        ...props,
+                        type,
+                        name: undefined,
+                        init: undefined,
+                    }),
+                }),
+            ],
+            statements: [
+                StatementFactory.constant({
+                    name,
+                    value: async ? ts.factory.createAwaitExpression(caller) : caller,
+                }),
+                ts.factory.createReturnStatement(ts.factory.createConditionalExpression(ts.factory.createCallExpression(ts.factory.createIdentifier("__is_return"), undefined, [ts.factory.createIdentifier(name)]), undefined, ts.factory.createIdentifier(name), undefined, ts.factory.createNull())),
+            ],
+        };
+    };
+})(FunctionalIsReturnProgrammer || (FunctionalIsReturnProgrammer = {}));
+
+export { FunctionalIsReturnProgrammer };
+//# sourceMappingURL=FunctionalIsReturnProgrammer.mjs.map

package/lib/programmers/functional/FunctionalIsReturnProgrammer.mjs.map

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

package/lib/programmers/functional/FunctionalValidateFunctionProgrammer.mjs

@@ -0,0 +1,53 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { FunctionalValidateParametersProgrammer } from './FunctionalValidateParametersProgrammer.mjs';
+import { FunctionalValidateReturnProgrammer } from './FunctionalValidateReturnProgrammer.mjs';
+
+var FunctionalValidateFunctionProgrammer;
+(function (FunctionalValidateFunctionProgrammer) {
+    FunctionalValidateFunctionProgrammer.write = (props) => {
+        const p = FunctionalValidateParametersProgrammer.decompose(props);
+        const r = FunctionalValidateReturnProgrammer.decompose(props);
+        return ExpressionFactory.selfCall(ts.factory.createBlock([
+            ...p.functions,
+            ...r.functions,
+            ts.factory.createReturnStatement(ts.factory.createArrowFunction(r.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined, undefined, props.declaration.parameters, FunctionalValidateFunctionProgrammer.getReturnTypeNode({
+                context: props.context,
+                declaration: props.declaration,
+                async: r.async,
+            }), undefined, ts.factory.createBlock([...p.statements, ...r.statements], true))),
+        ], true));
+    };
+    FunctionalValidateFunctionProgrammer.hookErrors = (props) => ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(props.expression, "map"), undefined, [
+        ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("error")], undefined, undefined, ts.factory.createObjectLiteralExpression([
+            ts.factory.createSpreadAssignment(ts.factory.createIdentifier("error")),
+            ts.factory.createPropertyAssignment("path", ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("error"), "path"), "replace"), undefined, [ts.factory.createStringLiteral("$input"), props.replacer])),
+        ], true)),
+    ]);
+    FunctionalValidateFunctionProgrammer.getReturnTypeNode = (props) => props.declaration.type
+        ? props.async
+            ? !!props.declaration.type.typeArguments?.[0]
+                ? ts.factory.createTypeReferenceNode("Promise", [
+                    props.context.importer.type({
+                        file: "typia",
+                        name: "IValidation",
+                        arguments: [
+                            props.declaration.type
+                                .typeArguments[0],
+                        ],
+                    }),
+                ])
+                : undefined
+            : props.context.importer.type({
+                file: "typia",
+                name: "IValidation",
+                arguments: [props.declaration.type],
+            })
+        : undefined;
+})(FunctionalValidateFunctionProgrammer || (FunctionalValidateFunctionProgrammer = {}));
+
+export { FunctionalValidateFunctionProgrammer };
+//# sourceMappingURL=FunctionalValidateFunctionProgrammer.mjs.map

package/lib/programmers/functional/FunctionalValidateFunctionProgrammer.mjs.map

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

package/lib/programmers/functional/FunctionalValidateParametersProgrammer.mjs

@@ -0,0 +1,92 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { StringUtil } from '../../utils/StringUtil.mjs';
+import { ValidateProgrammer } from '../ValidateProgrammer.mjs';
+import { FunctionalValidateFunctionProgrammer } from './FunctionalValidateFunctionProgrammer.mjs';
+import { FunctionalGeneralProgrammer } from './internal/FunctionalGeneralProgrammer.mjs';
+
+var FunctionalValidateParametersProgrammer;
+(function (FunctionalValidateParametersProgrammer) {
+    FunctionalValidateParametersProgrammer.write = (props) => {
+        const { async } = FunctionalGeneralProgrammer.getReturnType({
+            checker: props.context.checker,
+            declaration: props.declaration,
+        });
+        const result = FunctionalValidateParametersProgrammer.decompose(props);
+        const caller = ts.factory.createCallExpression(props.expression, undefined, props.declaration.parameters.map((p) => ts.factory.createIdentifier(p.name.getText())));
+        return ExpressionFactory.selfCall(ts.factory.createBlock([
+            ...result.functions,
+            ts.factory.createReturnStatement(ts.factory.createArrowFunction(async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined, undefined, props.declaration.parameters, FunctionalValidateFunctionProgrammer.getReturnTypeNode({
+                context: props.context,
+                declaration: props.declaration,
+                async,
+            }), undefined, ts.factory.createBlock([
+                ...result.statements,
+                ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression([
+                    ts.factory.createPropertyAssignment("success", ts.factory.createTrue()),
+                    ts.factory.createPropertyAssignment("data", async
+                        ? ts.factory.createAwaitExpression(caller)
+                        : caller),
+                    ts.factory.createPropertyAssignment("errors", ts.factory.createArrayLiteralExpression([])),
+                ], true)),
+            ], true))),
+        ], true));
+    };
+    FunctionalValidateParametersProgrammer.decompose = (props) => {
+        const resultName = StringUtil.escapeDuplicate({
+            keep: props.declaration.parameters.map((p) => p.name.getText()),
+            input: "paramErrorResults",
+        });
+        const validationResultArray = ts.factory.createArrayLiteralExpression(props.declaration.parameters.map((p, i) => ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createIdentifier(`__validate_param_${i}`), undefined, [ts.factory.createIdentifier(p.name.getText())]), props.context.importer.type({
+            file: "typia",
+            name: "IValidation.IFailure",
+        }))), true);
+        const errorMatrix = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(validationResultArray, "map"), undefined, [
+            ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("r"), IdentifierFactory.parameter("i")], undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createStrictEquality(ts.factory.createTrue(), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("r"), "success")), undefined, ts.factory.createIdentifier("r"), undefined, ts.factory.createObjectLiteralExpression([
+                ts.factory.createSpreadAssignment(ts.factory.createIdentifier("r")),
+                ts.factory.createPropertyAssignment("errors", FunctionalValidateFunctionProgrammer.hookErrors({
+                    expression: ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("r"), "errors"),
+                    replacer: ts.factory.createTemplateExpression(ts.factory.createTemplateHead("$input.parameters["), [
+                        ts.factory.createTemplateSpan(ts.factory.createIdentifier("i"), ts.factory.createTemplateTail("]")),
+                    ]),
+                })),
+            ], true))),
+        ]);
+        const failures = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(errorMatrix, "filter"), undefined, [
+            ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("r")], undefined, undefined, ts.factory.createStrictEquality(ts.factory.createFalse(), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("r"), "success"))),
+        ]);
+        return {
+            functions: props.declaration.parameters.map((p, i) => StatementFactory.constant({
+                name: `__validate_param_${i}`,
+                value: ValidateProgrammer.write({
+                    ...props,
+                    type: props.context.checker.getTypeFromTypeNode(p.type ?? TypeFactory.keyword("any")),
+                    name: undefined,
+                    init: undefined,
+                }),
+            })),
+            statements: [
+                StatementFactory.constant({
+                    name: resultName,
+                    value: failures,
+                }),
+                ts.factory.createIfStatement(ts.factory.createStrictInequality(ts.factory.createNumericLiteral("0"), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(resultName), "length")), ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression([
+                    ts.factory.createPropertyAssignment("success", ts.factory.createFalse()),
+                    ts.factory.createPropertyAssignment("errors", ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createIdentifier(resultName), "map"), undefined, [
+                        ts.factory.createArrowFunction(undefined, undefined, [
+                            IdentifierFactory.parameter("r", TypeFactory.keyword("any")),
+                        ], undefined, undefined, IdentifierFactory.access(ts.factory.createIdentifier("r"), "errors")),
+                    ]), "flat"), undefined, undefined)),
+                ], true))),
+            ],
+        };
+    };
+})(FunctionalValidateParametersProgrammer || (FunctionalValidateParametersProgrammer = {}));
+
+export { FunctionalValidateParametersProgrammer };
+//# sourceMappingURL=FunctionalValidateParametersProgrammer.mjs.map

package/lib/programmers/functional/FunctionalValidateParametersProgrammer.mjs.map

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

package/lib/programmers/functional/FunctionalValidateReturnProgrammer.mjs

@@ -0,0 +1,63 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { StringUtil } from '../../utils/StringUtil.mjs';
+import { ValidateProgrammer } from '../ValidateProgrammer.mjs';
+import { FunctionalValidateFunctionProgrammer } from './FunctionalValidateFunctionProgrammer.mjs';
+import { FunctionalGeneralProgrammer } from './internal/FunctionalGeneralProgrammer.mjs';
+
+var FunctionalValidateReturnProgrammer;
+(function (FunctionalValidateReturnProgrammer) {
+    FunctionalValidateReturnProgrammer.write = (props) => {
+        const result = FunctionalValidateReturnProgrammer.decompose(props);
+        return ExpressionFactory.selfCall(ts.factory.createBlock([
+            ...result.functions,
+            ts.factory.createReturnStatement(ts.factory.createArrowFunction(result.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined, undefined, props.declaration.parameters, FunctionalValidateFunctionProgrammer.getReturnTypeNode({
+                context: props.context,
+                declaration: props.declaration,
+                async: result.async,
+            }), undefined, ts.factory.createBlock(result.statements, true))),
+        ], true));
+    };
+    FunctionalValidateReturnProgrammer.decompose = (props) => {
+        const { type, async } = FunctionalGeneralProgrammer.getReturnType({
+            checker: props.context.checker,
+            declaration: props.declaration,
+        });
+        const caller = ts.factory.createCallExpression(props.expression, undefined, props.declaration.parameters.map((p) => ts.factory.createIdentifier(p.name.getText())));
+        const name = StringUtil.escapeDuplicate({
+            keep: props.declaration.parameters.map((p) => p.name.getText()),
+            input: "result",
+        });
+        return {
+            async,
+            functions: [
+                StatementFactory.constant({
+                    name: "__validate_return",
+                    value: ValidateProgrammer.write({
+                        ...props,
+                        type,
+                        name: undefined,
+                        init: undefined,
+                    }),
+                }),
+            ],
+            statements: [
+                StatementFactory.constant({
+                    name,
+                    value: ts.factory.createCallExpression(ts.factory.createIdentifier("__validate_return"), undefined, [async ? ts.factory.createAwaitExpression(caller) : caller]),
+                }),
+                ts.factory.createIfStatement(ts.factory.createStrictEquality(ts.factory.createFalse(), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(name), ts.factory.createIdentifier("success"))), ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(name), ts.factory.createIdentifier("errors")), ts.factory.createToken(ts.SyntaxKind.EqualsToken), FunctionalValidateFunctionProgrammer.hookErrors({
+                    expression: ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(name), ts.factory.createIdentifier("errors")),
+                    replacer: ts.factory.createStringLiteral("$input.return"),
+                })))),
+                ts.factory.createReturnStatement(ts.factory.createIdentifier("result")),
+            ],
+        };
+    };
+})(FunctionalValidateReturnProgrammer || (FunctionalValidateReturnProgrammer = {}));
+
+export { FunctionalValidateReturnProgrammer };
+//# sourceMappingURL=FunctionalValidateReturnProgrammer.mjs.map

package/lib/programmers/functional/FunctionalValidateReturnProgrammer.mjs.map

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

package/lib/programmers/functional/internal/FunctionalGeneralProgrammer.mjs

@@ -0,0 +1,23 @@
+import { TypeFactory } from '../../../factories/TypeFactory.mjs';
+
+var FunctionalGeneralProgrammer;
+(function (FunctionalGeneralProgrammer) {
+    FunctionalGeneralProgrammer.getReturnType = (props) => {
+        const signature = props.checker.getSignatureFromDeclaration(props.declaration);
+        const type = signature?.getReturnType() ??
+            props.checker.getTypeFromTypeNode(TypeFactory.keyword("any"));
+        if (type.symbol?.name === "Promise") {
+            const generic = props.checker.getTypeArguments(type);
+            return generic.length === 1
+                ? { type: generic[0], async: true }
+                : {
+                    type: props.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
+                    async: false,
+                };
+        }
+        return { type, async: false };
+    };
+})(FunctionalGeneralProgrammer || (FunctionalGeneralProgrammer = {}));
+
+export { FunctionalGeneralProgrammer };
+//# sourceMappingURL=FunctionalGeneralProgrammer.mjs.map

package/lib/programmers/functional/internal/FunctionalGeneralProgrammer.mjs.map

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

package/lib/programmers/helpers/AtomicPredicator.mjs

@@ -0,0 +1,13 @@
+import { ArrayUtil } from '../../utils/ArrayUtil.mjs';
+
+var AtomicPredicator;
+(function (AtomicPredicator) {
+    AtomicPredicator.constant = (props) => !ArrayUtil.has(props.metadata.natives, (native) => native.name.toLowerCase() === props.name);
+    AtomicPredicator.atomic = (props) => !ArrayUtil.has(props.metadata.natives, (native) => native.name.toLowerCase() === props.name);
+    AtomicPredicator.native = (name) => LIKE.has(name.toLowerCase());
+    AtomicPredicator.template = (metadata) => !ArrayUtil.has(metadata.natives, (native) => native.name.toLowerCase() === "string");
+})(AtomicPredicator || (AtomicPredicator = {}));
+const LIKE = new Set(["boolean", "bigint", "number", "string"]);
+
+export { AtomicPredicator };
+//# sourceMappingURL=AtomicPredicator.mjs.map

package/lib/programmers/helpers/AtomicPredicator.mjs.map

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

package/lib/programmers/helpers/CloneJoiner.mjs

@@ -0,0 +1,56 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { Escaper } from '../../utils/Escaper.mjs';
+import { metadata_to_pattern } from '../internal/metadata_to_pattern.mjs';
+
+var CloneJoiner;
+(function (CloneJoiner) {
+    CloneJoiner.object = (props) => {
+        if (props.entries.length === 0)
+            return ts.factory.createIdentifier("{}");
+        const regular = props.entries.filter((e) => e.key.isSoleLiteral());
+        const dynamic = props.entries.filter((e) => !e.key.isSoleLiteral());
+        const literal = ts.factory.createObjectLiteralExpression(regular.map((entry) => {
+            const str = entry.key.getSoleLiteral();
+            return ts.factory.createPropertyAssignment(Escaper.variable(str) ? str : ts.factory.createStringLiteral(str), entry.expression);
+        }), true);
+        if (dynamic.length === 0)
+            return literal;
+        const key = ts.factory.createIdentifier("key");
+        const output = ts.factory.createIdentifier("output");
+        const statements = [];
+        if (regular.length !== 0)
+            statements.push(ts.factory.createIfStatement(ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createArrayLiteralExpression(regular.map((r) => ts.factory.createStringLiteral(r.key.getSoleLiteral()))), "some"), undefined, [
+                ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("regular")], undefined, undefined, ts.factory.createStrictEquality(ts.factory.createIdentifier("regular"), ts.factory.createIdentifier("key"))),
+            ]), ts.factory.createContinueStatement()));
+        statements.push(...dynamic.map((entry) => ts.factory.createIfStatement(ts.factory.createCallExpression(ts.factory.createIdentifier(`RegExp(/${metadata_to_pattern({
+            top: true,
+            metadata: entry.key,
+        })}/).test`), undefined, [key]), ts.factory.createBlock([
+            ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createElementAccessExpression(output, key), ts.factory.createToken(ts.SyntaxKind.EqualsToken), entry.expression)),
+            ts.factory.createContinueStatement(),
+        ]))));
+        return ts.factory.createBlock([
+            StatementFactory.constant({
+                name: "output",
+                value: ts.factory.createAsExpression(literal, TypeFactory.keyword("any")),
+            }),
+            ts.factory.createForOfStatement(undefined, StatementFactory.entry({
+                key: "key",
+                value: "value",
+            }), ts.factory.createCallExpression(ts.factory.createIdentifier("Object.entries"), undefined, [props.input]), ts.factory.createBlock(statements)),
+            ts.factory.createReturnStatement(output),
+        ]);
+    };
+    CloneJoiner.tuple = (props) => {
+        return ts.factory.createAsExpression(ts.factory.createArrayLiteralExpression(props.rest === null
+            ? props.elements
+            : [...props.elements, ts.factory.createSpreadElement(props.rest)], true), TypeFactory.keyword("any"));
+    };
+    CloneJoiner.array = (props) => ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(props.input, "map"), undefined, [props.arrow]);
+})(CloneJoiner || (CloneJoiner = {}));
+
+export { CloneJoiner };
+//# sourceMappingURL=CloneJoiner.mjs.map

package/lib/programmers/helpers/CloneJoiner.mjs.map

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

package/lib/programmers/helpers/FunctionProgrammer.mjs

@@ -0,0 +1,53 @@
+import ts from 'typescript';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+
+class FunctionProgrammer {
+    method;
+    local_ = new Set();
+    unions_ = new Map();
+    variables_ = new Map();
+    sequence_ = 0;
+    constructor(method) {
+        this.method = method;
+    }
+    useLocal(name) {
+        this.local_.add(name);
+        return name;
+    }
+    hasLocal(name) {
+        return this.local_.has(name);
+    }
+    declare(includeUnions = true) {
+        return [
+            ...[...this.variables_.entries()].map(([name, value]) => StatementFactory.constant({ name, value })),
+            ...(includeUnions === true
+                ? [...this.unions_.values()].map(([name, value]) => StatementFactory.constant({ name, value }))
+                : []),
+        ];
+    }
+    declareUnions() {
+        return [...this.unions_.values()].map(([name, value]) => StatementFactory.constant({ name, value }));
+    }
+    increment() {
+        return ++this.sequence_;
+    }
+    emplaceUnion(prefix, name, factory) {
+        const key = `${prefix}::${name}`;
+        const oldbie = this.unions_.get(key);
+        if (oldbie)
+            return oldbie[0];
+        const index = this.unions_.size;
+        const accessor = `${prefix}p${index}`;
+        const tuple = [accessor, null];
+        this.unions_.set(key, tuple);
+        tuple[1] = factory();
+        return accessor;
+    }
+    emplaceVariable(name, value) {
+        this.variables_.set(name, value);
+        return ts.factory.createIdentifier(name);
+    }
+}
+
+export { FunctionProgrammer };
+//# sourceMappingURL=FunctionProgrammer.mjs.map

package/lib/programmers/helpers/FunctionProgrammer.mjs.map

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

package/lib/programmers/helpers/HttpMetadataUtil.mjs

@@ -0,0 +1,18 @@
+var HttpMetadataUtil;
+(function (HttpMetadataUtil) {
+    HttpMetadataUtil.atomics = (metadata) => new Set([
+        ...metadata.atomics.map((a) => a.type),
+        ...metadata.constants.map((c) => c.type),
+        ...(metadata.templates.length ? ["string"] : []),
+    ]);
+    HttpMetadataUtil.isUnion = (metadata) => HttpMetadataUtil.atomics(metadata).size +
+        metadata.arrays.length +
+        metadata.tuples.length +
+        metadata.natives.length +
+        metadata.maps.length +
+        metadata.objects.length >
+        1;
+})(HttpMetadataUtil || (HttpMetadataUtil = {}));
+
+export { HttpMetadataUtil };
+//# sourceMappingURL=HttpMetadataUtil.mjs.map

package/lib/programmers/helpers/HttpMetadataUtil.mjs.map

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

package/lib/programmers/helpers/ICheckEntry.mjs

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

package/lib/programmers/helpers/ICheckEntry.mjs.map

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

package/lib/programmers/helpers/IExpressionEntry.mjs

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

package/lib/programmers/helpers/IExpressionEntry.mjs.map

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

package/lib/programmers/helpers/NotationJoiner.mjs

@@ -0,0 +1,56 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { Escaper } from '../../utils/Escaper.mjs';
+import { metadata_to_pattern } from '../internal/metadata_to_pattern.mjs';
+
+var NotationJoiner;
+(function (NotationJoiner) {
+    NotationJoiner.object = (props) => {
+        if (props.entries.length === 0)
+            return ts.factory.createIdentifier("{}");
+        const regular = props.entries.filter((e) => e.key.isSoleLiteral());
+        const dynamic = props.entries.filter((e) => !e.key.isSoleLiteral());
+        const literal = ts.factory.createObjectLiteralExpression(regular.map((entry) => {
+            const str = props.rename(entry.key.getSoleLiteral());
+            return ts.factory.createPropertyAssignment(Escaper.variable(str) ? str : ts.factory.createStringLiteral(str), entry.expression);
+        }), true);
+        if (dynamic.length === 0)
+            return literal;
+        const key = ts.factory.createIdentifier("key");
+        const output = ts.factory.createIdentifier("output");
+        const statements = [];
+        if (regular.length !== 0)
+            statements.push(ts.factory.createIfStatement(ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createArrayLiteralExpression(regular.map((r) => ts.factory.createStringLiteral(r.key.getSoleLiteral()))), "some"), undefined, [
+                ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("regular")], undefined, undefined, ts.factory.createStrictEquality(ts.factory.createIdentifier("regular"), ts.factory.createIdentifier("key"))),
+            ]), ts.factory.createContinueStatement()));
+        statements.push(...dynamic.map((entry) => ts.factory.createIfStatement(ts.factory.createCallExpression(ts.factory.createIdentifier(`RegExp(/${metadata_to_pattern({
+            top: true,
+            metadata: entry.key,
+        })}/).test`), undefined, [key]), ts.factory.createBlock([
+            ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createElementAccessExpression(output, key), ts.factory.createToken(ts.SyntaxKind.EqualsToken), entry.expression)),
+            ts.factory.createContinueStatement(),
+        ]))));
+        return ts.factory.createBlock([
+            StatementFactory.constant({
+                name: "output",
+                value: ts.factory.createAsExpression(literal, TypeFactory.keyword("any")),
+            }),
+            ts.factory.createForOfStatement(undefined, StatementFactory.entry({
+                key: "key",
+                value: "value",
+            }), ts.factory.createCallExpression(ts.factory.createIdentifier("Object.entries"), undefined, [props.input]), ts.factory.createBlock(statements)),
+            ts.factory.createReturnStatement(output),
+        ]);
+    };
+    NotationJoiner.tuple = (props) => {
+        return ts.factory.createAsExpression(ts.factory.createArrayLiteralExpression(props.rest === null
+            ? props.elements
+            : [...props.elements, ts.factory.createSpreadElement(props.rest)], true), TypeFactory.keyword("any"));
+    };
+    NotationJoiner.array = (props) => ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(props.input, "map"), undefined, [props.arrow]);
+})(NotationJoiner || (NotationJoiner = {}));
+
+export { NotationJoiner };
+//# sourceMappingURL=NotationJoiner.mjs.map

package/lib/programmers/helpers/NotationJoiner.mjs.map

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

package/lib/programmers/helpers/OptionPredicator.mjs

@@ -0,0 +1,10 @@
+var OptionPredicator;
+(function (OptionPredicator) {
+    OptionPredicator.numeric = (options) => OptionPredicator.finite(options) || options.numeric === true;
+    OptionPredicator.functional = (options) => options.functional === true;
+    OptionPredicator.finite = (options) => options.finite === true;
+    OptionPredicator.undefined = (options) => options.undefined !== false;
+})(OptionPredicator || (OptionPredicator = {}));
+
+export { OptionPredicator };
+//# sourceMappingURL=OptionPredicator.mjs.map

package/lib/programmers/helpers/OptionPredicator.mjs.map

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