npm - typia - Versions diffs - 3.4.13 → 3.4.14 - Mend

typia 3.4.13 → 3.4.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (157) hide show

package/README.md +9 -8
package/lib/factories/internal/iterate_metadata_object.js +4 -2
package/lib/factories/internal/iterate_metadata_object.js.map +1 -1
package/package.json +1 -1
package/src/IValidation.ts +21 -21
package/src/Primitive.ts +82 -82
package/src/TypeGuardError.ts +36 -36
package/src/executable/internal/CommandParser.ts +15 -15
package/src/executable/internal/TypiaSetupWizard.ts +175 -175
package/src/executable/typia.ts +46 -46
package/src/factories/CommentFactory.ts +10 -10
package/src/factories/ExpressionFactory.ts +66 -66
package/src/factories/IdentifierFactory.ts +72 -72
package/src/factories/LiteralFactory.ts +44 -44
package/src/factories/MetadataCollection.ts +122 -122
package/src/factories/MetadataFactory.ts +46 -46
package/src/factories/MetadataTagFactory.ts +347 -347
package/src/factories/StatementFactory.ts +60 -60
package/src/factories/TemplateFactory.ts +56 -56
package/src/factories/TypeFactory.ts +101 -101
package/src/factories/ValueFactory.ts +12 -12
package/src/factories/internal/MetadataHelper.ts +12 -12
package/src/factories/internal/emplace_metadata_object.ts +140 -140
package/src/factories/internal/explore_metadata.ts +91 -91
package/src/factories/internal/iterate_metadata.ts +80 -80
package/src/factories/internal/iterate_metadata_array.ts +29 -29
package/src/factories/internal/iterate_metadata_atomic.ts +59 -59
package/src/factories/internal/iterate_metadata_coalesce.ts +33 -33
package/src/factories/internal/iterate_metadata_constant.ts +58 -58
package/src/factories/internal/iterate_metadata_map.ts +41 -41
package/src/factories/internal/iterate_metadata_native.ts +227 -227
package/src/factories/internal/iterate_metadata_object.ts +48 -45
package/src/factories/internal/iterate_metadata_resolve.ts +27 -27
package/src/factories/internal/iterate_metadata_set.ts +33 -33
package/src/factories/internal/iterate_metadata_template.ts +38 -38
package/src/factories/internal/iterate_metadata_tuple.ts +45 -45
package/src/factories/internal/iterate_metadata_union.ts +59 -59
package/src/functional/$every.ts +11 -11
package/src/functional/$guard.ts +35 -35
package/src/functional/$is_email.ts +5 -5
package/src/functional/$is_ipv4.ts +5 -5
package/src/functional/$is_ipv6.ts +5 -5
package/src/functional/$is_url.ts +5 -5
package/src/functional/$is_uuid.ts +5 -5
package/src/functional/$join.ts +50 -50
package/src/functional/$number.ts +19 -19
package/src/functional/$report.ts +15 -15
package/src/functional/$rest.ts +3 -3
package/src/functional/$string.ts +37 -37
package/src/functional/$tail.ts +6 -6
package/src/index.ts +4 -4
package/src/metadata/IJsDocTagInfo.ts +10 -10
package/src/metadata/IMetadata.ts +25 -25
package/src/metadata/IMetadataApplication.ts +7 -7
package/src/metadata/IMetadataConstant.ts +16 -16
package/src/metadata/IMetadataEntry.ts +6 -6
package/src/metadata/IMetadataObject.ts +29 -29
package/src/metadata/IMetadataProperty.ts +11 -11
package/src/metadata/IMetadataTag.ts +122 -122
package/src/metadata/Metadata.ts +477 -477
package/src/metadata/MetadataConstant.ts +3 -3
package/src/metadata/MetadataObject.ts +131 -131
package/src/metadata/MetadataProperty.ts +64 -64
package/src/module.ts +1535 -1535
package/src/programmers/ApplicationProgrammer.ts +55 -55
package/src/programmers/AssertParseProgrammer.ts +45 -45
package/src/programmers/AssertProgrammer.ts +444 -444
package/src/programmers/AssertStringifyProgrammer.ts +45 -45
package/src/programmers/CheckerProgrammer.ts +804 -804
package/src/programmers/FeatureProgrammer.ts +327 -327
package/src/programmers/IsParseProgrammer.ts +51 -51
package/src/programmers/IsProgrammer.ts +172 -172
package/src/programmers/IsStringifyProgrammer.ts +49 -49
package/src/programmers/StringifyProgrammer.ts +756 -756
package/src/programmers/ValidateParseProgrammer.ts +49 -49
package/src/programmers/ValidateProgrammer.ts +236 -236
package/src/programmers/ValidateStringifyProgrammer.ts +60 -60
package/src/programmers/helpers/AtomicPredicator.ts +15 -15
package/src/programmers/helpers/FunctionImporeter.ts +31 -31
package/src/programmers/helpers/IExpressionEntry.ts +10 -10
package/src/programmers/helpers/OptionPredicator.ts +11 -11
package/src/programmers/helpers/StringifyJoinder.ts +111 -111
package/src/programmers/helpers/StringifyPredicator.ts +18 -18
package/src/programmers/helpers/UnionExplorer.ts +437 -437
package/src/programmers/helpers/UnionPredicator.ts +81 -81
package/src/programmers/internal/application_array.ts +45 -45
package/src/programmers/internal/application_boolean.ts +17 -17
package/src/programmers/internal/application_constant.ts +29 -29
package/src/programmers/internal/application_default.ts +17 -17
package/src/programmers/internal/application_default_string.ts +32 -32
package/src/programmers/internal/application_native.ts +29 -29
package/src/programmers/internal/application_number.ts +76 -76
package/src/programmers/internal/application_object.ts +103 -103
package/src/programmers/internal/application_schema.ts +221 -221
package/src/programmers/internal/application_string.ts +49 -49
package/src/programmers/internal/application_templates.ts +27 -27
package/src/programmers/internal/application_tuple.ts +25 -25
package/src/programmers/internal/check_array.ts +44 -44
package/src/programmers/internal/check_dynamic_properties.ts +146 -146
package/src/programmers/internal/check_everything.ts +25 -25
package/src/programmers/internal/check_length.ts +46 -46
package/src/programmers/internal/check_native.ts +9 -9
package/src/programmers/internal/check_number.ts +178 -178
package/src/programmers/internal/check_object.ts +42 -42
package/src/programmers/internal/check_string.ts +24 -24
package/src/programmers/internal/check_string_tags.ts +63 -63
package/src/programmers/internal/check_template.ts +50 -50
package/src/programmers/internal/decode_union_object.ts +73 -73
package/src/programmers/internal/feature_object_entries.ts +49 -49
package/src/programmers/internal/metadata_to_pattern.ts +31 -31
package/src/programmers/internal/stringify_dynamic_properties.ts +164 -164
package/src/programmers/internal/stringify_native.ts +8 -8
package/src/programmers/internal/stringify_regular_properties.ts +81 -81
package/src/programmers/internal/template_to_pattern.ts +15 -15
package/src/schemas/IJsonApplication.ts +9 -9
package/src/schemas/IJsonComponents.ts +24 -24
package/src/schemas/IJsonSchema.ts +92 -92
package/src/transform.ts +20 -20
package/src/transformers/CallExpressionTransformer.ts +124 -124
package/src/transformers/ExpressionWithArgumentTransformer.ts +66 -66
package/src/transformers/FileTransformer.ts +49 -49
package/src/transformers/IProject.ts +11 -11
package/src/transformers/ITransformOptions.ts +4 -4
package/src/transformers/NodeTransformer.ts +19 -19
package/src/transformers/features/miscellaneous/ApplicationTransformer.ts +114 -114
package/src/transformers/features/miscellaneous/CreateInstanceTransformer.ts +41 -41
package/src/transformers/features/miscellaneous/MetadataTransformer.ts +55 -55
package/src/transformers/features/parsers/AssertParseTransformer.ts +36 -36
package/src/transformers/features/parsers/CreateAssertParseTransformer.ts +32 -32
package/src/transformers/features/parsers/CreateIsParseTransformer.ts +32 -32
package/src/transformers/features/parsers/CreateValidateParseTransformer.ts +32 -32
package/src/transformers/features/parsers/IsParseTransformer.ts +36 -36
package/src/transformers/features/parsers/ValidateParseTransformer.ts +36 -36
package/src/transformers/features/stringifiers/AssertStringifyTransformer.ts +38 -38
package/src/transformers/features/stringifiers/CreateAssertStringifyTransformer.ts +32 -32
package/src/transformers/features/stringifiers/CreateIsStringifyTransformer.ts +32 -32
package/src/transformers/features/stringifiers/CreateStringifyTransformer.ts +31 -31
package/src/transformers/features/stringifiers/CreateValidateStringifyProgrammer.ts +32 -32
package/src/transformers/features/stringifiers/IsStringifyTransformer.ts +38 -38
package/src/transformers/features/stringifiers/StringifyTransformer.ts +36 -36
package/src/transformers/features/stringifiers/ValidateStringifyTransformer.ts +38 -38
package/src/transformers/features/validators/AssertTransformer.ts +43 -43
package/src/transformers/features/validators/CreateAssertTransformer.ts +35 -35
package/src/transformers/features/validators/CreateIsTransformer.ts +35 -35
package/src/transformers/features/validators/CreateValidateTransformer.ts +35 -35
package/src/transformers/features/validators/IsTransformer.ts +43 -43
package/src/transformers/features/validators/ValidateTransformer.ts +43 -43
package/src/typings/Atomic.ts +17 -17
package/src/typings/ClassProperties.ts +5 -5
package/src/typings/OmitNever.ts +3 -3
package/src/typings/SpecialFields.ts +3 -3
package/src/typings/Writable.ts +11 -11
package/src/utils/ArrayUtil.ts +49 -49
package/src/utils/Escaper.ts +50 -50
package/src/utils/MapUtil.ts +14 -14
package/src/utils/PatternUtil.ts +30 -30
package/src/utils/Singleton.ts +17 -17

