@typia/core 12.0.0-dev.20260225

package/lib/programmers/internal/CheckerProgrammer.mjs

@@ -0,0 +1,1103 @@
+import ts from 'typescript';
+import { TransformerError } from '../../context/TransformerError.mjs';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { MetadataFactory } from '../../factories/MetadataFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { ValueFactory } from '../../factories/ValueFactory.mjs';
+import { MetadataArray } from '../../schemas/metadata/MetadataArray.mjs';
+import { MetadataStorage } from '../../schemas/metadata/MetadataStorage.mjs';
+import { MetadataTuple } from '../../schemas/metadata/MetadataTuple.mjs';
+import { IsProgrammer } from '../IsProgrammer.mjs';
+import { AtomicPredicator } from '../helpers/AtomicPredicator.mjs';
+import { OptionPredicator } from '../helpers/OptionPredicator.mjs';
+import { UnionExplorer } from '../helpers/UnionExplorer.mjs';
+import { check_array_length } from '../iterate/check_array_length.mjs';
+import { check_bigint } from '../iterate/check_bigint.mjs';
+import { check_native } from '../iterate/check_native.mjs';
+import { check_number } from '../iterate/check_number.mjs';
+import { check_string } from '../iterate/check_string.mjs';
+import { check_template } from '../iterate/check_template.mjs';
+import { decode_union_object } from '../iterate/decode_union_object.mjs';
+import { postfix_of_tuple } from '../iterate/postfix_of_tuple.mjs';
+import { wrap_metadata_rest_tuple } from '../iterate/wrap_metadata_rest_tuple.mjs';
+import { FeatureProgrammer } from './FeatureProgrammer.mjs';
+
+var CheckerProgrammer;
+(function (CheckerProgrammer) {
+    /* -----------------------------------------------------------
+          WRITERS
+      ----------------------------------------------------------- */
+    CheckerProgrammer.compose = (props) => FeatureProgrammer.compose({
+        ...props,
+        config: configure(props),
+    });
+    CheckerProgrammer.write = (props) => FeatureProgrammer.write({
+        config: configure(props),
+        context: props.context,
+        functor: props.functor,
+        type: props.type,
+        name: props.name,
+    });
+    CheckerProgrammer.write_object_functions = (props) => FeatureProgrammer.write_object_functions({
+        config: configure(props),
+        context: props.context,
+        collection: props.collection,
+    });
+    CheckerProgrammer.write_union_functions = (props) => FeatureProgrammer.write_union_functions({
+        config: configure({
+            context: props.context,
+            config: {
+                ...props.config,
+                numeric: false,
+            },
+            functor: props.functor,
+        }),
+        collection: props.collection,
+    });
+    CheckerProgrammer.write_array_functions = (props) => props.collection
+        .arrays()
+        .filter((a) => a.recursive)
+        .map((type, i) => StatementFactory.constant({
+        name: `${props.config.prefix}a${i}`,
+        value: ts.factory.createArrowFunction(undefined, undefined, FeatureProgrammer.parameterDeclarations({
+            config: props.config,
+            type: TypeFactory.keyword("any"),
+            input: ts.factory.createIdentifier("input"),
+        }), TypeFactory.keyword("any"), undefined, decode_array_inline({
+            ...props,
+            input: ts.factory.createIdentifier("input"),
+            array: MetadataArray.create({
+                type,
+                tags: [],
+            }),
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+            },
+        })),
+    }));
+    CheckerProgrammer.write_tuple_functions = (props) => props.collection
+        .tuples()
+        .filter((t) => t.recursive)
+        .map((tuple, i) => StatementFactory.constant({
+        name: `${props.config.prefix}t${i}`,
+        value: ts.factory.createArrowFunction(undefined, undefined, FeatureProgrammer.parameterDeclarations({
+            config: props.config,
+            type: TypeFactory.keyword("any"),
+            input: ts.factory.createIdentifier("input"),
+        }), TypeFactory.keyword("any"), undefined, decode_tuple_inline({
+            config: props.config,
+            context: props.context,
+            functor: props.functor,
+            input: ts.factory.createIdentifier("input"),
+            tuple,
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+            },
+        })),
+    }));
+    const configure = (props) => ({
+        types: {
+            input: () => TypeFactory.keyword("any"),
+            output: (type, name) => ts.factory.createTypePredicateNode(undefined, "input", ts.factory.createTypeReferenceNode(name ??
+                TypeFactory.getFullName({ checker: props.context.checker, type }))),
+        },
+        trace: props.config.trace,
+        path: props.config.path,
+        prefix: props.config.prefix,
+        initializer: (next) => {
+            const collection = new MetadataStorage();
+            const result = MetadataFactory.analyze({
+                checker: next.context.checker,
+                transformer: next.context.transformer,
+                options: {
+                    escape: false,
+                    constant: true,
+                    absorb: true,
+                },
+                components: collection,
+                type: next.type,
+            });
+            if (result.success === false)
+                throw TransformerError.from({
+                    code: next.functor.method,
+                    errors: result.errors,
+                });
+            return {
+                collection,
+                metadata: result.data,
+            };
+        },
+        addition: props.config.addition,
+        decoder: props.config.decoder
+            ? (next) => props.config.decoder(next)
+            : (next) => CheckerProgrammer.decode({
+                context: props.context,
+                config: props.config,
+                functor: props.functor,
+                input: next.input,
+                metadata: next.metadata,
+                explore: next.explore,
+            }),
+        objector: {
+            checker: props.config.decoder
+                ? (next) => props.config.decoder(next)
+                : (next) => CheckerProgrammer.decode({
+                    context: props.context,
+                    config: props.config,
+                    functor: props.functor,
+                    input: next.input,
+                    metadata: next.metadata,
+                    explore: next.explore,
+                }),
+            decoder: (next) => CheckerProgrammer.decode_object({
+                config: props.config,
+                functor: props.functor,
+                input: next.input,
+                object: next.object,
+                explore: next.explore,
+            }),
+            joiner: props.config.joiner.object,
+            unionizer: props.config.equals
+                ? (next) => decode_union_object({
+                    checker: (v) => CheckerProgrammer.decode_object({
+                        config: props.config,
+                        functor: props.functor,
+                        object: v.object,
+                        input: v.input,
+                        explore: v.explore,
+                    }),
+                    decoder: (v) => CheckerProgrammer.decode_object({
+                        config: props.config,
+                        functor: props.functor,
+                        input: v.input,
+                        object: v.object,
+                        explore: {
+                            ...v.explore,
+                            tracable: true,
+                        },
+                    }),
+                    success: props.config.joiner.is ?? ((expr) => expr),
+                    escaper: (v) => ts.factory.createReturnStatement(props.config.joiner.failure(v)),
+                    input: next.input,
+                    objects: next.objects,
+                    explore: next.explore,
+                })
+                : (next) => props.config.combiner({
+                    logic: "or",
+                    explore: next.explore,
+                    input: next.input,
+                    binaries: next.objects.map((object) => ({
+                        expression: CheckerProgrammer.decode_object({
+                            config: props.config,
+                            functor: props.functor,
+                            object,
+                            input: next.input,
+                            explore: next.explore,
+                        }),
+                        combined: true,
+                    })),
+                    expected: `(${next.objects.map((t) => t.name).join(" | ")})`,
+                }),
+            failure: (next) => ts.factory.createReturnStatement(props.config.joiner.failure(next)),
+            is: props.config.joiner.is,
+            required: props.config.joiner.required,
+            full: props.config.joiner.full
+                ? (next) => props.config.joiner.full(next)
+                : undefined,
+            type: TypeFactory.keyword("boolean"),
+        },
+        generator: {
+            unions: props.config.numeric
+                ? (collection) => FeatureProgrammer.write_union_functions({
+                    config: configure({
+                        ...props,
+                        config: {
+                            ...props.config,
+                            numeric: false,
+                        },
+                    }),
+                    collection,
+                })
+                : undefined,
+            arrays: (collection) => CheckerProgrammer.write_array_functions({
+                ...props,
+                collection,
+            }),
+            tuples: (collection) => CheckerProgrammer.write_tuple_functions({
+                ...props,
+                collection,
+            }),
+        },
+    });
+    /* -----------------------------------------------------------
+          DECODERS
+      ----------------------------------------------------------- */
+    CheckerProgrammer.decode = (props) => {
+        if (props.metadata.any)
+            return props.config.success;
+        const top = [];
+        const binaries = [];
+        const add = (next) => create_add({
+            binaries,
+            left: next.left,
+            right: next.right,
+            exact: next.exact,
+            default: props.input,
+        });
+        const getConstantValue = (value) => {
+            if (typeof value === "string")
+                return ts.factory.createStringLiteral(value);
+            else if (typeof value === "bigint")
+                return ExpressionFactory.bigint(value);
+            return ts.factory.createIdentifier(value.toString());
+        };
+        //----
+        // CHECK OPTIONAL
+        //----
+        // @todo -> should be elaborated
+        const checkOptional = props.metadata.empty() || props.metadata.isUnionBucket();
+        // NULLABLE
+        if (checkOptional || props.metadata.nullable)
+            if (props.metadata.nullable)
+                add({
+                    exact: props.metadata.nullable,
+                    left: ValueFactory.NULL(),
+                });
+            else
+                create_add({
+                    binaries: top,
+                    default: props.input,
+                    exact: props.metadata.nullable,
+                    left: ValueFactory.NULL(),
+                });
+        // UNDEFINDABLE
+        if (checkOptional || !props.metadata.isRequired())
+            if (props.metadata.isRequired())
+                create_add({
+                    binaries: top,
+                    default: props.input,
+                    exact: false,
+                    left: ValueFactory.UNDEFINED(),
+                });
+            else
+                add({
+                    exact: true,
+                    left: ValueFactory.UNDEFINED(),
+                });
+        // FUNCTIONAL
+        if (props.metadata.functions.length)
+            if (OptionPredicator.functional(props.context.options) ||
+                props.metadata.size() !== 1)
+                add({
+                    exact: true,
+                    left: ts.factory.createStringLiteral("function"),
+                    right: ValueFactory.TYPEOF(props.input),
+                });
+            else
+                binaries.push({
+                    combined: false,
+                    expression: props.config.success,
+                });
+        //----
+        // VALUES
+        //----
+        // CONSTANT VALUES
+        const constants = props.metadata.constants.filter((c) => AtomicPredicator.constant({
+            metadata: props.metadata,
+            name: c.type,
+        }));
+        const constantLength = constants
+            .map((c) => c.values.length)
+            .reduce((a, b) => a + b, 0);
+        if (constantLength >= 10) {
+            const values = constants
+                .map((c) => c.values.map((v) => v.value))
+                .flat();
+            add({
+                exact: true,
+                left: ts.factory.createTrue(),
+                right: ts.factory.createCallExpression(IdentifierFactory.access(props.functor.emplaceVariable(`${props.config.prefix}v${props.functor.increment()}`, ts.factory.createNewExpression(ts.factory.createIdentifier("Set"), undefined, [
+                    ts.factory.createArrayLiteralExpression(values.map((v) => typeof v === "boolean"
+                        ? v === true
+                            ? ts.factory.createTrue()
+                            : ts.factory.createFalse()
+                        : typeof v === "bigint"
+                            ? ExpressionFactory.bigint(v)
+                            : typeof v === "number"
+                                ? ExpressionFactory.number(v)
+                                : ts.factory.createStringLiteral(v.toString()))),
+                ])), "has"), undefined, [props.input]),
+            });
+        }
+        else
+            for (const c of constants)
+                if (AtomicPredicator.constant({
+                    metadata: props.metadata,
+                    name: c.type,
+                }))
+                    for (const v of c.values)
+                        add({
+                            exact: true,
+                            left: getConstantValue(v.value),
+                        });
+        // ATOMIC VALUES
+        for (const atom of props.metadata.atomics)
+            if (AtomicPredicator.atomic({
+                metadata: props.metadata,
+                name: atom.type,
+            }) === false)
+                continue;
+            else if (atom.type === "number")
+                binaries.push({
+                    expression: props.config.atomist({
+                        explore: props.explore,
+                        entry: check_number({
+                            context: props.context,
+                            numeric: props.config.numeric,
+                            atomic: atom,
+                            input: props.input,
+                        }),
+                        input: props.input,
+                    }),
+                    combined: false,
+                });
+            else if (atom.type === "bigint")
+                binaries.push({
+                    expression: props.config.atomist({
+                        explore: props.explore,
+                        entry: check_bigint({
+                            context: props.context,
+                            atomic: atom,
+                            input: props.input,
+                        }),
+                        input: props.input,
+                    }),
+                    combined: false,
+                });
+            else if (atom.type === "string")
+                binaries.push({
+                    expression: props.config.atomist({
+                        explore: props.explore,
+                        entry: check_string({
+                            context: props.context,
+                            atomic: atom,
+                            input: props.input,
+                        }),
+                        input: props.input,
+                    }),
+                    combined: false,
+                });
+            else
+                add({
+                    exact: true,
+                    left: ts.factory.createStringLiteral(atom.type),
+                    right: ValueFactory.TYPEOF(props.input),
+                });
+        // TEMPLATE LITERAL VALUES
+        if (props.metadata.templates.length)
+            if (AtomicPredicator.template(props.metadata))
+                binaries.push({
+                    expression: props.config.atomist({
+                        explore: props.explore,
+                        entry: check_template({
+                            templates: props.metadata.templates,
+                            input: props.input,
+                        }),
+                        input: props.input,
+                    }),
+                    combined: false,
+                });
+        // NATIVE CLASSES
+        for (const native of props.metadata.natives)
+            binaries.push({
+                expression: check_native({
+                    name: native.name,
+                    input: props.input,
+                }),
+                combined: false,
+            });
+        const instances = [];
+        const prepare = (next) => instances.push(next);
+        // SETS
+        if (props.metadata.sets.length) {
+            const install = (body) => prepare({
+                head: check_native({
+                    name: "Set",
+                    input: props.input,
+                }),
+                expected: props.metadata.sets
+                    .map((elem) => `Set<${elem.getName()}>`)
+                    .join(" | "),
+                body,
+            });
+            if (props.metadata.sets.some((elem) => elem.value.any))
+                install(null);
+            else
+                install(explore_sets({
+                    config: props.config,
+                    context: props.context,
+                    functor: props.functor,
+                    sets: props.metadata.sets,
+                    input: props.input,
+                    explore: {
+                        ...props.explore,
+                        from: "array",
+                    },
+                }));
+        }
+        // MAPS
+        if (props.metadata.maps.length) {
+            const install = (body) => prepare({
+                head: check_native({
+                    name: "Map",
+                    input: props.input,
+                }),
+                expected: props.metadata.maps
+                    .map(({ key, value }) => `Map<${key}, ${value}>`)
+                    .join(" | "),
+                body,
+            });
+            if (props.metadata.maps.some((elem) => elem.key.any && elem.value.any))
+                install(null);
+            else
+                install(explore_maps({
+                    config: props.config,
+                    context: props.context,
+                    functor: props.functor,
+                    maps: props.metadata.maps,
+                    input: props.input,
+                    explore: {
+                        ...props.explore,
+                        from: "array",
+                    },
+                }));
+        }
+        // ARRAYS AND TUPLES
+        if (props.metadata.tuples.length + props.metadata.arrays.length > 0) {
+            const install = (body) => prepare({
+                head: props.config.atomist({
+                    explore: props.explore,
+                    entry: {
+                        expected: [
+                            ...props.metadata.tuples.map((t) => t.type.name),
+                            ...props.metadata.arrays.map((a) => a.getName()),
+                        ].join(" | "),
+                        expression: ExpressionFactory.isArray(props.input),
+                        conditions: [],
+                    },
+                    input: props.input,
+                }),
+                expected: [...props.metadata.tuples, ...props.metadata.arrays]
+                    .map((elem) => elem.type.name)
+                    .join(" | "),
+                body,
+            });
+            if (props.metadata.arrays.length === 0)
+                if (props.metadata.tuples.length === 1)
+                    install(decode_tuple({
+                        config: props.config,
+                        context: props.context,
+                        functor: props.functor,
+                        tuple: props.metadata.tuples[0],
+                        input: props.input,
+                        explore: {
+                            ...props.explore,
+                            from: "array",
+                        },
+                    }));
+                // TUPLE ONLY
+                else
+                    install(explore_tuples({
+                        config: props.config,
+                        context: props.context,
+                        functor: props.functor,
+                        tuples: props.metadata.tuples,
+                        input: props.input,
+                        explore: {
+                            ...props.explore,
+                            from: "array",
+                        },
+                    }));
+            else if (props.metadata.arrays.some((elem) => elem.type.value.any))
+                install(null);
+            else if (props.metadata.tuples.length === 0)
+                if (props.metadata.arrays.length === 1)
+                    // ARRAY ONLY
+                    install(decode_array({
+                        config: props.config,
+                        context: props.context,
+                        functor: props.functor,
+                        array: props.metadata.arrays[0],
+                        input: props.input,
+                        explore: {
+                            ...props.explore,
+                            from: "array",
+                        },
+                    }));
+                else
+                    install(explore_arrays({
+                        config: props.config,
+                        context: props.context,
+                        functor: props.functor,
+                        arrays: props.metadata.arrays,
+                        input: props.input,
+                        explore: {
+                            ...props.explore,
+                            from: "array",
+                        },
+                    }));
+            else
+                install(explore_arrays_and_tuples({
+                    config: props.config,
+                    context: props.context,
+                    functor: props.functor,
+                    definitions: [...props.metadata.tuples, ...props.metadata.arrays],
+                    input: props.input,
+                    explore: props.explore,
+                }));
+        }
+        // OBJECT
+        if (props.metadata.objects.length > 0)
+            prepare({
+                head: ExpressionFactory.isObject({
+                    checkNull: true,
+                    checkArray: props.metadata.objects.some((obj) => obj.type.properties.every((prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired())),
+                    input: props.input,
+                }),
+                expected: props.metadata.objects
+                    .map((obj) => obj.type.name)
+                    .join(" | "),
+                body: explore_objects({
+                    config: props.config,
+                    functor: props.functor,
+                    metadata: props.metadata,
+                    input: props.input,
+                    explore: {
+                        ...props.explore,
+                        from: "object",
+                    },
+                }),
+            });
+        if (instances.length) {
+            const transformer = (merge) => (instance) => instance.body
+                ? {
+                    expression: merge(instance.head, instance.body),
+                    combined: true,
+                }
+                : {
+                    expression: instance.head,
+                    combined: false,
+                };
+            if (instances.length === 1)
+                binaries.push(transformer((head, body) => props.config.combiner({
+                    explore: props.explore,
+                    logic: "and",
+                    input: props.input,
+                    binaries: [head, body].map((expression) => ({
+                        expression,
+                        combined: expression !== head,
+                    })),
+                    expected: props.metadata.getName(),
+                }))(instances[0]));
+            else
+                binaries.push({
+                    expression: props.config.combiner({
+                        explore: props.explore,
+                        logic: "or",
+                        input: props.input,
+                        binaries: instances.map(transformer(ts.factory.createLogicalAnd)),
+                        expected: props.metadata.getName(),
+                    }),
+                    combined: true,
+                });
+        }
+        // ESCAPED CASE
+        if (props.metadata.escaped !== null)
+            binaries.push({
+                combined: false,
+                expression: props.metadata.escaped.original.size() === 1 &&
+                    props.metadata.escaped.original.natives.length === 1
+                    ? check_native({
+                        name: props.metadata.escaped.original.natives[0].name,
+                        input: props.input,
+                    })
+                    : ts.factory.createLogicalAnd(CheckerProgrammer.decode({
+                        context: props.context,
+                        config: props.config,
+                        functor: props.functor,
+                        metadata: props.metadata.escaped.original,
+                        input: props.input,
+                        explore: props.explore,
+                    }), ts.factory.createLogicalAnd(IsProgrammer.decode_to_json({
+                        checkNull: false,
+                        input: props.input,
+                    }), decode_escaped({
+                        config: props.config,
+                        context: props.context,
+                        functor: props.functor,
+                        metadata: props.metadata.escaped.returns,
+                        input: props.input,
+                        explore: props.explore,
+                    }))),
+            });
+        //----
+        // COMBINE CONDITIONS
+        //----
+        return top.length && binaries.length
+            ? props.config.combiner({
+                explore: props.explore,
+                logic: "and",
+                input: props.input,
+                binaries: [
+                    ...top,
+                    {
+                        expression: props.config.combiner({
+                            explore: props.explore,
+                            logic: "or",
+                            input: props.input,
+                            binaries,
+                            expected: props.metadata.getName(),
+                        }),
+                        combined: true,
+                    },
+                ],
+                expected: props.metadata.getName(),
+            })
+            : binaries.length
+                ? props.config.combiner({
+                    explore: props.explore,
+                    logic: "or",
+                    input: props.input,
+                    binaries,
+                    expected: props.metadata.getName(),
+                })
+                : props.config.success;
+    };
+    CheckerProgrammer.decode_object = (props) => {
+        props.object.validated ||= true;
+        return FeatureProgrammer.decode_object(props);
+    };
+    const decode_array = (props) => {
+        if (props.array.type.recursive === false)
+            return decode_array_inline(props);
+        const arrayExplore = {
+            ...props.explore,
+            source: "function",
+            from: "array",
+        };
+        return ts.factory.createLogicalOr(ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}a${props.array.type.index}`)), undefined, FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: {
+                ...arrayExplore,
+                source: "function",
+                from: "array",
+            },
+            input: props.input,
+        })), props.config.joiner.failure({
+            input: props.input,
+            expected: props.array.type.name,
+            explore: arrayExplore,
+        }));
+    };
+    const decode_array_inline = (props) => {
+        const length = check_array_length({
+            context: props.context,
+            array: props.array,
+            input: props.input,
+        });
+        const main = FeatureProgrammer.decode_array({
+            config: {
+                prefix: props.config.prefix,
+                trace: props.config.trace,
+                path: props.config.path,
+                decoder: (next) => CheckerProgrammer.decode({
+                    ...props,
+                    ...next,
+                }),
+            },
+            functor: props.functor,
+            combiner: props.config.joiner.array,
+            array: props.array,
+            input: props.input,
+            explore: props.explore,
+        });
+        return length.expression === null && length.conditions.length === 0
+            ? main
+            : ts.factory.createLogicalAnd(props.config.atomist({
+                explore: props.explore,
+                input: props.input,
+                entry: length,
+            }), main);
+    };
+    const decode_tuple = (props) => {
+        if (props.tuple.type.recursive === false)
+            return decode_tuple_inline({
+                ...props,
+                tuple: props.tuple.type,
+            });
+        const arrayExplore = {
+            ...props.explore,
+            source: "function",
+            from: "array",
+        };
+        return ts.factory.createLogicalOr(ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}t${props.tuple.type.index}`)), undefined, FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: {
+                ...arrayExplore,
+                source: "function",
+            },
+            input: props.input,
+        })), props.config.joiner.failure({
+            input: props.input,
+            expected: props.tuple.type.name,
+            explore: arrayExplore,
+        }));
+    };
+    const decode_tuple_inline = (props) => {
+        const binaries = props.tuple.elements
+            .filter((metadata) => metadata.rest === null)
+            .map((metadata, index) => CheckerProgrammer.decode({
+            context: props.context,
+            config: props.config,
+            functor: props.functor,
+            input: ts.factory.createElementAccessExpression(props.input, index),
+            metadata,
+            explore: {
+                ...props.explore,
+                from: "array",
+                postfix: props.explore.postfix.length
+                    ? `${postfix_of_tuple(props.explore.postfix)}[${index}]"`
+                    : `"[${index}]"`,
+            },
+        }));
+        const rest = props.tuple.elements.length && props.tuple.elements.at(-1).rest !== null
+            ? CheckerProgrammer.decode({
+                config: props.config,
+                context: props.context,
+                functor: props.functor,
+                input: ts.factory.createCallExpression(IdentifierFactory.access(props.input, "slice"), undefined, [ExpressionFactory.number(props.tuple.elements.length - 1)]),
+                metadata: wrap_metadata_rest_tuple(props.tuple.elements.at(-1).rest),
+                explore: {
+                    ...props.explore,
+                    start: props.tuple.elements.length - 1,
+                },
+            })
+            : null;
+        const arrayLength = ts.factory.createPropertyAccessExpression(props.input, "length");
+        return props.config.combiner({
+            explore: props.explore,
+            logic: "and",
+            input: props.input,
+            binaries: [
+                ...(rest === null
+                    ? props.tuple.elements.every((t) => t.optional === false)
+                        ? [
+                            {
+                                combined: false,
+                                expression: ts.factory.createStrictEquality(arrayLength, ExpressionFactory.number(props.tuple.elements.length)),
+                            },
+                        ]
+                        : [
+                            {
+                                combined: false,
+                                expression: ts.factory.createLogicalAnd(ts.factory.createLessThanEquals(ExpressionFactory.number(props.tuple.elements.filter((t) => t.optional === false)
+                                    .length), arrayLength), ts.factory.createGreaterThanEquals(ExpressionFactory.number(props.tuple.elements.length), arrayLength)),
+                            },
+                        ]
+                    : []),
+                ...(props.config.joiner.tuple
+                    ? [
+                        {
+                            expression: props.config.joiner.tuple(binaries),
+                            combined: true,
+                        },
+                    ]
+                    : binaries.map((expression) => ({
+                        expression,
+                        combined: true,
+                    }))),
+                ...(rest !== null
+                    ? [
+                        {
+                            expression: rest,
+                            combined: true,
+                        },
+                    ]
+                    : []),
+            ],
+            expected: `[${props.tuple.elements.map((t) => t.getName()).join(", ")}]`,
+        });
+    };
+    const decode_escaped = (props) => ts.factory.createCallExpression(ts.factory.createParenthesizedExpression(ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))], undefined, undefined, CheckerProgrammer.decode({
+        ...props,
+        input: ts.factory.createIdentifier("input"),
+    }))), undefined, [
+        ts.factory.createCallExpression(IdentifierFactory.access(props.input, "toJSON"), undefined, []),
+    ]);
+    /* -----------------------------------------------------------
+          UNION TYPE EXPLORERS
+      ----------------------------------------------------------- */
+    const explore_sets = (props) => ts.factory.createCallExpression(UnionExplorer.set({
+        config: {
+            checker: (v) => CheckerProgrammer.decode({
+                context: props.context,
+                config: props.config,
+                functor: props.functor,
+                input: v.input,
+                metadata: v.definition,
+                explore: v.explore,
+            }),
+            decoder: (v) => decode_array({
+                config: props.config,
+                context: props.context,
+                functor: props.functor,
+                array: v.definition,
+                input: v.input,
+                explore: v.explore,
+            }),
+            empty: props.config.success,
+            success: props.config.success,
+            failure: (v) => ts.factory.createReturnStatement(props.config.joiner.failure(v)),
+        },
+        parameters: [],
+        input: props.input,
+        sets: props.sets,
+        explore: props.explore,
+    }), undefined, undefined);
+    const explore_maps = (props) => ts.factory.createCallExpression(UnionExplorer.map({
+        config: {
+            checker: (v) => ts.factory.createLogicalAnd(CheckerProgrammer.decode({
+                config: props.config,
+                context: props.context,
+                functor: props.functor,
+                input: ts.factory.createElementAccessExpression(v.input, 0),
+                metadata: v.definition[0],
+                explore: {
+                    ...v.explore,
+                    postfix: `${v.explore.postfix}[0]`,
+                },
+            }), CheckerProgrammer.decode({
+                config: props.config,
+                context: props.context,
+                functor: props.functor,
+                input: ts.factory.createElementAccessExpression(v.input, 1),
+                metadata: v.definition[1],
+                explore: {
+                    ...v.explore,
+                    postfix: `${v.explore.postfix}[1]`,
+                },
+            })),
+            decoder: (v) => decode_array({
+                context: props.context,
+                config: props.config,
+                functor: props.functor,
+                array: v.definition,
+                input: v.input,
+                explore: v.explore,
+            }),
+            empty: props.config.success,
+            success: props.config.success,
+            failure: (v) => ts.factory.createReturnStatement(props.config.joiner.failure(v)),
+        },
+        parameters: [],
+        input: props.input,
+        maps: props.maps,
+        explore: props.explore,
+    }), undefined, undefined);
+    const explore_tuples = (props) => explore_array_like_union_types({
+        config: props.config,
+        functor: props.functor,
+        factory: (next) => UnionExplorer.tuple({
+            config: {
+                checker: (v) => decode_tuple({
+                    context: props.context,
+                    config: props.config,
+                    functor: props.functor,
+                    input: v.input,
+                    tuple: v.definition,
+                    explore: v.explore,
+                }),
+                decoder: (v) => decode_tuple({
+                    context: props.context,
+                    config: props.config,
+                    functor: props.functor,
+                    tuple: v.definition,
+                    input: v.input,
+                    explore: v.explore,
+                }),
+                empty: props.config.success,
+                success: props.config.success,
+                failure: (v) => ts.factory.createReturnStatement(props.config.joiner.failure(v)),
+            },
+            parameters: next.parameters,
+            tuples: next.definitions,
+            input: next.input,
+            explore: next.explore,
+        }),
+        definitions: props.tuples,
+        input: props.input,
+        explore: props.explore,
+    });
+    const explore_arrays = (props) => explore_array_like_union_types({
+        config: props.config,
+        functor: props.functor,
+        factory: (next) => UnionExplorer.array({
+            config: {
+                checker: (v) => CheckerProgrammer.decode({
+                    context: props.context,
+                    config: props.config,
+                    functor: props.functor,
+                    metadata: v.definition,
+                    input: v.input,
+                    explore: v.explore,
+                }),
+                decoder: (v) => decode_array({
+                    context: props.context,
+                    config: props.config,
+                    functor: props.functor,
+                    array: v.definition,
+                    input: v.input,
+                    explore: v.explore,
+                }),
+                empty: props.config.success,
+                success: props.config.success,
+                failure: (v) => ts.factory.createReturnStatement(props.config.joiner.failure(v)),
+            },
+            parameters: next.parameters,
+            arrays: next.definitions,
+            input: next.input,
+            explore: next.explore,
+        }),
+        definitions: props.arrays,
+        input: props.input,
+        explore: props.explore,
+    });
+    const explore_arrays_and_tuples = (props) => explore_array_like_union_types({
+        config: props.config,
+        functor: props.functor,
+        factory: (next) => UnionExplorer.array_or_tuple({
+            config: {
+                checker: (v) => v.definition instanceof MetadataTuple
+                    ? decode_tuple({
+                        config: props.config,
+                        context: props.context,
+                        functor: props.functor,
+                        input: v.input,
+                        tuple: v.definition,
+                        explore: v.explore,
+                    })
+                    : props.config.atomist({
+                        explore: v.explore,
+                        entry: {
+                            expected: props.definitions
+                                .map((elem) => elem instanceof MetadataArray
+                                ? elem.getName()
+                                : elem.type.name)
+                                .join(" | "),
+                            expression: CheckerProgrammer.decode({
+                                functor: props.functor,
+                                context: props.context,
+                                config: props.config,
+                                metadata: v.definition,
+                                input: v.input,
+                                explore: v.explore,
+                            }),
+                            conditions: [],
+                        },
+                        input: v.container,
+                    }),
+                decoder: (v) => v.definition instanceof MetadataTuple
+                    ? decode_tuple({
+                        context: props.context,
+                        config: props.config,
+                        functor: props.functor,
+                        input: v.input,
+                        tuple: v.definition,
+                        explore: v.explore,
+                    })
+                    : decode_array({
+                        context: props.context,
+                        config: props.config,
+                        functor: props.functor,
+                        input: v.input,
+                        array: v.definition,
+                        explore: v.explore,
+                    }),
+                empty: props.config.success,
+                success: props.config.success,
+                failure: (v) => ts.factory.createReturnStatement(props.config.joiner.failure(v)),
+            },
+            parameters: next.parameters,
+            definitions: next.definitions,
+            input: next.input,
+            explore: next.explore,
+        }),
+        input: props.input,
+        definitions: props.definitions,
+        explore: props.explore,
+    });
+    const explore_array_like_union_types = (props) => {
+        const arrow = (next) => props.factory({
+            parameters: next.parameters,
+            definitions: props.definitions,
+            input: next.input,
+            explore: next.explore,
+        });
+        if (props.definitions.every((e) => e.type.recursive === false))
+            ts.factory.createCallExpression(arrow({
+                explore: props.explore,
+                input: props.input,
+                parameters: [],
+            }), undefined, []);
+        const arrayExplore = {
+            ...props.explore,
+            source: "function",
+            from: "array",
+        };
+        return ts.factory.createLogicalOr(ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.emplaceUnion(props.config.prefix, props.definitions.map((e) => e.type.name).join(" | "), () => arrow({
+            parameters: FeatureProgrammer.parameterDeclarations({
+                config: props.config,
+                type: TypeFactory.keyword("any"),
+                input: ts.factory.createIdentifier("input"),
+            }),
+            explore: {
+                ...arrayExplore,
+                postfix: "",
+            },
+            input: ts.factory.createIdentifier("input"),
+        }))), undefined, FeatureProgrammer.argumentsArray(props)), props.config.joiner.failure({
+            input: props.input,
+            expected: props.definitions.map((e) => e.type.name).join(" | "),
+            explore: arrayExplore,
+        }));
+    };
+    const explore_objects = (props) => props.metadata.objects.length === 1
+        ? CheckerProgrammer.decode_object({
+            config: props.config,
+            functor: props.functor,
+            object: props.metadata.objects[0].type,
+            input: props.input,
+            explore: props.explore,
+        })
+        : ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}u${props.metadata.union_index}`)), undefined, FeatureProgrammer.argumentsArray(props));
+})(CheckerProgrammer || (CheckerProgrammer = {}));
+const create_add = (props) => {
+    const factory = props.exact
+        ? ts.factory.createStrictEquality
+        : ts.factory.createStrictInequality;
+    props.binaries.push({
+        expression: factory(props.left, props.right ?? props.default),
+        combined: false,
+    });
+};
+
+export { CheckerProgrammer };
+//# sourceMappingURL=CheckerProgrammer.mjs.map