typia 8.0.0 → 8.0.1

package/lib/programmers/helpers/ProtobufUtil.mjs

@@ -0,0 +1,170 @@
+var ProtobufUtil;
+(function (ProtobufUtil) {
+    ProtobufUtil.isStaticObject = (obj) => obj.properties.length >= 1 &&
+        obj.properties.every((p) => p.key.isSoleLiteral());
+    ProtobufUtil.size = (meta) => ProtobufUtil.getAtomics(meta).size +
+        meta.arrays.length +
+        meta.tuples.length +
+        meta.natives.length +
+        meta.objects.length +
+        meta.maps.length;
+    ProtobufUtil.getSequence = (tags) => {
+        const sequence = tags.find((t) => t.kind === "sequence" &&
+            typeof t.schema?.["x-protobuf-sequence"] === "number");
+        if (sequence === undefined)
+            return null;
+        const value = Number(sequence.schema["x-protobuf-sequence"]);
+        return Number.isNaN(value) ? null : value;
+    };
+    ProtobufUtil.isUnion = (meta) => ProtobufUtil.size(meta) > 1;
+    ProtobufUtil.getAtomics = (meta, union) => {
+        const map = union ?? new Map();
+        // CONSTANTS
+        for (const c of meta.constants)
+            if (c.type === "boolean")
+                map.set("bool", ProtobufUtil.getSequence(c.values[0]?.tags[0] ?? []));
+            else if (c.type === "bigint") {
+                const init = deduce_bigint_type(c.values.map((v) => BigInt(v.value)));
+                for (const value of c.values)
+                    decode_bigint({
+                        map,
+                        tags: value.tags,
+                        default: init,
+                    });
+            }
+            else if (c.type === "number") {
+                const init = deduce_numeric_type(c.values.map((v) => v.value));
+                for (const value of c.values)
+                    decode_number({
+                        map,
+                        tags: value.tags,
+                        default: init,
+                    });
+            }
+            else if (c.type === "string")
+                map.set("string", ProtobufUtil.getSequence(c.values[0]?.tags[0] ?? []));
+        if (meta.templates.length)
+            map.set("string", ProtobufUtil.getSequence(meta.templates[0]?.tags[0] ?? []));
+        // ATOMICS
+        for (const atomic of meta.atomics)
+            if (atomic.type === "boolean")
+                map.set("bool", ProtobufUtil.getSequence(atomic.tags[0] ?? []));
+            else if (atomic.type === "bigint")
+                decode_bigint({
+                    map,
+                    tags: atomic.tags,
+                    default: "int64",
+                });
+            else if (atomic.type === "number")
+                decode_number({
+                    map,
+                    tags: atomic.tags,
+                    default: "double",
+                });
+            else if (atomic.type === "string")
+                map.set("string", ProtobufUtil.getSequence(atomic.tags[0] ?? []));
+        // SORTING IF REQUIRED
+        if (Array.from(map.values()).some((v) => v === null))
+            arrange(map);
+        return map;
+    };
+    ProtobufUtil.getNumbers = (meta, union) => {
+        const map = union ?? new Map();
+        for (const c of meta.constants)
+            if (c.type === "number") {
+                const init = deduce_numeric_type(c.values.map((v) => v.value));
+                for (const value of c.values)
+                    decode_number({
+                        map,
+                        tags: value.tags,
+                        default: init,
+                    });
+            }
+        for (const atomic of meta.atomics)
+            if (atomic.type === "number")
+                decode_number({
+                    map,
+                    tags: atomic.tags,
+                    default: "double",
+                });
+        if (Array.from(map.values()).some((v) => v === null))
+            arrange(map);
+        return map;
+    };
+    ProtobufUtil.getBigints = (meta, union) => {
+        const map = union ?? new Map();
+        for (const c of meta.constants)
+            if (c.type === "bigint") {
+                const init = deduce_bigint_type(c.values.map((v) => BigInt(v.value)));
+                for (const value of c.values)
+                    decode_bigint({
+                        map,
+                        tags: value.tags,
+                        default: init,
+                    });
+            }
+        for (const atomic of meta.atomics)
+            if (atomic.type === "bigint")
+                decode_bigint({
+                    map,
+                    tags: atomic.tags,
+                    default: "int64",
+                });
+        if (Array.from(map.values()).some((v) => v === null))
+            arrange(map);
+        return map;
+    };
+    const arrange = (map) => {
+        const entries = Array.from(map.entries()).sort((a, b) => ProtobufUtil.compare(a[0], b[0]));
+        map.clear();
+        for (const [key, value] of entries)
+            map.set(key, value);
+    };
+    ProtobufUtil.compare = (x, y) => ATOMIC_ORDER.get(x) - ATOMIC_ORDER.get(y);
+})(ProtobufUtil || (ProtobufUtil = {}));
+const ATOMIC_ORDER = new Map([
+    "bool",
+    "int32",
+    "uint32",
+    "int64",
+    "uint64",
+    "float",
+    "double",
+    "string",
+].map((str, i) => [str, i]));
+const deduce_bigint_type = (values) => values.some((v) => v < 0) ? "int64" : "uint64";
+const deduce_numeric_type = (values) => values.every((v) => Math.floor(v) === v)
+    ? values.every((v) => -2147483648 <= v && v <= 2147483647)
+        ? "int32"
+        : "int64"
+    : "double";
+const decode_bigint = (next) => {
+    if (next.tags.length === 0) {
+        next.map.set(next.default, null);
+        return;
+    }
+    for (const row of next.tags) {
+        const value = row.find((tag) => tag.kind === "type" &&
+            (tag.value === "int64" || tag.value === "uint64"))?.value;
+        next.map.set(value ?? "int64", ProtobufUtil.getSequence(row));
+    }
+};
+const decode_number = (next) => {
+    if (next.tags.length === 0) {
+        next.map.set(next.default, null);
+        return;
+    }
+    for (const row of next.tags) {
+        const value = row.find((tag) => tag.kind === "type" &&
+            (tag.value === "int32" ||
+                tag.value === "uint32" ||
+                tag.value === "int64" ||
+                tag.value === "uint64" ||
+                tag.value === "float" ||
+                tag.value === "double"))?.value;
+        next.map.set(value ?? "double", ProtobufUtil.getSequence(row));
+    }
+};
+
+export { ProtobufUtil };
+//# sourceMappingURL=ProtobufUtil.mjs.map

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

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

