@typia/core 12.0.0-dev.20260225

package/lib/programmers/RandomProgrammer.js

@@ -0,0 +1,675 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomProgrammer = void 0;
+const utils_1 = require("@typia/utils");
+const typescript_1 = __importDefault(require("typescript"));
+const TransformerError_1 = require("../context/TransformerError");
+const ExpressionFactory_1 = require("../factories/ExpressionFactory");
+const IdentifierFactory_1 = require("../factories/IdentifierFactory");
+const LiteralFactory_1 = require("../factories/LiteralFactory");
+const MetadataCommentTagFactory_1 = require("../factories/MetadataCommentTagFactory");
+const MetadataFactory_1 = require("../factories/MetadataFactory");
+const StatementFactory_1 = require("../factories/StatementFactory");
+const TemplateFactory_1 = require("../factories/TemplateFactory");
+const TypeFactory_1 = require("../factories/TypeFactory");
+const MetadataArray_1 = require("../schemas/metadata/MetadataArray");
+const MetadataArrayType_1 = require("../schemas/metadata/MetadataArrayType");
+const MetadataAtomic_1 = require("../schemas/metadata/MetadataAtomic");
+const MetadataSchema_1 = require("../schemas/metadata/MetadataSchema");
+const MetadataStorage_1 = require("../schemas/metadata/MetadataStorage");
+const MetadataTuple_1 = require("../schemas/metadata/MetadataTuple");
+const MetadataTupleType_1 = require("../schemas/metadata/MetadataTupleType");
+const FunctionProgrammer_1 = require("./helpers/FunctionProgrammer");
+const RandomJoiner_1 = require("./helpers/RandomJoiner");
+const FeatureProgrammer_1 = require("./internal/FeatureProgrammer");
+const json_schema_array_1 = require("./iterate/json_schema_array");
+const json_schema_bigint_1 = require("./iterate/json_schema_bigint");
+const json_schema_boolean_1 = require("./iterate/json_schema_boolean");
+const json_schema_number_1 = require("./iterate/json_schema_number");
+const json_schema_string_1 = require("./iterate/json_schema_string");
+/**
+ * Random data generator code generator.
+ *
+ * Generates code that creates random values matching type constraints. Used by
+ * `typia.random<T>()`.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+var RandomProgrammer;
+(function (RandomProgrammer) {
+    RandomProgrammer.decompose = (props) => {
+        var _a, _b;
+        const collection = new MetadataStorage_1.MetadataStorage();
+        const result = MetadataFactory_1.MetadataFactory.analyze({
+            checker: props.context.checker,
+            transformer: props.context.transformer,
+            options: {
+                escape: false,
+                constant: true,
+                absorb: true,
+                validate: (meta) => {
+                    const output = [];
+                    if (meta.natives.some((native) => native.name === "WeakSet"))
+                        output.push(`WeakSet is not supported.`);
+                    else if (meta.natives.some((native) => native.name === "WeakMap"))
+                        output.push(`WeakMap is not supported.`);
+                    return output;
+                },
+            },
+            components: collection,
+            type: props.type,
+        });
+        if (result.success === false)
+            throw TransformerError_1.TransformerError.from({
+                code: props.functor.method,
+                errors: result.errors,
+            });
+        // GENERATE FUNCTION
+        const functions = Object.fromEntries([
+            ...write_object_functions({
+                context: props.context,
+                functor: props.functor,
+                collection,
+            }).map((v, i) => [Prefix.object(i), v]),
+            ...write_array_functions({
+                context: props.context,
+                functor: props.functor,
+                collection,
+            }).map((v, i) => [Prefix.array(i), v]),
+            ...write_tuple_functions({
+                context: props.context,
+                functor: props.functor,
+                collection,
+            }).map((v, i) => [Prefix.tuple(i), v]),
+        ]);
+        const arrow = typescript_1.default.factory.createArrowFunction(undefined, undefined, [
+            IdentifierFactory_1.IdentifierFactory.parameter("generator", typescript_1.default.factory.createTypeReferenceNode("Partial", [
+                props.context.importer.type({
+                    file: "typia",
+                    name: "IRandomGenerator",
+                }),
+            ]), (_a = props.init) !== null && _a !== void 0 ? _a : typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionToken)),
+        ], props.context.importer.type({
+            file: "typia",
+            name: "Resolved",
+            arguments: [
+                typescript_1.default.factory.createTypeReferenceNode((_b = props.name) !== null && _b !== void 0 ? _b : TypeFactory_1.TypeFactory.getFullName({
+                    checker: props.context.checker,
+                    type: props.type,
+                })),
+            ],
+        }), undefined, typescript_1.default.factory.createBlock([
+            typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createBinaryExpression(typescript_1.default.factory.createIdentifier("_generator"), typescript_1.default.SyntaxKind.EqualsToken, typescript_1.default.factory.createIdentifier("generator"))),
+            typescript_1.default.factory.createReturnStatement(decode({
+                context: props.context,
+                functor: props.functor,
+                explore: {
+                    function: false,
+                    recursive: false,
+                },
+                metadata: result.data,
+            })),
+        ], true));
+        return {
+            functions,
+            statements: [
+                StatementFactory_1.StatementFactory.mut({
+                    name: "_generator",
+                    type: typescript_1.default.factory.createUnionTypeNode([
+                        typescript_1.default.factory.createTypeReferenceNode("Partial", [
+                            props.context.importer.type({
+                                file: "typia",
+                                name: "IRandomGenerator",
+                            }),
+                        ]),
+                        typescript_1.default.factory.createTypeReferenceNode("undefined"),
+                    ]),
+                }),
+            ],
+            arrow,
+        };
+    };
+    RandomProgrammer.write = (props) => {
+        const functor = new FunctionProgrammer_1.FunctionProgrammer(props.modulo.getText());
+        const result = RandomProgrammer.decompose(Object.assign(Object.assign({}, props), { functor }));
+        return FeatureProgrammer_1.FeatureProgrammer.writeDecomposed({
+            modulo: props.modulo,
+            functor,
+            result,
+        });
+    };
+    const write_object_functions = (props) => props.collection.objects().map((obj, i) => StatementFactory_1.StatementFactory.constant({
+        name: Prefix.object(i),
+        value: typescript_1.default.factory.createArrowFunction(undefined, undefined, [
+            IdentifierFactory_1.IdentifierFactory.parameter("_recursive", TypeFactory_1.TypeFactory.keyword("boolean"), typescript_1.default.factory.createIdentifier(String(obj.recursive))),
+            IdentifierFactory_1.IdentifierFactory.parameter("_depth", TypeFactory_1.TypeFactory.keyword("number"), ExpressionFactory_1.ExpressionFactory.number(0)),
+        ], TypeFactory_1.TypeFactory.keyword("any"), undefined, RandomJoiner_1.RandomJoiner.object({
+            decode: (metadata) => decode({
+                context: props.context,
+                functor: props.functor,
+                explore: {
+                    recursive: obj.recursive,
+                    function: true,
+                },
+                metadata,
+            }),
+            object: obj,
+        })),
+    }));
+    const write_array_functions = (props) => props.collection
+        .arrays()
+        .filter((a) => a.recursive)
+        .map((array, i) => StatementFactory_1.StatementFactory.constant({
+        name: Prefix.array(i),
+        value: typescript_1.default.factory.createArrowFunction(undefined, undefined, [
+            IdentifierFactory_1.IdentifierFactory.parameter("_schema", TypeFactory_1.TypeFactory.keyword("boolean")),
+            IdentifierFactory_1.IdentifierFactory.parameter("_recursive", TypeFactory_1.TypeFactory.keyword("boolean"), typescript_1.default.factory.createTrue()),
+            IdentifierFactory_1.IdentifierFactory.parameter("_depth", TypeFactory_1.TypeFactory.keyword("number"), ExpressionFactory_1.ExpressionFactory.number(0)),
+        ], TypeFactory_1.TypeFactory.keyword("any"), undefined, RandomJoiner_1.RandomJoiner.array({
+            decode: (metadata) => decode({
+                context: props.context,
+                functor: props.functor,
+                explore: {
+                    recursive: true,
+                    function: true,
+                },
+                metadata,
+            }),
+            recursive: true,
+            expression: coalesce({
+                context: props.context,
+                method: "array",
+                internal: "randomArray",
+            }),
+            array,
+            schema: undefined,
+        })),
+    }));
+    const write_tuple_functions = (props) => props.collection
+        .tuples()
+        .filter((a) => a.recursive)
+        .map((tuple, i) => StatementFactory_1.StatementFactory.constant({
+        name: Prefix.tuple(i),
+        value: typescript_1.default.factory.createArrowFunction(undefined, undefined, [
+            IdentifierFactory_1.IdentifierFactory.parameter("_recursive", TypeFactory_1.TypeFactory.keyword("boolean"), typescript_1.default.factory.createTrue()),
+            IdentifierFactory_1.IdentifierFactory.parameter("_depth", TypeFactory_1.TypeFactory.keyword("number"), ExpressionFactory_1.ExpressionFactory.number(0)),
+        ], TypeFactory_1.TypeFactory.keyword("any"), undefined, RandomJoiner_1.RandomJoiner.tuple({
+            decode: (metadata) => decode({
+                context: props.context,
+                functor: props.functor,
+                explore: {
+                    function: true,
+                    recursive: true,
+                },
+                metadata,
+            }),
+            elements: tuple.elements,
+        })),
+    }));
+    /* -----------------------------------------------------------
+      DECODERS
+    ----------------------------------------------------------- */
+    const decode = (props) => {
+        const expressions = [];
+        if (props.metadata.any === true)
+            expressions.push(typescript_1.default.factory.createStringLiteral("any type used..."));
+        // NULL COALESCING
+        if (props.metadata.isRequired() === false ||
+            props.metadata.functions.length !== 0)
+            expressions.push(typescript_1.default.factory.createIdentifier("undefined"));
+        if (props.metadata.nullable === true)
+            expressions.push(typescript_1.default.factory.createNull());
+        // CONSTANT TYPES
+        for (const constant of props.metadata.constants)
+            for (const { value } of constant.values)
+                expressions.push(constant.type === "boolean"
+                    ? value === true
+                        ? typescript_1.default.factory.createTrue()
+                        : typescript_1.default.factory.createFalse()
+                    : constant.type === "bigint"
+                        ? ExpressionFactory_1.ExpressionFactory.bigint(value)
+                        : constant.type === "number"
+                            ? ExpressionFactory_1.ExpressionFactory.number(value)
+                            : typescript_1.default.factory.createStringLiteral(value));
+        // ATOMIC VARIABLES
+        for (const template of props.metadata.templates)
+            expressions.push(decode_template(Object.assign(Object.assign({}, props), { template })));
+        for (const atomic of props.metadata.atomics)
+            expressions.push(...decode_atomic({
+                context: props.context,
+                atomic,
+            }));
+        // INSTANCE TYPES
+        if (props.metadata.escaped)
+            expressions.push(decode(Object.assign(Object.assign({}, props), { metadata: props.metadata.escaped.returns })));
+        for (const array of props.metadata.arrays)
+            expressions.push(...decode_array(Object.assign(Object.assign({}, props), { array })));
+        for (const tuple of props.metadata.tuples)
+            expressions.push(decode_tuple(Object.assign(Object.assign({}, props), { tuple })));
+        for (const object of props.metadata.objects)
+            expressions.push(decode_object(Object.assign(Object.assign({}, props), { object: object.type })));
+        for (const native of props.metadata.natives)
+            expressions.push(decode_native({
+                context: props.context,
+                functor: props.functor,
+                explore: props.explore,
+                name: native.name,
+            }));
+        for (const set of props.metadata.sets)
+            expressions.push(decode_set(Object.assign(Object.assign({}, props), { set })));
+        for (const entry of props.metadata.maps)
+            expressions.push(decode_map(Object.assign(Object.assign({}, props), { map: entry })));
+        // PICK UP A TYPE
+        if (expressions.length === 1)
+            return expressions[0];
+        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createCallExpression(props.context.importer.internal("randomPick"), undefined, [
+            typescript_1.default.factory.createArrayLiteralExpression(expressions.map((expr) => typescript_1.default.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, expr)), true),
+        ]), undefined, undefined);
+    };
+    const decode_atomic = (props) => {
+        const schemaList = props.atomic.type === "boolean"
+            ? (0, json_schema_boolean_1.json_schema_boolean)(props.atomic)
+            : props.atomic.type === "string"
+                ? (0, json_schema_string_1.json_schema_string)(props.atomic)
+                : props.atomic.type === "bigint"
+                    ? (0, json_schema_bigint_1.json_schema_bigint)(props.atomic)
+                    : (0, json_schema_number_1.json_schema_number)(props.atomic);
+        return schemaList.map((schema) => {
+            const composed = (() => {
+                if (props.atomic.type === "string") {
+                    const string = schema;
+                    if (string.format !== undefined) {
+                        const format = string.format;
+                        if (format === "date-time")
+                            return {
+                                method: "datetime",
+                                internal: "randomFormatDatetime",
+                                arguments: [],
+                            };
+                        return {
+                            method: format
+                                .split("-")
+                                .map((s, i) => (i === 0 ? s : utils_1.NamingConvention.capitalize(s)))
+                                .join(""),
+                            internal: `randomFormat${format
+                                .split("-")
+                                .map(utils_1.NamingConvention.capitalize)
+                                .join("")}`,
+                            arguments: [],
+                        };
+                    }
+                    else if (string.pattern !== undefined)
+                        return {
+                            method: "pattern",
+                            internal: "randomPattern",
+                            arguments: [
+                                typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("RegExp"), undefined, [
+                                    typescript_1.default.factory.createStringLiteral(schema.pattern),
+                                ]),
+                            ],
+                        };
+                }
+                else if (props.atomic.type === "number") {
+                    const number = schema;
+                    if (number.type === "integer")
+                        return {
+                            method: "integer",
+                            internal: "randomInteger",
+                            arguments: [LiteralFactory_1.LiteralFactory.write(schema)],
+                        };
+                }
+                else if (props.atomic.type === "boolean")
+                    return {
+                        method: props.atomic.type,
+                        internal: "randomBoolean",
+                        arguments: [],
+                    };
+                return {
+                    method: props.atomic.type,
+                    internal: `random${utils_1.NamingConvention.capitalize(props.atomic.type)}`,
+                    arguments: [LiteralFactory_1.LiteralFactory.write(schema)],
+                };
+            })();
+            return typescript_1.default.factory.createCallExpression(ExpressionFactory_1.ExpressionFactory.coalesce(typescript_1.default.factory.createPropertyAccessChain(typescript_1.default.factory.createIdentifier("_generator"), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionDotToken), typescript_1.default.factory.createIdentifier(composed.method)), props.context.importer.internal(composed.internal)), undefined, composed.arguments);
+        });
+    };
+    const decode_template = (props) => TemplateFactory_1.TemplateFactory.generate(props.template.row.map((metadata) => decode(Object.assign(Object.assign({}, props), { metadata }))));
+    const decode_array = (props) => {
+        const components = {};
+        const schemaList = (0, json_schema_array_1.json_schema_array)({
+            components,
+            array: props.array,
+        });
+        if (props.array.type.recursive)
+            return schemaList.map((schema) => typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal(Prefix.array(props.array.type.index))), undefined, [
+                typescript_1.default.factory.createObjectLiteralExpression(Object.entries(schema)
+                    .filter(([key]) => key !== "items")
+                    .map(([key, value]) => typescript_1.default.factory.createPropertyAssignment(key, LiteralFactory_1.LiteralFactory.write(value))), true),
+            ]));
+        return schemaList.map((schema) => RandomJoiner_1.RandomJoiner.array({
+            decode: (metadata) => decode(Object.assign(Object.assign({}, props), { metadata })),
+            expression: coalesce({
+                context: props.context,
+                method: "array",
+                internal: "randomArray",
+            }),
+            array: props.array.type,
+            recursive: props.explore.recursive,
+            schema,
+        }));
+    };
+    const decode_tuple = (props) => props.tuple.type.recursive
+        ? typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal(Prefix.tuple(props.tuple.type.index))), undefined, [
+            typescript_1.default.factory.createTrue(),
+            props.explore.recursive
+                ? typescript_1.default.factory.createAdd(ExpressionFactory_1.ExpressionFactory.number(1), typescript_1.default.factory.createIdentifier("_depth"))
+                : ExpressionFactory_1.ExpressionFactory.number(0),
+        ])
+        : RandomJoiner_1.RandomJoiner.tuple({
+            decode: (metadata) => decode(Object.assign(Object.assign({}, props), { metadata })),
+            elements: props.tuple.type.elements,
+        });
+    const decode_object = (props) => typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(props.functor.useLocal(Prefix.object(props.object.index))), undefined, props.explore.function
+        ? [
+            props.explore.recursive
+                ? typescript_1.default.factory.createTrue()
+                : typescript_1.default.factory.createIdentifier("_recursive"),
+            typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createIdentifier("_recursive"), undefined, typescript_1.default.factory.createAdd(ExpressionFactory_1.ExpressionFactory.number(1), typescript_1.default.factory.createIdentifier("_depth")), undefined, typescript_1.default.factory.createIdentifier("_depth")),
+        ]
+        : undefined);
+    /* -----------------------------------------------------------
+      NATIVE CLASSES
+    ----------------------------------------------------------- */
+    const decode_set = (props) => typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Set"), undefined, [
+        decode_array(Object.assign(Object.assign({}, props), { array: MetadataArray_1.MetadataArray.create({
+                tags: [],
+                type: MetadataArrayType_1.MetadataArrayType.create({
+                    value: props.set.value,
+                    recursive: false,
+                    index: null,
+                    nullables: [],
+                    name: props.set.getName(),
+                }),
+            }) }))[0],
+    ]);
+    const decode_map = (props) => typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Map"), undefined, [
+        decode_array(Object.assign(Object.assign({}, props), { array: MetadataArray_1.MetadataArray.create({
+                tags: [],
+                type: MetadataArrayType_1.MetadataArrayType.create({
+                    name: props.map.getName(),
+                    index: null,
+                    recursive: false,
+                    nullables: [],
+                    value: MetadataSchema_1.MetadataSchema.create(Object.assign(Object.assign({}, MetadataSchema_1.MetadataSchema.initialize()), { tuples: [
+                            (() => {
+                                const type = MetadataTupleType_1.MetadataTupleType.create({
+                                    name: `[${props.map.key.getName()}, ${props.map.value.getName()}]`,
+                                    index: null,
+                                    recursive: false,
+                                    nullables: [],
+                                    elements: [props.map.key, props.map.value],
+                                });
+                                type.of_map = true;
+                                return MetadataTuple_1.MetadataTuple.create({
+                                    type,
+                                    tags: [],
+                                });
+                            })(),
+                        ] })),
+                }),
+            }) }))[0],
+    ]);
+    const decode_native = (props) => {
+        if (props.name === "Boolean" ||
+            props.name === "Number" ||
+            props.name === "BigInt" ||
+            props.name === "String")
+            return decode_atomic({
+                context: props.context,
+                atomic: MetadataAtomic_1.MetadataAtomic.create({
+                    type: props.name.toLowerCase(),
+                    tags: [],
+                }),
+            })[0];
+        else if (props.name === "Date")
+            return decode_native_date(props.context);
+        else if (props.name === "Uint8Array" ||
+            props.name === "Uint8ClampedArray" ||
+            props.name === "Uint16Array" ||
+            props.name === "Uint32Array" ||
+            props.name === "BigUint64Array" ||
+            props.name === "Int8Array" ||
+            props.name === "Int16Array" ||
+            props.name === "Int32Array" ||
+            props.name === "BigInt64Array" ||
+            props.name === "Float32Array" ||
+            props.name === "Float64Array")
+            return decode_native_byte_array(Object.assign(Object.assign({}, props), { name: props.name }));
+        else if (props.name === "ArrayBuffer" || props.name === "SharedArrayBuffer")
+            return decode_native_array_buffer(Object.assign(Object.assign({}, props), { name: props.name }));
+        else if (props.name === "DataView")
+            return decode_native_data_view(props);
+        else if (props.name === "Blob")
+            return decode_native_blob(props);
+        else if (props.name === "File")
+            return decode_native_file(props);
+        else if (props.name === "RegExp")
+            return decode_regexp(props.context);
+        else
+            return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(props.name), undefined, []);
+    };
+    const decode_native_date = (context) => typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Date"), undefined, [
+        typescript_1.default.factory.createCallExpression(coalesce({
+            context,
+            method: "datetime",
+            internal: "randomFormatDatetime",
+        }), undefined, []),
+    ]);
+    const decode_native_byte_array = (props) => {
+        new BigInt64Array();
+        const [type, minimum, maximum] = (() => {
+            if (props.name === "Uint8Array" || props.name === "Uint8ClampedArray")
+                return ["uint32", 0, 255];
+            else if (props.name === "Uint16Array")
+                return ["uint32", 0, 65535];
+            else if (props.name === "Uint32Array")
+                return ["uint32", 0, 4294967295];
+            else if (props.name === "BigUint64Array")
+                return ["uint64", 0, 18446744073709551615];
+            else if (props.name === "Int8Array")
+                return ["int32", -128, 127];
+            else if (props.name === "Int16Array")
+                return ["int32", -32768, 32767];
+            else if (props.name === "Int32Array")
+                return ["int32", -2147483648, 2147483647];
+            else if (props.name === "BigInt64Array")
+                return ["uint64", -9223372036854775808, 9223372036854775807];
+            else if (props.name === "Float32Array")
+                return ["float", -1.175494351e38, 3.4028235e38];
+            return ["double", Number.MIN_VALUE, Number.MAX_VALUE];
+        })();
+        const atomic = props.name === "BigInt64Array" || props.name === "BigUint64Array"
+            ? "bigint"
+            : "number";
+        const value = MetadataSchema_1.MetadataSchema.create(Object.assign(Object.assign({}, MetadataSchema_1.MetadataSchema.initialize()), { atomics: [
+                MetadataAtomic_1.MetadataAtomic.create({
+                    type: atomic,
+                    tags: [
+                        [
+                            ...MetadataCommentTagFactory_1.MetadataCommentTagFactory.get({
+                                kind: "type",
+                                type: atomic,
+                                value: type,
+                            }),
+                            ...MetadataCommentTagFactory_1.MetadataCommentTagFactory.get({
+                                kind: "minimum",
+                                type: "number",
+                                value: minimum.toString(),
+                            }),
+                            ...MetadataCommentTagFactory_1.MetadataCommentTagFactory.get({
+                                kind: "maximum",
+                                type: "number",
+                                value: maximum.toString(),
+                            }),
+                        ],
+                    ],
+                }),
+            ] }));
+        return typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier(props.name), [], decode_array({
+            context: props.context,
+            functor: props.functor,
+            explore: props.explore,
+            array: MetadataArray_1.MetadataArray.create({
+                tags: [],
+                type: MetadataArrayType_1.MetadataArrayType.create({
+                    name: `${props.name}<${atomic}>`,
+                    value,
+                    recursive: false,
+                    index: null,
+                    nullables: [],
+                }),
+            }),
+        }));
+    };
+    const decode_native_blob = (props) => typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Blob"), undefined, [
+        typescript_1.default.factory.createArrayLiteralExpression([
+            decode_native_byte_array({
+                context: props.context,
+                functor: props.functor,
+                explore: props.explore,
+                name: "Uint8Array",
+            }),
+        ], true),
+    ]);
+    const decode_native_file = (props) => typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("File"), undefined, [
+        typescript_1.default.factory.createArrayLiteralExpression([
+            decode_native_byte_array({
+                context: props.context,
+                functor: props.functor,
+                explore: props.explore,
+                name: "Uint8Array",
+            }),
+        ], true),
+        typescript_1.default.factory.createTemplateExpression(typescript_1.default.factory.createTemplateHead(""), [
+            typescript_1.default.factory.createTemplateSpan(writeRangedString({
+                context: props.context,
+                minLength: 1,
+                maxLength: 8,
+            }), typescript_1.default.factory.createTemplateMiddle(".")),
+            typescript_1.default.factory.createTemplateSpan(writeRangedString({
+                context: props.context,
+                minLength: 3,
+                maxLength: 3,
+            }), typescript_1.default.factory.createTemplateTail("")),
+        ]),
+    ]);
+    const decode_native_array_buffer = (props) => props.name === "ArrayBuffer"
+        ? IdentifierFactory_1.IdentifierFactory.access(decode_native_byte_array({
+            context: props.context,
+            functor: props.functor,
+            explore: props.explore,
+            name: "Uint8Array",
+        }), "buffer")
+        : ExpressionFactory_1.ExpressionFactory.selfCall(typescript_1.default.factory.createBlock([
+            StatementFactory_1.StatementFactory.constant({
+                name: "length",
+                value: decode_atomic({
+                    context: props.context,
+                    atomic: MetadataAtomic_1.MetadataAtomic.create({
+                        type: "number",
+                        tags: [
+                            MetadataCommentTagFactory_1.MetadataCommentTagFactory.get({
+                                type: "number",
+                                kind: "type",
+                                value: "uint32",
+                            }),
+                        ],
+                    }),
+                })[0],
+            }),
+            StatementFactory_1.StatementFactory.constant({
+                name: "buffer",
+                value: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("SharedArrayBuffer"), [], [typescript_1.default.factory.createIdentifier("length")]),
+            }),
+            StatementFactory_1.StatementFactory.constant({
+                name: "bytes",
+                value: typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Uint8Array"), [], [typescript_1.default.factory.createIdentifier("buffer")]),
+            }),
+            typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createCallExpression(IdentifierFactory_1.IdentifierFactory.access(typescript_1.default.factory.createIdentifier("bytes"), "set"), undefined, [
+                typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("Array"), undefined, [typescript_1.default.factory.createIdentifier("length")]), typescript_1.default.factory.createIdentifier("fill")), undefined, [typescript_1.default.factory.createNumericLiteral("0")]), typescript_1.default.factory.createIdentifier("map")), undefined, [
+                    typescript_1.default.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, decode_atomic({
+                        context: props.context,
+                        atomic: MetadataAtomic_1.MetadataAtomic.create({
+                            type: "number",
+                            tags: [
+                                [
+                                    ...MetadataCommentTagFactory_1.MetadataCommentTagFactory.get({
+                                        kind: "type",
+                                        type: "number",
+                                        value: "uint32",
+                                    }),
+                                    ...MetadataCommentTagFactory_1.MetadataCommentTagFactory.get({
+                                        kind: "minimum",
+                                        type: "number",
+                                        value: "0",
+                                    }),
+                                    ...MetadataCommentTagFactory_1.MetadataCommentTagFactory.get({
+                                        kind: "maximum",
+                                        type: "number",
+                                        value: "255",
+                                    }),
+                                ],
+                            ],
+                        }),
+                    })[0]),
+                ]),
+                ExpressionFactory_1.ExpressionFactory.number(0),
+            ])),
+            typescript_1.default.factory.createReturnStatement(typescript_1.default.factory.createIdentifier("buffer")),
+        ], true));
+    const decode_native_data_view = (props) => typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("DataView"), [], [
+        IdentifierFactory_1.IdentifierFactory.access(decode_native_byte_array({
+            context: props.context,
+            functor: props.functor,
+            explore: props.explore,
+            name: "Uint8Array",
+        }), "buffer"),
+    ]);
+    const decode_regexp = (context) => typescript_1.default.factory.createNewExpression(typescript_1.default.factory.createIdentifier("RegExp"), [], [
+        typescript_1.default.factory.createCallExpression(coalesce({
+            context,
+            method: "regex",
+            internal: "randomFormatRegex",
+        }), undefined, undefined),
+    ]);
+    const writeRangedString = (props) => decode_atomic({
+        context: props.context,
+        atomic: MetadataAtomic_1.MetadataAtomic.create({
+            type: "string",
+            tags: [
+                [
+                    ...MetadataCommentTagFactory_1.MetadataCommentTagFactory.get({
+                        kind: "minLength",
+                        type: "string",
+                        value: props.minLength.toString(),
+                    }),
+                    ...MetadataCommentTagFactory_1.MetadataCommentTagFactory.get({
+                        kind: "maxLength",
+                        type: "string",
+                        value: props.maxLength.toString(),
+                    }),
+                ],
+            ],
+        }),
+    })[0];
+})(RandomProgrammer || (exports.RandomProgrammer = RandomProgrammer = {}));
+const coalesce = (props) => ExpressionFactory_1.ExpressionFactory.coalesce(typescript_1.default.factory.createPropertyAccessChain(typescript_1.default.factory.createIdentifier("_generator"), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionDotToken), typescript_1.default.factory.createIdentifier(props.method)), props.context.importer.internal(props.internal));
+const Prefix = {
+    object: (i) => `_ro${i}`,
+    array: (i) => `_ra${i}`,
+    tuple: (i) => `_rt${i}`,
+};
+//# sourceMappingURL=RandomProgrammer.js.map