typia 5.0.0-dev.20230818 → 5.0.0-dev.20230820

package/src/programmers/internal/check_number.ts

@@ -22,18 +22,32 @@ export const check_number =
         const entries: [IMetadataTag, ts.Expression][] = [];
         for (const tag of metaTags)
             if (tag.kind === "type") {
-                entries.push([
-                    tag,
-                    ts.factory.createStrictEquality(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("parseInt"),
-                            undefined,
-                            [input],
+                // MUST BE INTEGER
+                if (
+                    tag.value === "int" ||
+                    tag.value === "uint" ||
+                    tag.value === "int32" ||
+                    tag.value === "uint32" ||
+                    tag.value === "int64" ||
+                    tag.value === "uint64"
+                )
+                    entries.push([
+                        tag,
+                        ts.factory.createStrictEquality(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("Math.floor"),
+                                undefined,
+                                [input],
+                            ),
+                            input,
                         ),
-                        input,
-                    ),
-                ]);
-                if (tag.value === "uint")
+                    ]);
+                // GREATER THAN OR EQUAL TO ZERO
+                if (
+                    tag.value === "uint" ||
+                    tag.value === "uint32" ||
+                    tag.value === "uint64"
+                )
                     entries.push([
                         tag,
                         ts.factory.createLessThanEquals(
@@ -41,6 +55,45 @@ export const check_number =
                             input,
                         ),
                     ]);
