typia 8.0.0 → 8.0.1

package/lib/programmers/misc/MiscIsCloneProgrammer.mjs

@@ -0,0 +1,64 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { IsProgrammer } from '../IsProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { MiscCloneProgrammer } from './MiscCloneProgrammer.mjs';
+
+var MiscIsCloneProgrammer;
+(function (MiscIsCloneProgrammer) {
+    MiscIsCloneProgrammer.decompose = (props) => {
+        const is = IsProgrammer.decompose({
+            ...props,
+            config: {
+                equals: false,
+            },
+        });
+        const clone = MiscCloneProgrammer.decompose({
+            ...props,
+            validated: true,
+        });
+        return {
+            functions: {
+                ...is.functions,
+                ...clone.functions,
+            },
+            statements: [
+                ...is.statements,
+                ...clone.statements,
+                StatementFactory.constant({
+                    name: "__is",
+                    value: is.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__clone",
+                    value: clone.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))], ts.factory.createUnionTypeNode([
+                clone.arrow.type ?? TypeFactory.keyword("any"),
+                ts.factory.createTypeReferenceNode("null"),
+            ]), undefined, ts.factory.createBlock([
+                ts.factory.createIfStatement(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, ts.factory.createCallExpression(ts.factory.createIdentifier("__is"), undefined, [ts.factory.createIdentifier("input")])), ts.factory.createReturnStatement(ts.factory.createNull())),
+                ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("__clone"), undefined, [ts.factory.createIdentifier("input")])),
+            ], true)),
+        };
+    };
+    MiscIsCloneProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = MiscIsCloneProgrammer.decompose({
+            ...props,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(MiscIsCloneProgrammer || (MiscIsCloneProgrammer = {}));
+
+export { MiscIsCloneProgrammer };
+//# sourceMappingURL=MiscIsCloneProgrammer.mjs.map

package/lib/programmers/misc/MiscIsCloneProgrammer.mjs.map

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

package/lib/programmers/misc/MiscIsPruneProgrammer.mjs

@@ -0,0 +1,62 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { IsProgrammer } from '../IsProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { MiscPruneProgrammer } from './MiscPruneProgrammer.mjs';
+
+var MiscIsPruneProgrammer;
+(function (MiscIsPruneProgrammer) {
+    MiscIsPruneProgrammer.decompose = (props) => {
+        const is = IsProgrammer.decompose({
+            ...props,
+            config: {
+                equals: false,
+            },
+        });
+        const prune = MiscPruneProgrammer.decompose({
+            ...props,
+            validated: true,
+        });
+        return {
+            functions: {
+                ...is.functions,
+                ...prune.functions,
+            },
+            statements: [
+                ...is.statements,
+                ...prune.statements,
+                StatementFactory.constant({
+                    name: "__is",
+                    value: is.arrow,
+                }),
+                StatementFactory.constant({
+                    name: "__prune",
+                    value: prune.arrow,
+                }),
+            ],
+            arrow: ts.factory.createArrowFunction(undefined, undefined, [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))], is.arrow.type, undefined, ts.factory.createBlock([
+                ts.factory.createIfStatement(ts.factory.createEquality(ts.factory.createFalse(), ts.factory.createCallExpression(ts.factory.createIdentifier("__is"), undefined, [ts.factory.createIdentifier("input")])), ts.factory.createReturnStatement(ts.factory.createFalse())),
+                ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("__prune"), undefined, [ts.factory.createIdentifier("input")])),
+                ts.factory.createReturnStatement(ts.factory.createTrue()),
+            ], true)),
+        };
+    };
+    MiscIsPruneProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = MiscIsPruneProgrammer.decompose({
+            ...props,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+})(MiscIsPruneProgrammer || (MiscIsPruneProgrammer = {}));
+
+export { MiscIsPruneProgrammer };
+//# sourceMappingURL=MiscIsPruneProgrammer.mjs.map

package/lib/programmers/misc/MiscIsPruneProgrammer.mjs.map

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

package/lib/programmers/misc/MiscLiteralsProgrammer.mjs