package/src/programmers/ValidateParseProgrammer.ts CHANGED Viewed

@@ -1,49 +1,49 @@
-import ts from "typescript";
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { StatementFactory } from "../factories/StatementFactory";
-import { IProject } from "../transformers/IProject";
-import { ValidateProgrammer } from "./ValidateProgrammer";
-export namespace ValidateParseProgrammer {
-    export const generate =
-        (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "validate",
-                        ValidateProgrammer.generate(project, modulo)(type),
-                    ),
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createBinaryExpression(
-                            ts.factory.createIdentifier("input"),
-                            ts.SyntaxKind.EqualsToken,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("JSON.parse"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                        ),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("validate"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+import { IProject } from "../transformers/IProject";
+import { ValidateProgrammer } from "./ValidateProgrammer";
+export namespace ValidateParseProgrammer {
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "validate",
+                        ValidateProgrammer.generate(project, modulo)(type),
+                    ),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createBinaryExpression(
+                            ts.factory.createIdentifier("input"),
+                            ts.SyntaxKind.EqualsToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("JSON.parse"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                        ),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("validate"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/ValidateProgrammer.ts CHANGED Viewed

@@ -1,236 +1,236 @@
-import ts from "typescript";
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { StatementFactory } from "../factories/StatementFactory";
-import { IProject } from "../transformers/IProject";
-import { CheckerProgrammer } from "./CheckerProgrammer";
-import { IsProgrammer } from "./IsProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
-import { check_everything } from "./internal/check_everything";
-import { check_object } from "./internal/check_object";
-export namespace ValidateProgrammer {
-    export const generate =
-        (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            equals: boolean = false,
-        ) =>
-        (type: ts.Type) => {
-            const importer: FunctionImporter = new FunctionImporter();
-            const program: ts.ArrowFunction = CheckerProgrammer.generate(
-                project,
-                {
-                    functors: "$vo",
-                    unioners: "$vu",
-                    path: true,
-                    trace: true,
-                    numeric: !!project.options.numeric,
-                    equals,
-                    combiner: combine(equals)(importer),
-                    joiner: joiner(equals)(importer),
-                    success: ts.factory.createTrue(),
-                },
-                importer,
-            )(type);
-            return ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
-                undefined,
-                ts.factory.createBlock(
-                    [
-                        StatementFactory.constant(
-                            "errors",
-                            ts.factory.createArrayLiteralExpression([]),
-                        ),
-                        StatementFactory.constant(
-                            "$report",
-                            ts.factory.createCallExpression(
-                                IdentifierFactory.join(modulo, "report"),
-                                [],
-                                [ts.factory.createIdentifier("errors")],
-                            ),
-                        ),
-                        ...importer.declare(modulo),
-                        ts.factory.createExpressionStatement(
-                            ts.factory.createCallExpression(
-                                program,
-                                undefined,
-                                [
-                                    ts.factory.createIdentifier("input"),
-                                    ts.factory.createStringLiteral("$input"),
-                                    ts.factory.createTrue(),
-                                ],
-                            ),
-                        ),
-                        StatementFactory.constant(
-                            "success",
-                            ts.factory.createStrictEquality(
-                                ts.factory.createNumericLiteral(0),
-                                ts.factory.createIdentifier("errors.length"),
-                            ),
-                        ),
-                        ts.factory.createReturnStatement(create_output()),
-                    ],
-                    true,
-                ),
-            );
-        };
-}
-const combine =
-    (equals: boolean) =>
-    (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
-    (explore: CheckerProgrammer.IExplore) => {
-        if (explore.tracable === false && explore.from !== "top")
-            return IsProgrammer.CONFIG({
-                object: validate_object(equals)(importer),
-                numeric: true,
-            }).combiner(explore);
-        const path: string = explore.postfix
-            ? `path + ${explore.postfix}`
-            : "path";
-        return (logic) => (input, binaries, expected) =>
-            logic === "and"
-                ? binaries
-                      .map((binary) =>
-                          binary.combined
-                              ? binary.expression
-                              : ts.factory.createLogicalOr(
-                                    binary.expression,
-                                    create_report_call(
-                                        explore.source === "top"
-                                            ? ts.factory.createTrue()
-                                            : ts.factory.createIdentifier(
-                                                  "exceptionable",
-                                              ),
-                                    )(
-                                        ts.factory.createIdentifier(path),
-                                        expected,
-                                        input,
-                                    ),
-                                ),
-                      )
-                      .reduce(ts.factory.createLogicalAnd)
-                : ts.factory.createLogicalOr(
-                      binaries
-                          .map((binary) => binary.expression)
-                          .reduce(ts.factory.createLogicalOr),
-                      create_report_call(
-                          explore.source === "top"
-                              ? ts.factory.createTrue()
-                              : ts.factory.createIdentifier("exceptionable"),
-                      )(ts.factory.createIdentifier(path), expected, input),
-                  );
-    };
-const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
-    check_object({
-        equals,
-        assert: false,
-        reduce: ts.factory.createLogicalAnd,
-        positive: ts.factory.createTrue(),
-        superfluous: (value) =>
-            create_report_call()(
-                ts.factory.createAdd(
-                    ts.factory.createIdentifier("path"),
-                    ts.factory.createCallExpression(
-                        importer.use("join"),
-                        undefined,
-                        [ts.factory.createIdentifier("key")],
-                    ),
-                ),
-                "undefined",
-                value,
-            ),
-        halt: (expr) =>
-            ts.factory.createLogicalOr(
-                ts.factory.createStrictEquality(
-                    ts.factory.createFalse(),
-                    ts.factory.createIdentifier("exceptionable"),
-                ),
-                expr,
-            ),
-    });
-const joiner =
-    (equals: boolean) =>
-    (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-        object: validate_object(equals)(importer),
-        array: (input, arrow) =>
-            check_everything(
-                ts.factory.createCallExpression(
-                    IdentifierFactory.join(input, "map"),
-                    undefined,
-                    [arrow],
-                ),
-            ),
-        failure: (value, expected, explore) =>
-            create_report_call(
-                explore?.from === "top"
-                    ? ts.factory.createTrue()
-                    : ts.factory.createIdentifier("exceptionable"),
-            )(
-                ts.factory.createIdentifier(
-                    explore?.postfix ? `path + ${explore.postfix}` : "path",
-                ),
-                expected,
-                value,
-            ),
-        tuple: (binaries) =>
-            check_everything(
-                ts.factory.createArrayLiteralExpression(binaries, true),
-            ),
-    });
-function create_output() {
-    return ts.factory.createObjectLiteralExpression(
-        [
-            ts.factory.createShorthandPropertyAssignment("success"),
-            ts.factory.createShorthandPropertyAssignment("errors"),
-            ts.factory.createPropertyAssignment(
-                "data",
-                ts.factory.createConditionalExpression(
-                    ts.factory.createIdentifier("success"),
-                    undefined,
-                    ts.factory.createIdentifier("input"),
-                    undefined,
-                    ts.factory.createIdentifier("undefined"),
-                ),
-            ),
-        ],
-        true,
-    );
-}
-const create_report_call =
-    (exceptionable?: ts.Expression) =>
-    (
-        path: ts.Expression,
-        expected: string,
-        value: ts.Expression,
-    ): ts.Expression =>
-        ts.factory.createCallExpression(
-            ts.factory.createIdentifier("$report"),
-            undefined,
-            [
-                exceptionable || ts.factory.createIdentifier("exceptionable"),
-                ts.factory.createObjectLiteralExpression(
-                    [
-                        ts.factory.createPropertyAssignment("path", path),
-                        ts.factory.createPropertyAssignment(
-                            "expected",
-                            ts.factory.createStringLiteral(expected),
-                        ),
-                        ts.factory.createPropertyAssignment("value", value),
-                    ],
-                    true,
-                ),
-            ],
-        );
+import ts from "typescript";
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+import { IProject } from "../transformers/IProject";
+import { CheckerProgrammer } from "./CheckerProgrammer";
+import { IsProgrammer } from "./IsProgrammer";
+import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { check_everything } from "./internal/check_everything";
+import { check_object } from "./internal/check_object";
+export namespace ValidateProgrammer {
+    export const generate =
+        (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            equals: boolean = false,
+        ) =>
+        (type: ts.Type) => {
+            const importer: FunctionImporter = new FunctionImporter();
+            const program: ts.ArrowFunction = CheckerProgrammer.generate(
+                project,
+                {
+                    functors: "$vo",
+                    unioners: "$vu",
+                    path: true,
+                    trace: true,
+                    numeric: !!project.options.numeric,
+                    equals,
+                    combiner: combine(equals)(importer),
+                    joiner: joiner(equals)(importer),
+                    success: ts.factory.createTrue(),
+                },
+                importer,
+            )(type);
+            return ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock(
+                    [
+                        StatementFactory.constant(
+                            "errors",
+                            ts.factory.createArrayLiteralExpression([]),
+                        ),
+                        StatementFactory.constant(
+                            "$report",
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.join(modulo, "report"),
+                                [],
+                                [ts.factory.createIdentifier("errors")],
+                            ),
+                        ),
+                        ...importer.declare(modulo),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createCallExpression(
+                                program,
+                                undefined,
+                                [
+                                    ts.factory.createIdentifier("input"),
+                                    ts.factory.createStringLiteral("$input"),
+                                    ts.factory.createTrue(),
+                                ],
+                            ),
+                        ),
+                        StatementFactory.constant(
+                            "success",
+                            ts.factory.createStrictEquality(
+                                ts.factory.createNumericLiteral(0),
+                                ts.factory.createIdentifier("errors.length"),
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(create_output()),
+                    ],
+                    true,
+                ),
+            );
+        };
+}
+const combine =
+    (equals: boolean) =>
+    (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
+    (explore: CheckerProgrammer.IExplore) => {
+        if (explore.tracable === false && explore.from !== "top")
+            return IsProgrammer.CONFIG({
+                object: validate_object(equals)(importer),
+                numeric: true,
+            }).combiner(explore);
+        const path: string = explore.postfix
+            ? `path + ${explore.postfix}`
+            : "path";
+        return (logic) => (input, binaries, expected) =>
+            logic === "and"
+                ? binaries
+                      .map((binary) =>
+                          binary.combined
+                              ? binary.expression
+                              : ts.factory.createLogicalOr(
+                                    binary.expression,
+                                    create_report_call(
+                                        explore.source === "top"
+                                            ? ts.factory.createTrue()
+                                            : ts.factory.createIdentifier(
+                                                  "exceptionable",
+                                              ),
+                                    )(
+                                        ts.factory.createIdentifier(path),
+                                        expected,
+                                        input,
+                                    ),
+                                ),
+                      )
+                      .reduce(ts.factory.createLogicalAnd)
+                : ts.factory.createLogicalOr(
+                      binaries
+                          .map((binary) => binary.expression)
+                          .reduce(ts.factory.createLogicalOr),
+                      create_report_call(
+                          explore.source === "top"
+                              ? ts.factory.createTrue()
+                              : ts.factory.createIdentifier("exceptionable"),
+                      )(ts.factory.createIdentifier(path), expected, input),
+                  );
+    };
+const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
+    check_object({
+        equals,
+        assert: false,
+        reduce: ts.factory.createLogicalAnd,
+        positive: ts.factory.createTrue(),
+        superfluous: (value) =>
+            create_report_call()(
+                ts.factory.createAdd(
+                    ts.factory.createIdentifier("path"),
+                    ts.factory.createCallExpression(
+                        importer.use("join"),
+                        undefined,
+                        [ts.factory.createIdentifier("key")],
+                    ),
+                ),
+                "undefined",
+                value,
+            ),
+        halt: (expr) =>
+            ts.factory.createLogicalOr(
+                ts.factory.createStrictEquality(
+                    ts.factory.createFalse(),
+                    ts.factory.createIdentifier("exceptionable"),
+                ),
+                expr,
+            ),
+    });
+const joiner =
+    (equals: boolean) =>
+    (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
+        object: validate_object(equals)(importer),
+        array: (input, arrow) =>
+            check_everything(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.join(input, "map"),
+                    undefined,
+                    [arrow],
+                ),
+            ),
+        failure: (value, expected, explore) =>
+            create_report_call(
+                explore?.from === "top"
+                    ? ts.factory.createTrue()
+                    : ts.factory.createIdentifier("exceptionable"),
+            )(
+                ts.factory.createIdentifier(
+                    explore?.postfix ? `path + ${explore.postfix}` : "path",
+                ),
+                expected,
+                value,
+            ),
+        tuple: (binaries) =>
+            check_everything(
+                ts.factory.createArrayLiteralExpression(binaries, true),
+            ),
+    });
+function create_output() {
+    return ts.factory.createObjectLiteralExpression(
+        [
+            ts.factory.createShorthandPropertyAssignment("success"),
+            ts.factory.createShorthandPropertyAssignment("errors"),
+            ts.factory.createPropertyAssignment(
+                "data",
+                ts.factory.createConditionalExpression(
+                    ts.factory.createIdentifier("success"),
+                    undefined,
+                    ts.factory.createIdentifier("input"),
+                    undefined,
+                    ts.factory.createIdentifier("undefined"),
+                ),
+            ),
+        ],
+        true,
+    );
+}
+const create_report_call =
+    (exceptionable?: ts.Expression) =>
+    (
+        path: ts.Expression,
+        expected: string,
+        value: ts.Expression,
+    ): ts.Expression =>
+        ts.factory.createCallExpression(
+            ts.factory.createIdentifier("$report"),
+            undefined,
+            [
+                exceptionable || ts.factory.createIdentifier("exceptionable"),
+                ts.factory.createObjectLiteralExpression(
+                    [
+                        ts.factory.createPropertyAssignment("path", path),
+                        ts.factory.createPropertyAssignment(
+                            "expected",
+                            ts.factory.createStringLiteral(expected),
+                        ),
+                        ts.factory.createPropertyAssignment("value", value),
+                    ],
+                    true,
+                ),
+            ],
+        );