+                // RANGE LIMIT
+                if (tag.value === "uint32")
+                    entries.push([
+                        tag,
+                        ts.factory.createLessThanEquals(
+                            input,
+                            ts.factory.createNumericLiteral(4294967295),
+                        ),
+                    ]);
+                else if (tag.value === "int32")
+                    entries.push([
+                        tag,
+                        ts.factory.createLogicalAnd(
+                            ts.factory.createLessThanEquals(
+                                ts.factory.createNumericLiteral(-2147483648),
+                                input,
+                            ),
+                            ts.factory.createLessThanEquals(
+                                input,
+                                ts.factory.createNumericLiteral(2147483647),
+                            ),
+                        ),
+                    ]);
+                else if (tag.value === "float")
+                    entries.push([
+                        tag,
+                        ts.factory.createLogicalAnd(
+                            ts.factory.createLessThanEquals(
+                                ts.factory.createNumericLiteral(
+                                    -1.175494351e38,
+                                ),
+                                input,
+                            ),
+                            ts.factory.createLessThanEquals(
+                                input,
+                                ts.factory.createNumericLiteral(3.4028235e38),
+                            ),
+                        ),
+                    ]);
             } else if (tag.kind === "multipleOf")
                 entries.push([
                     tag,

package/src/programmers/internal/decode_union_object.ts

@@ -55,13 +55,24 @@ const iterate =
     (input: ts.Expression, unions: IUnion[], expected: string) =>
         ts.factory.createBlock(
             [
-                ...unions.map((u) =>
-                    ts.factory.createIfStatement(
-                        u.is(),
-                        ts.factory.createReturnStatement(u.value()),
+                unions
+                    .map((u, i) =>
+                        ts.factory.createIfStatement(
+                            u.is(),
+                            ts.factory.createReturnStatement(u.value()),
+                            i === unions.length - 1
+                                ? escaper(input, expected)
+                                : undefined,
+                        ),
+                    )
+                    .reverse()
+                    .reduce((a, b) =>
+                        ts.factory.createIfStatement(
+                            b.expression,
+                            b.thenStatement,
+                            a,
+                        ),
                     ),
-                ),
-                escaper(input, expected),
             ],
             true,
         );

package/src/programmers/misc/MiscLiteralsProgrammer.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { MetadataCollection } from "../../factories/MetadataCollection";
 import { MetadataFactory } from "../../factories/MetadataFactory";
 
@@ -47,7 +48,7 @@ export namespace MiscLiteralsProgrammer {
                         : typeof v === "number"
                         ? ts.factory.createNumericLiteral(v)
                         : typeof v === "bigint"
-                        ? ts.factory.createBigIntLiteral(v.toString())
+                        ? ExpressionFactory.bigint(Number(v))
                         : ts.factory.createStringLiteral(v),
                 ),
                 true,

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -25,6 +25,8 @@ import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { ProtobufUtil } from "../helpers/ProtobufUtil";
 import { ProtobufWire } from "../helpers/ProtobufWire";
 import { UnionExplorer } from "../helpers/UnionExplorer";
+import { UnionPredicator } from "../helpers/UnionPredicator";
+import { decode_union_object } from "../internal/decode_union_object";
 
 export namespace ProtobufEncodeProgrammer {
     export const write =
@@ -92,7 +94,7 @@ export namespace ProtobufEncodeProgrammer {
                 ts.factory.createTypeReferenceNode("Uint8Array"),
                 undefined,
                 ts.factory.createBlock(
-                    [...importer.declare(modulo), ...block],
+                    [...importer.declare(modulo, false), ...block],
                     true,
                 ),
             );
@@ -102,8 +104,37 @@ export namespace ProtobufEncodeProgrammer {
         (project: IProject) =>
         (importer: FunctionImporter) =>
         (collection: MetadataCollection) =>
-        (meta: Metadata): ts.ArrowFunction =>
-            ts.factory.createArrowFunction(
+        (meta: Metadata): ts.ArrowFunction => {
+            const functors = collection
+                .objects()
+                .filter((obj) => obj._Messagable())
+                .map((obj) =>
+                    StatementFactory.constant(
+                        `${PREFIX}o${obj.index}`,
+                        write_object_function(project)(importer)(
+                            ts.factory.createIdentifier("input"),
+                            obj,
+                            {
+                                source: "function",
+                                from: "object",
+                                tracable: false,
+                                postfix: "",
+                            },
+                        ),
+                    ),
+                );
+            const main = decode(project)(importer)(null)(
+                ts.factory.createIdentifier("input"),
+                meta,
+                {
+                    source: "top",
+                    from: "top",
+                    tracable: false,
+                    postfix: "",
+                },
+                [],
+            );
+            return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [IdentifierFactory.parameter("writer")],
@@ -111,35 +142,12 @@ export namespace ProtobufEncodeProgrammer {
                 undefined,
                 ts.factory.createBlock(
                     [
-                        ...collection
-                            .objects()
-                            .filter((obj) => obj._Messagable())
-                            .map((obj) =>
-                                StatementFactory.constant(
-                                    `${PREFIX}o${obj.index}`,
-                                    write_object_function(project)(importer)(
-                                        ts.factory.createIdentifier("input"),
-                                        obj,
-                                        {
-                                            source: "function",
-                                            from: "object",
-                                            tracable: false,
-                                            postfix: "",
-                                        },
-                                    ),
-                                ),
-                            ),
-                        ...decode(project)(importer)(null)(
-                            ts.factory.createIdentifier("input"),
-                            meta,
-                            {
-                                source: "top",
-                                from: "top",
-                                tracable: false,
-                                postfix: "",
-                            },
-                            [],
-                        ).statements,
+                        ...importer.declareUnions(),
+                        ...functors,
+                        ...IsProgrammer.write_function_statements(project)(
+                            importer,
+                        )(collection),
+                        ...main.statements,
                         ts.factory.createReturnStatement(
                             ts.factory.createIdentifier("writer"),
                         ),
@@ -147,6 +155,7 @@ export namespace ProtobufEncodeProgrammer {
                     true,
                 ),
             );
+        };
 
     const write_object_function =
         (project: IProject) =>
@@ -266,7 +275,7 @@ export namespace ProtobufEncodeProgrammer {
                         ts.factory.createStringLiteral(type),
                         ts.factory.createTypeOfExpression(input),
                     ),
-                value: () => decode_atomic(index!)(input, type, tags),
+                value: (index) => decode_atomic(index!)(input, type, tags),
             }));
 
             // CONSIDER BYTES
@@ -275,7 +284,7 @@ export namespace ProtobufEncodeProgrammer {
                     type: "bytes",
                     is: () =>
                         ExpressionFactory.isInstanceOf("Uint8Array")(input),
-                    value: () => decode_bytes("bytes")(index!)(input),
+                    value: (index) => decode_bytes("bytes")(index!)(input),
                 });
 
             // CONSIDER MAPS
@@ -283,7 +292,7 @@ export namespace ProtobufEncodeProgrammer {
                 unions.push({
                     type: "map",
                     is: () => ExpressionFactory.isInstanceOf("Map")(input),
-                    value: () =>
+                    value: (index) =>
                         decode_map(project)(importer)(index!)(
                             input,
                             meta.maps[0]!,
@@ -300,7 +309,7 @@ export namespace ProtobufEncodeProgrammer {
                 unions.push({
                     type: "array",
                     is: () => ExpressionFactory.isArray(input),
-                    value: () =>
+                    value: (index) =>
                         explore_arrays(project)(importer)(index!)(
                             input,
                             meta.arrays,
@@ -321,10 +330,10 @@ export namespace ProtobufEncodeProgrammer {
                             checkNull: true,
                             checkArray: false,
                         })(input),
-                    value: () =>
-                        explore_objects(project)(index)(importer)(
+                    value: (index) =>
+                        explore_objects(project)(importer)(0)(index)(
                             input,
-                            meta,
+                            meta.objects,
                             {
                                 ...explore,
                                 from: "object",
@@ -349,10 +358,26 @@ export namespace ProtobufEncodeProgrammer {
         (input: ts.Expression) =>
             ts.factory.createBlock(
                 [
-                    ...unions.map((u) =>
-                        ts.factory.createIfStatement(u.is(), u.value(index)),
-                    ),
-                    create_throw_error(importer)(expected)(input),
+                    unions
+                        .map((u, i) =>
+                            ts.factory.createIfStatement(
+                                u.is(),
+                                u.value(index ? index + i : null),
+                                i === unions.length - 1
+                                    ? create_throw_error(importer)(expected)(
+                                          input,
+                                      )
+                                    : undefined,
+                            ),
+                        )
+                        .reverse()
+                        .reduce((a, b) =>
+                            ts.factory.createIfStatement(
+                                b.expression,
+                                b.thenStatement,
+                                a,
+                            ),
+                        ),
                 ],
                 true,
             );
@@ -424,7 +449,11 @@ export namespace ProtobufEncodeProgrammer {
             const top: MetadataProperty = object.properties[0]!;
             if (top.key.isSoleLiteral() === false)
                 return decode_map(project)(importer)(index!)(
-                    input,
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("Object.entries"),
+                        [],
+                        [input],
+                    ),
                     top,
                     explore,
                     tags,
@@ -637,35 +666,107 @@ export namespace ProtobufEncodeProgrammer {
     ----------------------------------------------------------- */
     const explore_objects =
         (project: IProject) =>
-        (index: number | null) =>
         (importer: FunctionImporter) =>
+        (level: number) =>
+        (index: number | null) =>
         (
             input: ts.Expression,
-            meta: Metadata,
+            targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
-        ): ts.Block =>
-            meta.objects.length === 1
-                ? decode_object(project)(importer)(index)(
-                      input,
-                      meta.objects[0]!,
-                      explore,
-                      tags,
-                  )
-                : StatementFactory.block(
-                      ts.factory.createCallExpression(
-                          ts.factory.createIdentifier(
-                              importer.useLocal(
-                                  `${PREFIX}u${meta.union_index!}`,
-                              ),
-                          ),
-                          undefined,
-                          FeatureProgrammer.argumentsArray({
-                              trace: false,
-                              path: false,
-                          })(explore)(input),
-                      ),
-                  );
+        ): ts.Block => {
+            if (targets.length === 1)
+                return decode_object(project)(importer)(index)(
+                    input,
+                    targets[0]!,
+                    explore,
+                    tags,
+                );
+
+            const expected: string = `(${targets
+                .map((t) => t.name)
+                .join(" | ")})`;
+
+            // POSSIBLE TO SPECIALIZE?
+            const specList = UnionPredicator.object(targets);
+            if (specList.length === 0) {
+                const condition: ts.Expression = decode_union_object(
+                    IsProgrammer.decode_object(importer),
+                )((i, o, e) =>
+                    ExpressionFactory.selfCall(
+                        decode_object(project)(importer)(index)(i, o, e, tags),
+                    ),
+                )((expr) => expr)((value, expected) =>
+                    create_throw_error(importer)(expected)(value),
+                )(input, targets, explore);
+                return StatementFactory.block(condition);
+            }
+            const remained: MetadataObject[] = targets.filter(
+                (t) => specList.find((s) => s.object === t) === undefined,
+            );
+
+            // DO SPECIALIZE
+            const condition: ts.IfStatement = specList
+                .filter((spec) => spec.property.key.getSoleLiteral() !== null)
+                .map((spec, i, array) => {
+                    const key: string = spec.property.key.getSoleLiteral()!;
+                    const accessor: ts.Expression =
+                        IdentifierFactory.access(input)(key);
+                    const pred: ts.Expression = spec.neighbour
+                        ? IsProgrammer.decode(project)(importer)(
+                              accessor,
+                              spec.property.value,
+                              {
+                                  ...explore,
+                                  tracable: false,
+                                  postfix: IdentifierFactory.postfix(key),
+                              },
+                              tags,
+                              [],
+                          )
+                        : ExpressionFactory.isRequired(accessor);
+                    return ts.factory.createIfStatement(
+                        pred,
+                        ts.factory.createReturnStatement(
+                            ExpressionFactory.selfCall(
+                                decode_object(project)(importer)(index)(
+                                    input,
+                                    spec.object,
+                                    explore,
+                                    tags,
+                                ),
+                            ),
+                        ),
+                        i === array.length - 1
+                            ? remained.length
+                                ? ts.factory.createReturnStatement(
+                                      ExpressionFactory.selfCall(
+                                          explore_objects(project)(importer)(
+                                              level + 1,
+                                          )(index)(
+                                              input,
+                                              remained,
+                                              explore,
+                                              tags,
+                                          ),
+                                      ),
+                                  )
+                                : create_throw_error(importer)(expected)(input)
+                            : undefined,
+                    );
+                })
+                .reverse()
+                .reduce((a, b) =>
+                    ts.factory.createIfStatement(
+                        b.expression,
+                        b.thenStatement,
+                        a,
+                    ),
+                );
+
+            // RETURNS WITH CONDITIONS
+            return ts.factory.createBlock([condition], true);
+        };
 
     const explore_arrays =
         (project: IProject) =>

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -138,7 +138,12 @@ export namespace ProtobufMessageProgrammer {
         (tags: IMetadataTag[]) =>
         (literal: Atomic.Literal): string => {
             if (literal === "boolean") return "bool";
-            else if (literal === "bigint") return "int64";
+            else if (literal === "bigint")
+                return tags.find(
+                    (t) => t.kind === "type" && t.value === "uint64",
+                )
+                    ? "uint64"
+                    : "int64";
             else if (literal === "number") {
                 const type = tags.find((t) => t.kind === "type") as
                     | IMetadataTag.INumberType

package/src/protobuf.ts

@@ -80,7 +80,7 @@ Object.assign(validateDecode, Namespace.protobuf.decode("validateDecode"));
 /* -----------------------------------------------------------
     ENCODE
 ----------------------------------------------------------- */
-export function encode<T>(input: T): Uint16Array;
+export function encode<T>(input: T): Uint8Array;
 
 /**
  * @internal
@@ -90,7 +90,7 @@ export function encode(): never {
 }
 Object.assign(encode, Namespace.protobuf.encode("encode"));
 
-export function isEncode<T>(input: T): Uint16Array | null;
+export function isEncode<T>(input: T): Uint8Array | null;
 
 /**
  * @internal
@@ -101,7 +101,7 @@ export function isEncode(): never {
 Object.assign(isEncode, Namespace.is());
 Object.assign(isEncode, Namespace.protobuf.encode("isEncode"));
 
-export function assertEncode<T>(input: T): Uint16Array;
+export function assertEncode<T>(input: T): Uint8Array;
 
 /**
  * @internal
@@ -112,7 +112,7 @@ export function assertEncode(): never {
 Object.assign(assertEncode, Namespace.assert("assertEncode"));
 Object.assign(assertEncode, Namespace.protobuf.encode("assertEncode"));
 
-export function validateEncode<T>(input: T): IValidation<Uint16Array>;
+export function validateEncode<T>(input: T): IValidation<Uint8Array>;
 
 /**
  * @internal
@@ -192,8 +192,8 @@ export function createIsEncode<T>(): (input: T) => Uint8Array | null;
 export function createIsEncode<T>(): (input: T) => Uint8Array | null {
     halt("createIsEncode");
 }
-Object.assign(createIsEncode, Namespace.is);
-Object.assign(createIsEncode, Namespace.protobuf.encode);
+Object.assign(createIsEncode, Namespace.is());
+Object.assign(createIsEncode, Namespace.protobuf.encode("createIsEncode"));
 
 export function createAssertEncode(): never;
 export function createAssertEncode<T>(): (input: T) => Uint8Array;
@@ -204,8 +204,11 @@ export function createAssertEncode<T>(): (input: T) => Uint8Array;
 export function createAssertEncode<T>(): (input: T) => Uint8Array {
     halt("createAssertEncode");
 }
-Object.assign(createAssertEncode, Namespace.assert);
-Object.assign(createAssertEncode, Namespace.protobuf.encode);
+Object.assign(createAssertEncode, Namespace.assert("createAssertEncode"));
+Object.assign(
+    createAssertEncode,
+    Namespace.protobuf.encode("createAssertEncode"),
+);
 
 export function createValidateEncode(): never;
 export function createValidateEncode<T>(): (
@@ -220,8 +223,11 @@ export function createValidateEncode<T>(): (
 ) => IValidation<Uint8Array> {
     halt("createValidateEncode");
 }
-Object.assign(createValidateEncode, Namespace.validate);
-Object.assign(createValidateEncode, Namespace.protobuf.encode);
+Object.assign(createValidateEncode, Namespace.validate());
+Object.assign(
+    createValidateEncode,
+    Namespace.protobuf.encode("createValidateEncode"),
+);
 
 /**
  * @internal

package/src/schemas/metadata/MetadataTuple.ts

@@ -11,6 +11,11 @@ export class MetadataTuple {
     public readonly recursive: boolean;
     public readonly nullables: boolean[];
 
+    /**
+     * @internal
+     */
+    public of_map?: boolean;
+
     /**
      * @internal
      */

package/lib/functional/$proto_bytes.d.ts

@@ -1,2 +0,0 @@
-export declare function $proto_bytes_encode(dst: Uint8Array, offset: number, value: Uint8Array): number;
-export declare function $proto_bytes_decode(src: Uint8Array, offset: number): [value: Uint8Array, offset: number];

package/lib/functional/$proto_bytes.js

@@ -1,37 +0,0 @@
-"use strict";
-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.$proto_bytes_decode = exports.$proto_bytes_encode = void 0;
-var _varint_1 = require("./$varint");
-function $proto_bytes_encode(dst, offset, value) {
-    offset = (0, _varint_1.$varint_encode)(dst, offset, value.length);
-    dst.set(value, offset);
-    offset += value.length;
-    return offset;
-}
-exports.$proto_bytes_encode = $proto_bytes_encode;
-function $proto_bytes_decode(src, offset) {
-    var _a;
-    var length = 0;
-    _a = __read((0, _varint_1.$varint_decode_i32)(src, offset), 2), length = _a[0], offset = _a[1];
-    var value = src.subarray(offset, offset + length);
-    offset += length;
-    return [value, offset];
-}
-exports.$proto_bytes_decode = $proto_bytes_decode;
-//# sourceMappingURL=$proto_bytes.js.map

package/lib/functional/$proto_bytes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"$proto_bytes.js","sourceRoot":"","sources":["../../src/functional/$proto_bytes.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,qCAA+D;AAE/D,SAAgB,mBAAmB,CAC/B,GAAe,EACf,MAAc,EACd,KAAiB;IAEjB,MAAM,GAAG,IAAA,wBAAc,EAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACnD,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACvB,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC;IACvB,OAAO,MAAM,CAAC;AAClB,CAAC;AATD,kDASC;AAED,SAAgB,mBAAmB,CAC/B,GAAe,EACf,MAAc;;IAEd,IAAI,MAAM,GAAG,CAAC,CAAC;IAEf,KAAA,OAAmB,IAAA,4BAAkB,EAAC,GAAG,EAAE,MAAM,CAAC,IAAA,EAAjD,MAAM,QAAA,EAAE,MAAM,QAAA,CAAoC;IACnD,IAAM,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IACpD,MAAM,IAAI,MAAM,CAAC;IAEjB,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AAC3B,CAAC;AAXD,kDAWC"}

package/lib/functional/$proto_field.d.ts

@@ -1,10 +0,0 @@
-export declare enum $proto_field_wiretype {
-    VARINT = 0,
-    I64 = 1,
-    LEN = 2,
-    SGROUP = 3,
-    EGROUP = 4,
-    I32 = 5
-}
-export declare function $proto_field_encode(dst: Uint8Array, offset: number, fieldNumber: number, wireType: $proto_field_wiretype): number;
-export declare function $proto_field_decode(buf: Uint8Array, offset: number): [fieldNumber: number, wireType: $proto_field_wiretype, offset: number];

package/lib/functional/$proto_field.js

@@ -1,42 +0,0 @@
-"use strict";
-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.$proto_field_decode = exports.$proto_field_encode = exports.$proto_field_wiretype = void 0;
-var _varint_1 = require("./$varint");
-var $proto_field_wiretype;
-(function ($proto_field_wiretype) {
-    $proto_field_wiretype[$proto_field_wiretype["VARINT"] = 0] = "VARINT";
-    $proto_field_wiretype[$proto_field_wiretype["I64"] = 1] = "I64";
-    $proto_field_wiretype[$proto_field_wiretype["LEN"] = 2] = "LEN";
-    $proto_field_wiretype[$proto_field_wiretype["SGROUP"] = 3] = "SGROUP";
-    $proto_field_wiretype[$proto_field_wiretype["EGROUP"] = 4] = "EGROUP";
-    $proto_field_wiretype[$proto_field_wiretype["I32"] = 5] = "I32";
-})($proto_field_wiretype || (exports.$proto_field_wiretype = $proto_field_wiretype = {}));
-function $proto_field_encode(dst, offset, fieldNumber, wireType) {
-    var tag = (fieldNumber << 3) | Number(wireType);
-    return (0, _varint_1.$varint_encode)(dst, offset, tag);
-}
-exports.$proto_field_encode = $proto_field_encode;
-function $proto_field_decode(buf, offset) {
-    var _a = __read((0, _varint_1.$varint_decode_i32)(buf, offset), 2), tag = _a[0], o = _a[1];
-    var fieldNumber = tag >>> 3;
-    var wireType = tag & 7;
-    return [fieldNumber, wireType, o];
-}
-exports.$proto_field_decode = $proto_field_decode;
-//# sourceMappingURL=$proto_field.js.map