@@ -0,0 +1,65 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { MetadataCollection } from '../../factories/MetadataCollection.mjs';
+import { MetadataFactory } from '../../factories/MetadataFactory.mjs';
+import { TransformerError } from '../../transformers/TransformerError.mjs';
+
+var MiscLiteralsProgrammer;
+(function (MiscLiteralsProgrammer) {
+    MiscLiteralsProgrammer.write = (props) => {
+        const result = MetadataFactory.analyze({
+            checker: props.context.checker,
+            transformer: props.context.transformer,
+            options: {
+                escape: true,
+                constant: true,
+                absorb: true,
+                validate: (meta) => {
+                    const length = meta.constants
+                        .map((c) => c.values.length)
+                        .reduce((a, b) => a + b, 0) +
+                        meta.atomics.filter((a) => a.type === "boolean").length;
+                    if (0 === length)
+                        return [ErrorMessages.NO];
+                    else if (meta.size() !== length)
+                        return [ErrorMessages.ONLY];
+                    return [];
+                },
+            },
+            collection: new MetadataCollection(),
+            type: props.type,
+        });
+        if (result.success === false)
+            throw TransformerError.from({
+                code: `typia.misc.literals`,
+                errors: result.errors,
+            });
+        const metadata = result.data;
+        const values = new Set([
+            ...metadata.constants.map((c) => c.values.map((v) => v.value)).flat(),
+            ...(metadata.atomics.filter((a) => a.type === "boolean").length
+                ? [true, false]
+                : []),
+            ...(metadata.nullable ? [null] : []),
+        ]);
+        return ts.factory.createAsExpression(ts.factory.createArrayLiteralExpression([...values].map((v) => v === null
+            ? ts.factory.createNull()
+            : typeof v === "boolean"
+                ? v
+                    ? ts.factory.createTrue()
+                    : ts.factory.createFalse()
+                : typeof v === "number"
+                    ? ExpressionFactory.number(v)
+                    : typeof v === "bigint"
+                        ? ExpressionFactory.bigint(Number(v))
+                        : ts.factory.createStringLiteral(v)), true), ts.factory.createTypeReferenceNode("const"));
+    };
+})(MiscLiteralsProgrammer || (MiscLiteralsProgrammer = {}));
+var ErrorMessages;
+(function (ErrorMessages) {
+    ErrorMessages["NO"] = "no constant literal type found.";
+    ErrorMessages["ONLY"] = "only constant literal types are allowed.";
+})(ErrorMessages || (ErrorMessages = {}));
+
+export { MiscLiteralsProgrammer };
+//# sourceMappingURL=MiscLiteralsProgrammer.mjs.map

package/lib/programmers/misc/MiscLiteralsProgrammer.mjs.map

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

package/lib/programmers/misc/MiscPruneProgrammer.mjs

