typia 3.7.0-dev.20230310 → 3.7.0-dev.20230401

package/lib/utils/NameEncoder.js

@@ -1,89 +0,0 @@
-"use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NameEncoder = void 0;
-var NameEncoder;
-(function (NameEncoder) {
-    function encode(str) {
-        var e_1, _a;
-        try {
-            for (var REPLACERS_1 = __values(REPLACERS), REPLACERS_1_1 = REPLACERS_1.next(); !REPLACERS_1_1.done; REPLACERS_1_1 = REPLACERS_1.next()) {
-                var _b = __read(REPLACERS_1_1.value, 2), before = _b[0], after = _b[1];
-                str = str.split(before).join(after);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (REPLACERS_1_1 && !REPLACERS_1_1.done && (_a = REPLACERS_1.return)) _a.call(REPLACERS_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return str;
-    }
-    NameEncoder.encode = encode;
-    function decode(str) {
-        var e_2, _a;
-        try {
-            for (var REPLACERS_2 = __values(REPLACERS), REPLACERS_2_1 = REPLACERS_2.next(); !REPLACERS_2_1.done; REPLACERS_2_1 = REPLACERS_2.next()) {
-                var _b = __read(REPLACERS_2_1.value, 2), before = _b[0], after = _b[1];
-                if (after !== "")
-                    str = str.split(after).join(before);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (REPLACERS_2_1 && !REPLACERS_2_1.done && (_a = REPLACERS_2.return)) _a.call(REPLACERS_2);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return str;
-    }
-    NameEncoder.decode = decode;
-})(NameEncoder = exports.NameEncoder || (exports.NameEncoder = {}));
-var REPLACERS = [
-    ["$", "_dollar_"],
-    ["&", "_and_"],
-    ["|", "_or_"],
-    ["{", "_blt_"],
-    ["}", "_bgt_"],
-    ["<", "_lt_"],
-    [">", "_gt_"],
-    ["(", "_lp_"],
-    [")", "_rp_"],
-    ["[", "_alt_"],
-    ["]", "_agt_"],
-    [",", "_comma_"],
-    ["`", "_backquote_"],
-    ["'", "_singlequote_"],
-    ['"', "_doublequote_"],
-    [" ", "_space_"],
-];
-//# sourceMappingURL=NameEncoder.js.map

package/lib/utils/NameEncoder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NameEncoder.js","sourceRoot":"","sources":["../../src/utils/NameEncoder.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAiB,WAAW,CAY3B;AAZD,WAAiB,WAAW;IACxB,SAAgB,MAAM,CAAC,GAAW;;;YAC9B,KAA8B,IAAA,cAAA,SAAA,SAAS,CAAA,oCAAA;gBAA5B,IAAA,KAAA,8BAAe,EAAd,MAAM,QAAA,EAAE,KAAK,QAAA;gBACrB,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;aAAA;;;;;;;;;QACxC,OAAO,GAAG,CAAC;IACf,CAAC;IAJe,kBAAM,SAIrB,CAAA;IAED,SAAgB,MAAM,CAAC,GAAW;;;YAC9B,KAA8B,IAAA,cAAA,SAAA,SAAS,CAAA,oCAAA;gBAA5B,IAAA,KAAA,8BAAe,EAAd,MAAM,QAAA,EAAE,KAAK,QAAA;gBACrB,IAAI,KAAK,KAAK,EAAE;oBAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAAA;;;;;;;;;QAC1D,OAAO,GAAG,CAAC;IACf,CAAC;IAJe,kBAAM,SAIrB,CAAA;AACL,CAAC,EAZgB,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAY3B;AAED,IAAM,SAAS,GAAuB;IAClC,CAAC,GAAG,EAAE,UAAU,CAAC;IACjB,CAAC,GAAG,EAAE,OAAO,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,OAAO,CAAC;IACd,CAAC,GAAG,EAAE,OAAO,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,OAAO,CAAC;IACd,CAAC,GAAG,EAAE,OAAO,CAAC;IACd,CAAC,GAAG,EAAE,SAAS,CAAC;IAChB,CAAC,GAAG,EAAE,aAAa,CAAC;IACpB,CAAC,GAAG,EAAE,eAAe,CAAC;IACtB,CAAC,GAAG,EAAE,eAAe,CAAC;IACtB,CAAC,GAAG,EAAE,SAAS,CAAC;CACnB,CAAC"}

package/src/factories/ProtocolFactory.ts

@@ -1,79 +0,0 @@
-import ts from "typescript";
-
-import { Metadata } from "../metadata/Metadata";
-
-import { IProtocolMessage } from "../messages/IProtocolMessage";
-import { MetadataCollection } from "./MetadataCollection";
-import { MetadataFactory } from "./MetadataFactory";
-import { emplace_protocol_object } from "./internal/protocols/emplace_protocol_object";
-import { iterate_protocol_main } from "./internal/protocols/iterate_protocol_main";
-
-export namespace ProtocolFactory {
-    export const metadata =
-        (checker: ts.TypeChecker) =>
-        (collection: MetadataCollection) =>
-        (type: ts.Type) =>
-            MetadataFactory.generate(checker, collection, type, {
-                resolve: false,
-                constant: true,
-                validate: (meta) => {
-                    if (meta.any) throw new Error(ErrorMessages.NO_ANY);
-                    else if (meta.functional && meta.size() !== 1)
-                        throw new Error(ErrorMessages.NO_FUNCTIONAL);
-                    else if (meta.objects.find((o) => o.name === "__Main"))
-                        throw new Error(ErrorMessages.NO_MAIN);
-                    else if (meta.objects.find((o) => o.name === "__Timestamp"))
-                        throw new Error(ErrorMessages.NO_TIMESTAMP);
-                    else if (
-                        meta.objects.some((o) =>
-                            o.properties.some((p) => !is_atomic_key(p.key)),
-                        ) ||
-                        meta.maps.some((m) => !is_atomic_key(m.key))
-                    )
-                        throw new Error(ErrorMessages.NOT_ALLOWED_KEY);
-                },
-            });
-
-    export const generate =
-        (collection: MetadataCollection) =>
-        (dict: Map<string, IProtocolMessage>) =>
-        (meta: Metadata) => {
-            // EMPLACE OBJECTS
-            for (const obj of collection.objects())
-                emplace_protocol_object(dict)(obj);
-
-            // WHEN NOT OBJECT, WRAP IT INTO A FAKE MAIN OBJECT
-            iterate_protocol_main(dict)(meta);
-        };
-
-    const is_atomic_key = (key: Metadata) => {
-        if (
-            key.required &&
-            key.nullable === false &&
-            key.functional === false &&
-            key.resolved === null &&
-            key.size() ===
-                key.atomics.length +
-                    key.constants
-                        .map((c) => c.values.length)
-                        .reduce((a, b) => a + b, 0) +
-                    key.templates.length
-        ) {
-            const set: Set<string> = new Set();
-            for (const atomic of key.atomics) set.add(atomic);
-            for (const constant of key.constants) set.add(constant.type);
-            if (key.templates.length) set.add("string");
-
-            return set.size === 1;
-        }
-        return false;
-    };
-}
-
-const enum ErrorMessages {
-    NO_ANY = `Error on typia.message(): any type is not supported in protocol buffer.`,
-    NO_FUNCTIONAL = `Error on typia.message(): functional type is not supported in protocol buffer.`,
-    NO_MAIN = `Error on typia.message(): reserved type "__Main" has been detected.`,
-    NO_TIMESTAMP = `Error on typia.message(): reserved type "__Timestamp" has been detected.`,
-    NOT_ALLOWED_KEY = `Error on typia.message(): only atomic key type is supported in protocol buffer.`,
-}

package/src/factories/internal/protocols/ProtocolMetadataUtil.ts

@@ -1,163 +0,0 @@
-import { IMetadataTag } from "../../../metadata/IMetadataTag";
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-import { MetadataProperty } from "../../../metadata/MetadataProperty";
-
-import { Atomic } from "../../../typings/Atomic";
-
-export namespace ProtocolMetadataUtil {
-    export function size(meta: Metadata): number {
-        return (
-            meta.atomics.length +
-            meta.constants.filter(
-                (c) =>
-                    meta.atomics.find((type) => c.type === type) === undefined,
-            ).length +
-            (meta.templates.length !== 0 &&
-            meta.atomics.find((type) => type === "string") === undefined &&
-            meta.constants.find((c) => c.type === "string") === undefined
-                ? 1
-                : 0) +
-            meta.tuples.length +
-            meta.arrays.length +
-            meta.sets.length +
-            meta.maps.length +
-            meta.objects.length +
-            meta.natives.filter((n) => n === "Date").length +
-            (meta.natives.filter((n) => n !== "Date").length ? 1 : 0)
-        );
-    }
-
-    export function standalone(meta: Metadata): boolean {
-        return (
-            size(meta) === 1 &&
-            meta.required === true &&
-            meta.nullable === false &&
-            meta.tuples.length === 0 &&
-            meta.arrays.length === 0 &&
-            meta.sets.length === 0 &&
-            meta.maps.length === 0 &&
-            meta.objects.every((obj) =>
-                obj.properties.every((p) => p.key.isSoleLiteral()),
-            )
-        );
-    }
-
-    export function regular(obj: MetadataObject): boolean {
-        return obj.properties.every((p) => p.key.isSoleLiteral());
-    }
-
-    export function object(name: string, index: number): MetadataObject {
-        return MetadataObject.create({
-            name,
-            index,
-            properties: [],
-            description: undefined,
-            jsDocTags: [],
-            validated: false,
-            recursive: false,
-            nullables: [false],
-        });
-    }
-
-    export function property(
-        key: string,
-        value: Metadata,
-        tags: IMetadataTag[],
-    ): MetadataProperty {
-        return MetadataProperty.create({
-            key: (() => {
-                const meta: Metadata = Metadata.initialize();
-                meta.constants.push({
-                    type: "string",
-                    values: [key],
-                });
-                return meta;
-            })(),
-            value: value,
-            description: undefined,
-            tags,
-            jsDocTags: [],
-        });
-    }
-
-    export function array(meta: Metadata): Metadata {
-        return Metadata.create({
-            any: false,
-            required: true,
-            nullable: false,
-            functional: false,
-            resolved: null,
-            atomics: [],
-            constants: [],
-            templates: [],
-            rest: null,
-            arrays: [meta],
-            tuples: [],
-            objects: [],
-            natives: [],
-            sets: [],
-            maps: [],
-        });
-    }
-
-    export function atomic(type: Atomic.Literal): Metadata {
-        return Metadata.create({
-            any: false,
-            required: true,
-            nullable: false,
-            functional: false,
-            resolved: null,
-            atomics: [type],
-            constants: [],
-            templates: [],
-            rest: null,
-            arrays: [],
-            tuples: [],
-            objects: [],
-            natives: [],
-            sets: [],
-            maps: [],
-        });
-    }
-
-    export function reference(obj: MetadataObject): Metadata {
-        return Metadata.create({
-            any: false,
-            required: true,
-            nullable: false,
-            functional: false,
-            resolved: null,
-            atomics: [],
-            constants: [],
-            templates: [],
-            rest: null,
-            arrays: [],
-            tuples: [],
-            objects: [obj],
-            natives: [],
-            sets: [],
-            maps: [],
-        });
-    }
-
-    export function map(elem: Metadata.Entry): Metadata {
-        return Metadata.create({
-            any: false,
-            required: true,
-            nullable: false,
-            functional: false,
-            resolved: null,
-            atomics: [],
-            constants: [],
-            templates: [],
-            rest: null,
-            arrays: [],
-            tuples: [],
-            objects: [],
-            natives: [],
-            sets: [],
-            maps: [elem],
-        });
-    }
-}

package/src/factories/internal/protocols/emplace_protocol_object.ts

@@ -1,25 +0,0 @@
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { emplace_protocol_property } from "./emplace_protocol_property";
-
-export const emplace_protocol_object =
-    (dict: Map<string, IProtocolMessage>) => (object: MetadataObject) => {
-        if (dict.has(object.name)) return;
-
-        const regular = object.properties.filter((p) => p.key.isSoleLiteral());
-        const dynamic = object.properties.filter((p) => !p.key.isSoleLiteral());
-
-        if (dynamic.length) return;
-
-        const output: IProtocolMessage = {
-            name: object.name,
-            properties: [],
-        };
-        dict.set(object.name, output);
-
-        output.properties.push(
-            ...regular.map((prop) => emplace_protocol_property(dict)(prop)),
-        );
-        return output;
-    };

package/src/factories/internal/protocols/emplace_protocol_property.ts

@@ -1,12 +0,0 @@
-import { MetadataProperty } from "../../../metadata/MetadataProperty";
-
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { IProtocolProperty } from "../../../messages/IProtocolProperty";
-import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
-
-export const emplace_protocol_property =
-    (dict: Map<string, IProtocolMessage>) =>
-    (property: MetadataProperty): IProtocolProperty => ({
-        key: property.key.getSoleLiteral()!,
-        ...iterate_protocol_metadata(dict)(property.value)(property.tags),
-    });

package/src/factories/internal/protocols/iterate_protocol_atomic.ts

@@ -1,34 +0,0 @@
-import { IMetadataTag } from "../../../metadata/IMetadataTag";
-
-import { Atomic } from "../../../typings/Atomic";
-
-export const iterate_protocol_atomic =
-    (tags: IMetadataTag[]) => (type: Atomic.Literal) => {
-        if (type === "boolean") return "bool";
-        else if (type === "number") return number(tags);
-        else if (type === "bigint") return bigint(tags);
-        else return "string";
-    };
-
-const number = (tagList: IMetadataTag[]) => {
-    const filtered: IMetadataTag.INumberType[] = tagList.filter(
-        (tag) => tag.kind === "type",
-    ) as IMetadataTag.INumberType[];
-
-    for (const { value } of filtered)
-        if (value === "int") return "int32";
-        else if (value === "uint") return "uint32";
-    return "double";
-};
-
-const bigint = (tagList: IMetadataTag[]) => {
-    const filtered: IMetadataTag.IBigintType[] = tagList.filter(
-        (tag) =>
-            tag.kind === "type" &&
-            (tag.value === "int64" || tag.value === "uint64"),
-    ) as IMetadataTag.IBigintType[];
-
-    for (const { value } of filtered)
-        if (value === "int64" || value === "uint64") return value;
-    return "int64";
-};

package/src/factories/internal/protocols/iterate_protocol_constant.ts

@@ -1,27 +0,0 @@
-import { MetadataConstant } from "../../../metadata/MetadataConstant";
-
-export const iterate_protocol_constant = ({
-    type,
-    values,
-}: MetadataConstant) => {
-    if (type === "boolean") return "bool";
-    else if (type === "number") return number(values);
-    else if (type === "bigint") return bigint(values);
-    else return "string";
-};
-
-const bigint = (values: bigint[]): string => {
-    return values.every((v) => v >= BigInt(0)) ? "uint64" : "int64";
-};
-
-const number = (values: number[]): string => {
-    return values.some((v) => Math.floor(v) !== v)
-        ? "double"
-        : values.every((v) => v >= 0)
-        ? values.every((v) => v <= 2 ** 64 - 1)
-            ? "uint32"
-            : "uint64"
-        : values.every((v) => -(2 ** 31) <= v && v <= 2 ** 31 - 1)
-        ? "int32"
-        : "int64";
-};

package/src/factories/internal/protocols/iterate_protocol_main.ts

@@ -1,19 +0,0 @@
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-
-export const iterate_protocol_main =
-    (dict: Map<string, IProtocolMessage>) =>
-    (meta: Metadata): string => {
-        // ONLY ONE OBJECT TYPE
-        if (ProtocolMetadataUtil.standalone(meta) && meta.objects.length === 1)
-            return meta.getName();
-
-        const obj = ProtocolMetadataUtil.object("__Main", dict.size);
-        obj.properties.push(ProtocolMetadataUtil.property("value", meta, []));
-        emplace_protocol_object(dict)(obj);
-
-        return obj.name;
-    };

package/src/factories/internal/protocols/iterate_protocol_map.ts

@@ -1,58 +0,0 @@
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { IProtocolMap } from "../../../messages/IProtocolMap";
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-import { iterate_protocol_atomic } from "./iterate_protocol_atomic";
-import { iterate_protocol_constant } from "./iterate_protocol_constant";
-import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
-
-export const iterate_protocol_map =
-    (sole: boolean) =>
-    (dict: Map<string, IProtocolMessage>) =>
-    (prop: Metadata.Entry): string | IProtocolMap => {
-        if (sole === true)
-            return {
-                type: "map",
-                key: getKeyName(prop.key),
-                value: getValueName(dict)(prop.value),
-            };
-
-        const obj: MetadataObject = ProtocolMetadataUtil.object(
-            `Map.Wrapper<${prop.key.getName()}, ${prop.value.getName()}>`,
-            dict.size,
-        );
-        obj.properties.push(
-            ProtocolMetadataUtil.property(
-                "value",
-                ProtocolMetadataUtil.map(prop),
-                [],
-            ),
-        );
-        emplace_protocol_object(dict)(obj);
-        return obj.name;
-    };
-
-const getKeyName = (meta: Metadata) => {
-    for (const atomic of meta.atomics)
-        return iterate_protocol_atomic([])(atomic);
-    for (const constant of meta.constants)
-        return iterate_protocol_constant(constant);
-    return "string";
-};
-
-const getValueName =
-    (dict: Map<string, IProtocolMessage>) => (meta: Metadata) => {
-        if (ProtocolMetadataUtil.standalone(meta))
-            return iterate_protocol_metadata(dict)(meta)([]).oneOf[0]!.type;
-
-        const obj: MetadataObject = ProtocolMetadataUtil.object(
-            `Map.Value<${meta.getName()}>`,
-            dict.size,
-        );
-        obj.properties.push(ProtocolMetadataUtil.property("value", meta, []));
-        emplace_protocol_object(dict)(obj);
-        return obj.name;
-    };

package/src/factories/internal/protocols/iterate_protocol_metadata.ts

@@ -1,96 +0,0 @@
-import { IMetadataTag } from "../../../metadata/IMetadataTag";
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProtocolMap } from "../../../messages/IProtocolMap";
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { IProtocolProperty } from "../../../messages/IProtocolProperty";
-import { iterate_protocol_atomic } from "./iterate_protocol_atomic";
-import { iterate_protocol_constant } from "./iterate_protocol_constant";
-import { iterate_protocol_map } from "./iterate_protocol_map";
-import { iterate_protocol_native } from "./iterate_protocol_native";
-import { iterate_protocol_never } from "./iterate_protocol_never";
-import { iterate_protocol_object } from "./iterate_protocol_object";
-import { iterate_protocol_repeated } from "./iterate_protocol_repeated";
-import { iterate_protocol_tuple } from "./iterate_protocol_tuple";
-
-export const iterate_protocol_metadata =
-    (dict: Map<string, IProtocolMessage>) =>
-    (meta: Metadata) =>
-    (tags: IMetadataTag[]): Omit<IProtocolProperty, "key"> => {
-        // PREPARE ASSETS
-        const sole: boolean = meta.size() === 1;
-        const bucket: boolean = sole && meta.bucket() === 1;
-        const required: boolean =
-            (meta.required && !meta.nullable) ||
-            (sole &&
-                (meta.arrays.length === 1 ||
-                    meta.sets.length === 1 ||
-                    meta.maps.length === 1 ||
-                    (meta.objects.length === 1 &&
-                        meta.objects[0]!.properties.length === 1 &&
-                        !meta.objects[0]!.properties[0]?.key.isSoleLiteral())));
-
-        const oneOf: IProtocolProperty.IOneOf[] = [];
-        const add = (type: string | IProtocolMap) => {
-            if (oneOf.some((one) => one.type === type)) return;
-            oneOf.push({
-                type,
-            });
-        };
-
-        // WHEN SINGULAR ARRAY TYPE
-        if (sole && meta.arrays.length + meta.sets.length === 1) {
-            const [container, child] =
-                meta.arrays.length === 1
-                    ? (["Array", meta.arrays[0]!] as const)
-                    : (["Set", meta.sets[0]!] as const);
-            add(
-                iterate_protocol_repeated(container)(true, true)(dict)(child)(
-                    tags,
-                ),
-            );
-            return {
-                required,
-                oneOf,
-                repeated: true,
-            };
-        }
-
-        // ATOMIC TYPES
-        for (const type of meta.atomics)
-            add(iterate_protocol_atomic(tags)(type));
-        for (const constant of meta.constants)
-            add(iterate_protocol_constant(constant));
-        if (meta.templates.length) add("string");
-        if (meta.size() === 0) add(iterate_protocol_never());
-
-        // OBJECT TYPES
-        for (const obj of meta.objects)
-            add(iterate_protocol_object(sole)(dict)(obj));
-        for (const map of meta.maps) add(iterate_protocol_map(sole)(dict)(map));
-        for (const native of meta.natives)
-            add(iterate_protocol_native(dict)(native));
-
-        // ARRAY TYPES
-        for (const tuple of meta.tuples)
-            add(iterate_protocol_tuple(dict)(tuple));
-        for (const array of meta.arrays)
-            add(
-                iterate_protocol_repeated("Array")(false, bucket)(dict)(array)(
-                    tags,
-                ),
-            );
-        for (const set of meta.sets)
-            add(
-                iterate_protocol_repeated("Set")(false, bucket)(dict)(set)(
-                    tags,
-                ),
-            );
-
-        // RETURNS
-        return {
-            required,
-            oneOf,
-            repeated: false,
-        };
-    };

package/src/factories/internal/protocols/iterate_protocol_native.ts

@@ -1,34 +0,0 @@
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-
-export const iterate_protocol_native =
-    (dict: Map<string, IProtocolMessage>) => (native: string) => {
-        if (native === "Date") {
-            const obj = ProtocolMetadataUtil.object("__Timestamp", dict.size);
-            obj.properties.push(
-                ProtocolMetadataUtil.property("seconds", integer("bigint"), [
-                    {
-                        kind: "type",
-                        value: "int64",
-                    },
-                ]),
-                ProtocolMetadataUtil.property("nanos", integer("number"), [
-                    {
-                        kind: "type",
-                        value: "int",
-                    },
-                ]),
-            );
-            emplace_protocol_object(dict)(obj);
-            return "__Timestamp";
-        } else return "bytes";
-    };
-
-const integer = (type: "number" | "bigint") => {
-    const meta = Metadata.initialize();
-    meta.atomics.push(type);
-    return meta;
-};

package/src/factories/internal/protocols/iterate_protocol_never.ts

@@ -1 +0,0 @@
-export const iterate_protocol_never = () => "uint32";