@aptre/protobuf-es-lite 0.1.0

package/dist/message.js

@@ -0,0 +1,247 @@
+"use strict";
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessageType = exports.cloneMessage = exports.compareMessages = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const field_js_1 = require("./field.js");
+const partial_js_1 = require("./partial.js");
+const scalar_js_1 = require("./scalar.js");
+const binary_js_1 = require("./binary.js");
+const json_js_1 = require("./json.js");
+// compareMessages compares two messages for equality.
+function compareMessages(fields, a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (!a || !b) {
+        return false;
+    }
+    return fields.byMember().every((m) => {
+        const va = a[m.localName];
+        const vb = b[m.localName];
+        if (m.repeated) {
+            if (va.length !== vb.length) {
+                return false;
+            }
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
+            switch (m.kind) {
+                case "message":
+                    return va.every((a, i) => m.T.equals(a, vb[i]));
+                case "scalar":
+                    return va.every((a, i) => (0, scalar_js_1.scalarEquals)(m.T, a, vb[i]));
+                case "enum":
+                    return va.every((a, i) => (0, scalar_js_1.scalarEquals)(protobuf_1.ScalarType.INT32, a, vb[i]));
+            }
+            throw new Error(`repeated cannot contain ${m.kind}`);
+        }
+        switch (m.kind) {
+            case "message":
+                return m.T.equals(va, vb);
+            case "enum":
+                return (0, scalar_js_1.scalarEquals)(protobuf_1.ScalarType.INT32, va, vb);
+            case "scalar":
+                return (0, scalar_js_1.scalarEquals)(m.T, va, vb);
+            case "oneof":
+                if (va.case !== vb.case) {
+                    return false;
+                }
+                const s = m.findField(va.case);
+                if (s === undefined) {
+                    return true;
+                }
+                // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- oneof fields are never "map"
+                switch (s.kind) {
+                    case "message":
+                        return s.T.equals(va.value, vb.value);
+                    case "enum":
+                        return (0, scalar_js_1.scalarEquals)(protobuf_1.ScalarType.INT32, va.value, vb.value);
+                    case "scalar":
+                        return (0, scalar_js_1.scalarEquals)(s.T, va.value, vb.value);
+                }
+                throw new Error(`oneof cannot contain ${s.kind}`);
+            case "map":
+                const keys = Object.keys(va).concat(Object.keys(vb));
+                switch (m.V.kind) {
+                    case "message":
+                        const messageType = m.V.T;
+                        return keys.every((k) => messageType.equals(va[k], vb[k]));
+                    case "enum":
+                        return keys.every((k) => (0, scalar_js_1.scalarEquals)(protobuf_1.ScalarType.INT32, va[k], vb[k]));
+                    case "scalar":
+                        const scalarType = m.V.T;
+                        return keys.every((k) => (0, scalar_js_1.scalarEquals)(scalarType, va[k], vb[k]));
+                }
+        }
+    });
+}
+exports.compareMessages = compareMessages;
+// clone a single field value - i.e. the element type of repeated fields, the value type of maps
+function cloneSingularField(value, fieldInfo) {
+    if (value === undefined) {
+        return value;
+    }
+    if (fieldInfo.kind === "message") {
+        return cloneMessage(value, fieldInfo.T.fields);
+    }
+    if (fieldInfo.kind === "oneof") {
+        if (value.case === undefined) {
+            return undefined;
+        }
+        const selectedField = fieldInfo.findField(value.case);
+        if (!selectedField) {
+            throw new Error(`Invalid oneof case "${value.case}" for ${fieldInfo.name}`);
+        }
+        return {
+            case: value.case,
+            value: cloneSingularField(value.value, selectedField),
+        };
+    }
+    if (value instanceof Uint8Array) {
+        const c = new Uint8Array(value.byteLength);
+        c.set(value);
+        return c;
+    }
+    return value;
+}
+// TODO use isFieldSet() here to support future field presence
+function cloneMessage(message, fields) {
+    const clone = {};
+    for (const member of fields.byMember()) {
+        const source = message[member.localName];
+        let copy;
+        if (member.repeated) {
+            copy = source.map((v) => cloneSingularField(v, member));
+        }
+        else if (member.kind == "map") {
+            copy = {};
+            for (const [key, v] of Object.entries(source)) {
+                copy[key] = cloneSingularField(v, member);
+            }
+        }
+        else if (member.kind == "oneof") {
+            const f = member.findField(source.case);
+            copy = f
+                ? { case: source.case, value: cloneSingularField(source.value, member) }
+                : { case: undefined };
+        }
+        else {
+            copy = cloneSingularField(source, member);
+        }
+        clone[member.localName] = copy;
+    }
+    return clone;
+}
+exports.cloneMessage = cloneMessage;
+/**
+ * createMessageType creates a new message type.
+ *
+ * The argument `packedByDefault` specifies whether fields that do not specify
+ * `packed` should be packed (proto3) or unpacked (proto2).
+ */
+function createMessageType(params) {
+    const { fields: fieldsSource, typeName, packedByDefault, delimitedMessageEncoding, fieldWrapper, } = params;
+    const fields = (0, field_js_1.newFieldList)(fieldsSource, packedByDefault);
+    const mt = {
+        typeName,
+        fields,
+        fieldWrapper,
+        create(partial) {
+            const message = createMessage(fields);
+            (0, partial_js_1.applyPartialMessage)(partial, message, fields);
+            return message;
+        },
+        equals(a, b) {
+            return compareMessages(fields, a, b);
+        },
+        clone(a) {
+            if (a == null) {
+                return a;
+            }
+            return cloneMessage(a, fields);
+        },
+        fromBinary(bytes, options) {
+            const message = this.create();
+            const opt = (0, binary_js_1.makeReadOptions)(options);
+            (0, binary_js_1.readMessage)(message, fields, opt.readerFactory(bytes), bytes.byteLength, opt, delimitedMessageEncoding);
+            return message;
+        },
+        fromJson(jsonValue, options) {
+            const message = this.create();
+            const opts = (0, json_js_1.makeReadOptions)(options);
+            (0, json_js_1.readMessage)(fields, typeName, jsonValue, opts, message);
+            return message;
+        },
+        fromJsonString(jsonString, options) {
+            let json;
+            try {
+                json = JSON.parse(jsonString);
+            }
+            catch (e) {
+                throw new Error(`cannot decode ${typeName} from JSON: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            return this.fromJson(json, options);
+        },
+        toBinary(a, options) {
+            const opt = (0, binary_js_1.makeWriteOptions)(options);
+            const writer = opt.writerFactory();
+            (0, binary_js_1.writeMessage)(a, fields, writer, opt);
+            return writer.finish();
+        },
+        toJson(a, options) {
+            const opt = (0, json_js_1.makeWriteOptions)(options);
+            return (0, json_js_1.writeMessage)(a, fields, opt);
+        },
+        toJsonString(a, options) {
+            const value = this.toJson(a, options);
+            return JSON.stringify(value, null, options?.prettySpaces ?? 0);
+        },
+    };
+    if (params.toJson) {
+        mt.toJson = params.toJson;
+    }
+    return mt;
+}
+exports.createMessageType = createMessageType;
+/**
+ * createMessage recursively builds a message filled with zero values based on the given FieldList.
+ */
+function createMessage(fields) {
+    const message = {};
+    for (const field of fields.list()) {
+        const fieldKind = field.kind;
+        switch (fieldKind) {
+            case "scalar":
+                message[field.localName] = (field.T == protobuf_1.ScalarType.BOOL ? false : 0);
+                break;
+            case "enum":
+                message[field.localName] = 0;
+                break;
+            case "message":
+                if (field.oneof) {
+                    // leave oneofs undefined
+                    message[field.localName] = undefined;
+                    continue;
+                }
+                message[field.localName] = createMessage(field.T.fields);
+                break;
+            case "map":
+                message[field.localName] = {};
+                break;
+            default:
+                field;
+        }
+    }
+    return message;
+}

package/dist/partial.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPartialMessage = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const is_message_js_1 = require("./is-message.js");
+// applyPartialMessage applies a partial message to a message.
+function applyPartialMessage(source, target, fields) {
+    if (source === undefined) {
+        return;
+    }
+    for (const member of fields.byMember()) {
+        const localName = member.localName, t = target, s = source;
+        if (s[localName] === undefined) {
+            // TODO if source is a Message instance, we should use isFieldSet() here to support future field presence
+            continue;
+        }
+        switch (member.kind) {
+            case "oneof":
+                const sk = s[localName].case;
+                if (sk === undefined) {
+                    continue;
+                }
+                const sourceField = member.findField(sk);
+                let val = s[localName].value;
+                if (sourceField &&
+                    sourceField.kind == "message" &&
+                    !(0, is_message_js_1.isCompleteMessage)(val, sourceField.T.fields.list())) {
+                    val = sourceField.T.create(val);
+                }
+                else if (sourceField &&
+                    sourceField.kind === "scalar" &&
+                    sourceField.T === protobuf_1.ScalarType.BYTES) {
+                    val = toU8Arr(val);
+                }
+                t[localName] = { case: sk, value: val };
+                break;
+            case "scalar":
+            case "enum":
+                let copy = s[localName];
+                if (member.T === protobuf_1.ScalarType.BYTES) {
+                    copy = member.repeated
+                        ? copy.map(toU8Arr)
+                        : toU8Arr(copy);
+                }
+                t[localName] = copy;
+                break;
+            case "map":
+                switch (member.V.kind) {
+                    case "scalar":
+                    case "enum":
+                        if (member.V.T === protobuf_1.ScalarType.BYTES) {
+                            for (const [k, v] of Object.entries(s[localName])) {
+                                t[localName][k] = toU8Arr(v);
+                            }
+                        }
+                        else {
+                            Object.assign(t[localName], s[localName]);
+                        }
+                        break;
+                    case "message":
+                        const messageType = member.V.T;
+                        for (const k of Object.keys(s[localName])) {
+                            let val = s[localName][k];
+                            if (!messageType.fieldWrapper) {
+                                // We only take partial input for messages that are not a wrapper type.
+                                // For those messages, we recursively normalize the partial input.
+                                val = messageType.create(val);
+                            }
+                            t[localName][k] = val;
+                        }
+                        break;
+                }
+                break;
+            case "message":
+                const mt = member.T;
+                if (member.repeated) {
+                    t[localName] = s[localName].map((val) => (0, is_message_js_1.isCompleteMessage)(val, mt.fields.list()) ? val : mt.create(val));
+                }
+                else {
+                    const val = s[localName];
+                    if (mt.fieldWrapper) {
+                        if (
+                        // We can't use BytesValue.typeName as that will create a circular import
+                        mt.typeName === "google.protobuf.BytesValue") {
+                            t[localName] = toU8Arr(val);
+                        }
+                        else {
+                            t[localName] = val;
+                        }
+                    }
+                    else {
+                        t[localName] = (0, is_message_js_1.isCompleteMessage)(val, mt.fields.list())
+                            ? val
+                            : mt.create(val);
+                    }
+                }
+                break;
+        }
+    }
+}
+exports.applyPartialMessage = applyPartialMessage;
+// converts any ArrayLike<number> to Uint8Array if necessary.
+function toU8Arr(input) {
+    return input instanceof Uint8Array ? input : new Uint8Array(input);
+}

package/dist/protoc-gen-es-lite-plugin.js

@@ -0,0 +1,25 @@
+"use strict";
+// Copyright 2024 Aperture Robotics, LLC.
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protocGenEsLite = void 0;
+const protoplugin_1 = require("@bufbuild/protoplugin");
+const typescript_js_1 = require("./typescript.js");
+// import { version } from "../package.json";
+exports.protocGenEsLite = (0, protoplugin_1.createEcmaScriptPlugin)({
+    name: "protoc-gen-es-lite",
+    version: `unknown`,
+    generateTs: typescript_js_1.generateTs,
+});

package/dist/scalar.js

@@ -0,0 +1,104 @@
+"use strict";
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScalarZeroValue = exports.scalarZeroValue = exports.scalarEquals = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+/**
+ * Returns true if both scalar values are equal.
+ */
+function scalarEquals(type, a, b) {
+    if (a === b) {
+        // This correctly matches equal values except BYTES and (possibly) 64-bit integers.
+        return true;
+    }
+    // Special case BYTES - we need to compare each byte individually
+    if (type == protobuf_1.ScalarType.BYTES) {
+        if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {
+            return false;
+        }
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Special case 64-bit integers - we support number, string and bigint representation.
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (type) {
+        case protobuf_1.ScalarType.UINT64:
+        case protobuf_1.ScalarType.FIXED64:
+        case protobuf_1.ScalarType.INT64:
+        case protobuf_1.ScalarType.SFIXED64:
+        case protobuf_1.ScalarType.SINT64:
+            // Loose comparison will match between 0n, 0 and "0".
+            return a == b;
+    }
+    // Anything that hasn't been caught by strict comparison or special cased
+    // BYTES and 64-bit integers is not equal.
+    return false;
+}
+exports.scalarEquals = scalarEquals;
+/**
+ * Returns the zero value for the given scalar type.
+ */
+function scalarZeroValue(type, longType) {
+    switch (type) {
+        case protobuf_1.ScalarType.BOOL:
+            return false;
+        case protobuf_1.ScalarType.UINT64:
+        case protobuf_1.ScalarType.FIXED64:
+        case protobuf_1.ScalarType.INT64:
+        case protobuf_1.ScalarType.SFIXED64:
+        case protobuf_1.ScalarType.SINT64:
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- acceptable since it's covered by tests
+            return (longType == 0 ? protobuf_1.protoInt64.zero : "0");
+        case protobuf_1.ScalarType.DOUBLE:
+        case protobuf_1.ScalarType.FLOAT:
+            return 0.0;
+        case protobuf_1.ScalarType.BYTES:
+            return new Uint8Array(0);
+        case protobuf_1.ScalarType.STRING:
+            return "";
+        default:
+            // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
+            // We do not use individual cases to save a few bytes code size.
+            return 0;
+    }
+}
+exports.scalarZeroValue = scalarZeroValue;
+/**
+ * Returns true for a zero-value. For example, an integer has the zero-value `0`,
+ * a boolean is `false`, a string is `""`, and bytes is an empty Uint8Array.
+ *
+ * In proto3, zero-values are not written to the wire, unless the field is
+ * optional or repeated.
+ */
+function isScalarZeroValue(type, value) {
+    switch (type) {
+        case protobuf_1.ScalarType.BOOL:
+            return value === false;
+        case protobuf_1.ScalarType.STRING:
+            return value === "";
+        case protobuf_1.ScalarType.BYTES:
+            return value instanceof Uint8Array && !value.byteLength;
+        default:
+            return value == 0; // Loose comparison matches 0n, 0 and "0"
+    }
+}
+exports.isScalarZeroValue = isScalarZeroValue;

package/dist/typescript.js

@@ -0,0 +1,177 @@
+"use strict";
+// Copyright 2024 Aperture Robotics, LLC.
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldInfoLiteral = exports.generateFieldInfo = exports.generateTs = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
+const editions_js_1 = require("./editions.js");
+const util_js_1 = require("./util.js");
+const libPkg = "@aptre/protobuf-es-lite";
+const MessageImport = (0, ecmascript_1.createImportSymbol)("Message", libPkg);
+const MessageTypeImport = (0, ecmascript_1.createImportSymbol)("MessageType", libPkg);
+const CreateMessageTypeImport = (0, ecmascript_1.createImportSymbol)("createMessageType", libPkg);
+function generateTs(schema) {
+    for (const file of schema.files) {
+        const f = schema.generateFile(file.name + "_pb.ts");
+        f.preamble(file);
+        f.print(`export const protobufPackage = "${file.proto.package}";`);
+        f.print();
+        for (const enumeration of file.enums) {
+            generateEnum(f, enumeration);
+        }
+        for (const message of file.messages) {
+            generateMessage(schema, f, message);
+        }
+        // We do not generate anything for services or extensions
+    }
+}
+exports.generateTs = generateTs;
+// prettier-ignore
+function generateEnum(f, enumeration) {
+    f.print(f.jsDoc(enumeration));
+    f.print(f.exportDecl("enum", enumeration), " {");
+    for (const value of enumeration.values) {
+        if (enumeration.values.indexOf(value) > 0) {
+            f.print();
+        }
+        f.print(f.jsDoc(value, "  "));
+        f.print("  ", (0, ecmascript_1.localName)(value), " = ", value.number, ",");
+    }
+    f.print("}");
+    f.print();
+    f.print("// ", enumeration, "_Name maps the enum names to the values.");
+    f.print(f.exportDecl("const", enumeration.name + "_Name"), " = {");
+    for (const value of enumeration.values) {
+        f.print("  ", (0, ecmascript_1.localName)(value), ": ", enumeration, ".", (0, ecmascript_1.localName)(value), ",");
+    }
+    f.print("};");
+    f.print();
+}
+// prettier-ignore
+function generateMessage(schema, f, message) {
+    // check if we support this runtime
+    (0, editions_js_1.getNonEditionRuntime)(schema, message.file);
+    f.print(f.jsDoc(message));
+    f.print(f.exportDecl("interface", message), " extends ", MessageImport, "<", message, "> {");
+    for (const member of message.members) {
+        switch (member.kind) {
+            case "field":
+                generateField(f, member);
+                break;
+        }
+        f.print();
+    }
+    f.print("}");
+    f.print();
+    f.print(f.exportDecl("const", message), ": ", MessageTypeImport, "<", message, "> = ", CreateMessageTypeImport, "(");
+    f.print("  {");
+    f.print("    typeName: ", f.string(message.typeName), ",");
+    f.print("    fields: [");
+    for (const field of message.fields) {
+        generateFieldInfo(f, field);
+    }
+    f.print("    ],");
+    f.print("    packedByDefault: ", message.file.proto.syntax === "proto3", ",");
+    f.print("  },");
+    f.print("  true,");
+    f.print(");");
+    f.print();
+    for (const nestedEnum of message.nestedEnums) {
+        generateEnum(f, nestedEnum);
+    }
+    for (const nestedMessage of message.nestedMessages) {
+        generateMessage(schema, f, nestedMessage);
+    }
+}
+// prettier-ignore
+function generateField(f, field) {
+    f.print(f.jsDoc(field, "  "));
+    const { typing } = (0, util_js_1.getFieldTypeInfo)(field);
+    f.print("  ", (0, ecmascript_1.localName)(field), ": ", typing, ";");
+}
+// prettier-ignore
+function generateFieldInfo(f, field) {
+    f.print("        ", getFieldInfoLiteral(field), ",");
+}
+exports.generateFieldInfo = generateFieldInfo;
+// prettier-ignore
+function getFieldInfoLiteral(field) {
+    const e = [];
+    e.push("{ no: ", field.number, `, `);
+    if (field.kind == "field") {
+        e.push(`name: "`, field.name, `", `);
+        if (field.jsonName !== undefined) {
+            e.push(`jsonName: "`, field.jsonName, `", `);
+        }
+    }
+    switch (field.fieldKind) {
+        case "scalar":
+            e.push(`kind: "scalar", T: `, field.scalar, ` /* ScalarType.`, protobuf_1.ScalarType[field.scalar], ` */, `);
+            if (field.longType != protobuf_1.LongType.BIGINT) {
+                e.push(`L: `, field.longType, ` /* LongType.`, protobuf_1.LongType[field.longType], ` */, `);
+            }
+            break;
+        case "map":
+            e.push(`kind: "map", K: `, field.mapKey, ` /* ScalarType.`, protobuf_1.ScalarType[field.mapKey], ` */, `);
+            switch (field.mapValue.kind) {
+                case "scalar":
+                    e.push(`V: {kind: "scalar", T: `, field.mapValue.scalar, ` /* ScalarType.`, protobuf_1.ScalarType[field.mapValue.scalar], ` */}, `);
+                    break;
+                case "message":
+                    e.push(`V: {kind: "message", T: `, field.mapValue.message, `}, `);
+                    break;
+                case "enum":
+                    e.push(`V: {kind: "enum", T: `, field.mapValue.enum, `}, `);
+                    break;
+            }
+            break;
+        case "message":
+            e.push(`kind: "message", T: `, field.message, `, `);
+            if (field.proto.type === protobuf_1.FieldDescriptorProto_Type.GROUP) {
+                e.push(`delimited: true, `);
+            }
+            break;
+        case "enum":
+            e.push(`kind: "enum", T: `, field.enum, `, `);
+            break;
+    }
+    if (field.repeated) {
+        e.push(`repeated: true, `);
+        if (field.packed !== field.packedByDefault) {
+            e.push(`packed: `, field.packed, `, `);
+        }
+    }
+    if (field.optional) {
+        e.push(`opt: true, `);
+    }
+    else if (field.proto.label === protobuf_1.FieldDescriptorProto_Label.REQUIRED) {
+        e.push(`req: true, `);
+    }
+    const defaultValue = (0, util_js_1.getFieldDefaultValueExpression)(field);
+    if (defaultValue !== undefined) {
+        e.push(`default: `, defaultValue, `, `);
+    }
+    if (field.oneof) {
+        e.push(`oneof: "`, field.oneof.name, `", `);
+    }
+    const lastE = e[e.length - 1];
+    if (typeof lastE == "string" && lastE.endsWith(", ")) {
+        e[e.length - 1] = lastE.substring(0, lastE.length - 2);
+    }
+    e.push(" }");
+    return e;
+}
+exports.getFieldInfoLiteral = getFieldInfoLiteral;

package/dist/unknown.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUnknownField = exports.listUnknownFields = exports.unknownFieldsSymbol = void 0;
+// unknownFieldsSymbol is the symbol used for unknown fields.
+exports.unknownFieldsSymbol = Symbol("@aptre/protobuf-es-lite/unknown-fields");
+function listUnknownFields(message) {
+    return message[exports.unknownFieldsSymbol] ?? [];
+}
+exports.listUnknownFields = listUnknownFields;
+// handleUnknownField stores an unknown field.
+function handleUnknownField(message, no, wireType, data) {
+    if (typeof message !== "object") {
+        return;
+    }
+    const m = message;
+    if (!Array.isArray(m[exports.unknownFieldsSymbol])) {
+        m[exports.unknownFieldsSymbol] = [];
+    }
+    m[exports.unknownFieldsSymbol].push({ no, wireType, data });
+}
+exports.handleUnknownField = handleUnknownField;