@@ -0,0 +1,475 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { MetadataCollection } from '../../factories/MetadataCollection.mjs';
+import { MetadataFactory } from '../../factories/MetadataFactory.mjs';
+import { StatementFactory } from '../../factories/StatementFactory.mjs';
+import { TypeFactory } from '../../factories/TypeFactory.mjs';
+import { Metadata } from '../../schemas/metadata/Metadata.mjs';
+import { MetadataArray } from '../../schemas/metadata/MetadataArray.mjs';
+import { TransformerError } from '../../transformers/TransformerError.mjs';
+import { FeatureProgrammer } from '../FeatureProgrammer.mjs';
+import { IsProgrammer } from '../IsProgrammer.mjs';
+import { FunctionProgrammer } from '../helpers/FunctionProgrammer.mjs';
+import { PruneJoiner } from '../helpers/PruneJoiner.mjs';
+import { UnionExplorer } from '../helpers/UnionExplorer.mjs';
+import { decode_union_object } from '../internal/decode_union_object.mjs';
+import { postfix_of_tuple } from '../internal/postfix_of_tuple.mjs';
+import { wrap_metadata_rest_tuple } from '../internal/wrap_metadata_rest_tuple.mjs';
+
+var MiscPruneProgrammer;
+(function (MiscPruneProgrammer) {
+    MiscPruneProgrammer.decompose = (props) => {
+        const config = configure(props);
+        if (props.validated === false)
+            config.addition = (collection) => IsProgrammer.write_function_statements({
+                context: props.context,
+                functor: props.functor,
+                collection,
+            });
+        const composed = FeatureProgrammer.compose({
+            ...props,
+            config,
+        });
+        return {
+            functions: composed.functions,
+            statements: composed.statements,
+            arrow: ts.factory.createArrowFunction(undefined, undefined, composed.parameters, composed.response, undefined, composed.body),
+        };
+    };
+    MiscPruneProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer(props.modulo.getText());
+        const result = MiscPruneProgrammer.decompose({
+            ...props,
+            validated: false,
+            functor,
+        });
+        return FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+    const 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({
+            config: props.config,
+            functor: props.functor,
+            input: ts.factory.createIdentifier("input"),
+            array: MetadataArray.create({
+                type,
+                tags: [],
+            }),
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+            },
+        })),
+    }));
+    const 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({
+            context: props.context,
+            config: props.config,
+            functor: props.functor,
+            input: ts.factory.createIdentifier("input"),
+            tuple,
+            explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+            },
+        })),
+    }));
+    /* -----------------------------------------------------------
+          DECODERS
+      ----------------------------------------------------------- */
+    const decode = (props) => {
+        if (filter(props.metadata) === false)
+            return ts.factory.createBlock([]);
+        const unions = [];
+        //----
+        // LIST UP UNION TYPES
+        //----
+        // TUPLES
+        for (const tuple of props.metadata.tuples.filter((tuple) => tuple.type.elements.some((e) => filter(e.rest ?? e))))
+            unions.push({
+                type: "tuple",
+                is: () => IsProgrammer.decode({
+                    ...props,
+                    metadata: (() => {
+                        const partial = Metadata.initialize();
+                        partial.tuples.push(tuple);
+                        return partial;
+                    })(),
+                }),
+                value: () => decode_tuple({
+                    ...props,
+                    tuple,
+                }),
+            });
+        // ARRAYS
+        if (props.metadata.arrays.filter((a) => filter(a.type.value)).length)
+            unions.push({
+                type: "array",
+                is: () => ExpressionFactory.isArray(props.input),
+                value: () => explore_arrays({
+                    ...props,
+                    arrays: props.metadata.arrays,
+                    explore: {
+                        ...props.explore,
+                        from: "array",
+                    },
+                }),
+            });
+        // BUILT-IN CLASSES
+        if (props.metadata.natives.length)
+            for (const native of props.metadata.natives)
+                unions.push({
+                    type: "native",
+                    is: () => ExpressionFactory.isInstanceOf(native.name, props.input),
+                    value: () => ts.factory.createReturnStatement(),
+                });
+        if (props.metadata.sets.length)
+            unions.push({
+                type: "set",
+                is: () => ExpressionFactory.isInstanceOf("Set", props.input),
+                value: () => ts.factory.createReturnStatement(),
+            });
+        if (props.metadata.maps.length)
+            unions.push({
+                type: "map",
+                is: () => ExpressionFactory.isInstanceOf("Map", props.input),
+                value: () => ts.factory.createReturnStatement(),
+            });
+        // OBJECTS
+        if (props.metadata.objects.length)
+            unions.push({
+                type: "object",
+                is: () => ExpressionFactory.isObject({
+                    checkNull: true,
+                    checkArray: false,
+                    input: props.input,
+                }),
+                value: () => explore_objects({
+                    ...props,
+                    explore: {
+                        ...props.explore,
+                        from: "object",
+                    },
+                }),
+            });
+        //----
+        // STATEMENTS
+        //----
+        const converter = (v) => ts.isReturnStatement(v) || ts.isBlock(v)
+            ? v
+            : ts.factory.createExpressionStatement(v);
+        const statements = unions.map((u) => ts.factory.createIfStatement(u.is(), converter(u.value())));
+        return ts.factory.createBlock(statements, true);
+    };
+    const decode_object = (props) => FeatureProgrammer.decode_object({
+        config: {
+            trace: false,
+            path: false,
+            prefix: PREFIX,
+        },
+        functor: props.functor,
+        object: props.object,
+        input: props.input,
+        explore: props.explore,
+    });
+    const decode_array = (props) => props.array.type.recursive
+        ? ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}a${props.array.type.index}`)), undefined, FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: {
+                ...props.explore,
+                source: "function",
+                from: "array",
+            },
+            input: props.input,
+        }))
+        : decode_array_inline(props);
+    const decode_array_inline = (props) => FeatureProgrammer.decode_array({
+        config: props.config,
+        functor: props.functor,
+        combiner: PruneJoiner.array,
+        array: props.array,
+        input: props.input,
+        explore: props.explore,
+    });
+    const decode_tuple = (props) => props.tuple.type.recursive
+        ? ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.useLocal(`${props.config.prefix}t${props.tuple.type.index}`)), undefined, FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: {
+                ...props.explore,
+                source: "function",
+            },
+            input: props.input,
+        }))
+        : decode_tuple_inline({
+            ...props,
+            tuple: props.tuple.type,
+        });
+    const decode_tuple_inline = (props) => {
+        const elements = props.tuple.elements
+            .map((elem, index) => [elem, index])
+            .filter(([elem]) => filter(elem) && elem.rest === null)
+            .map(([elem, index]) => decode({
+            context: props.context,
+            config: props.config,
+            functor: props.functor,
+            input: ts.factory.createElementAccessExpression(props.input, index),
+            metadata: elem,
+            explore: {
+                ...props.explore,
+                from: "array",
+                postfix: props.explore.postfix.length
+                    ? `${postfix_of_tuple(props.explore.postfix)}[${index}]"`
+                    : `"[${index}]"`,
+            },
+        }));
+        const rest = (() => {
+            if (props.tuple.elements.length === 0)
+                return null;
+            const last = props.tuple.elements.at(-1);
+            const rest = last.rest;
+            if (rest === null || filter(rest) === false)
+                return null;
+            return decode({
+                context: props.context,
+                config: props.config,
+                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,
+                },
+            });
+        })();
+        return PruneJoiner.tuple({
+            elements,
+            rest,
+        });
+    };
+    /* -----------------------------------------------------------
+          UNION TYPE EXPLORERS
+      ----------------------------------------------------------- */
+    const explore_objects = (props) => {
+        if (props.metadata.objects.length === 1)
+            return decode_object({
+                ...props,
+                object: props.metadata.objects[0].type,
+            });
+        return ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.useLocal(`${PREFIX}u${props.metadata.union_index}`)), undefined, FeatureProgrammer.argumentsArray(props));
+    };
+    const explore_arrays = (props) => explore_array_like_union_types({
+        ...props,
+        elements: props.arrays,
+        factory: (next) => UnionExplorer.array({
+            config: {
+                checker: (v) => IsProgrammer.decode({
+                    context: props.context,
+                    functor: props.functor,
+                    metadata: v.definition,
+                    input: v.input,
+                    explore: v.explore,
+                }),
+                decoder: (v) => decode_array({
+                    config: props.config,
+                    functor: props.functor,
+                    input: v.input,
+                    array: v.definition,
+                    explore: v.explore,
+                }),
+                empty: ts.factory.createStringLiteral("[]"),
+                success: ts.factory.createTrue(),
+                failure: (v) => create_throw_error({
+                    context: props.context,
+                    functor: props.functor,
+                    expected: v.expected,
+                    input: v.input,
+                }),
+            },
+            parameters: next.parameters,
+            input: next.input,
+            arrays: next.definitions,
+            explore: next.explore,
+        }),
+    });
+    //(next.parameters)(next.input, next.elements, next.explore),
+    const explore_array_like_union_types = (props) => {
+        const arrow = (next) => props.factory({
+            definitions: props.elements,
+            parameters: next.parameters,
+            input: next.input,
+            explore: next.explore,
+        });
+        if (props.elements.every((e) => e.type.recursive === false))
+            ts.factory.createCallExpression(arrow({
+                parameters: [],
+                explore: props.explore,
+                input: props.input,
+            }), undefined, []);
+        const arrayExplore = {
+            ...props.explore,
+            source: "function",
+            from: "array",
+        };
+        return ts.factory.createCallExpression(ts.factory.createIdentifier(props.functor.emplaceUnion(props.config.prefix, props.elements.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));
+    };
+    // @todo -> must filter out recursive visit
+    const filter = (metadata) => metadata.any === false &&
+        (metadata.objects.length !== 0 ||
+            metadata.tuples.some((t) => !!t.type.elements.length &&
+                t.type.elements.some((e) => filter(e.rest ?? e))) ||
+            metadata.arrays.some((e) => filter(e.type.value)));
+    /* -----------------------------------------------------------
+          CONFIGURATIONS
+      ----------------------------------------------------------- */
+    const PREFIX = "_p";
+    const configure = (props) => {
+        const config = {
+            types: {
+                input: (type, name) => ts.factory.createTypeReferenceNode(name ??
+                    TypeFactory.getFullName({ checker: props.context.checker, type })),
+                output: () => TypeFactory.keyword("void"),
+            },
+            prefix: PREFIX,
+            trace: false,
+            path: false,
+            initializer,
+            decoder: (next) => decode({
+                context: props.context,
+                functor: props.functor,
+                config,
+                input: next.input,
+                metadata: next.metadata,
+                explore: next.explore,
+            }),
+            objector: {
+                checker: (next) => IsProgrammer.decode({
+                    context: props.context,
+                    functor: props.functor,
+                    input: next.input,
+                    metadata: next.metadata,
+                    explore: next.explore,
+                }),
+                decoder: (next) => decode_object({
+                    functor: props.functor,
+                    input: next.input,
+                    object: next.object,
+                    explore: next.explore,
+                }),
+                joiner: PruneJoiner.object,
+                unionizer: (next) => decode_union_object({
+                    checker: (v) => IsProgrammer.decode_object({
+                        context: props.context,
+                        functor: props.functor,
+                        input: v.input,
+                        object: v.object,
+                        explore: v.explore,
+                    }),
+                    decoder: (v) => decode_object({
+                        functor: props.functor,
+                        input: v.input,
+                        object: v.object,
+                        explore: v.explore,
+                    }),
+                    success: (exp) => exp,
+                    escaper: (v) => create_throw_error({
+                        context: props.context,
+                        functor: props.functor,
+                        expected: v.expected,
+                        input: v.input,
+                    }),
+                    input: next.input,
+                    objects: next.objects,
+                    explore: next.explore,
+                }),
+                failure: (next) => create_throw_error({
+                    context: props.context,
+                    functor: props.functor,
+                    expected: next.expected,
+                    input: next.input,
+                }),
+            },
+            generator: {
+                arrays: (collection) => write_array_functions({
+                    config,
+                    functor: props.functor,
+                    collection,
+                }),
+                tuples: (collection) => write_tuple_functions({
+                    config,
+                    context: props.context,
+                    functor: props.functor,
+                    collection,
+                }),
+            },
+        };
+        return config;
+    };
+    const initializer = (props) => {
+        const collection = new MetadataCollection();
+        const result = MetadataFactory.analyze({
+            checker: props.context.checker,
+            transformer: props.context.transformer,
+            options: {
+                escape: false,
+                constant: true,
+                absorb: true,
+            },
+            collection,
+            type: props.type,
+        });
+        if (result.success === false)
+            throw TransformerError.from({
+                code: props.functor.method,
+                errors: result.errors,
+            });
+        return {
+            collection,
+            metadata: result.data,
+        };
+    };
+    const create_throw_error = (props) => ts.factory.createExpressionStatement(ts.factory.createCallExpression(props.context.importer.internal("throwTypeGuardError"), [], [
+        ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment("method", ts.factory.createStringLiteral(props.functor.method)),
+            ts.factory.createPropertyAssignment("expected", ts.factory.createStringLiteral(props.expected)),
+            ts.factory.createPropertyAssignment("value", props.input),
+        ], true),
+    ]));
+})(MiscPruneProgrammer || (MiscPruneProgrammer = {}));
+
+export { MiscPruneProgrammer };
+//# sourceMappingURL=MiscPruneProgrammer.mjs.map

package/lib/programmers/misc/MiscPruneProgrammer.mjs.map

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