package/lib/programmers/helpers/ProtobufWire.mjs

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

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

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

package/lib/programmers/helpers/PruneJoiner.mjs

@@ -0,0 +1,57 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { metadata_to_pattern } from '../internal/metadata_to_pattern.mjs';
+import { prune_object_properties } from '../internal/prune_object_properties.mjs';
+
+var PruneJoiner;
+(function (PruneJoiner) {
+    PruneJoiner.object = (props) => {
+        // PREPARE ASSETS
+        const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
+        const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
+        const statements = regular
+            .map((entry) => ts.isBlock(entry.expression)
+            ? [...entry.expression.statements]
+            : [ts.factory.createExpressionStatement(entry.expression)])
+            .flat();
+        if (dynamic.length)
+            statements.push(ts.factory.createExpressionStatement(iterate_dynamic_properties({
+                regular,
+                dynamic,
+                input: props.input,
+            })));
+        statements.push(prune_object_properties(props.object));
+        return ts.factory.createBlock(statements, true);
+    };
+    PruneJoiner.array = (props) => ts.factory.createCallExpression(IdentifierFactory.access(props.input, "forEach"), undefined, [props.arrow]);
+    PruneJoiner.tuple = (props) => {
+        const entire = [...props.elements];
+        if (props.rest !== null)
+            entire.push(props.rest);
+        const statements = entire
+            .map((elem) => ts.isBlock(elem)
+            ? [...elem.statements]
+            : [ts.factory.createExpressionStatement(elem)])
+            .flat();
+        return ts.factory.createBlock(statements, true);
+    };
+})(PruneJoiner || (PruneJoiner = {}));
+const iterate_dynamic_properties = (props) => ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createCallExpression(ts.factory.createIdentifier("Object.entries"), undefined, [props.input]), "forEach"), undefined, [
+    ts.factory.createArrowFunction(undefined, undefined, [
+        IdentifierFactory.parameter(ts.factory.createArrayBindingPattern(["key", "value"].map((l) => ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(l), undefined)))),
+    ], undefined, undefined, ts.factory.createBlock([
+        ts.factory.createIfStatement(ts.factory.createStrictEquality(ts.factory.createIdentifier("undefined"), ts.factory.createIdentifier("value")), ts.factory.createReturnStatement()),
+        ...props.regular.map(({ key }) => ts.factory.createIfStatement(ts.factory.createStrictEquality(ts.factory.createStringLiteral(key.getSoleLiteral()), ts.factory.createIdentifier("key")), ts.factory.createReturnStatement())),
+        ...props.dynamic.map((dynamic) => ts.factory.createIfStatement(ts.factory.createCallExpression(ts.factory.createIdentifier(`RegExp(/${metadata_to_pattern({
+            top: true,
+            metadata: dynamic.key,
+        })}/).test`), undefined, [ts.factory.createIdentifier("key")]), ts.isBlock(dynamic.expression)
+            ? dynamic.expression
+            : ts.factory.createBlock([
+                ts.factory.createExpressionStatement(dynamic.expression),
+            ]))),
+    ], true)),
+]);
+
+export { PruneJoiner };
+//# sourceMappingURL=PruneJoiner.mjs.map

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

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

package/lib/programmers/helpers/RandomJoiner.mjs

@@ -0,0 +1,86 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { LiteralFactory } from '../../factories/LiteralFactory.mjs';
+import { Metadata } from '../../schemas/metadata/Metadata.mjs';
+import { MetadataArray } from '../../schemas/metadata/MetadataArray.mjs';
+import { MetadataArrayType } from '../../schemas/metadata/MetadataArrayType.mjs';
+import { MetadataTuple } from '../../schemas/metadata/MetadataTuple.mjs';
+import { MetadataTupleType } from '../../schemas/metadata/MetadataTupleType.mjs';
+import { Escaper } from '../../utils/Escaper.mjs';
+
+var RandomJoiner;
+(function (RandomJoiner) {
+    RandomJoiner.array = (props) => {
+        const call = ts.factory.createCallExpression(props.expression, undefined, [
+            ts.factory.createObjectLiteralExpression([
+                ...(props.schema
+                    ? Object.entries(props.schema)
+                        .filter(([key]) => key !== "items")
+                        .map(([key, value]) => ts.factory.createPropertyAssignment(IdentifierFactory.identifier(key), LiteralFactory.write(value)))
+                    : []),
+                ...(props.schema
+                    ? []
+                    : [
+                        ts.factory.createSpreadAssignment(ts.factory.createIdentifier("_schema")),
+                    ]),
+                ts.factory.createPropertyAssignment("element", ts.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, props.decode(props.array.value))),
+            ], true),
+        ]);
+        if (props.recursive === false)
+            return call;
+        return ts.factory.createConditionalExpression(ts.factory.createGreaterThanEquals(ExpressionFactory.number(5), ts.factory.createIdentifier("_depth")), undefined, call, undefined, ts.factory.createArrayLiteralExpression([]));
+    };
+    RandomJoiner.tuple = (props) => ts.factory.createArrayLiteralExpression(props.elements.map((elem) => props.decode(elem.rest ?? elem)), true);
+    RandomJoiner.object = (props) => {
+        if (props.object.properties.length === 0)
+            return LiteralFactory.write({});
+        // LIST UP PROPERTIES
+        const regular = props.object.properties.filter((p) => p.key.isSoleLiteral());
+        const dynamic = props.object.properties.filter((p) => !p.key.isSoleLiteral());
+        return ts.factory.createObjectLiteralExpression([
+            ...regular.map((p) => {
+                const str = p.key.getSoleLiteral();
+                return ts.factory.createPropertyAssignment(Escaper.variable(str) ? str : ts.factory.createStringLiteral(str), props.decode(p.value));
+            }),
+            ...dynamic.map((property) => ts.factory.createSpreadAssignment(dynamicProperty({
+                decode: props.decode,
+                property: property,
+            }))),
+        ], true);
+    };
+    const dynamicProperty = (props) => {
+        const tuple = MetadataTuple.create({
+            type: MetadataTupleType.create({
+                name: `[${props.property.key.getName()}, ${props.property.value.getName()}]`,
+                elements: [props.property.key, props.property.value],
+                index: null,
+                recursive: false,
+                nullables: [false],
+            }),
+            tags: [],
+        });
+        const array = MetadataArray.create({
+            type: MetadataArrayType.create({
+                name: `Array<[${props.property.key.getName()}, ${props.property.value.getName()}]>`,
+                value: Metadata.create({
+                    ...Metadata.initialize(),
+                    tuples: [tuple],
+                }),
+                nullables: [false],
+                recursive: false,
+                index: null,
+            }),
+            tags: [[]],
+        });
+        return ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createIdentifier("Object"), "fromEntries"), undefined, [
+            props.decode(Metadata.create({
+                ...Metadata.initialize(),
+                arrays: [array],
+            })),
+        ]);
+    };
+})(RandomJoiner || (RandomJoiner = {}));
+
+export { RandomJoiner };
+//# sourceMappingURL=RandomJoiner.mjs.map

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

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

package/lib/programmers/helpers/StringifyJoinder.mjs

@@ -0,0 +1,72 @@
+import ts from 'typescript';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { TemplateFactory } from '../../factories/TemplateFactory.mjs';
+import { stringify_dynamic_properties } from '../internal/stringify_dynamic_properties.mjs';
+import { stringify_regular_properties } from '../internal/stringify_regular_properties.mjs';
+
+var StringifyJoiner;
+(function (StringifyJoiner) {
+    StringifyJoiner.object = (props) => {
+        // CHECK AND SORT ENTRIES
+        if (props.entries.length === 0)
+            return ts.factory.createStringLiteral("{}");
+        // PROPERTIES
+        const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
+        const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
+        const expressions = [
+            ...stringify_regular_properties({
+                regular,
+                dynamic,
+            }),
+            ...(dynamic.length
+                ? [
+                    stringify_dynamic_properties(dynamic, regular.map((r) => r.key.getSoleLiteral())),
+                ]
+                : []),
+        ];
+        // POP LAST COMMA, IF REQUIRED
+        const filtered = (regular.length &&
+            regular[regular.length - 1].meta.isRequired() &&
+            dynamic.length === 0) ||
+            (regular.length === 0 && dynamic.length)
+            ? expressions
+            : [
+                ts.factory.createCallExpression(props.context.importer.internal("jsonStringifyTail"), undefined, [TemplateFactory.generate(expressions)]),
+            ];
+        // RETURNS WITH OBJECT BRACKET
+        return TemplateFactory.generate([
+            ts.factory.createStringLiteral(`{`),
+            ...filtered,
+            ts.factory.createStringLiteral(`}`),
+        ]);
+    };
+    StringifyJoiner.array = (props) => TemplateFactory.generate([
+        ts.factory.createStringLiteral(`[`),
+        ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(IdentifierFactory.access(props.input, "map"), undefined, [props.arrow]), ts.factory.createIdentifier("join")), undefined, [ts.factory.createStringLiteral(`,`)]),
+        ts.factory.createStringLiteral(`]`),
+    ]);
+    StringifyJoiner.tuple = (props) => {
+        if (props.elements.length === 0)
+            return ts.factory.createStringLiteral("[]");
+        if (props.rest === null &&
+            props.elements.every((child) => ts.isStringLiteral(child)))
+            return ts.factory.createStringLiteral("[" +
+                props.elements
+                    .map((child) => child.text)
+                    .join(",") +
+                "]");
+        const expressions = [ts.factory.createStringLiteral(`[`)];
+        props.elements.forEach((child, i) => {
+            expressions.push(child);
+            if (i !== props.elements.length - 1)
+                expressions.push(ts.factory.createStringLiteral(`,`));
+        });
+        if (props.rest !== null)
+            expressions.push(props.rest);
+        expressions.push(ts.factory.createStringLiteral(`]`));
+        return TemplateFactory.generate(expressions);
+    };
+})(StringifyJoiner || (StringifyJoiner = {}));
+
+export { StringifyJoiner };
+//# sourceMappingURL=StringifyJoinder.mjs.map

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

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

package/lib/programmers/helpers/StringifyPredicator.mjs

@@ -0,0 +1,11 @@
+var StringifyPredicator;
+(function (StringifyPredicator) {
+    StringifyPredicator.require_escape = (value) => value.split("").some((ch) => ESCAPED.some((escaped) => escaped === ch));
+    StringifyPredicator.undefindable = (metadata) => metadata.isRequired() === false ||
+        (metadata.escaped !== null &&
+            metadata.escaped.returns.isRequired() === false);
+    const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
+})(StringifyPredicator || (StringifyPredicator = {}));
+
+export { StringifyPredicator };
+//# sourceMappingURL=StringifyPredicator.mjs.map

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

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

package/lib/programmers/helpers/UnionExplorer.mjs

@@ -0,0 +1,206 @@
+import ts from 'typescript';
+import { ExpressionFactory } from '../../factories/ExpressionFactory.mjs';
+import { IdentifierFactory } from '../../factories/IdentifierFactory.mjs';
+import { Metadata } from '../../schemas/metadata/Metadata.mjs';
+import { MetadataArray } from '../../schemas/metadata/MetadataArray.mjs';
+import { MetadataArrayType } from '../../schemas/metadata/MetadataArrayType.mjs';
+import { MetadataTuple } from '../../schemas/metadata/MetadataTuple.mjs';
+import { MetadataTupleType } from '../../schemas/metadata/MetadataTupleType.mjs';
+import { check_union_array_like } from '../internal/check_union_array_like.mjs';
+import { UnionPredicator } from './UnionPredicator.mjs';
+
+var UnionExplorer;
+(function (UnionExplorer) {
+    /* -----------------------------------------------------------
+          OBJECT
+      ----------------------------------------------------------- */
+    UnionExplorer.object = (props) => {
+        // BREAKER
+        if (props.objects.length === 1)
+            return props.config.objector.decoder({
+                input: props.input,
+                object: props.objects[0],
+                explore: props.explore,
+            });
+        const expected = `(${props.objects.map((t) => t.name).join(" | ")})`;
+        // POSSIBLE TO SPECIALIZE?
+        const specList = UnionPredicator.object(props.objects);
+        if (specList.length === 0) {
+            const condition = props.config.objector.unionizer({
+                objects: props.objects,
+                input: props.input,
+                explore: {
+                    ...props.explore,
+                    tracable: false,
+                },
+            });
+            return props.config.objector.full
+                ? props.config.objector.full({
+                    condition,
+                    expected,
+                    explore: props.explore,
+                    input: props.input,
+                })
+                : condition;
+        }
+        const remained = props.objects.filter((t) => specList.find((s) => s.object === t) === undefined);
+        // DO SPECIALIZE
+        const condition = specList
+            .filter((spec) => spec.property.key.getSoleLiteral() !== null)
+            .map((spec, i, array) => {
+            const key = spec.property.key.getSoleLiteral();
+            const accessor = IdentifierFactory.access(props.input, key);
+            const pred = spec.neighbor
+                ? props.config.objector.checker({
+                    input: accessor,
+                    metadata: spec.property.value,
+                    explore: {
+                        ...props.explore,
+                        tracable: false,
+                        postfix: IdentifierFactory.postfix(key),
+                    },
+                })
+                : (props.config.objector.required || ((exp) => exp))(ExpressionFactory.isRequired(accessor));
+            return ts.factory.createIfStatement((props.config.objector.is || ((exp) => exp))(pred), ts.factory.createReturnStatement(props.config.objector.decoder({
+                object: spec.object,
+                input: props.input,
+                explore: props.explore,
+            })), i === array.length - 1
+                ? remained.length
+                    ? ts.factory.createReturnStatement(UnionExplorer.object({
+                        config: props.config,
+                        level: (props.level ?? 0) + 1,
+                        input: props.input,
+                        objects: remained,
+                        explore: props.explore,
+                    }))
+                    : props.config.objector.failure({
+                        input: props.input,
+                        explore: props.explore,
+                        expected,
+                    })
+                : undefined);
+        })
+            .reverse()
+            .reduce((a, b) => ts.factory.createIfStatement(b.expression, b.thenStatement, a));
+        // RETURNS WITH CONDITIONS
+        return ts.factory.createCallExpression(ts.factory.createArrowFunction(undefined, undefined, [], undefined, undefined, ts.factory.createBlock([condition], true)), undefined, undefined);
+    };
+    /* -----------------------------------------------------------
+          ARRAY LIKE
+      ----------------------------------------------------------- */
+    UnionExplorer.tuple = (props) => check_union_array_like({
+        config: props.config,
+        accessor: {
+            transform: (x) => x,
+            element: (x) => x,
+            size: null,
+            front: (input) => input,
+            array: (input) => input,
+            name: (t) => t.type.name,
+        },
+        parameters: props.parameters,
+        input: props.input,
+        definitions: props.tuples,
+        explore: props.explore,
+    });
+    UnionExplorer.array = (props) => check_union_array_like({
+        config: props.config,
+        accessor: {
+            transform: (x) => x,
+            element: (x) => x.type.value,
+            size: (input) => IdentifierFactory.access(input, "length"),
+            front: (input) => ts.factory.createElementAccessExpression(input, 0),
+            array: (input) => input,
+            name: (t) => t.type.name,
+        },
+        parameters: props.parameters,
+        input: props.input,
+        definitions: props.arrays,
+        explore: props.explore,
+    });
+    UnionExplorer.array_or_tuple = (props) => check_union_array_like({
+        config: props.config,
+        accessor: {
+            transform: (x) => x,
+            element: (x) => (x instanceof MetadataArray ? x.type.value : x),
+            size: (input) => IdentifierFactory.access(input, "length"),
+            front: (input) => ts.factory.createElementAccessExpression(input, 0),
+            array: (input) => input,
+            name: (m) => m.type.name,
+        },
+        parameters: props.parameters,
+        input: props.input,
+        definitions: props.definitions,
+        explore: props.explore,
+    });
+    UnionExplorer.set = (props) => check_union_array_like({
+        config: props.config,
+        accessor: {
+            transform: (value) => MetadataArray.create({
+                tags: [],
+                type: MetadataArrayType.create({
+                    name: `Set<${value.getName()}>`,
+                    index: null,
+                    recursive: false,
+                    nullables: [],
+                    value,
+                }),
+            }),
+            element: (array) => array.type.value,
+            size: (input) => IdentifierFactory.access(input, "size"),
+            front: (input) => IdentifierFactory.access(ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createCallExpression(IdentifierFactory.access(input, "values"), undefined, undefined), "next"), undefined, undefined), "value"),
+            array: (input) => ts.factory.createArrayLiteralExpression([ts.factory.createSpreadElement(input)], false),
+            name: (_m, e) => `Set<${e.getName()}>`,
+        },
+        parameters: props.parameters,
+        input: props.input,
+        definitions: props.sets.map((s) => s.value),
+        explore: props.explore,
+    });
+    UnionExplorer.map = (props) => check_union_array_like({
+        config: props.config,
+        accessor: {
+            element: (array) => array.type.value.tuples[0].type.elements,
+            size: (input) => IdentifierFactory.access(input, "size"),
+            front: (input) => IdentifierFactory.access(ts.factory.createCallExpression(IdentifierFactory.access(ts.factory.createCallExpression(IdentifierFactory.access(input, "entries"), undefined, undefined), "next"), undefined, undefined), "value"),
+            array: (input) => ts.factory.createArrayLiteralExpression([ts.factory.createSpreadElement(input)], false),
+            name: (_m, [k, v]) => `Map<${k.getName()}, ${v.getName()}>`,
+            transform: (m) => MetadataArray.create({
+                tags: [],
+                type: MetadataArrayType.create({
+                    name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
+                    index: null,
+                    recursive: false,
+                    nullables: [],
+                    value: Metadata.create({
+                        ...Metadata.initialize(),
+                        tuples: [
+                            (() => {
+                                const tuple = MetadataTuple.create({
+                                    tags: [],
+                                    type: MetadataTupleType.create({
+                                        name: `[${m.key.getName()}, ${m.value.getName()}]`,
+                                        index: null,
+                                        recursive: false,
+                                        nullables: [],
+                                        elements: [m.key, m.value],
+                                    }),
+                                });
+                                tuple.type.of_map = true;
+                                return tuple;
+                            })(),
+                        ],
+                    }),
+                }),
+            }),
+        },
+        parameters: props.parameters,
+        input: props.input,
+        definitions: props.maps,
+        explore: props.explore,
+    });
+})(UnionExplorer || (UnionExplorer = {}));
+
+export { UnionExplorer };
+//# sourceMappingURL=UnionExplorer.mjs.map

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

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