├── .npmignore ├── .gitignore ├── tsconfig.json ├── index.d.ts ├── index.ts ├── protocol-buffers-schema.d.ts ├── package.json ├── LICENSE.md ├── README.md ├── cli.ts ├── test.proto ├── test.ts ├── generate.ts ├── test.proto.es6.js └── test.proto.es5.js /.npmignore: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules/ 2 | *.js 3 | -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "module": "commonjs", 4 | "target": "es6", 5 | "strict": true 6 | } 7 | } -------------------------------------------------------------------------------- /index.d.ts: -------------------------------------------------------------------------------- 1 | export interface ParsedSchema { 2 | compile(): any; 3 | toJavaScript(options?: JsOptions): string; 4 | toTypeScript(): string; 5 | } 6 | 7 | export interface JsOptions { 8 | es6?: boolean; 9 | } 10 | 11 | export function parseSchema(contents: string): ParsedSchema; 12 | -------------------------------------------------------------------------------- /index.ts: -------------------------------------------------------------------------------- 1 | import * as parser from 'protocol-buffers-schema'; 2 | import { generate } from './generate'; 3 | import { ParsedSchema, JsOptions } from './index.d'; 4 | 5 | export function parseSchema(contents: string): ParsedSchema { 6 | const schema = parser.parse(contents); 7 | 8 | return { 9 | compile(): any { 10 | const result = {}; 11 | new Function('exports', generate(schema))(result); 12 | return result; 13 | }, 14 | 15 | toJavaScript({ es6 }: JsOptions = {}): string { 16 | return generate(schema, { es6 }); 17 | }, 18 | 19 | toTypeScript(): string { 20 | return generate(schema, { typescript: true }); 21 | }, 22 | }; 23 | }; 24 | -------------------------------------------------------------------------------- /protocol-buffers-schema.d.ts: -------------------------------------------------------------------------------- 1 | declare module 'protocol-buffers-schema' { 2 | export interface Schema { 3 | package: string | null; 4 | syntax: number; 5 | enums: { 6 | name: string; 7 | values: { 8 | value: string; 9 | }[]; 10 | }[]; 11 | messages: { 12 | name: string; 13 | fields: { 14 | name: string; 15 | tag: number; 16 | type: string; 17 | required: boolean; 18 | repeated: boolean; 19 | map: { from: string, to: string } | null; 20 | oneof: string | null; 21 | options: { [key: string]: string }; 22 | }[]; 23 | }[]; 24 | } 25 | 26 | export function parse(text: string): Schema; 27 | } 28 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "pbjs", 3 | "version": "0.0.14", 4 | "description": "A minimal implementation of Google Protocol Buffers for JavaScript", 5 | "main": "./index.js", 6 | "types": "./index.d.ts", 7 | "bin": { 8 | "pbjs": "./cli.js" 9 | }, 10 | "scripts": { 11 | "test": "tsc && mocha", 12 | "generate": "rm -f proto.test.ts && tsc && node cli test.proto --es5 test.proto.es5.js --es6 test.proto.es6.js --ts test.proto.ts", 13 | "build": "tsc", 14 | "prepublishOnly": "tsc && chmod +x cli.js" 15 | }, 16 | "dependencies": { 17 | "commander": "4.0.1", 18 | "protocol-buffers-schema": "3.1.0" 19 | }, 20 | "devDependencies": { 21 | "@types/mocha": "5.2.7", 22 | "long": "4.0.0", 23 | "mocha": "6.2.2", 24 | "protobufjs": "6.8.8", 25 | "typescript": "3.7.2" 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | Copyright 2019 Evan Wallace 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 4 | 5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 6 | 7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 8 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Protocol Buffers for JavaScript 2 | 3 | This is a minimal implementation of [Google Protocol Buffers](https://developers.google.com/protocol-buffers/) for JavaScript and TypeScript. 4 | It generates completely self-contained code without any dependencies. 5 | Install it using npm: 6 | 7 | ``` 8 | npm install pbjs 9 | ``` 10 | 11 | Unlike other JavaScript implementations, this library doesn't write out default values. 12 | This makes it possible to tell if a field has been written at all or not, which allows for efficient encoding of maps. 13 | For example, it's possible to distinguish between a missing list and a list that is present but empty. 14 | 15 | ## Command-Line Examples 16 | 17 | * Generate ES5 JavaScript: 18 | 19 | ``` 20 | pbjs wire-format.proto --es5 wire-format.js 21 | ``` 22 | 23 | See [test.proto.es5.js](https://github.com/evanw/pbjs/blob/master/test.proto.es5.js) for an example of the generated code. 24 | 25 | * Generate ES6 JavaScript: 26 | 27 | ``` 28 | pbjs wire-format.proto --es6 wire-format.js 29 | ``` 30 | 31 | See [test.proto.es6.js](https://github.com/evanw/pbjs/blob/master/test.proto.es6.js) for an example of the generated code. 32 | 33 | * Generate TypeScript: 34 | 35 | ``` 36 | pbjs wire-format.proto --ts wire-format.ts 37 | ``` 38 | 39 | See [test.proto.ts](https://github.com/evanw/pbjs/blob/master/test.proto.ts) for an example of the generated code. 40 | 41 | * Convert to JSON: 42 | 43 | ``` 44 | pbjs wire-format.proto --decode MessageType < wire-format.bin > wire-format.json 45 | ``` 46 | 47 | * Convert to Binary: 48 | 49 | ``` 50 | pbjs wire-format.proto --encode MessageType < wire-format.json > wire-format.bin 51 | ``` 52 | 53 | ## API Example 54 | 55 | ```js 56 | const pbjs = require('pbjs'); 57 | 58 | const schema = pbjs.parseSchema(` 59 | message Demo { 60 | optional int32 x = 1; 61 | optional float y = 2; 62 | } 63 | `).compile(); 64 | 65 | const buffer = schema.encodeDemo({x: 1, y: 2}); 66 | console.log(buffer); 67 | 68 | const message = schema.decodeDemo(buffer); 69 | console.log(message); 70 | ``` 71 | 72 | Running the above code should output this: 73 | 74 | ``` 75 | 76 | { x: 1, y: 2 } 77 | ``` 78 | -------------------------------------------------------------------------------- /cli.ts: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env node 2 | 3 | import * as commander from 'commander'; 4 | import * as fs from 'fs'; 5 | import { parseSchema } from './index'; 6 | 7 | commander 8 | .version(JSON.parse(fs.readFileSync(__dirname + '/package.json', 'utf8')).version) 9 | .arguments('') 10 | .option('--es5 ', 'Generate ES5 JavaScript code') 11 | .option('--es6 ', 'Generate ES6 JavaScript code') 12 | .option('--ts ', 'Generate TypeScript code') 13 | .option('--decode ', 'Decode standard input to JSON') 14 | .option('--encode ', 'Encode standard input to JSON') 15 | .parse(process.argv); 16 | 17 | if (!process.argv.slice(2).length) { 18 | commander.outputHelp(); 19 | process.exit(1); 20 | } 21 | 22 | const contents = fs.readFileSync(commander.args[0], 'utf8'); 23 | const schema = parseSchema(contents); 24 | 25 | // Generate ES5 JavaScript code 26 | if (commander.es5) { 27 | const js = schema.toJavaScript({ es6: false }); 28 | fs.writeFileSync(commander.es5, js); 29 | } 30 | 31 | // Generate ES6 JavaScript code 32 | if (commander.es6) { 33 | const js = schema.toJavaScript({ es6: true }); 34 | fs.writeFileSync(commander.es6, js); 35 | } 36 | 37 | // Generate TypeScript code 38 | if (commander.ts) { 39 | const ts = schema.toTypeScript(); 40 | fs.writeFileSync(commander.ts, ts); 41 | } 42 | 43 | // Decode standard input to JSON 44 | if (commander.decode) { 45 | const chunks: Buffer[] = []; 46 | process.stdin.on('data', chunk => { 47 | chunks.push(chunk); 48 | }); 49 | process.stdin.on('end', () => { 50 | console.log(JSON.stringify(schema.compile()['decode' + commander.decode](Buffer.concat(chunks)), null, 2)); 51 | }); 52 | process.stdin.resume(); 53 | } 54 | 55 | // Encode standard input to JSON 56 | else if (commander.encode) { 57 | const chunks: Buffer[] = []; 58 | process.stdin.on('data', chunk => { 59 | chunks.push(chunk); 60 | }); 61 | process.stdin.on('end', () => { 62 | process.stdout.write(schema.compile()['encode' + commander.encode](JSON.parse(chunks.join('')))); 63 | }); 64 | process.stdin.resume(); 65 | } 66 | 67 | if ( 68 | !commander.es5 && 69 | !commander.es6 && 70 | !commander.ts && 71 | !commander.decode && 72 | !commander.encode 73 | ) { 74 | commander.outputHelp(); 75 | process.exit(1); 76 | } 77 | -------------------------------------------------------------------------------- /test.proto: -------------------------------------------------------------------------------- 1 | syntax = "proto2"; 2 | 3 | package test; 4 | 5 | enum Enum { 6 | A = 0; 7 | B = 1; 8 | } 9 | 10 | message Nested { 11 | optional float x = 1; 12 | optional float y = 2; 13 | } 14 | 15 | message Optional { 16 | optional int32 field_int32 = 1; 17 | optional int64 field_int64 = 2; 18 | optional uint32 field_uint32 = 3; 19 | optional uint64 field_uint64 = 4; 20 | optional sint32 field_sint32 = 5; 21 | optional sint64 field_sint64 = 6; 22 | optional bool field_bool = 7; 23 | optional fixed64 field_fixed64 = 8; 24 | optional sfixed64 field_sfixed64 = 9; 25 | optional double field_double = 10; 26 | optional string field_string = 11; 27 | optional bytes field_bytes = 12; 28 | optional fixed32 field_fixed32 = 13; 29 | optional sfixed32 field_sfixed32 = 14; 30 | optional float field_float = 15; 31 | optional Nested field_nested = 16; 32 | } 33 | 34 | message RepeatedUnpacked { 35 | repeated int32 field_int32 = 1 [ packed = false ]; 36 | repeated int64 field_int64 = 2 [ packed = false ]; 37 | repeated uint32 field_uint32 = 3 [ packed = false ]; 38 | repeated uint64 field_uint64 = 4 [ packed = false ]; 39 | repeated sint32 field_sint32 = 5 [ packed = false ]; 40 | repeated sint64 field_sint64 = 6 [ packed = false ]; 41 | repeated bool field_bool = 7 [ packed = false ]; 42 | repeated fixed64 field_fixed64 = 8 [ packed = false ]; 43 | repeated sfixed64 field_sfixed64 = 9 [ packed = false ]; 44 | repeated double field_double = 10 [ packed = false ]; 45 | repeated string field_string = 11 [ packed = false ]; 46 | repeated bytes field_bytes = 12 [ packed = false ]; 47 | repeated fixed32 field_fixed32 = 13 [ packed = false ]; 48 | repeated sfixed32 field_sfixed32 = 14 [ packed = false ]; 49 | repeated float field_float = 15 [ packed = false ]; 50 | repeated Nested field_nested = 16 [ packed = false ]; 51 | } 52 | 53 | message RepeatedPacked { 54 | repeated int32 field_int32 = 1 [ packed = true ]; 55 | repeated int64 field_int64 = 2 [ packed = true ]; 56 | repeated uint32 field_uint32 = 3 [ packed = true ]; 57 | repeated uint64 field_uint64 = 4 [ packed = true ]; 58 | repeated sint32 field_sint32 = 5 [ packed = true ]; 59 | repeated sint64 field_sint64 = 6 [ packed = true ]; 60 | repeated bool field_bool = 7 [ packed = true ]; 61 | repeated fixed64 field_fixed64 = 8 [ packed = true ]; 62 | repeated sfixed64 field_sfixed64 = 9 [ packed = true ]; 63 | repeated double field_double = 10 [ packed = true ]; 64 | repeated string field_string = 11 [ packed = false ]; 65 | repeated bytes field_bytes = 12 [ packed = false ]; 66 | repeated fixed32 field_fixed32 = 13 [ packed = true ]; 67 | repeated sfixed32 field_sfixed32 = 14 [ packed = true ]; 68 | repeated float field_float = 15 [ packed = true ]; 69 | repeated Nested field_nested = 16 [ packed = false ]; 70 | } 71 | 72 | message EnumTest { 73 | optional Enum a = 1; 74 | required Enum b = 2; 75 | repeated Enum c = 3; 76 | } 77 | 78 | message MapTestIntAndString { 79 | map field_int32 = 1; 80 | map field_uint32 = 2; 81 | map field_sint32 = 3; 82 | map field_string = 5; 83 | map field_fixed32 = 6; 84 | map field_sfixed32 = 7; 85 | } 86 | 87 | message MapTestLongAndBool { 88 | map field_int64 = 1; 89 | map field_uint64 = 2; 90 | map field_sint64 = 3; 91 | map field_fixed64 = 4; 92 | map field_sfixed64 = 5; 93 | map field_bool = 6; 94 | } 95 | -------------------------------------------------------------------------------- /test.ts: -------------------------------------------------------------------------------- 1 | import * as child_process from 'child_process'; 2 | import * as protobufjs from 'protobufjs'; 3 | import * as assert from 'assert'; 4 | import * as Long from 'long'; 5 | import * as fs from 'fs'; 6 | import { parseSchema } from './index'; 7 | import { 8 | Enum, 9 | EnumTest, 10 | MapTestLongAndBool, 11 | MapTestIntAndString, 12 | Optional, 13 | RepeatedPacked, 14 | RepeatedUnpacked, 15 | } from './test.proto'; 16 | 17 | function parseTestProto(): typeof import('./test.proto') { 18 | return parseSchema(fs.readFileSync('./test.proto', 'utf8')).compile(); 19 | } 20 | 21 | function prngUint32(): () => number { 22 | let seed = 1; 23 | return () => { 24 | const temp = (seed * 20077 + (seed & 0xFFFF) * 1103495168 + 12345) & 0x7FFFFFFF; 25 | seed = (temp * 20077 + (temp & 0xFFFF) * 1103495168 + 12345) & 0x7FFFFFFF; 26 | return ((temp & 0xFFFF) | (seed << 16)) >>> 0; 27 | }; 28 | } 29 | 30 | function* randomMessageStream(): Iterable { 31 | const randomUint32 = prngUint32(); 32 | const randomFloat64 = () => randomUint32() / (-1 >>> 0); 33 | 34 | for (let i = 0; i < 1000; i++) { 35 | yield { 36 | field_int32: randomUint32() | 0, 37 | field_int64: new Long(randomUint32(), randomUint32()), 38 | field_uint32: randomUint32(), 39 | field_uint64: new Long(randomUint32(), randomUint32(), true), 40 | field_sint32: randomUint32() | 0, 41 | field_sint64: new Long(randomUint32(), randomUint32()), 42 | field_fixed64: new Long(randomUint32(), randomUint32(), true), 43 | field_sfixed64: new Long(randomUint32(), randomUint32()), 44 | field_double: randomFloat64(), 45 | field_fixed32: randomUint32(), 46 | field_sfixed32: randomUint32() | 0, 47 | field_float: Math.fround(randomFloat64()), 48 | }; 49 | } 50 | } 51 | 52 | //////////////////////////////////////////////////////////////////////////////// 53 | 54 | it('optional', async () => { 55 | const schema = parseTestProto(); 56 | 57 | const message: Optional = { 58 | field_int32: -1, 59 | field_int64: new Long(-1, -2), 60 | field_uint32: -1 >>> 0, 61 | field_uint64: new Long(-1 >>> 0, -2 >>> 0, true), 62 | field_sint32: -1, 63 | field_sint64: new Long(-1, -2), 64 | field_bool: true, 65 | field_fixed64: new Long(12345678, 87654321, true), 66 | field_sfixed64: new Long(-87654321, -12345678), 67 | field_double: 2.5, 68 | field_string: 'testing 🙉🙈🙊', 69 | field_bytes: new Uint8Array([1, 2, 3, 4, 5]), 70 | field_fixed32: -1 >>> 0, 71 | field_sfixed32: -1, 72 | field_float: 3.25, 73 | field_nested: { x: 1.5 }, 74 | }; 75 | 76 | const buffer = schema.encodeOptional(message); 77 | const message2 = schema.decodeOptional(buffer); 78 | assert.deepEqual(message2, message); 79 | 80 | const root = new protobufjs.Root(); 81 | await root.load('./test.proto', { keepCase: true }); 82 | 83 | const Optional = root.lookupType('test.Optional'); 84 | const message3 = Optional.decode(buffer); 85 | assert.deepEqual(message3, message); 86 | 87 | const buffer2 = Optional.encode(message).finish(); 88 | assert.deepEqual(buffer2, buffer); 89 | }); 90 | 91 | //////////////////////////////////////////////////////////////////////////////// 92 | 93 | it('repeated unpacked', async () => { 94 | const schema = parseTestProto(); 95 | 96 | const message: RepeatedUnpacked = { 97 | field_int32: [-1, -2], 98 | field_int64: [new Long(-1, -2), new Long(-3, -4)], 99 | field_uint32: [-1 >>> 0, -2 >>> 0], 100 | field_uint64: [new Long(-1 >>> 0, -2 >>> 0, true), new Long(-3 >>> 0, -4 >>> 0, true)], 101 | field_sint32: [-1, -2], 102 | field_sint64: [new Long(-1, -2), new Long(-3, -4)], 103 | field_bool: [true, false], 104 | field_fixed64: [new Long(12345678, 87654321, true), new Long(8765, 1234, true)], 105 | field_sfixed64: [new Long(-87654321, -12345678), new Long(-1234, -8765)], 106 | field_double: [2.5, -2.5], 107 | field_string: ['testing', '🙉🙈🙊'], 108 | field_bytes: [new Uint8Array([1, 2, 3, 4, 5]), new Uint8Array([]), new Uint8Array([5, 4, 3])], 109 | field_fixed32: [-1 >>> 0, -2 >>> 0], 110 | field_sfixed32: [-1, -2], 111 | field_float: [3.25, -3.25], 112 | field_nested: [{ x: 1.5 }, {}, { y: 0.5 }], 113 | }; 114 | 115 | const buffer = schema.encodeRepeatedUnpacked(message); 116 | const message2 = schema.decodeRepeatedUnpacked(buffer); 117 | assert.deepEqual(message2, message); 118 | 119 | const root = new protobufjs.Root(); 120 | await root.load('./test.proto', { keepCase: true }); 121 | 122 | const RepeatedUnpacked = root.lookupType('test.RepeatedUnpacked'); 123 | const message3 = RepeatedUnpacked.decode(buffer); 124 | assert.deepEqual(message3, message); 125 | 126 | const buffer2 = RepeatedUnpacked.encode(message).finish(); 127 | assert.deepEqual(buffer2, buffer); 128 | }); 129 | 130 | //////////////////////////////////////////////////////////////////////////////// 131 | 132 | it('repeated packed', async () => { 133 | const schema = parseTestProto(); 134 | 135 | const message: RepeatedPacked = { 136 | field_int32: [-1, -2], 137 | field_int64: [new Long(-1, -2), new Long(-3, -4)], 138 | field_uint32: [-1 >>> 0, -2 >>> 0], 139 | field_uint64: [new Long(-1 >>> 0, -2 >>> 0, true), new Long(-3 >>> 0, -4 >>> 0, true)], 140 | field_sint32: [-1, -2], 141 | field_sint64: [new Long(-1, -2), new Long(-3, -4)], 142 | field_bool: [true, false], 143 | field_fixed64: [new Long(12345678, 87654321, true), new Long(8765, 1234, true)], 144 | field_sfixed64: [new Long(-87654321, -12345678), new Long(-1234, -8765)], 145 | field_double: [2.5, -2.5], 146 | field_string: ['testing', '🙉🙈🙊'], 147 | field_bytes: [new Uint8Array([1, 2, 3, 4, 5]), new Uint8Array([]), new Uint8Array([5, 4, 3])], 148 | field_fixed32: [-1 >>> 0, -2 >>> 0], 149 | field_sfixed32: [-1, -2], 150 | field_float: [3.25, -3.25], 151 | field_nested: [{ x: 1.5 }, {}, { y: 0.5 }], 152 | }; 153 | 154 | const buffer = schema.encodeRepeatedPacked(message); 155 | const message2 = schema.decodeRepeatedPacked(buffer); 156 | assert.deepEqual(message2, message); 157 | 158 | const root = new protobufjs.Root(); 159 | await root.load('./test.proto', { keepCase: true }); 160 | 161 | const RepeatedPacked = root.lookupType('test.RepeatedPacked'); 162 | const message3 = RepeatedPacked.decode(buffer); 163 | assert.deepEqual(message3, message); 164 | 165 | const buffer2 = RepeatedPacked.encode(message).finish(); 166 | assert.deepEqual(buffer2, buffer); 167 | }); 168 | 169 | //////////////////////////////////////////////////////////////////////////////// 170 | 171 | it('enum test', async () => { 172 | const schema = parseTestProto(); 173 | 174 | const message: EnumTest = { 175 | a: Enum.B, 176 | b: Enum.A, 177 | c: [Enum.A, Enum.B], 178 | }; 179 | 180 | const buffer = schema.encodeEnumTest(message); 181 | const message2 = schema.decodeEnumTest(buffer); 182 | assert.deepEqual(message2, message); 183 | }); 184 | 185 | //////////////////////////////////////////////////////////////////////////////// 186 | 187 | it('map test (int and string keys)', async () => { 188 | const schema = parseTestProto(); 189 | 190 | const message: MapTestIntAndString = { 191 | field_int32: { [-1]: 'testing', [1]: '🙉🙈🙊' }, 192 | field_uint32: { [-1 >>> 0]: new Uint8Array([1, 2, 3]), [1]: new Uint8Array([254, 255]) }, 193 | field_sint32: { [-1]: new Long(123, 234), [1]: new Long(-1, -2) }, 194 | field_string: { 'testing': 12.34, '🙉🙈🙊': 56.78 }, 195 | field_fixed32: { [-1 >>> 0]: false, [1]: true }, 196 | field_sfixed32: { [-1]: { x: 2 }, [1]: { y: -2 } }, 197 | }; 198 | 199 | const buffer = schema.encodeMapTestIntAndString(message); 200 | const message2 = schema.decodeMapTestIntAndString(buffer); 201 | assert.deepEqual(message2, message); 202 | 203 | const root = new protobufjs.Root(); 204 | await root.load('./test.proto', { keepCase: true }); 205 | 206 | const MapTestIntAndString = root.lookupType('test.MapTestIntAndString'); 207 | const message3 = MapTestIntAndString.decode(buffer); 208 | assert.deepEqual(message3, message); 209 | 210 | const buffer2 = MapTestIntAndString.encode(message).finish(); 211 | assert.deepEqual(buffer2, buffer); 212 | }); 213 | 214 | //////////////////////////////////////////////////////////////////////////////// 215 | 216 | it('map test (long and bool keys)', async () => { 217 | const schema = parseTestProto(); 218 | 219 | const message: MapTestLongAndBool = { 220 | field_int64: { '\uFEDC\uBA98\u7654\u3210': 'testing 🙉🙈🙊' }, 221 | field_uint64: { '\uBA98\u7654\u3210\uFEDC': new Uint8Array([0, 1, 254, 255]) }, 222 | field_sint64: { '\u7654\u3210\uFEDC\uBA98': new Long(-1, -2) }, 223 | field_fixed64: { '\u3210\uFEDC\uBA98\u7654': 12.34 }, 224 | field_sfixed64: { '\uFEDC\uBA98\u7654\u3210': true }, 225 | field_bool: { false: { x: 2 }, true: { y: -2 } }, 226 | }; 227 | 228 | // Note: The output can't be compared against protobuf.js because it has a 229 | // bug that prevents it from round-tripping 64-bit keys correctly. The keys 230 | // are encoded in decimal but decoded in binary. Whoops! See this for more 231 | // information: https://github.com/protobufjs/protobuf.js/issues/1203. 232 | // Because 64-bit keys are broken in protobuf.js, this library uses a more 233 | // efficient 16-bit encoding of 64-bit keys instead of an 8-bit encoding. 234 | // 235 | // It also seems to have a bug that breaks round-tripping boolean keys. I 236 | // couldn't find an associated bug but I also couldn't get it to work. 237 | 238 | const buffer = schema.encodeMapTestLongAndBool(message); 239 | const message2 = schema.decodeMapTestLongAndBool(buffer); 240 | assert.deepEqual(message2, message); 241 | 242 | const root = new protobufjs.Root(); 243 | await root.load('./test.proto', { keepCase: true }); 244 | 245 | // Even though we can't compare against the contents, still test that the 246 | // buffer is valid and can be decoded without throwing an error. 247 | const MapTestLongAndBool = root.lookupType('test.MapTestLongAndBool'); 248 | MapTestLongAndBool.decode(buffer); 249 | }); 250 | 251 | //////////////////////////////////////////////////////////////////////////////// 252 | 253 | it('fuzzing protobufjs', async () => { 254 | const schema = parseTestProto(); 255 | 256 | for (const message of randomMessageStream()) { 257 | const buffer = schema.encodeOptional(message); 258 | const message2 = schema.decodeOptional(buffer); 259 | assert.deepEqual(message2, message); 260 | } 261 | }); 262 | 263 | //////////////////////////////////////////////////////////////////////////////// 264 | 265 | it('fuzzing pbjs', async () => { 266 | const root = new protobufjs.Root(); 267 | await root.load('./test.proto', { keepCase: true }); 268 | const Optional = root.lookupType('test.Optional'); 269 | 270 | for (const message of randomMessageStream()) { 271 | const buffer = Optional.encode(message).finish(); 272 | const message2 = Optional.decode(buffer); 273 | assert.deepEqual(message2, message); 274 | } 275 | }); 276 | 277 | //////////////////////////////////////////////////////////////////////////////// 278 | 279 | it('javascript (es5)', () => { 280 | const js = fs.readFileSync('./test.proto.es5.js', 'utf8'); 281 | const js2 = parseSchema(fs.readFileSync('./test.proto', 'utf8')).toJavaScript(); 282 | assert.strictEqual(js, js2); 283 | }); 284 | 285 | //////////////////////////////////////////////////////////////////////////////// 286 | 287 | it('javascript (es6)', () => { 288 | const js = fs.readFileSync('./test.proto.es6.js', 'utf8'); 289 | const js2 = parseSchema(fs.readFileSync('./test.proto', 'utf8')).toJavaScript({ es6: true }); 290 | assert.strictEqual(js, js2); 291 | }); 292 | 293 | //////////////////////////////////////////////////////////////////////////////// 294 | 295 | it('typescript', () => { 296 | const ts = fs.readFileSync('./test.proto.ts', 'utf8'); 297 | const ts2 = parseSchema(fs.readFileSync('./test.proto', 'utf8')).toTypeScript(); 298 | assert.strictEqual(ts, ts2); 299 | }); 300 | 301 | //////////////////////////////////////////////////////////////////////////////// 302 | 303 | it('cli: generate javascript (es5)', async () => { 304 | try { 305 | fs.unlinkSync('./temp.js'); 306 | } catch (e) { 307 | } 308 | const js = fs.readFileSync('./test.proto.es5.js', 'utf8'); 309 | const cli = child_process.spawn('node', ['./cli.js', './test.proto', '--es5', './temp.js']); 310 | await new Promise(resolve => cli.on('close', resolve)); 311 | const js2 = fs.readFileSync('./temp.js', 'utf8'); 312 | fs.unlinkSync('./temp.js'); 313 | assert.strictEqual(js, js2); 314 | }); 315 | 316 | //////////////////////////////////////////////////////////////////////////////// 317 | 318 | it('cli: generate javascript (es6)', async () => { 319 | try { 320 | fs.unlinkSync('./temp.js'); 321 | } catch (e) { 322 | } 323 | const js = fs.readFileSync('./test.proto.es6.js', 'utf8'); 324 | const cli = child_process.spawn('node', ['./cli.js', './test.proto', '--es6', './temp.js']); 325 | await new Promise(resolve => cli.on('close', resolve)); 326 | const js2 = fs.readFileSync('./temp.js', 'utf8'); 327 | fs.unlinkSync('./temp.js'); 328 | assert.strictEqual(js, js2); 329 | }); 330 | 331 | //////////////////////////////////////////////////////////////////////////////// 332 | 333 | it('cli: generate typescript', async () => { 334 | try { 335 | fs.unlinkSync('./temp.ts'); 336 | } catch (e) { 337 | } 338 | const ts = fs.readFileSync('./test.proto.ts', 'utf8'); 339 | const cli = child_process.spawn('node', ['./cli.js', './test.proto', '--ts', './temp.ts']); 340 | await new Promise(resolve => cli.on('close', resolve)); 341 | const ts2 = fs.readFileSync('./temp.ts', 'utf8'); 342 | fs.unlinkSync('./temp.ts'); 343 | assert.strictEqual(ts, ts2); 344 | }); 345 | 346 | //////////////////////////////////////////////////////////////////////////////// 347 | 348 | it('cli: encode', async () => { 349 | const schema = parseTestProto(); 350 | 351 | const message = { 352 | x: 1.5, 353 | y: -2.5, 354 | }; 355 | 356 | const cli = child_process.spawn('node', ['./cli.js', './test.proto', '--encode', 'Nested']); 357 | const chunks: Buffer[] = []; 358 | 359 | cli.stdin.write(JSON.stringify(message)); 360 | cli.stdin.end(); 361 | 362 | cli.stdout.on('data', chunk => chunks.push(chunk)); 363 | await new Promise(resolve => cli.on('close', resolve)); 364 | 365 | assert.deepStrictEqual(new Uint8Array(Buffer.concat(chunks)), schema.encodeNested(message)); 366 | }); 367 | 368 | //////////////////////////////////////////////////////////////////////////////// 369 | 370 | it('cli: decode', async () => { 371 | const schema = parseTestProto(); 372 | 373 | const message = { 374 | x: 1.5, 375 | y: -2.5, 376 | }; 377 | 378 | const cli = child_process.spawn('node', ['./cli.js', './test.proto', '--decode', 'Nested']); 379 | const chunks: Buffer[] = []; 380 | 381 | cli.stdin.write(schema.encodeNested(message)); 382 | cli.stdin.end(); 383 | 384 | cli.stdout.on('data', chunk => chunks.push(chunk)); 385 | await new Promise(resolve => cli.on('close', resolve)); 386 | 387 | assert.strictEqual(Buffer.concat(chunks).toString(), JSON.stringify(message, null, 2) + '\n'); 388 | }); 389 | -------------------------------------------------------------------------------- /generate.ts: -------------------------------------------------------------------------------- 1 | import { Schema } from "protocol-buffers-schema"; 2 | 3 | function quote(value: any): string { 4 | return JSON.stringify(value, null, 2); 5 | } 6 | 7 | export interface Options { 8 | typescript?: boolean; 9 | es6?: boolean; 10 | } 11 | 12 | export function generate(schema: Schema, options?: Options): string { 13 | options = options || {}; 14 | let pkg = 'exports'; 15 | const typescript = !!options.typescript; 16 | const es6 = typescript || !!options.es6; 17 | const varOrLet = es6 ? 'let' : 'var'; 18 | const prefix = es6 ? '' : pkg + '.'; 19 | const enums: { [key: string]: boolean } = {}; 20 | const lines: string[] = []; 21 | 22 | const packableTypes: { [type: string]: boolean } = { 23 | 'bool': true, 24 | 'double': true, 25 | 'fixed32': true, 26 | 'fixed64': true, 27 | 'float': true, 28 | 'int32': true, 29 | 'int64': true, 30 | 'sfixed32': true, 31 | 'sfixed64': true, 32 | 'sint32': true, 33 | 'sint64': true, 34 | 'uint32': true, 35 | 'uint64': true, 36 | }; 37 | 38 | function ts(code: string): string { 39 | return typescript ? ': ' + code : ''; 40 | } 41 | 42 | const TYPE_VAR_INT = 0; 43 | const TYPE_SIZE_8 = 1; 44 | const TYPE_SIZE_N = 2; 45 | const TYPE_SIZE_4 = 5; 46 | 47 | function codeForEnumExport(name: string): string { 48 | return es6 ? `export const ${name}` : `${pkg}.${name}`; 49 | } 50 | 51 | for (const def of schema.enums) { 52 | const prefix = def.name + '_'; 53 | const items: string[] = []; 54 | const encode: string[] = []; 55 | const decode: string[] = []; 56 | 57 | for (let key in def.values) { 58 | const value = def.values[key]; 59 | 60 | // Protocol buffers made the stupid decision to use C-style enum scoping 61 | // rules. Attempt to fix this by stripping the "EnumType_" prefix if present. 62 | if (key.slice(0, prefix.length) === prefix) { 63 | key = key.slice(prefix.length); 64 | } 65 | 66 | items.push(` ${key} = ${quote(key)},`); 67 | encode.push(` ${key}: ${value.value},`); 68 | decode.push(` ${value.value}: ${typescript ? `${def.name}.${key}` : quote(key)},`); 69 | } 70 | 71 | if (typescript) { 72 | lines.push(`export const enum ${def.name} {`); 73 | lines.push.apply(lines, items); 74 | lines.push(`}`); 75 | lines.push(``); 76 | } 77 | 78 | lines.push(`${codeForEnumExport('encode' + def.name)}${ts(`{ [key: string]: number }`)} = {`); 79 | lines.push.apply(lines, encode); 80 | lines.push(`};`); 81 | lines.push(''); 82 | 83 | lines.push(`${codeForEnumExport('decode' + def.name)}${ts(`{ [key: number]: ${def.name} }`)} = {`); 84 | lines.push.apply(lines, decode); 85 | lines.push(`};`); 86 | lines.push(''); 87 | 88 | enums[def.name] = true; 89 | packableTypes[def.name] = true; 90 | } 91 | 92 | // Validate the "packed" option once 93 | for (const def of schema.messages) { 94 | for (const field of def.fields) { 95 | if (field.options.packed === 'true' && (!field.repeated || !(field.type in packableTypes))) { 96 | throw new Error(field.name + ': [packed = true] can only be specified for repeated primitive fields'); 97 | } 98 | } 99 | } 100 | 101 | function codeForFunctionExport(name: string): string { 102 | return es6 ? `export function ${name}` : `${pkg}.${name} = function `; 103 | } 104 | 105 | const protoToType: { [type: string]: string } = { 106 | bool: 'boolean', 107 | bytes: 'Uint8Array', 108 | 109 | double: 'number', 110 | fixed32: 'number', 111 | float: 'number', 112 | int32: 'number', 113 | sfixed32: 'number', 114 | sint32: 'number', 115 | uint32: 'number', 116 | 117 | fixed64: 'Long', 118 | int64: 'Long', 119 | sfixed64: 'Long', 120 | sint64: 'Long', 121 | uint64: 'Long', 122 | } 123 | 124 | for (const def of schema.messages) { 125 | if (typescript) { 126 | lines.push(`export interface ${def.name} {`); 127 | 128 | for (const field of def.fields) { 129 | let type = protoToType[field.type] || field.type; 130 | 131 | if (field.map !== null) { 132 | let { from, to } = field.map; 133 | if (from === 'bool' || from === 'string') from = 'string'; 134 | else if (protoToType[from] === 'number') from = 'number'; 135 | else if (protoToType[from] === 'Long') from = 'string'; 136 | else throw new Error(`The type ${from} cannot be used as a map key`); 137 | type = `{ [key: ${from}]: ${protoToType[to] || to} }`; 138 | } 139 | 140 | const required = field.required ? '' : '?'; 141 | const repeated = field.repeated ? '[]' : ''; 142 | lines.push(` ${field.name}${required}: ${type}${repeated};`); 143 | } 144 | 145 | lines.push(`}`); 146 | lines.push(``); 147 | } 148 | 149 | lines.push(`${codeForFunctionExport('encode' + def.name)}(message${ts(def.name)})${ts('Uint8Array')} {`); 150 | lines.push(` ${varOrLet} bb = popByteBuffer();`); 151 | lines.push(` _encode${def.name}(message, bb);`); 152 | lines.push(` return toUint8Array(bb);`); 153 | lines.push(`}`); 154 | lines.push(``); 155 | 156 | lines.push(`function _encode${def.name}(message${ts(def.name)}, bb${ts('ByteBuffer')})${ts('void')} {`); 157 | 158 | function encodeValue(name: string, buffer: string, value: string, nested = 'nested') { 159 | let type: number; 160 | let write: string[]; 161 | 162 | switch (name) { 163 | case 'bool': type = TYPE_VAR_INT; write = [`writeByte(${buffer}, ${value} ? 1 : 0)`]; break; 164 | case 'bytes': type = TYPE_SIZE_N; write = [`writeVarint32(${buffer}, ${value}.length), writeBytes(${buffer}, ${value})`]; break; 165 | case 'double': type = TYPE_SIZE_8; write = [`writeDouble(${buffer}, ${value})`]; break; 166 | case 'fixed32': type = TYPE_SIZE_4; write = [`writeInt32(${buffer}, ${value})`]; break; 167 | case 'fixed64': type = TYPE_SIZE_8; write = [`writeInt64(${buffer}, ${value})`]; break; 168 | case 'float': type = TYPE_SIZE_4; write = [`writeFloat(${buffer}, ${value})`]; break; 169 | case 'int32': type = TYPE_VAR_INT; write = [`writeVarint64(${buffer}, intToLong(${value}))`]; break; 170 | case 'int64': type = TYPE_VAR_INT; write = [`writeVarint64(${buffer}, ${value})`]; break; 171 | case 'sfixed32': type = TYPE_SIZE_4; write = [`writeInt32(${buffer}, ${value})`]; break; 172 | case 'sfixed64': type = TYPE_SIZE_8; write = [`writeInt64(${buffer}, ${value})`]; break; 173 | case 'sint32': type = TYPE_VAR_INT; write = [`writeVarint32ZigZag(${buffer}, ${value})`]; break; 174 | case 'sint64': type = TYPE_VAR_INT; write = [`writeVarint64ZigZag(${buffer}, ${value})`]; break; 175 | case 'uint32': type = TYPE_VAR_INT; write = [`writeVarint32(${buffer}, ${value})`]; break; 176 | case 'uint64': type = TYPE_VAR_INT; write = [`writeVarint64(${buffer}, ${value})`]; break; 177 | case 'string': type = TYPE_SIZE_N; write = [`writeString(${buffer}, ${value})`]; break; 178 | 179 | default: { 180 | if (name in enums) { 181 | type = TYPE_VAR_INT; 182 | write = [`writeVarint32(${buffer}, ${prefix}encode${name}[${value}])`]; 183 | } else { 184 | type = TYPE_SIZE_N; 185 | write = [ 186 | `${varOrLet} ${nested} = popByteBuffer()`, 187 | `_encode${name}(${value}, ${nested})`, 188 | `writeVarint32(${buffer}, ${nested}.limit)`, 189 | `writeByteBuffer(${buffer}, ${nested})`, 190 | `pushByteBuffer(${nested})`, 191 | ]; 192 | } 193 | break; 194 | } 195 | } 196 | 197 | return { type, write }; 198 | } 199 | 200 | for (const field of def.fields) { 201 | const isPacked = field.repeated && field.options.packed !== 'false' && field.type in packableTypes; 202 | const modifier = field.repeated ? 'repeated ' : field.required ? 'required ' : 'optional '; 203 | 204 | let humanType = field.type; 205 | if (field.map !== null) humanType += `<${field.map.from}, ${field.map.to}>`; 206 | lines.push(` // ${modifier}${humanType} ${field.name} = ${field.tag};`); 207 | 208 | if (field.repeated || field.map !== null) { 209 | const collection = `${field.repeated ? 'array' : 'map'}$${field.name}`; 210 | lines.push(` ${varOrLet} ${collection} = message.${field.name};`); 211 | lines.push(` if (${collection} !== undefined) {`); 212 | 213 | if (field.map !== null) { 214 | let { from, to } = field.map; 215 | let keyValue = 'key'; 216 | 217 | if (from === 'bool') keyValue = 'key === "true"'; 218 | else if (protoToType[from] === 'number') keyValue = '+key'; 219 | else if (protoToType[from] === 'Long') keyValue = 'stringToLong(key)'; 220 | 221 | const key = encodeValue(from, 'nested', keyValue, 'nestedKey'); 222 | const value = encodeValue(to, 'nested', 'value', 'nestedValue'); 223 | 224 | lines.push(` for (${varOrLet} key in ${collection}) {`); 225 | lines.push(` ${varOrLet} nested = popByteBuffer();`); 226 | lines.push(` ${varOrLet} value = ${collection}[key];`); 227 | lines.push(` writeVarint32(nested, ${(1 << 3) | key.type});`); 228 | for (const line of key.write) lines.push(` ${line};`); 229 | lines.push(` writeVarint32(nested, ${(2 << 3) | value.type});`); 230 | for (const line of value.write) lines.push(` ${line};`); 231 | lines.push(` writeVarint32(bb, ${(field.tag << 3) | TYPE_SIZE_N});`); 232 | lines.push(` writeVarint32(bb, nested.offset);`); 233 | lines.push(` writeByteBuffer(bb, nested);`); 234 | lines.push(` pushByteBuffer(nested);`); 235 | lines.push(` }`); 236 | } 237 | 238 | else if (isPacked) { 239 | const { write } = encodeValue(field.type, 'packed', 'value'); 240 | lines.push(` ${varOrLet} packed = popByteBuffer();`); 241 | if (es6) { 242 | lines.push(` for (let value of ${collection}) {`); 243 | } else { 244 | lines.push(` for (var i = 0; i < ${collection}.length; i++) {`); 245 | lines.push(` var value = ${collection}[i];`); 246 | } 247 | for (const line of write) lines.push(` ${line};`); 248 | lines.push(` }`); 249 | lines.push(` writeVarint32(bb, ${(field.tag << 3) | TYPE_SIZE_N});`); 250 | lines.push(` writeVarint32(bb, packed.offset);`); 251 | lines.push(` writeByteBuffer(bb, packed);`); 252 | lines.push(` pushByteBuffer(packed);`); 253 | } 254 | 255 | else { 256 | const { type, write } = encodeValue(field.type, 'bb', 'value'); 257 | if (es6) { 258 | lines.push(` for (let value of ${collection}) {`); 259 | } else { 260 | lines.push(` for (var i = 0; i < ${collection}.length; i++) {`); 261 | lines.push(` var value = ${collection}[i];`); 262 | } 263 | lines.push(` writeVarint32(bb, ${(field.tag << 3) | type});`); 264 | for (const line of write) lines.push(` ${line};`); 265 | lines.push(` }`); 266 | } 267 | 268 | lines.push(` }`); 269 | lines.push(``); 270 | } 271 | 272 | else { 273 | const value = `$${field.name}`; 274 | const { type, write } = encodeValue(field.type, 'bb', value); 275 | lines.push(` ${varOrLet} ${value} = message.${field.name};`); 276 | lines.push(` if (${value} !== undefined) {`); 277 | lines.push(` writeVarint32(bb, ${(field.tag << 3) | type});`); 278 | for (const line of write) lines.push(` ${line};`); 279 | lines.push(` }`); 280 | lines.push(``); 281 | } 282 | } 283 | 284 | if (def.fields.length > 0) { 285 | lines.pop(); 286 | } 287 | 288 | lines.push(es6 ? '}' : '};'); 289 | lines.push(``); 290 | 291 | lines.push(`${codeForFunctionExport('decode' + def.name)}(binary${ts('Uint8Array')})${ts(def.name)} {`); 292 | lines.push(` return _decode${def.name}(wrapByteBuffer(binary));`); 293 | lines.push(`}`); 294 | lines.push(``); 295 | 296 | lines.push(`function _decode${def.name}(bb${ts('ByteBuffer')})${ts(def.name)} {`); 297 | lines.push(` ${varOrLet} message${ts(def.name)} = {}${typescript ? ' as any' : ''};`); 298 | lines.push(``); 299 | lines.push(` end_of_message: while (!isAtEnd(bb)) {`); 300 | lines.push(` ${varOrLet} tag = readVarint32(bb);`); 301 | lines.push(``); 302 | lines.push(` switch (tag >>> 3) {`); 303 | lines.push(` case 0:`); 304 | lines.push(` break end_of_message;`); 305 | lines.push(``); 306 | 307 | function decodeValue(name: string, limit = 'limit') { 308 | let read: string; 309 | let before: string | null = null; 310 | let after: string | null = null; 311 | 312 | switch (name) { 313 | case 'bool': read = `!!readByte(bb)`; break; 314 | case 'bytes': read = `readBytes(bb, readVarint32(bb))`; break; 315 | case 'double': read = `readDouble(bb)`; break; 316 | case 'fixed32': read = `readInt32(bb) >>> 0`; break; 317 | case 'fixed64': read = `readInt64(bb, /* unsigned */ true)`; break; 318 | case 'float': read = `readFloat(bb)`; break; 319 | case 'int32': read = `readVarint32(bb)`; break; 320 | case 'int64': read = `readVarint64(bb, /* unsigned */ false)`; break; 321 | case 'sfixed32': read = `readInt32(bb)`; break; 322 | case 'sfixed64': read = `readInt64(bb, /* unsigned */ false)`; break; 323 | case 'sint32': read = `readVarint32ZigZag(bb)`; break; 324 | case 'sint64': read = `readVarint64ZigZag(bb)`; break; 325 | case 'string': read = `readString(bb, readVarint32(bb))`; break; 326 | case 'uint32': read = `readVarint32(bb) >>> 0`; break; 327 | case 'uint64': read = `readVarint64(bb, /* unsigned */ true)`; break; 328 | 329 | default: { 330 | if (name in enums) { 331 | read = `${prefix}decode${name}[readVarint32(bb)]`; 332 | } else { 333 | before = `${varOrLet} ${limit} = pushTemporaryLength(bb)`; 334 | read = `_decode${name}(bb)`; 335 | after = `bb.limit = ${limit}`; 336 | } 337 | break; 338 | } 339 | } 340 | 341 | return { read, before, after }; 342 | } 343 | 344 | for (const field of def.fields) { 345 | const modifier = field.repeated ? 'repeated ' : field.required ? 'required ' : 'optional '; 346 | 347 | let humanType = field.type; 348 | if (field.map !== null) humanType += `<${field.map.from}, ${field.map.to}>`; 349 | lines.push(` // ${modifier}${humanType} ${field.name} = ${field.tag};`); 350 | lines.push(` case ${field.tag}: {`); 351 | 352 | if (field.map !== null) { 353 | const { from, to } = field.map; 354 | const key = decodeValue(from, 'keyLimit'); 355 | const value = decodeValue(to, 'valueLimit'); 356 | lines.push(` ${varOrLet} values = message.${field.name} || (message.${field.name} = {});`); 357 | lines.push(` ${varOrLet} outerLimit = pushTemporaryLength(bb);`); 358 | lines.push(` ${varOrLet} key${ts(`${protoToType[from] || from} | undefined`)};`); 359 | lines.push(` ${varOrLet} value${ts(`${protoToType[to] || to} | undefined`)};`); 360 | lines.push(` end_of_entry: while (!isAtEnd(bb)) {`); 361 | lines.push(` ${varOrLet} tag = readVarint32(bb);`); 362 | lines.push(` switch (tag >>> 3) {`); 363 | lines.push(` case 0:`); 364 | lines.push(` break end_of_entry;`); 365 | lines.push(` case 1: {`); 366 | if (key.before) lines.push(` ${key.before};`); 367 | lines.push(` key = ${key.read};`); 368 | if (key.after) lines.push(` ${key.after};`); 369 | lines.push(` break;`); 370 | lines.push(` }`); 371 | lines.push(` case 2: {`); 372 | if (value.before) lines.push(` ${value.before};`); 373 | lines.push(` value = ${value.read};`); 374 | if (value.after) lines.push(` ${value.after};`); 375 | lines.push(` break;`); 376 | lines.push(` }`); 377 | lines.push(` default:`); 378 | lines.push(` skipUnknownField(bb, tag & 7);`); 379 | lines.push(` }`); 380 | lines.push(` }`); 381 | lines.push(` if (key === undefined || value === undefined)`); 382 | lines.push(` throw new Error(${quote(`Invalid data for map: ${field.name}`)});`); 383 | if (from === 'bool') lines.push(` values[key + ''] = value;`); 384 | else if (protoToType[from] === 'Long') lines.push(` values[longToString(key)] = value;`); 385 | else lines.push(` values[key] = value;`); 386 | lines.push(` bb.limit = outerLimit;`); 387 | } 388 | 389 | else if (field.repeated) { 390 | const { read, before, after } = decodeValue(field.type); 391 | if (before) lines.push(` ${before};`); 392 | lines.push(` ${varOrLet} values = message.${field.name} || (message.${field.name} = []);`); 393 | 394 | // Support both packed and unpacked encodings for primitive types 395 | if (field.type in packableTypes) { 396 | lines.push(` if ((tag & 7) === ${TYPE_SIZE_N}) {`); 397 | lines.push(` ${varOrLet} outerLimit = pushTemporaryLength(bb);`); 398 | lines.push(` while (!isAtEnd(bb)) {`); 399 | lines.push(` values.push(${read});`); 400 | if (after) lines.push(` ${after};`); 401 | lines.push(` }`); 402 | lines.push(` bb.limit = outerLimit;`); 403 | lines.push(` } else {`); 404 | lines.push(` values.push(${read});`); 405 | if (after) lines.push(` ${after};`); 406 | lines.push(` }`); 407 | } 408 | 409 | else { 410 | lines.push(` values.push(${read});`); 411 | if (after) lines.push(` ${after};`); 412 | } 413 | } 414 | 415 | else { 416 | const { read, before, after } = decodeValue(field.type); 417 | if (before) lines.push(` ${before};`); 418 | lines.push(` message.${field.name} = ${read};`); 419 | if (after) lines.push(` ${after};`); 420 | } 421 | 422 | lines.push(` break;`); 423 | lines.push(` }`); 424 | lines.push(``); 425 | } 426 | 427 | lines.push(` default:`); 428 | lines.push(` skipUnknownField(bb, tag & 7);`); 429 | lines.push(` }`); 430 | lines.push(` }`); 431 | lines.push(``); 432 | 433 | for (const field of def.fields) { 434 | if (field.required) { 435 | lines.push(` if (message.${field.name} === undefined)`); 436 | lines.push(` throw new Error(${quote(`Missing required field: ${field.name}`)});`); 437 | lines.push(``); 438 | } 439 | } 440 | 441 | lines.push(` return message;`); 442 | lines.push(es6 ? '}' : '};'); 443 | lines.push(``); 444 | } 445 | 446 | if (typescript) { 447 | lines.push(`export interface Long {`); 448 | lines.push(` low: number;`); 449 | lines.push(` high: number;`); 450 | lines.push(` unsigned: boolean;`); 451 | lines.push(`}`); 452 | lines.push(``); 453 | 454 | lines.push(`interface ByteBuffer {`); 455 | lines.push(` bytes: Uint8Array;`); 456 | lines.push(` offset: number;`); 457 | lines.push(` limit: number;`); 458 | lines.push(`}`); 459 | lines.push(``); 460 | } 461 | 462 | lines.push(`function pushTemporaryLength(bb${ts('ByteBuffer')})${ts('number')} {`); 463 | lines.push(` ${varOrLet} length = readVarint32(bb);`); 464 | lines.push(` ${varOrLet} limit = bb.limit;`); 465 | lines.push(` bb.limit = bb.offset + length;`); 466 | lines.push(` return limit;`); 467 | lines.push(`}`); 468 | lines.push(``); 469 | 470 | lines.push(`function skipUnknownField(bb${ts('ByteBuffer')}, type${ts('number')})${ts('void')} {`); 471 | lines.push(` switch (type) {`); 472 | lines.push(` case ${TYPE_VAR_INT}: while (readByte(bb) & 0x80) { } break;`); 473 | lines.push(` case ${TYPE_SIZE_N}: skip(bb, readVarint32(bb)); break;`); 474 | lines.push(` case ${TYPE_SIZE_4}: skip(bb, 4); break;`); 475 | lines.push(` case ${TYPE_SIZE_8}: skip(bb, 8); break;`); 476 | lines.push(` default: throw new Error("Unimplemented type: " + type);`); 477 | lines.push(` }`); 478 | lines.push(`}`); 479 | lines.push(``); 480 | 481 | lines.push(`function stringToLong(value${ts('string')})${ts('Long')} {`); 482 | lines.push(` return {`); 483 | lines.push(` low: value.charCodeAt(0) | (value.charCodeAt(1) << 16),`); 484 | lines.push(` high: value.charCodeAt(2) | (value.charCodeAt(3) << 16),`); 485 | lines.push(` unsigned: false,`); 486 | lines.push(` };`); 487 | lines.push(`}`); 488 | lines.push(``); 489 | 490 | lines.push(`function longToString(value${ts('Long')})${ts('string')} {`); 491 | lines.push(` ${varOrLet} low = value.low;`); 492 | lines.push(` ${varOrLet} high = value.high;`); 493 | lines.push(` return String.fromCharCode(`); 494 | lines.push(` low & 0xFFFF,`); 495 | lines.push(` low >>> 16,`); 496 | lines.push(` high & 0xFFFF,`); 497 | lines.push(` high >>> 16);`); 498 | lines.push(`}`); 499 | lines.push(``); 500 | 501 | lines.push(`// The code below was modified from https://github.com/protobufjs/bytebuffer.js`); 502 | lines.push(`// which is under the Apache License 2.0.`); 503 | lines.push(``); 504 | 505 | lines.push(`${varOrLet} f32 = new Float32Array(1);`); 506 | lines.push(`${varOrLet} f32_u8 = new Uint8Array(f32.buffer);`); 507 | lines.push(``); 508 | 509 | lines.push(`${varOrLet} f64 = new Float64Array(1);`); 510 | lines.push(`${varOrLet} f64_u8 = new Uint8Array(f64.buffer);`); 511 | lines.push(``); 512 | 513 | lines.push(`function intToLong(value${ts('number')})${ts('Long')} {`); 514 | lines.push(` value |= 0;`); 515 | lines.push(` return {`); 516 | lines.push(` low: value,`); 517 | lines.push(` high: value >> 31,`); 518 | lines.push(` unsigned: value >= 0,`); 519 | lines.push(` };`); 520 | lines.push(`}`); 521 | lines.push(``); 522 | 523 | lines.push(`${varOrLet} bbStack${ts('ByteBuffer[]')} = [];`); 524 | lines.push(``); 525 | 526 | lines.push(`function popByteBuffer()${ts('ByteBuffer')} {`); 527 | lines.push(` const bb = bbStack.pop();`); 528 | lines.push(` if (!bb) return { bytes: new Uint8Array(64), offset: 0, limit: 0 };`); 529 | lines.push(` bb.offset = bb.limit = 0;`); 530 | lines.push(` return bb;`); 531 | lines.push(`}`); 532 | lines.push(``); 533 | 534 | lines.push(`function pushByteBuffer(bb${ts('ByteBuffer')})${ts('void')} {`); 535 | lines.push(` bbStack.push(bb);`); 536 | lines.push(`}`); 537 | lines.push(``); 538 | 539 | lines.push(`function wrapByteBuffer(bytes${typescript ? ': Uint8Array' : ''})${ts('ByteBuffer')} {`); 540 | lines.push(` return { bytes, offset: 0, limit: bytes.length };`); 541 | lines.push(`}`); 542 | lines.push(``); 543 | 544 | lines.push(`function toUint8Array(bb${ts('ByteBuffer')})${ts('Uint8Array')} {`); 545 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 546 | lines.push(` ${varOrLet} limit = bb.limit;`); 547 | lines.push(` return bytes.length === limit ? bytes : bytes.subarray(0, limit);`); 548 | lines.push(`}`); 549 | lines.push(``); 550 | 551 | lines.push(`function skip(bb${ts('ByteBuffer')}, offset${ts('number')})${ts('void')} {`); 552 | lines.push(` if (bb.offset + offset > bb.limit) {`); 553 | lines.push(` throw new Error('Skip past limit');`); 554 | lines.push(` }`); 555 | lines.push(` bb.offset += offset;`); 556 | lines.push(`}`); 557 | lines.push(``); 558 | 559 | lines.push(`function isAtEnd(bb${ts('ByteBuffer')})${ts('boolean')} {`); 560 | lines.push(` return bb.offset >= bb.limit;`); 561 | lines.push(`}`); 562 | lines.push(``); 563 | 564 | lines.push(`function grow(bb${ts('ByteBuffer')}, count${ts('number')})${ts('number')} {`); 565 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 566 | lines.push(` ${varOrLet} offset = bb.offset;`); 567 | lines.push(` ${varOrLet} limit = bb.limit;`); 568 | lines.push(` ${varOrLet} finalOffset = offset + count;`); 569 | lines.push(` if (finalOffset > bytes.length) {`); 570 | lines.push(` ${varOrLet} newBytes = new Uint8Array(finalOffset * 2);`); 571 | lines.push(` newBytes.set(bytes);`); 572 | lines.push(` bb.bytes = newBytes;`); 573 | lines.push(` }`); 574 | lines.push(` bb.offset = finalOffset;`); 575 | lines.push(` if (finalOffset > limit) {`); 576 | lines.push(` bb.limit = finalOffset;`); 577 | lines.push(` }`); 578 | lines.push(` return offset;`); 579 | lines.push(`}`); 580 | lines.push(``); 581 | 582 | lines.push(`function advance(bb${ts('ByteBuffer')}, count${ts('number')})${ts('number')} {`); 583 | lines.push(` ${varOrLet} offset = bb.offset;`); 584 | lines.push(` if (offset + count > bb.limit) {`); 585 | lines.push(` throw new Error('Read past limit');`); 586 | lines.push(` }`); 587 | lines.push(` bb.offset += count;`); 588 | lines.push(` return offset;`); 589 | lines.push(`}`); 590 | lines.push(``); 591 | 592 | lines.push(`function readBytes(bb${ts('ByteBuffer')}, count${ts('number')})${ts('Uint8Array')} {`); 593 | lines.push(` ${varOrLet} offset = advance(bb, count);`); 594 | lines.push(` return bb.bytes.subarray(offset, offset + count);`); 595 | lines.push(`}`); 596 | lines.push(``); 597 | 598 | lines.push(`function writeBytes(bb${ts('ByteBuffer')}, buffer${ts('Uint8Array')})${ts('void')} {`); 599 | lines.push(` ${varOrLet} offset = grow(bb, buffer.length);`); 600 | lines.push(` bb.bytes.set(buffer, offset);`); 601 | lines.push(`}`); 602 | lines.push(``); 603 | 604 | lines.push(`function readString(bb${ts('ByteBuffer')}, count${ts('number')})${ts('string')} {`); 605 | lines.push(` // Sadly a hand-coded UTF8 decoder is much faster than subarray+TextDecoder in V8`); 606 | lines.push(` ${varOrLet} offset = advance(bb, count);`); 607 | lines.push(` ${varOrLet} fromCharCode = String.fromCharCode;`); 608 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 609 | lines.push(` ${varOrLet} invalid = '\\uFFFD';`); 610 | lines.push(` ${varOrLet} text = '';`); 611 | lines.push(``); 612 | lines.push(` for (${varOrLet} i = 0; i < count; i++) {`); 613 | lines.push(` ${varOrLet} c1 = bytes[i + offset], c2${ts('number')}, c3${ts('number')}, c4${ts('number')}, c${ts('number')};`); 614 | lines.push(``); 615 | lines.push(` // 1 byte`); 616 | lines.push(` if ((c1 & 0x80) === 0) {`); 617 | lines.push(` text += fromCharCode(c1);`); 618 | lines.push(` }`); 619 | lines.push(``); 620 | lines.push(` // 2 bytes`); 621 | lines.push(` else if ((c1 & 0xE0) === 0xC0) {`); 622 | lines.push(` if (i + 1 >= count) text += invalid;`); 623 | lines.push(` else {`); 624 | lines.push(` c2 = bytes[i + offset + 1];`); 625 | lines.push(` if ((c2 & 0xC0) !== 0x80) text += invalid;`); 626 | lines.push(` else {`); 627 | lines.push(` c = ((c1 & 0x1F) << 6) | (c2 & 0x3F);`); 628 | lines.push(` if (c < 0x80) text += invalid;`); 629 | lines.push(` else {`); 630 | lines.push(` text += fromCharCode(c);`); 631 | lines.push(` i++;`); 632 | lines.push(` }`); 633 | lines.push(` }`); 634 | lines.push(` }`); 635 | lines.push(` }`); 636 | lines.push(``); 637 | lines.push(` // 3 bytes`); 638 | lines.push(` else if ((c1 & 0xF0) == 0xE0) {`); 639 | lines.push(` if (i + 2 >= count) text += invalid;`); 640 | lines.push(` else {`); 641 | lines.push(` c2 = bytes[i + offset + 1];`); 642 | lines.push(` c3 = bytes[i + offset + 2];`); 643 | lines.push(` if (((c2 | (c3 << 8)) & 0xC0C0) !== 0x8080) text += invalid;`); 644 | lines.push(` else {`); 645 | lines.push(` c = ((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F);`); 646 | lines.push(` if (c < 0x0800 || (c >= 0xD800 && c <= 0xDFFF)) text += invalid;`); 647 | lines.push(` else {`); 648 | lines.push(` text += fromCharCode(c);`); 649 | lines.push(` i += 2;`); 650 | lines.push(` }`); 651 | lines.push(` }`); 652 | lines.push(` }`); 653 | lines.push(` }`); 654 | lines.push(``); 655 | lines.push(` // 4 bytes`); 656 | lines.push(` else if ((c1 & 0xF8) == 0xF0) {`); 657 | lines.push(` if (i + 3 >= count) text += invalid;`); 658 | lines.push(` else {`); 659 | lines.push(` c2 = bytes[i + offset + 1];`); 660 | lines.push(` c3 = bytes[i + offset + 2];`); 661 | lines.push(` c4 = bytes[i + offset + 3];`); 662 | lines.push(` if (((c2 | (c3 << 8) | (c4 << 16)) & 0xC0C0C0) !== 0x808080) text += invalid;`); 663 | lines.push(` else {`); 664 | lines.push(` c = ((c1 & 0x07) << 0x12) | ((c2 & 0x3F) << 0x0C) | ((c3 & 0x3F) << 0x06) | (c4 & 0x3F);`); 665 | lines.push(` if (c < 0x10000 || c > 0x10FFFF) text += invalid;`); 666 | lines.push(` else {`); 667 | lines.push(` c -= 0x10000;`); 668 | lines.push(` text += fromCharCode((c >> 10) + 0xD800, (c & 0x3FF) + 0xDC00);`); 669 | lines.push(` i += 3;`); 670 | lines.push(` }`); 671 | lines.push(` }`); 672 | lines.push(` }`); 673 | lines.push(` }`); 674 | lines.push(``); 675 | lines.push(` else text += invalid;`); 676 | lines.push(` }`); 677 | lines.push(``); 678 | lines.push(` return text;`); 679 | lines.push(`}`); 680 | lines.push(``); 681 | 682 | lines.push(`function writeString(bb${ts('ByteBuffer')}, text${ts('string')})${ts('void')} {`); 683 | lines.push(` // Sadly a hand-coded UTF8 encoder is much faster than TextEncoder+set in V8`); 684 | lines.push(` ${varOrLet} n = text.length;`); 685 | lines.push(` ${varOrLet} byteCount = 0;`); 686 | lines.push(``); 687 | lines.push(` // Write the byte count first`); 688 | lines.push(` for (${varOrLet} i = 0; i < n; i++) {`); 689 | lines.push(` ${varOrLet} c = text.charCodeAt(i);`); 690 | lines.push(` if (c >= 0xD800 && c <= 0xDBFF && i + 1 < n) {`); 691 | lines.push(` c = (c << 10) + text.charCodeAt(++i) - 0x35FDC00;`); 692 | lines.push(` }`); 693 | lines.push(` byteCount += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;`); 694 | lines.push(` }`); 695 | lines.push(` writeVarint32(bb, byteCount);`); 696 | lines.push(``); 697 | lines.push(` ${varOrLet} offset = grow(bb, byteCount);`); 698 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 699 | lines.push(``); 700 | lines.push(` // Then write the bytes`); 701 | lines.push(` for (${varOrLet} i = 0; i < n; i++) {`); 702 | lines.push(` ${varOrLet} c = text.charCodeAt(i);`); 703 | lines.push(` if (c >= 0xD800 && c <= 0xDBFF && i + 1 < n) {`); 704 | lines.push(` c = (c << 10) + text.charCodeAt(++i) - 0x35FDC00;`); 705 | lines.push(` }`); 706 | lines.push(` if (c < 0x80) {`); 707 | lines.push(` bytes[offset++] = c;`); 708 | lines.push(` } else {`); 709 | lines.push(` if (c < 0x800) {`); 710 | lines.push(` bytes[offset++] = ((c >> 6) & 0x1F) | 0xC0;`); 711 | lines.push(` } else {`); 712 | lines.push(` if (c < 0x10000) {`); 713 | lines.push(` bytes[offset++] = ((c >> 12) & 0x0F) | 0xE0;`); 714 | lines.push(` } else {`); 715 | lines.push(` bytes[offset++] = ((c >> 18) & 0x07) | 0xF0;`); 716 | lines.push(` bytes[offset++] = ((c >> 12) & 0x3F) | 0x80;`); 717 | lines.push(` }`); 718 | lines.push(` bytes[offset++] = ((c >> 6) & 0x3F) | 0x80;`); 719 | lines.push(` }`); 720 | lines.push(` bytes[offset++] = (c & 0x3F) | 0x80;`); 721 | lines.push(` }`); 722 | lines.push(` }`); 723 | lines.push(`}`); 724 | lines.push(``); 725 | 726 | lines.push(`function writeByteBuffer(bb${ts('ByteBuffer')}, buffer${ts('ByteBuffer')})${ts('void')} {`); 727 | lines.push(` ${varOrLet} offset = grow(bb, buffer.limit);`); 728 | lines.push(` ${varOrLet} from = bb.bytes;`); 729 | lines.push(` ${varOrLet} to = buffer.bytes;`); 730 | lines.push(``); 731 | lines.push(` // This for loop is much faster than subarray+set on V8`); 732 | lines.push(` for (${varOrLet} i = 0, n = buffer.limit; i < n; i++) {`); 733 | lines.push(` from[i + offset] = to[i];`); 734 | lines.push(` }`); 735 | lines.push(`}`); 736 | lines.push(``); 737 | 738 | lines.push(`function readByte(bb${ts('ByteBuffer')})${ts('number')} {`); 739 | lines.push(` return bb.bytes[advance(bb, 1)];`); 740 | lines.push(`}`); 741 | lines.push(``); 742 | 743 | lines.push(`function writeByte(bb${ts('ByteBuffer')}, value${ts('number')})${ts('void')} {`); 744 | lines.push(` ${varOrLet} offset = grow(bb, 1);`); 745 | lines.push(` bb.bytes[offset] = value;`); 746 | lines.push(`}`); 747 | lines.push(``); 748 | 749 | lines.push(`function readFloat(bb${ts('ByteBuffer')})${ts('number')} {`); 750 | lines.push(` ${varOrLet} offset = advance(bb, 4);`); 751 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 752 | lines.push(``); 753 | lines.push(` // Manual copying is much faster than subarray+set in V8`); 754 | lines.push(` f32_u8[0] = bytes[offset++];`); 755 | lines.push(` f32_u8[1] = bytes[offset++];`); 756 | lines.push(` f32_u8[2] = bytes[offset++];`); 757 | lines.push(` f32_u8[3] = bytes[offset++];`); 758 | lines.push(` return f32[0];`); 759 | lines.push(`}`); 760 | lines.push(``); 761 | 762 | lines.push(`function writeFloat(bb${ts('ByteBuffer')}, value${ts('number')})${ts('void')} {`); 763 | lines.push(` ${varOrLet} offset = grow(bb, 4);`); 764 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 765 | lines.push(` f32[0] = value;`); 766 | lines.push(``); 767 | lines.push(` // Manual copying is much faster than subarray+set in V8`); 768 | lines.push(` bytes[offset++] = f32_u8[0];`); 769 | lines.push(` bytes[offset++] = f32_u8[1];`); 770 | lines.push(` bytes[offset++] = f32_u8[2];`); 771 | lines.push(` bytes[offset++] = f32_u8[3];`); 772 | lines.push(`}`); 773 | lines.push(``); 774 | 775 | lines.push(`function readDouble(bb${ts('ByteBuffer')})${ts('number')} {`); 776 | lines.push(` ${varOrLet} offset = advance(bb, 8);`); 777 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 778 | lines.push(``); 779 | lines.push(` // Manual copying is much faster than subarray+set in V8`); 780 | lines.push(` f64_u8[0] = bytes[offset++];`); 781 | lines.push(` f64_u8[1] = bytes[offset++];`); 782 | lines.push(` f64_u8[2] = bytes[offset++];`); 783 | lines.push(` f64_u8[3] = bytes[offset++];`); 784 | lines.push(` f64_u8[4] = bytes[offset++];`); 785 | lines.push(` f64_u8[5] = bytes[offset++];`); 786 | lines.push(` f64_u8[6] = bytes[offset++];`); 787 | lines.push(` f64_u8[7] = bytes[offset++];`); 788 | lines.push(` return f64[0];`); 789 | lines.push(`}`); 790 | lines.push(``); 791 | 792 | lines.push(`function writeDouble(bb${ts('ByteBuffer')}, value${ts('number')})${ts('void')} {`); 793 | lines.push(` ${varOrLet} offset = grow(bb, 8);`); 794 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 795 | lines.push(` f64[0] = value;`); 796 | lines.push(``); 797 | lines.push(` // Manual copying is much faster than subarray+set in V8`); 798 | lines.push(` bytes[offset++] = f64_u8[0];`); 799 | lines.push(` bytes[offset++] = f64_u8[1];`); 800 | lines.push(` bytes[offset++] = f64_u8[2];`); 801 | lines.push(` bytes[offset++] = f64_u8[3];`); 802 | lines.push(` bytes[offset++] = f64_u8[4];`); 803 | lines.push(` bytes[offset++] = f64_u8[5];`); 804 | lines.push(` bytes[offset++] = f64_u8[6];`); 805 | lines.push(` bytes[offset++] = f64_u8[7];`); 806 | lines.push(`}`); 807 | lines.push(``); 808 | 809 | lines.push(`function readInt32(bb${ts('ByteBuffer')})${ts('number')} {`); 810 | lines.push(` ${varOrLet} offset = advance(bb, 4);`); 811 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 812 | lines.push(` return (`); 813 | lines.push(` bytes[offset] |`); 814 | lines.push(` (bytes[offset + 1] << 8) |`); 815 | lines.push(` (bytes[offset + 2] << 16) |`); 816 | lines.push(` (bytes[offset + 3] << 24)`); 817 | lines.push(` );`); 818 | lines.push(`}`); 819 | lines.push(``); 820 | 821 | lines.push(`function writeInt32(bb${ts('ByteBuffer')}, value${ts('number')})${ts('void')} {`); 822 | lines.push(` ${varOrLet} offset = grow(bb, 4);`); 823 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 824 | lines.push(` bytes[offset] = value;`); 825 | lines.push(` bytes[offset + 1] = value >> 8;`); 826 | lines.push(` bytes[offset + 2] = value >> 16;`); 827 | lines.push(` bytes[offset + 3] = value >> 24;`); 828 | lines.push(`}`); 829 | lines.push(``); 830 | 831 | lines.push(`function readInt64(bb${ts('ByteBuffer')}, unsigned${ts('boolean')})${ts('Long')} {`); 832 | lines.push(` return {`); 833 | lines.push(` low: readInt32(bb),`); 834 | lines.push(` high: readInt32(bb),`); 835 | lines.push(` unsigned,`); 836 | lines.push(` };`); 837 | lines.push(`}`); 838 | lines.push(``); 839 | 840 | lines.push(`function writeInt64(bb${ts('ByteBuffer')}, value${ts('Long')})${ts('void')} {`); 841 | lines.push(` writeInt32(bb, value.low);`); 842 | lines.push(` writeInt32(bb, value.high);`); 843 | lines.push(`}`); 844 | lines.push(``); 845 | 846 | lines.push(`function readVarint32(bb${ts('ByteBuffer')})${ts('number')} {`); 847 | lines.push(` ${varOrLet} c = 0;`); 848 | lines.push(` ${varOrLet} value = 0;`); 849 | lines.push(` ${varOrLet} b${ts('number')};`); 850 | lines.push(` do {`); 851 | lines.push(` b = readByte(bb);`); 852 | lines.push(` if (c < 32) value |= (b & 0x7F) << c;`); 853 | lines.push(` c += 7;`); 854 | lines.push(` } while (b & 0x80);`); 855 | lines.push(` return value;`); 856 | lines.push(`}`); 857 | lines.push(``); 858 | 859 | lines.push(`function writeVarint32(bb${ts('ByteBuffer')}, value${ts('number')})${ts('void')} {`); 860 | lines.push(` value >>>= 0;`); 861 | lines.push(` while (value >= 0x80) {`); 862 | lines.push(` writeByte(bb, (value & 0x7f) | 0x80);`); 863 | lines.push(` value >>>= 7;`); 864 | lines.push(` }`); 865 | lines.push(` writeByte(bb, value);`); 866 | lines.push(`}`); 867 | lines.push(``); 868 | 869 | lines.push(`function readVarint64(bb${ts('ByteBuffer')}, unsigned${ts('boolean')})${ts('Long')} {`); 870 | lines.push(` ${varOrLet} part0 = 0;`); 871 | lines.push(` ${varOrLet} part1 = 0;`); 872 | lines.push(` ${varOrLet} part2 = 0;`); 873 | lines.push(` ${varOrLet} b${ts('number')};`); 874 | lines.push(``); 875 | lines.push(` b = readByte(bb); part0 = (b & 0x7F); if (b & 0x80) {`); 876 | lines.push(` b = readByte(bb); part0 |= (b & 0x7F) << 7; if (b & 0x80) {`); 877 | lines.push(` b = readByte(bb); part0 |= (b & 0x7F) << 14; if (b & 0x80) {`); 878 | lines.push(` b = readByte(bb); part0 |= (b & 0x7F) << 21; if (b & 0x80) {`); 879 | lines.push(``); 880 | lines.push(` b = readByte(bb); part1 = (b & 0x7F); if (b & 0x80) {`); 881 | lines.push(` b = readByte(bb); part1 |= (b & 0x7F) << 7; if (b & 0x80) {`); 882 | lines.push(` b = readByte(bb); part1 |= (b & 0x7F) << 14; if (b & 0x80) {`); 883 | lines.push(` b = readByte(bb); part1 |= (b & 0x7F) << 21; if (b & 0x80) {`); 884 | lines.push(``); 885 | lines.push(` b = readByte(bb); part2 = (b & 0x7F); if (b & 0x80) {`); 886 | lines.push(` b = readByte(bb); part2 |= (b & 0x7F) << 7;`); 887 | lines.push(` }`); 888 | lines.push(` }`); 889 | lines.push(` }`); 890 | lines.push(` }`); 891 | lines.push(` }`); 892 | lines.push(` }`); 893 | lines.push(` }`); 894 | lines.push(` }`); 895 | lines.push(` }`); 896 | lines.push(``); 897 | lines.push(` return {`); 898 | lines.push(` low: part0 | (part1 << 28),`); 899 | lines.push(` high: (part1 >>> 4) | (part2 << 24),`); 900 | lines.push(` unsigned,`); 901 | lines.push(` };`); 902 | lines.push(`}`); 903 | lines.push(``); 904 | 905 | lines.push(`function writeVarint64(bb${ts('ByteBuffer')}, value${ts('Long')})${ts('void')} {`); 906 | lines.push(` ${varOrLet} part0 = value.low >>> 0;`); 907 | lines.push(` ${varOrLet} part1 = ((value.low >>> 28) | (value.high << 4)) >>> 0;`); 908 | lines.push(` ${varOrLet} part2 = value.high >>> 24;`); 909 | lines.push(``); 910 | lines.push(` // ref: src/google/protobuf/io/coded_stream.cc`); 911 | lines.push(` ${varOrLet} size =`); 912 | lines.push(` part2 === 0 ?`); 913 | lines.push(` part1 === 0 ?`); 914 | lines.push(` part0 < 1 << 14 ?`); 915 | lines.push(` part0 < 1 << 7 ? 1 : 2 :`); 916 | lines.push(` part0 < 1 << 21 ? 3 : 4 :`); 917 | lines.push(` part1 < 1 << 14 ?`); 918 | lines.push(` part1 < 1 << 7 ? 5 : 6 :`); 919 | lines.push(` part1 < 1 << 21 ? 7 : 8 :`); 920 | lines.push(` part2 < 1 << 7 ? 9 : 10;`); 921 | lines.push(``); 922 | lines.push(` ${varOrLet} offset = grow(bb, size);`); 923 | lines.push(` ${varOrLet} bytes = bb.bytes;`); 924 | lines.push(``); 925 | lines.push(` switch (size) {`); 926 | lines.push(` case 10: bytes[offset + 9] = (part2 >>> 7) & 0x01;`); 927 | lines.push(` case 9: bytes[offset + 8] = size !== 9 ? part2 | 0x80 : part2 & 0x7F;`); 928 | lines.push(` case 8: bytes[offset + 7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F;`); 929 | lines.push(` case 7: bytes[offset + 6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F;`); 930 | lines.push(` case 6: bytes[offset + 5] = size !== 6 ? (part1 >>> 7) | 0x80 : (part1 >>> 7) & 0x7F;`); 931 | lines.push(` case 5: bytes[offset + 4] = size !== 5 ? part1 | 0x80 : part1 & 0x7F;`); 932 | lines.push(` case 4: bytes[offset + 3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F;`); 933 | lines.push(` case 3: bytes[offset + 2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F;`); 934 | lines.push(` case 2: bytes[offset + 1] = size !== 2 ? (part0 >>> 7) | 0x80 : (part0 >>> 7) & 0x7F;`); 935 | lines.push(` case 1: bytes[offset] = size !== 1 ? part0 | 0x80 : part0 & 0x7F;`); 936 | lines.push(` }`); 937 | lines.push(`}`); 938 | lines.push(``); 939 | 940 | lines.push(`function readVarint32ZigZag(bb${ts('ByteBuffer')})${ts('number')} {`); 941 | lines.push(` ${varOrLet} value = readVarint32(bb);`); 942 | lines.push(``); 943 | lines.push(` // ref: src/google/protobuf/wire_format_lite.h`); 944 | lines.push(` return (value >>> 1) ^ -(value & 1);`); 945 | lines.push(`}`); 946 | lines.push(``); 947 | 948 | lines.push(`function writeVarint32ZigZag(bb${ts('ByteBuffer')}, value${ts('number')})${ts('void')} {`); 949 | lines.push(` // ref: src/google/protobuf/wire_format_lite.h`); 950 | lines.push(` writeVarint32(bb, (value << 1) ^ (value >> 31));`); 951 | lines.push(`}`); 952 | lines.push(``); 953 | 954 | lines.push(`function readVarint64ZigZag(bb${ts('ByteBuffer')})${ts('Long')} {`); 955 | lines.push(` ${varOrLet} value = readVarint64(bb, /* unsigned */ false);`); 956 | lines.push(` ${varOrLet} low = value.low;`); 957 | lines.push(` ${varOrLet} high = value.high;`); 958 | lines.push(` ${varOrLet} flip = -(low & 1);`); 959 | lines.push(``); 960 | lines.push(` // ref: src/google/protobuf/wire_format_lite.h`); 961 | lines.push(` return {`); 962 | lines.push(` low: ((low >>> 1) | (high << 31)) ^ flip,`); 963 | lines.push(` high: (high >>> 1) ^ flip,`); 964 | lines.push(` unsigned: false,`); 965 | lines.push(` };`); 966 | lines.push(`}`); 967 | lines.push(``); 968 | 969 | lines.push(`function writeVarint64ZigZag(bb${ts('ByteBuffer')}, value${ts('Long')})${ts('void')} {`); 970 | lines.push(` ${varOrLet} low = value.low;`); 971 | lines.push(` ${varOrLet} high = value.high;`); 972 | lines.push(` ${varOrLet} flip = high >> 31;`); 973 | lines.push(``); 974 | lines.push(` // ref: src/google/protobuf/wire_format_lite.h`); 975 | lines.push(` writeVarint64(bb, {`); 976 | lines.push(` low: (low << 1) ^ flip,`); 977 | lines.push(` high: ((high << 1) | (low >>> 31)) ^ flip,`); 978 | lines.push(` unsigned: false,`); 979 | lines.push(` });`); 980 | lines.push(`}`); 981 | lines.push(``); 982 | 983 | return lines.join('\n'); 984 | } 985 | -------------------------------------------------------------------------------- /test.proto.es6.js: -------------------------------------------------------------------------------- 1 | export const encodeEnum = { 2 | A: 0, 3 | B: 1, 4 | }; 5 | 6 | export const decodeEnum = { 7 | 0: "A", 8 | 1: "B", 9 | }; 10 | 11 | export function encodeNested(message) { 12 | let bb = popByteBuffer(); 13 | _encodeNested(message, bb); 14 | return toUint8Array(bb); 15 | } 16 | 17 | function _encodeNested(message, bb) { 18 | // optional float x = 1; 19 | let $x = message.x; 20 | if ($x !== undefined) { 21 | writeVarint32(bb, 13); 22 | writeFloat(bb, $x); 23 | } 24 | 25 | // optional float y = 2; 26 | let $y = message.y; 27 | if ($y !== undefined) { 28 | writeVarint32(bb, 21); 29 | writeFloat(bb, $y); 30 | } 31 | } 32 | 33 | export function decodeNested(binary) { 34 | return _decodeNested(wrapByteBuffer(binary)); 35 | } 36 | 37 | function _decodeNested(bb) { 38 | let message = {}; 39 | 40 | end_of_message: while (!isAtEnd(bb)) { 41 | let tag = readVarint32(bb); 42 | 43 | switch (tag >>> 3) { 44 | case 0: 45 | break end_of_message; 46 | 47 | // optional float x = 1; 48 | case 1: { 49 | message.x = readFloat(bb); 50 | break; 51 | } 52 | 53 | // optional float y = 2; 54 | case 2: { 55 | message.y = readFloat(bb); 56 | break; 57 | } 58 | 59 | default: 60 | skipUnknownField(bb, tag & 7); 61 | } 62 | } 63 | 64 | return message; 65 | } 66 | 67 | export function encodeOptional(message) { 68 | let bb = popByteBuffer(); 69 | _encodeOptional(message, bb); 70 | return toUint8Array(bb); 71 | } 72 | 73 | function _encodeOptional(message, bb) { 74 | // optional int32 field_int32 = 1; 75 | let $field_int32 = message.field_int32; 76 | if ($field_int32 !== undefined) { 77 | writeVarint32(bb, 8); 78 | writeVarint64(bb, intToLong($field_int32)); 79 | } 80 | 81 | // optional int64 field_int64 = 2; 82 | let $field_int64 = message.field_int64; 83 | if ($field_int64 !== undefined) { 84 | writeVarint32(bb, 16); 85 | writeVarint64(bb, $field_int64); 86 | } 87 | 88 | // optional uint32 field_uint32 = 3; 89 | let $field_uint32 = message.field_uint32; 90 | if ($field_uint32 !== undefined) { 91 | writeVarint32(bb, 24); 92 | writeVarint32(bb, $field_uint32); 93 | } 94 | 95 | // optional uint64 field_uint64 = 4; 96 | let $field_uint64 = message.field_uint64; 97 | if ($field_uint64 !== undefined) { 98 | writeVarint32(bb, 32); 99 | writeVarint64(bb, $field_uint64); 100 | } 101 | 102 | // optional sint32 field_sint32 = 5; 103 | let $field_sint32 = message.field_sint32; 104 | if ($field_sint32 !== undefined) { 105 | writeVarint32(bb, 40); 106 | writeVarint32ZigZag(bb, $field_sint32); 107 | } 108 | 109 | // optional sint64 field_sint64 = 6; 110 | let $field_sint64 = message.field_sint64; 111 | if ($field_sint64 !== undefined) { 112 | writeVarint32(bb, 48); 113 | writeVarint64ZigZag(bb, $field_sint64); 114 | } 115 | 116 | // optional bool field_bool = 7; 117 | let $field_bool = message.field_bool; 118 | if ($field_bool !== undefined) { 119 | writeVarint32(bb, 56); 120 | writeByte(bb, $field_bool ? 1 : 0); 121 | } 122 | 123 | // optional fixed64 field_fixed64 = 8; 124 | let $field_fixed64 = message.field_fixed64; 125 | if ($field_fixed64 !== undefined) { 126 | writeVarint32(bb, 65); 127 | writeInt64(bb, $field_fixed64); 128 | } 129 | 130 | // optional sfixed64 field_sfixed64 = 9; 131 | let $field_sfixed64 = message.field_sfixed64; 132 | if ($field_sfixed64 !== undefined) { 133 | writeVarint32(bb, 73); 134 | writeInt64(bb, $field_sfixed64); 135 | } 136 | 137 | // optional double field_double = 10; 138 | let $field_double = message.field_double; 139 | if ($field_double !== undefined) { 140 | writeVarint32(bb, 81); 141 | writeDouble(bb, $field_double); 142 | } 143 | 144 | // optional string field_string = 11; 145 | let $field_string = message.field_string; 146 | if ($field_string !== undefined) { 147 | writeVarint32(bb, 90); 148 | writeString(bb, $field_string); 149 | } 150 | 151 | // optional bytes field_bytes = 12; 152 | let $field_bytes = message.field_bytes; 153 | if ($field_bytes !== undefined) { 154 | writeVarint32(bb, 98); 155 | writeVarint32(bb, $field_bytes.length), writeBytes(bb, $field_bytes); 156 | } 157 | 158 | // optional fixed32 field_fixed32 = 13; 159 | let $field_fixed32 = message.field_fixed32; 160 | if ($field_fixed32 !== undefined) { 161 | writeVarint32(bb, 109); 162 | writeInt32(bb, $field_fixed32); 163 | } 164 | 165 | // optional sfixed32 field_sfixed32 = 14; 166 | let $field_sfixed32 = message.field_sfixed32; 167 | if ($field_sfixed32 !== undefined) { 168 | writeVarint32(bb, 117); 169 | writeInt32(bb, $field_sfixed32); 170 | } 171 | 172 | // optional float field_float = 15; 173 | let $field_float = message.field_float; 174 | if ($field_float !== undefined) { 175 | writeVarint32(bb, 125); 176 | writeFloat(bb, $field_float); 177 | } 178 | 179 | // optional Nested field_nested = 16; 180 | let $field_nested = message.field_nested; 181 | if ($field_nested !== undefined) { 182 | writeVarint32(bb, 130); 183 | let nested = popByteBuffer(); 184 | _encodeNested($field_nested, nested); 185 | writeVarint32(bb, nested.limit); 186 | writeByteBuffer(bb, nested); 187 | pushByteBuffer(nested); 188 | } 189 | } 190 | 191 | export function decodeOptional(binary) { 192 | return _decodeOptional(wrapByteBuffer(binary)); 193 | } 194 | 195 | function _decodeOptional(bb) { 196 | let message = {}; 197 | 198 | end_of_message: while (!isAtEnd(bb)) { 199 | let tag = readVarint32(bb); 200 | 201 | switch (tag >>> 3) { 202 | case 0: 203 | break end_of_message; 204 | 205 | // optional int32 field_int32 = 1; 206 | case 1: { 207 | message.field_int32 = readVarint32(bb); 208 | break; 209 | } 210 | 211 | // optional int64 field_int64 = 2; 212 | case 2: { 213 | message.field_int64 = readVarint64(bb, /* unsigned */ false); 214 | break; 215 | } 216 | 217 | // optional uint32 field_uint32 = 3; 218 | case 3: { 219 | message.field_uint32 = readVarint32(bb) >>> 0; 220 | break; 221 | } 222 | 223 | // optional uint64 field_uint64 = 4; 224 | case 4: { 225 | message.field_uint64 = readVarint64(bb, /* unsigned */ true); 226 | break; 227 | } 228 | 229 | // optional sint32 field_sint32 = 5; 230 | case 5: { 231 | message.field_sint32 = readVarint32ZigZag(bb); 232 | break; 233 | } 234 | 235 | // optional sint64 field_sint64 = 6; 236 | case 6: { 237 | message.field_sint64 = readVarint64ZigZag(bb); 238 | break; 239 | } 240 | 241 | // optional bool field_bool = 7; 242 | case 7: { 243 | message.field_bool = !!readByte(bb); 244 | break; 245 | } 246 | 247 | // optional fixed64 field_fixed64 = 8; 248 | case 8: { 249 | message.field_fixed64 = readInt64(bb, /* unsigned */ true); 250 | break; 251 | } 252 | 253 | // optional sfixed64 field_sfixed64 = 9; 254 | case 9: { 255 | message.field_sfixed64 = readInt64(bb, /* unsigned */ false); 256 | break; 257 | } 258 | 259 | // optional double field_double = 10; 260 | case 10: { 261 | message.field_double = readDouble(bb); 262 | break; 263 | } 264 | 265 | // optional string field_string = 11; 266 | case 11: { 267 | message.field_string = readString(bb, readVarint32(bb)); 268 | break; 269 | } 270 | 271 | // optional bytes field_bytes = 12; 272 | case 12: { 273 | message.field_bytes = readBytes(bb, readVarint32(bb)); 274 | break; 275 | } 276 | 277 | // optional fixed32 field_fixed32 = 13; 278 | case 13: { 279 | message.field_fixed32 = readInt32(bb) >>> 0; 280 | break; 281 | } 282 | 283 | // optional sfixed32 field_sfixed32 = 14; 284 | case 14: { 285 | message.field_sfixed32 = readInt32(bb); 286 | break; 287 | } 288 | 289 | // optional float field_float = 15; 290 | case 15: { 291 | message.field_float = readFloat(bb); 292 | break; 293 | } 294 | 295 | // optional Nested field_nested = 16; 296 | case 16: { 297 | let limit = pushTemporaryLength(bb); 298 | message.field_nested = _decodeNested(bb); 299 | bb.limit = limit; 300 | break; 301 | } 302 | 303 | default: 304 | skipUnknownField(bb, tag & 7); 305 | } 306 | } 307 | 308 | return message; 309 | } 310 | 311 | export function encodeRepeatedUnpacked(message) { 312 | let bb = popByteBuffer(); 313 | _encodeRepeatedUnpacked(message, bb); 314 | return toUint8Array(bb); 315 | } 316 | 317 | function _encodeRepeatedUnpacked(message, bb) { 318 | // repeated int32 field_int32 = 1; 319 | let array$field_int32 = message.field_int32; 320 | if (array$field_int32 !== undefined) { 321 | for (let value of array$field_int32) { 322 | writeVarint32(bb, 8); 323 | writeVarint64(bb, intToLong(value)); 324 | } 325 | } 326 | 327 | // repeated int64 field_int64 = 2; 328 | let array$field_int64 = message.field_int64; 329 | if (array$field_int64 !== undefined) { 330 | for (let value of array$field_int64) { 331 | writeVarint32(bb, 16); 332 | writeVarint64(bb, value); 333 | } 334 | } 335 | 336 | // repeated uint32 field_uint32 = 3; 337 | let array$field_uint32 = message.field_uint32; 338 | if (array$field_uint32 !== undefined) { 339 | for (let value of array$field_uint32) { 340 | writeVarint32(bb, 24); 341 | writeVarint32(bb, value); 342 | } 343 | } 344 | 345 | // repeated uint64 field_uint64 = 4; 346 | let array$field_uint64 = message.field_uint64; 347 | if (array$field_uint64 !== undefined) { 348 | for (let value of array$field_uint64) { 349 | writeVarint32(bb, 32); 350 | writeVarint64(bb, value); 351 | } 352 | } 353 | 354 | // repeated sint32 field_sint32 = 5; 355 | let array$field_sint32 = message.field_sint32; 356 | if (array$field_sint32 !== undefined) { 357 | for (let value of array$field_sint32) { 358 | writeVarint32(bb, 40); 359 | writeVarint32ZigZag(bb, value); 360 | } 361 | } 362 | 363 | // repeated sint64 field_sint64 = 6; 364 | let array$field_sint64 = message.field_sint64; 365 | if (array$field_sint64 !== undefined) { 366 | for (let value of array$field_sint64) { 367 | writeVarint32(bb, 48); 368 | writeVarint64ZigZag(bb, value); 369 | } 370 | } 371 | 372 | // repeated bool field_bool = 7; 373 | let array$field_bool = message.field_bool; 374 | if (array$field_bool !== undefined) { 375 | for (let value of array$field_bool) { 376 | writeVarint32(bb, 56); 377 | writeByte(bb, value ? 1 : 0); 378 | } 379 | } 380 | 381 | // repeated fixed64 field_fixed64 = 8; 382 | let array$field_fixed64 = message.field_fixed64; 383 | if (array$field_fixed64 !== undefined) { 384 | for (let value of array$field_fixed64) { 385 | writeVarint32(bb, 65); 386 | writeInt64(bb, value); 387 | } 388 | } 389 | 390 | // repeated sfixed64 field_sfixed64 = 9; 391 | let array$field_sfixed64 = message.field_sfixed64; 392 | if (array$field_sfixed64 !== undefined) { 393 | for (let value of array$field_sfixed64) { 394 | writeVarint32(bb, 73); 395 | writeInt64(bb, value); 396 | } 397 | } 398 | 399 | // repeated double field_double = 10; 400 | let array$field_double = message.field_double; 401 | if (array$field_double !== undefined) { 402 | for (let value of array$field_double) { 403 | writeVarint32(bb, 81); 404 | writeDouble(bb, value); 405 | } 406 | } 407 | 408 | // repeated string field_string = 11; 409 | let array$field_string = message.field_string; 410 | if (array$field_string !== undefined) { 411 | for (let value of array$field_string) { 412 | writeVarint32(bb, 90); 413 | writeString(bb, value); 414 | } 415 | } 416 | 417 | // repeated bytes field_bytes = 12; 418 | let array$field_bytes = message.field_bytes; 419 | if (array$field_bytes !== undefined) { 420 | for (let value of array$field_bytes) { 421 | writeVarint32(bb, 98); 422 | writeVarint32(bb, value.length), writeBytes(bb, value); 423 | } 424 | } 425 | 426 | // repeated fixed32 field_fixed32 = 13; 427 | let array$field_fixed32 = message.field_fixed32; 428 | if (array$field_fixed32 !== undefined) { 429 | for (let value of array$field_fixed32) { 430 | writeVarint32(bb, 109); 431 | writeInt32(bb, value); 432 | } 433 | } 434 | 435 | // repeated sfixed32 field_sfixed32 = 14; 436 | let array$field_sfixed32 = message.field_sfixed32; 437 | if (array$field_sfixed32 !== undefined) { 438 | for (let value of array$field_sfixed32) { 439 | writeVarint32(bb, 117); 440 | writeInt32(bb, value); 441 | } 442 | } 443 | 444 | // repeated float field_float = 15; 445 | let array$field_float = message.field_float; 446 | if (array$field_float !== undefined) { 447 | for (let value of array$field_float) { 448 | writeVarint32(bb, 125); 449 | writeFloat(bb, value); 450 | } 451 | } 452 | 453 | // repeated Nested field_nested = 16; 454 | let array$field_nested = message.field_nested; 455 | if (array$field_nested !== undefined) { 456 | for (let value of array$field_nested) { 457 | writeVarint32(bb, 130); 458 | let nested = popByteBuffer(); 459 | _encodeNested(value, nested); 460 | writeVarint32(bb, nested.limit); 461 | writeByteBuffer(bb, nested); 462 | pushByteBuffer(nested); 463 | } 464 | } 465 | } 466 | 467 | export function decodeRepeatedUnpacked(binary) { 468 | return _decodeRepeatedUnpacked(wrapByteBuffer(binary)); 469 | } 470 | 471 | function _decodeRepeatedUnpacked(bb) { 472 | let message = {}; 473 | 474 | end_of_message: while (!isAtEnd(bb)) { 475 | let tag = readVarint32(bb); 476 | 477 | switch (tag >>> 3) { 478 | case 0: 479 | break end_of_message; 480 | 481 | // repeated int32 field_int32 = 1; 482 | case 1: { 483 | let values = message.field_int32 || (message.field_int32 = []); 484 | if ((tag & 7) === 2) { 485 | let outerLimit = pushTemporaryLength(bb); 486 | while (!isAtEnd(bb)) { 487 | values.push(readVarint32(bb)); 488 | } 489 | bb.limit = outerLimit; 490 | } else { 491 | values.push(readVarint32(bb)); 492 | } 493 | break; 494 | } 495 | 496 | // repeated int64 field_int64 = 2; 497 | case 2: { 498 | let values = message.field_int64 || (message.field_int64 = []); 499 | if ((tag & 7) === 2) { 500 | let outerLimit = pushTemporaryLength(bb); 501 | while (!isAtEnd(bb)) { 502 | values.push(readVarint64(bb, /* unsigned */ false)); 503 | } 504 | bb.limit = outerLimit; 505 | } else { 506 | values.push(readVarint64(bb, /* unsigned */ false)); 507 | } 508 | break; 509 | } 510 | 511 | // repeated uint32 field_uint32 = 3; 512 | case 3: { 513 | let values = message.field_uint32 || (message.field_uint32 = []); 514 | if ((tag & 7) === 2) { 515 | let outerLimit = pushTemporaryLength(bb); 516 | while (!isAtEnd(bb)) { 517 | values.push(readVarint32(bb) >>> 0); 518 | } 519 | bb.limit = outerLimit; 520 | } else { 521 | values.push(readVarint32(bb) >>> 0); 522 | } 523 | break; 524 | } 525 | 526 | // repeated uint64 field_uint64 = 4; 527 | case 4: { 528 | let values = message.field_uint64 || (message.field_uint64 = []); 529 | if ((tag & 7) === 2) { 530 | let outerLimit = pushTemporaryLength(bb); 531 | while (!isAtEnd(bb)) { 532 | values.push(readVarint64(bb, /* unsigned */ true)); 533 | } 534 | bb.limit = outerLimit; 535 | } else { 536 | values.push(readVarint64(bb, /* unsigned */ true)); 537 | } 538 | break; 539 | } 540 | 541 | // repeated sint32 field_sint32 = 5; 542 | case 5: { 543 | let values = message.field_sint32 || (message.field_sint32 = []); 544 | if ((tag & 7) === 2) { 545 | let outerLimit = pushTemporaryLength(bb); 546 | while (!isAtEnd(bb)) { 547 | values.push(readVarint32ZigZag(bb)); 548 | } 549 | bb.limit = outerLimit; 550 | } else { 551 | values.push(readVarint32ZigZag(bb)); 552 | } 553 | break; 554 | } 555 | 556 | // repeated sint64 field_sint64 = 6; 557 | case 6: { 558 | let values = message.field_sint64 || (message.field_sint64 = []); 559 | if ((tag & 7) === 2) { 560 | let outerLimit = pushTemporaryLength(bb); 561 | while (!isAtEnd(bb)) { 562 | values.push(readVarint64ZigZag(bb)); 563 | } 564 | bb.limit = outerLimit; 565 | } else { 566 | values.push(readVarint64ZigZag(bb)); 567 | } 568 | break; 569 | } 570 | 571 | // repeated bool field_bool = 7; 572 | case 7: { 573 | let values = message.field_bool || (message.field_bool = []); 574 | if ((tag & 7) === 2) { 575 | let outerLimit = pushTemporaryLength(bb); 576 | while (!isAtEnd(bb)) { 577 | values.push(!!readByte(bb)); 578 | } 579 | bb.limit = outerLimit; 580 | } else { 581 | values.push(!!readByte(bb)); 582 | } 583 | break; 584 | } 585 | 586 | // repeated fixed64 field_fixed64 = 8; 587 | case 8: { 588 | let values = message.field_fixed64 || (message.field_fixed64 = []); 589 | if ((tag & 7) === 2) { 590 | let outerLimit = pushTemporaryLength(bb); 591 | while (!isAtEnd(bb)) { 592 | values.push(readInt64(bb, /* unsigned */ true)); 593 | } 594 | bb.limit = outerLimit; 595 | } else { 596 | values.push(readInt64(bb, /* unsigned */ true)); 597 | } 598 | break; 599 | } 600 | 601 | // repeated sfixed64 field_sfixed64 = 9; 602 | case 9: { 603 | let values = message.field_sfixed64 || (message.field_sfixed64 = []); 604 | if ((tag & 7) === 2) { 605 | let outerLimit = pushTemporaryLength(bb); 606 | while (!isAtEnd(bb)) { 607 | values.push(readInt64(bb, /* unsigned */ false)); 608 | } 609 | bb.limit = outerLimit; 610 | } else { 611 | values.push(readInt64(bb, /* unsigned */ false)); 612 | } 613 | break; 614 | } 615 | 616 | // repeated double field_double = 10; 617 | case 10: { 618 | let values = message.field_double || (message.field_double = []); 619 | if ((tag & 7) === 2) { 620 | let outerLimit = pushTemporaryLength(bb); 621 | while (!isAtEnd(bb)) { 622 | values.push(readDouble(bb)); 623 | } 624 | bb.limit = outerLimit; 625 | } else { 626 | values.push(readDouble(bb)); 627 | } 628 | break; 629 | } 630 | 631 | // repeated string field_string = 11; 632 | case 11: { 633 | let values = message.field_string || (message.field_string = []); 634 | values.push(readString(bb, readVarint32(bb))); 635 | break; 636 | } 637 | 638 | // repeated bytes field_bytes = 12; 639 | case 12: { 640 | let values = message.field_bytes || (message.field_bytes = []); 641 | values.push(readBytes(bb, readVarint32(bb))); 642 | break; 643 | } 644 | 645 | // repeated fixed32 field_fixed32 = 13; 646 | case 13: { 647 | let values = message.field_fixed32 || (message.field_fixed32 = []); 648 | if ((tag & 7) === 2) { 649 | let outerLimit = pushTemporaryLength(bb); 650 | while (!isAtEnd(bb)) { 651 | values.push(readInt32(bb) >>> 0); 652 | } 653 | bb.limit = outerLimit; 654 | } else { 655 | values.push(readInt32(bb) >>> 0); 656 | } 657 | break; 658 | } 659 | 660 | // repeated sfixed32 field_sfixed32 = 14; 661 | case 14: { 662 | let values = message.field_sfixed32 || (message.field_sfixed32 = []); 663 | if ((tag & 7) === 2) { 664 | let outerLimit = pushTemporaryLength(bb); 665 | while (!isAtEnd(bb)) { 666 | values.push(readInt32(bb)); 667 | } 668 | bb.limit = outerLimit; 669 | } else { 670 | values.push(readInt32(bb)); 671 | } 672 | break; 673 | } 674 | 675 | // repeated float field_float = 15; 676 | case 15: { 677 | let values = message.field_float || (message.field_float = []); 678 | if ((tag & 7) === 2) { 679 | let outerLimit = pushTemporaryLength(bb); 680 | while (!isAtEnd(bb)) { 681 | values.push(readFloat(bb)); 682 | } 683 | bb.limit = outerLimit; 684 | } else { 685 | values.push(readFloat(bb)); 686 | } 687 | break; 688 | } 689 | 690 | // repeated Nested field_nested = 16; 691 | case 16: { 692 | let limit = pushTemporaryLength(bb); 693 | let values = message.field_nested || (message.field_nested = []); 694 | values.push(_decodeNested(bb)); 695 | bb.limit = limit; 696 | break; 697 | } 698 | 699 | default: 700 | skipUnknownField(bb, tag & 7); 701 | } 702 | } 703 | 704 | return message; 705 | } 706 | 707 | export function encodeRepeatedPacked(message) { 708 | let bb = popByteBuffer(); 709 | _encodeRepeatedPacked(message, bb); 710 | return toUint8Array(bb); 711 | } 712 | 713 | function _encodeRepeatedPacked(message, bb) { 714 | // repeated int32 field_int32 = 1; 715 | let array$field_int32 = message.field_int32; 716 | if (array$field_int32 !== undefined) { 717 | let packed = popByteBuffer(); 718 | for (let value of array$field_int32) { 719 | writeVarint64(packed, intToLong(value)); 720 | } 721 | writeVarint32(bb, 10); 722 | writeVarint32(bb, packed.offset); 723 | writeByteBuffer(bb, packed); 724 | pushByteBuffer(packed); 725 | } 726 | 727 | // repeated int64 field_int64 = 2; 728 | let array$field_int64 = message.field_int64; 729 | if (array$field_int64 !== undefined) { 730 | let packed = popByteBuffer(); 731 | for (let value of array$field_int64) { 732 | writeVarint64(packed, value); 733 | } 734 | writeVarint32(bb, 18); 735 | writeVarint32(bb, packed.offset); 736 | writeByteBuffer(bb, packed); 737 | pushByteBuffer(packed); 738 | } 739 | 740 | // repeated uint32 field_uint32 = 3; 741 | let array$field_uint32 = message.field_uint32; 742 | if (array$field_uint32 !== undefined) { 743 | let packed = popByteBuffer(); 744 | for (let value of array$field_uint32) { 745 | writeVarint32(packed, value); 746 | } 747 | writeVarint32(bb, 26); 748 | writeVarint32(bb, packed.offset); 749 | writeByteBuffer(bb, packed); 750 | pushByteBuffer(packed); 751 | } 752 | 753 | // repeated uint64 field_uint64 = 4; 754 | let array$field_uint64 = message.field_uint64; 755 | if (array$field_uint64 !== undefined) { 756 | let packed = popByteBuffer(); 757 | for (let value of array$field_uint64) { 758 | writeVarint64(packed, value); 759 | } 760 | writeVarint32(bb, 34); 761 | writeVarint32(bb, packed.offset); 762 | writeByteBuffer(bb, packed); 763 | pushByteBuffer(packed); 764 | } 765 | 766 | // repeated sint32 field_sint32 = 5; 767 | let array$field_sint32 = message.field_sint32; 768 | if (array$field_sint32 !== undefined) { 769 | let packed = popByteBuffer(); 770 | for (let value of array$field_sint32) { 771 | writeVarint32ZigZag(packed, value); 772 | } 773 | writeVarint32(bb, 42); 774 | writeVarint32(bb, packed.offset); 775 | writeByteBuffer(bb, packed); 776 | pushByteBuffer(packed); 777 | } 778 | 779 | // repeated sint64 field_sint64 = 6; 780 | let array$field_sint64 = message.field_sint64; 781 | if (array$field_sint64 !== undefined) { 782 | let packed = popByteBuffer(); 783 | for (let value of array$field_sint64) { 784 | writeVarint64ZigZag(packed, value); 785 | } 786 | writeVarint32(bb, 50); 787 | writeVarint32(bb, packed.offset); 788 | writeByteBuffer(bb, packed); 789 | pushByteBuffer(packed); 790 | } 791 | 792 | // repeated bool field_bool = 7; 793 | let array$field_bool = message.field_bool; 794 | if (array$field_bool !== undefined) { 795 | let packed = popByteBuffer(); 796 | for (let value of array$field_bool) { 797 | writeByte(packed, value ? 1 : 0); 798 | } 799 | writeVarint32(bb, 58); 800 | writeVarint32(bb, packed.offset); 801 | writeByteBuffer(bb, packed); 802 | pushByteBuffer(packed); 803 | } 804 | 805 | // repeated fixed64 field_fixed64 = 8; 806 | let array$field_fixed64 = message.field_fixed64; 807 | if (array$field_fixed64 !== undefined) { 808 | let packed = popByteBuffer(); 809 | for (let value of array$field_fixed64) { 810 | writeInt64(packed, value); 811 | } 812 | writeVarint32(bb, 66); 813 | writeVarint32(bb, packed.offset); 814 | writeByteBuffer(bb, packed); 815 | pushByteBuffer(packed); 816 | } 817 | 818 | // repeated sfixed64 field_sfixed64 = 9; 819 | let array$field_sfixed64 = message.field_sfixed64; 820 | if (array$field_sfixed64 !== undefined) { 821 | let packed = popByteBuffer(); 822 | for (let value of array$field_sfixed64) { 823 | writeInt64(packed, value); 824 | } 825 | writeVarint32(bb, 74); 826 | writeVarint32(bb, packed.offset); 827 | writeByteBuffer(bb, packed); 828 | pushByteBuffer(packed); 829 | } 830 | 831 | // repeated double field_double = 10; 832 | let array$field_double = message.field_double; 833 | if (array$field_double !== undefined) { 834 | let packed = popByteBuffer(); 835 | for (let value of array$field_double) { 836 | writeDouble(packed, value); 837 | } 838 | writeVarint32(bb, 82); 839 | writeVarint32(bb, packed.offset); 840 | writeByteBuffer(bb, packed); 841 | pushByteBuffer(packed); 842 | } 843 | 844 | // repeated string field_string = 11; 845 | let array$field_string = message.field_string; 846 | if (array$field_string !== undefined) { 847 | for (let value of array$field_string) { 848 | writeVarint32(bb, 90); 849 | writeString(bb, value); 850 | } 851 | } 852 | 853 | // repeated bytes field_bytes = 12; 854 | let array$field_bytes = message.field_bytes; 855 | if (array$field_bytes !== undefined) { 856 | for (let value of array$field_bytes) { 857 | writeVarint32(bb, 98); 858 | writeVarint32(bb, value.length), writeBytes(bb, value); 859 | } 860 | } 861 | 862 | // repeated fixed32 field_fixed32 = 13; 863 | let array$field_fixed32 = message.field_fixed32; 864 | if (array$field_fixed32 !== undefined) { 865 | let packed = popByteBuffer(); 866 | for (let value of array$field_fixed32) { 867 | writeInt32(packed, value); 868 | } 869 | writeVarint32(bb, 106); 870 | writeVarint32(bb, packed.offset); 871 | writeByteBuffer(bb, packed); 872 | pushByteBuffer(packed); 873 | } 874 | 875 | // repeated sfixed32 field_sfixed32 = 14; 876 | let array$field_sfixed32 = message.field_sfixed32; 877 | if (array$field_sfixed32 !== undefined) { 878 | let packed = popByteBuffer(); 879 | for (let value of array$field_sfixed32) { 880 | writeInt32(packed, value); 881 | } 882 | writeVarint32(bb, 114); 883 | writeVarint32(bb, packed.offset); 884 | writeByteBuffer(bb, packed); 885 | pushByteBuffer(packed); 886 | } 887 | 888 | // repeated float field_float = 15; 889 | let array$field_float = message.field_float; 890 | if (array$field_float !== undefined) { 891 | let packed = popByteBuffer(); 892 | for (let value of array$field_float) { 893 | writeFloat(packed, value); 894 | } 895 | writeVarint32(bb, 122); 896 | writeVarint32(bb, packed.offset); 897 | writeByteBuffer(bb, packed); 898 | pushByteBuffer(packed); 899 | } 900 | 901 | // repeated Nested field_nested = 16; 902 | let array$field_nested = message.field_nested; 903 | if (array$field_nested !== undefined) { 904 | for (let value of array$field_nested) { 905 | writeVarint32(bb, 130); 906 | let nested = popByteBuffer(); 907 | _encodeNested(value, nested); 908 | writeVarint32(bb, nested.limit); 909 | writeByteBuffer(bb, nested); 910 | pushByteBuffer(nested); 911 | } 912 | } 913 | } 914 | 915 | export function decodeRepeatedPacked(binary) { 916 | return _decodeRepeatedPacked(wrapByteBuffer(binary)); 917 | } 918 | 919 | function _decodeRepeatedPacked(bb) { 920 | let message = {}; 921 | 922 | end_of_message: while (!isAtEnd(bb)) { 923 | let tag = readVarint32(bb); 924 | 925 | switch (tag >>> 3) { 926 | case 0: 927 | break end_of_message; 928 | 929 | // repeated int32 field_int32 = 1; 930 | case 1: { 931 | let values = message.field_int32 || (message.field_int32 = []); 932 | if ((tag & 7) === 2) { 933 | let outerLimit = pushTemporaryLength(bb); 934 | while (!isAtEnd(bb)) { 935 | values.push(readVarint32(bb)); 936 | } 937 | bb.limit = outerLimit; 938 | } else { 939 | values.push(readVarint32(bb)); 940 | } 941 | break; 942 | } 943 | 944 | // repeated int64 field_int64 = 2; 945 | case 2: { 946 | let values = message.field_int64 || (message.field_int64 = []); 947 | if ((tag & 7) === 2) { 948 | let outerLimit = pushTemporaryLength(bb); 949 | while (!isAtEnd(bb)) { 950 | values.push(readVarint64(bb, /* unsigned */ false)); 951 | } 952 | bb.limit = outerLimit; 953 | } else { 954 | values.push(readVarint64(bb, /* unsigned */ false)); 955 | } 956 | break; 957 | } 958 | 959 | // repeated uint32 field_uint32 = 3; 960 | case 3: { 961 | let values = message.field_uint32 || (message.field_uint32 = []); 962 | if ((tag & 7) === 2) { 963 | let outerLimit = pushTemporaryLength(bb); 964 | while (!isAtEnd(bb)) { 965 | values.push(readVarint32(bb) >>> 0); 966 | } 967 | bb.limit = outerLimit; 968 | } else { 969 | values.push(readVarint32(bb) >>> 0); 970 | } 971 | break; 972 | } 973 | 974 | // repeated uint64 field_uint64 = 4; 975 | case 4: { 976 | let values = message.field_uint64 || (message.field_uint64 = []); 977 | if ((tag & 7) === 2) { 978 | let outerLimit = pushTemporaryLength(bb); 979 | while (!isAtEnd(bb)) { 980 | values.push(readVarint64(bb, /* unsigned */ true)); 981 | } 982 | bb.limit = outerLimit; 983 | } else { 984 | values.push(readVarint64(bb, /* unsigned */ true)); 985 | } 986 | break; 987 | } 988 | 989 | // repeated sint32 field_sint32 = 5; 990 | case 5: { 991 | let values = message.field_sint32 || (message.field_sint32 = []); 992 | if ((tag & 7) === 2) { 993 | let outerLimit = pushTemporaryLength(bb); 994 | while (!isAtEnd(bb)) { 995 | values.push(readVarint32ZigZag(bb)); 996 | } 997 | bb.limit = outerLimit; 998 | } else { 999 | values.push(readVarint32ZigZag(bb)); 1000 | } 1001 | break; 1002 | } 1003 | 1004 | // repeated sint64 field_sint64 = 6; 1005 | case 6: { 1006 | let values = message.field_sint64 || (message.field_sint64 = []); 1007 | if ((tag & 7) === 2) { 1008 | let outerLimit = pushTemporaryLength(bb); 1009 | while (!isAtEnd(bb)) { 1010 | values.push(readVarint64ZigZag(bb)); 1011 | } 1012 | bb.limit = outerLimit; 1013 | } else { 1014 | values.push(readVarint64ZigZag(bb)); 1015 | } 1016 | break; 1017 | } 1018 | 1019 | // repeated bool field_bool = 7; 1020 | case 7: { 1021 | let values = message.field_bool || (message.field_bool = []); 1022 | if ((tag & 7) === 2) { 1023 | let outerLimit = pushTemporaryLength(bb); 1024 | while (!isAtEnd(bb)) { 1025 | values.push(!!readByte(bb)); 1026 | } 1027 | bb.limit = outerLimit; 1028 | } else { 1029 | values.push(!!readByte(bb)); 1030 | } 1031 | break; 1032 | } 1033 | 1034 | // repeated fixed64 field_fixed64 = 8; 1035 | case 8: { 1036 | let values = message.field_fixed64 || (message.field_fixed64 = []); 1037 | if ((tag & 7) === 2) { 1038 | let outerLimit = pushTemporaryLength(bb); 1039 | while (!isAtEnd(bb)) { 1040 | values.push(readInt64(bb, /* unsigned */ true)); 1041 | } 1042 | bb.limit = outerLimit; 1043 | } else { 1044 | values.push(readInt64(bb, /* unsigned */ true)); 1045 | } 1046 | break; 1047 | } 1048 | 1049 | // repeated sfixed64 field_sfixed64 = 9; 1050 | case 9: { 1051 | let values = message.field_sfixed64 || (message.field_sfixed64 = []); 1052 | if ((tag & 7) === 2) { 1053 | let outerLimit = pushTemporaryLength(bb); 1054 | while (!isAtEnd(bb)) { 1055 | values.push(readInt64(bb, /* unsigned */ false)); 1056 | } 1057 | bb.limit = outerLimit; 1058 | } else { 1059 | values.push(readInt64(bb, /* unsigned */ false)); 1060 | } 1061 | break; 1062 | } 1063 | 1064 | // repeated double field_double = 10; 1065 | case 10: { 1066 | let values = message.field_double || (message.field_double = []); 1067 | if ((tag & 7) === 2) { 1068 | let outerLimit = pushTemporaryLength(bb); 1069 | while (!isAtEnd(bb)) { 1070 | values.push(readDouble(bb)); 1071 | } 1072 | bb.limit = outerLimit; 1073 | } else { 1074 | values.push(readDouble(bb)); 1075 | } 1076 | break; 1077 | } 1078 | 1079 | // repeated string field_string = 11; 1080 | case 11: { 1081 | let values = message.field_string || (message.field_string = []); 1082 | values.push(readString(bb, readVarint32(bb))); 1083 | break; 1084 | } 1085 | 1086 | // repeated bytes field_bytes = 12; 1087 | case 12: { 1088 | let values = message.field_bytes || (message.field_bytes = []); 1089 | values.push(readBytes(bb, readVarint32(bb))); 1090 | break; 1091 | } 1092 | 1093 | // repeated fixed32 field_fixed32 = 13; 1094 | case 13: { 1095 | let values = message.field_fixed32 || (message.field_fixed32 = []); 1096 | if ((tag & 7) === 2) { 1097 | let outerLimit = pushTemporaryLength(bb); 1098 | while (!isAtEnd(bb)) { 1099 | values.push(readInt32(bb) >>> 0); 1100 | } 1101 | bb.limit = outerLimit; 1102 | } else { 1103 | values.push(readInt32(bb) >>> 0); 1104 | } 1105 | break; 1106 | } 1107 | 1108 | // repeated sfixed32 field_sfixed32 = 14; 1109 | case 14: { 1110 | let values = message.field_sfixed32 || (message.field_sfixed32 = []); 1111 | if ((tag & 7) === 2) { 1112 | let outerLimit = pushTemporaryLength(bb); 1113 | while (!isAtEnd(bb)) { 1114 | values.push(readInt32(bb)); 1115 | } 1116 | bb.limit = outerLimit; 1117 | } else { 1118 | values.push(readInt32(bb)); 1119 | } 1120 | break; 1121 | } 1122 | 1123 | // repeated float field_float = 15; 1124 | case 15: { 1125 | let values = message.field_float || (message.field_float = []); 1126 | if ((tag & 7) === 2) { 1127 | let outerLimit = pushTemporaryLength(bb); 1128 | while (!isAtEnd(bb)) { 1129 | values.push(readFloat(bb)); 1130 | } 1131 | bb.limit = outerLimit; 1132 | } else { 1133 | values.push(readFloat(bb)); 1134 | } 1135 | break; 1136 | } 1137 | 1138 | // repeated Nested field_nested = 16; 1139 | case 16: { 1140 | let limit = pushTemporaryLength(bb); 1141 | let values = message.field_nested || (message.field_nested = []); 1142 | values.push(_decodeNested(bb)); 1143 | bb.limit = limit; 1144 | break; 1145 | } 1146 | 1147 | default: 1148 | skipUnknownField(bb, tag & 7); 1149 | } 1150 | } 1151 | 1152 | return message; 1153 | } 1154 | 1155 | export function encodeEnumTest(message) { 1156 | let bb = popByteBuffer(); 1157 | _encodeEnumTest(message, bb); 1158 | return toUint8Array(bb); 1159 | } 1160 | 1161 | function _encodeEnumTest(message, bb) { 1162 | // optional Enum a = 1; 1163 | let $a = message.a; 1164 | if ($a !== undefined) { 1165 | writeVarint32(bb, 8); 1166 | writeVarint32(bb, encodeEnum[$a]); 1167 | } 1168 | 1169 | // required Enum b = 2; 1170 | let $b = message.b; 1171 | if ($b !== undefined) { 1172 | writeVarint32(bb, 16); 1173 | writeVarint32(bb, encodeEnum[$b]); 1174 | } 1175 | 1176 | // repeated Enum c = 3; 1177 | let array$c = message.c; 1178 | if (array$c !== undefined) { 1179 | let packed = popByteBuffer(); 1180 | for (let value of array$c) { 1181 | writeVarint32(packed, encodeEnum[value]); 1182 | } 1183 | writeVarint32(bb, 26); 1184 | writeVarint32(bb, packed.offset); 1185 | writeByteBuffer(bb, packed); 1186 | pushByteBuffer(packed); 1187 | } 1188 | } 1189 | 1190 | export function decodeEnumTest(binary) { 1191 | return _decodeEnumTest(wrapByteBuffer(binary)); 1192 | } 1193 | 1194 | function _decodeEnumTest(bb) { 1195 | let message = {}; 1196 | 1197 | end_of_message: while (!isAtEnd(bb)) { 1198 | let tag = readVarint32(bb); 1199 | 1200 | switch (tag >>> 3) { 1201 | case 0: 1202 | break end_of_message; 1203 | 1204 | // optional Enum a = 1; 1205 | case 1: { 1206 | message.a = decodeEnum[readVarint32(bb)]; 1207 | break; 1208 | } 1209 | 1210 | // required Enum b = 2; 1211 | case 2: { 1212 | message.b = decodeEnum[readVarint32(bb)]; 1213 | break; 1214 | } 1215 | 1216 | // repeated Enum c = 3; 1217 | case 3: { 1218 | let values = message.c || (message.c = []); 1219 | if ((tag & 7) === 2) { 1220 | let outerLimit = pushTemporaryLength(bb); 1221 | while (!isAtEnd(bb)) { 1222 | values.push(decodeEnum[readVarint32(bb)]); 1223 | } 1224 | bb.limit = outerLimit; 1225 | } else { 1226 | values.push(decodeEnum[readVarint32(bb)]); 1227 | } 1228 | break; 1229 | } 1230 | 1231 | default: 1232 | skipUnknownField(bb, tag & 7); 1233 | } 1234 | } 1235 | 1236 | if (message.b === undefined) 1237 | throw new Error("Missing required field: b"); 1238 | 1239 | return message; 1240 | } 1241 | 1242 | export function encodeMapTestIntAndString(message) { 1243 | let bb = popByteBuffer(); 1244 | _encodeMapTestIntAndString(message, bb); 1245 | return toUint8Array(bb); 1246 | } 1247 | 1248 | function _encodeMapTestIntAndString(message, bb) { 1249 | // optional map field_int32 = 1; 1250 | let map$field_int32 = message.field_int32; 1251 | if (map$field_int32 !== undefined) { 1252 | for (let key in map$field_int32) { 1253 | let nested = popByteBuffer(); 1254 | let value = map$field_int32[key]; 1255 | writeVarint32(nested, 8); 1256 | writeVarint64(nested, intToLong(+key)); 1257 | writeVarint32(nested, 18); 1258 | writeString(nested, value); 1259 | writeVarint32(bb, 10); 1260 | writeVarint32(bb, nested.offset); 1261 | writeByteBuffer(bb, nested); 1262 | pushByteBuffer(nested); 1263 | } 1264 | } 1265 | 1266 | // optional map field_uint32 = 2; 1267 | let map$field_uint32 = message.field_uint32; 1268 | if (map$field_uint32 !== undefined) { 1269 | for (let key in map$field_uint32) { 1270 | let nested = popByteBuffer(); 1271 | let value = map$field_uint32[key]; 1272 | writeVarint32(nested, 8); 1273 | writeVarint32(nested, +key); 1274 | writeVarint32(nested, 18); 1275 | writeVarint32(nested, value.length), writeBytes(nested, value); 1276 | writeVarint32(bb, 18); 1277 | writeVarint32(bb, nested.offset); 1278 | writeByteBuffer(bb, nested); 1279 | pushByteBuffer(nested); 1280 | } 1281 | } 1282 | 1283 | // optional map field_sint32 = 3; 1284 | let map$field_sint32 = message.field_sint32; 1285 | if (map$field_sint32 !== undefined) { 1286 | for (let key in map$field_sint32) { 1287 | let nested = popByteBuffer(); 1288 | let value = map$field_sint32[key]; 1289 | writeVarint32(nested, 8); 1290 | writeVarint32ZigZag(nested, +key); 1291 | writeVarint32(nested, 16); 1292 | writeVarint64(nested, value); 1293 | writeVarint32(bb, 26); 1294 | writeVarint32(bb, nested.offset); 1295 | writeByteBuffer(bb, nested); 1296 | pushByteBuffer(nested); 1297 | } 1298 | } 1299 | 1300 | // optional map field_string = 5; 1301 | let map$field_string = message.field_string; 1302 | if (map$field_string !== undefined) { 1303 | for (let key in map$field_string) { 1304 | let nested = popByteBuffer(); 1305 | let value = map$field_string[key]; 1306 | writeVarint32(nested, 10); 1307 | writeString(nested, key); 1308 | writeVarint32(nested, 17); 1309 | writeDouble(nested, value); 1310 | writeVarint32(bb, 42); 1311 | writeVarint32(bb, nested.offset); 1312 | writeByteBuffer(bb, nested); 1313 | pushByteBuffer(nested); 1314 | } 1315 | } 1316 | 1317 | // optional map field_fixed32 = 6; 1318 | let map$field_fixed32 = message.field_fixed32; 1319 | if (map$field_fixed32 !== undefined) { 1320 | for (let key in map$field_fixed32) { 1321 | let nested = popByteBuffer(); 1322 | let value = map$field_fixed32[key]; 1323 | writeVarint32(nested, 13); 1324 | writeInt32(nested, +key); 1325 | writeVarint32(nested, 16); 1326 | writeByte(nested, value ? 1 : 0); 1327 | writeVarint32(bb, 50); 1328 | writeVarint32(bb, nested.offset); 1329 | writeByteBuffer(bb, nested); 1330 | pushByteBuffer(nested); 1331 | } 1332 | } 1333 | 1334 | // optional map field_sfixed32 = 7; 1335 | let map$field_sfixed32 = message.field_sfixed32; 1336 | if (map$field_sfixed32 !== undefined) { 1337 | for (let key in map$field_sfixed32) { 1338 | let nested = popByteBuffer(); 1339 | let value = map$field_sfixed32[key]; 1340 | writeVarint32(nested, 13); 1341 | writeInt32(nested, +key); 1342 | writeVarint32(nested, 18); 1343 | let nestedValue = popByteBuffer(); 1344 | _encodeNested(value, nestedValue); 1345 | writeVarint32(nested, nestedValue.limit); 1346 | writeByteBuffer(nested, nestedValue); 1347 | pushByteBuffer(nestedValue); 1348 | writeVarint32(bb, 58); 1349 | writeVarint32(bb, nested.offset); 1350 | writeByteBuffer(bb, nested); 1351 | pushByteBuffer(nested); 1352 | } 1353 | } 1354 | } 1355 | 1356 | export function decodeMapTestIntAndString(binary) { 1357 | return _decodeMapTestIntAndString(wrapByteBuffer(binary)); 1358 | } 1359 | 1360 | function _decodeMapTestIntAndString(bb) { 1361 | let message = {}; 1362 | 1363 | end_of_message: while (!isAtEnd(bb)) { 1364 | let tag = readVarint32(bb); 1365 | 1366 | switch (tag >>> 3) { 1367 | case 0: 1368 | break end_of_message; 1369 | 1370 | // optional map field_int32 = 1; 1371 | case 1: { 1372 | let values = message.field_int32 || (message.field_int32 = {}); 1373 | let outerLimit = pushTemporaryLength(bb); 1374 | let key; 1375 | let value; 1376 | end_of_entry: while (!isAtEnd(bb)) { 1377 | let tag = readVarint32(bb); 1378 | switch (tag >>> 3) { 1379 | case 0: 1380 | break end_of_entry; 1381 | case 1: { 1382 | key = readVarint32(bb); 1383 | break; 1384 | } 1385 | case 2: { 1386 | value = readString(bb, readVarint32(bb)); 1387 | break; 1388 | } 1389 | default: 1390 | skipUnknownField(bb, tag & 7); 1391 | } 1392 | } 1393 | if (key === undefined || value === undefined) 1394 | throw new Error("Invalid data for map: field_int32"); 1395 | values[key] = value; 1396 | bb.limit = outerLimit; 1397 | break; 1398 | } 1399 | 1400 | // optional map field_uint32 = 2; 1401 | case 2: { 1402 | let values = message.field_uint32 || (message.field_uint32 = {}); 1403 | let outerLimit = pushTemporaryLength(bb); 1404 | let key; 1405 | let value; 1406 | end_of_entry: while (!isAtEnd(bb)) { 1407 | let tag = readVarint32(bb); 1408 | switch (tag >>> 3) { 1409 | case 0: 1410 | break end_of_entry; 1411 | case 1: { 1412 | key = readVarint32(bb) >>> 0; 1413 | break; 1414 | } 1415 | case 2: { 1416 | value = readBytes(bb, readVarint32(bb)); 1417 | break; 1418 | } 1419 | default: 1420 | skipUnknownField(bb, tag & 7); 1421 | } 1422 | } 1423 | if (key === undefined || value === undefined) 1424 | throw new Error("Invalid data for map: field_uint32"); 1425 | values[key] = value; 1426 | bb.limit = outerLimit; 1427 | break; 1428 | } 1429 | 1430 | // optional map field_sint32 = 3; 1431 | case 3: { 1432 | let values = message.field_sint32 || (message.field_sint32 = {}); 1433 | let outerLimit = pushTemporaryLength(bb); 1434 | let key; 1435 | let value; 1436 | end_of_entry: while (!isAtEnd(bb)) { 1437 | let tag = readVarint32(bb); 1438 | switch (tag >>> 3) { 1439 | case 0: 1440 | break end_of_entry; 1441 | case 1: { 1442 | key = readVarint32ZigZag(bb); 1443 | break; 1444 | } 1445 | case 2: { 1446 | value = readVarint64(bb, /* unsigned */ false); 1447 | break; 1448 | } 1449 | default: 1450 | skipUnknownField(bb, tag & 7); 1451 | } 1452 | } 1453 | if (key === undefined || value === undefined) 1454 | throw new Error("Invalid data for map: field_sint32"); 1455 | values[key] = value; 1456 | bb.limit = outerLimit; 1457 | break; 1458 | } 1459 | 1460 | // optional map field_string = 5; 1461 | case 5: { 1462 | let values = message.field_string || (message.field_string = {}); 1463 | let outerLimit = pushTemporaryLength(bb); 1464 | let key; 1465 | let value; 1466 | end_of_entry: while (!isAtEnd(bb)) { 1467 | let tag = readVarint32(bb); 1468 | switch (tag >>> 3) { 1469 | case 0: 1470 | break end_of_entry; 1471 | case 1: { 1472 | key = readString(bb, readVarint32(bb)); 1473 | break; 1474 | } 1475 | case 2: { 1476 | value = readDouble(bb); 1477 | break; 1478 | } 1479 | default: 1480 | skipUnknownField(bb, tag & 7); 1481 | } 1482 | } 1483 | if (key === undefined || value === undefined) 1484 | throw new Error("Invalid data for map: field_string"); 1485 | values[key] = value; 1486 | bb.limit = outerLimit; 1487 | break; 1488 | } 1489 | 1490 | // optional map field_fixed32 = 6; 1491 | case 6: { 1492 | let values = message.field_fixed32 || (message.field_fixed32 = {}); 1493 | let outerLimit = pushTemporaryLength(bb); 1494 | let key; 1495 | let value; 1496 | end_of_entry: while (!isAtEnd(bb)) { 1497 | let tag = readVarint32(bb); 1498 | switch (tag >>> 3) { 1499 | case 0: 1500 | break end_of_entry; 1501 | case 1: { 1502 | key = readInt32(bb) >>> 0; 1503 | break; 1504 | } 1505 | case 2: { 1506 | value = !!readByte(bb); 1507 | break; 1508 | } 1509 | default: 1510 | skipUnknownField(bb, tag & 7); 1511 | } 1512 | } 1513 | if (key === undefined || value === undefined) 1514 | throw new Error("Invalid data for map: field_fixed32"); 1515 | values[key] = value; 1516 | bb.limit = outerLimit; 1517 | break; 1518 | } 1519 | 1520 | // optional map field_sfixed32 = 7; 1521 | case 7: { 1522 | let values = message.field_sfixed32 || (message.field_sfixed32 = {}); 1523 | let outerLimit = pushTemporaryLength(bb); 1524 | let key; 1525 | let value; 1526 | end_of_entry: while (!isAtEnd(bb)) { 1527 | let tag = readVarint32(bb); 1528 | switch (tag >>> 3) { 1529 | case 0: 1530 | break end_of_entry; 1531 | case 1: { 1532 | key = readInt32(bb); 1533 | break; 1534 | } 1535 | case 2: { 1536 | let valueLimit = pushTemporaryLength(bb); 1537 | value = _decodeNested(bb); 1538 | bb.limit = valueLimit; 1539 | break; 1540 | } 1541 | default: 1542 | skipUnknownField(bb, tag & 7); 1543 | } 1544 | } 1545 | if (key === undefined || value === undefined) 1546 | throw new Error("Invalid data for map: field_sfixed32"); 1547 | values[key] = value; 1548 | bb.limit = outerLimit; 1549 | break; 1550 | } 1551 | 1552 | default: 1553 | skipUnknownField(bb, tag & 7); 1554 | } 1555 | } 1556 | 1557 | return message; 1558 | } 1559 | 1560 | export function encodeMapTestLongAndBool(message) { 1561 | let bb = popByteBuffer(); 1562 | _encodeMapTestLongAndBool(message, bb); 1563 | return toUint8Array(bb); 1564 | } 1565 | 1566 | function _encodeMapTestLongAndBool(message, bb) { 1567 | // optional map field_int64 = 1; 1568 | let map$field_int64 = message.field_int64; 1569 | if (map$field_int64 !== undefined) { 1570 | for (let key in map$field_int64) { 1571 | let nested = popByteBuffer(); 1572 | let value = map$field_int64[key]; 1573 | writeVarint32(nested, 8); 1574 | writeVarint64(nested, stringToLong(key)); 1575 | writeVarint32(nested, 18); 1576 | writeString(nested, value); 1577 | writeVarint32(bb, 10); 1578 | writeVarint32(bb, nested.offset); 1579 | writeByteBuffer(bb, nested); 1580 | pushByteBuffer(nested); 1581 | } 1582 | } 1583 | 1584 | // optional map field_uint64 = 2; 1585 | let map$field_uint64 = message.field_uint64; 1586 | if (map$field_uint64 !== undefined) { 1587 | for (let key in map$field_uint64) { 1588 | let nested = popByteBuffer(); 1589 | let value = map$field_uint64[key]; 1590 | writeVarint32(nested, 8); 1591 | writeVarint64(nested, stringToLong(key)); 1592 | writeVarint32(nested, 18); 1593 | writeVarint32(nested, value.length), writeBytes(nested, value); 1594 | writeVarint32(bb, 18); 1595 | writeVarint32(bb, nested.offset); 1596 | writeByteBuffer(bb, nested); 1597 | pushByteBuffer(nested); 1598 | } 1599 | } 1600 | 1601 | // optional map field_sint64 = 3; 1602 | let map$field_sint64 = message.field_sint64; 1603 | if (map$field_sint64 !== undefined) { 1604 | for (let key in map$field_sint64) { 1605 | let nested = popByteBuffer(); 1606 | let value = map$field_sint64[key]; 1607 | writeVarint32(nested, 8); 1608 | writeVarint64ZigZag(nested, stringToLong(key)); 1609 | writeVarint32(nested, 16); 1610 | writeVarint64(nested, value); 1611 | writeVarint32(bb, 26); 1612 | writeVarint32(bb, nested.offset); 1613 | writeByteBuffer(bb, nested); 1614 | pushByteBuffer(nested); 1615 | } 1616 | } 1617 | 1618 | // optional map field_fixed64 = 4; 1619 | let map$field_fixed64 = message.field_fixed64; 1620 | if (map$field_fixed64 !== undefined) { 1621 | for (let key in map$field_fixed64) { 1622 | let nested = popByteBuffer(); 1623 | let value = map$field_fixed64[key]; 1624 | writeVarint32(nested, 9); 1625 | writeInt64(nested, stringToLong(key)); 1626 | writeVarint32(nested, 17); 1627 | writeDouble(nested, value); 1628 | writeVarint32(bb, 34); 1629 | writeVarint32(bb, nested.offset); 1630 | writeByteBuffer(bb, nested); 1631 | pushByteBuffer(nested); 1632 | } 1633 | } 1634 | 1635 | // optional map field_sfixed64 = 5; 1636 | let map$field_sfixed64 = message.field_sfixed64; 1637 | if (map$field_sfixed64 !== undefined) { 1638 | for (let key in map$field_sfixed64) { 1639 | let nested = popByteBuffer(); 1640 | let value = map$field_sfixed64[key]; 1641 | writeVarint32(nested, 9); 1642 | writeInt64(nested, stringToLong(key)); 1643 | writeVarint32(nested, 16); 1644 | writeByte(nested, value ? 1 : 0); 1645 | writeVarint32(bb, 42); 1646 | writeVarint32(bb, nested.offset); 1647 | writeByteBuffer(bb, nested); 1648 | pushByteBuffer(nested); 1649 | } 1650 | } 1651 | 1652 | // optional map field_bool = 6; 1653 | let map$field_bool = message.field_bool; 1654 | if (map$field_bool !== undefined) { 1655 | for (let key in map$field_bool) { 1656 | let nested = popByteBuffer(); 1657 | let value = map$field_bool[key]; 1658 | writeVarint32(nested, 8); 1659 | writeByte(nested, key === "true" ? 1 : 0); 1660 | writeVarint32(nested, 18); 1661 | let nestedValue = popByteBuffer(); 1662 | _encodeNested(value, nestedValue); 1663 | writeVarint32(nested, nestedValue.limit); 1664 | writeByteBuffer(nested, nestedValue); 1665 | pushByteBuffer(nestedValue); 1666 | writeVarint32(bb, 50); 1667 | writeVarint32(bb, nested.offset); 1668 | writeByteBuffer(bb, nested); 1669 | pushByteBuffer(nested); 1670 | } 1671 | } 1672 | } 1673 | 1674 | export function decodeMapTestLongAndBool(binary) { 1675 | return _decodeMapTestLongAndBool(wrapByteBuffer(binary)); 1676 | } 1677 | 1678 | function _decodeMapTestLongAndBool(bb) { 1679 | let message = {}; 1680 | 1681 | end_of_message: while (!isAtEnd(bb)) { 1682 | let tag = readVarint32(bb); 1683 | 1684 | switch (tag >>> 3) { 1685 | case 0: 1686 | break end_of_message; 1687 | 1688 | // optional map field_int64 = 1; 1689 | case 1: { 1690 | let values = message.field_int64 || (message.field_int64 = {}); 1691 | let outerLimit = pushTemporaryLength(bb); 1692 | let key; 1693 | let value; 1694 | end_of_entry: while (!isAtEnd(bb)) { 1695 | let tag = readVarint32(bb); 1696 | switch (tag >>> 3) { 1697 | case 0: 1698 | break end_of_entry; 1699 | case 1: { 1700 | key = readVarint64(bb, /* unsigned */ false); 1701 | break; 1702 | } 1703 | case 2: { 1704 | value = readString(bb, readVarint32(bb)); 1705 | break; 1706 | } 1707 | default: 1708 | skipUnknownField(bb, tag & 7); 1709 | } 1710 | } 1711 | if (key === undefined || value === undefined) 1712 | throw new Error("Invalid data for map: field_int64"); 1713 | values[longToString(key)] = value; 1714 | bb.limit = outerLimit; 1715 | break; 1716 | } 1717 | 1718 | // optional map field_uint64 = 2; 1719 | case 2: { 1720 | let values = message.field_uint64 || (message.field_uint64 = {}); 1721 | let outerLimit = pushTemporaryLength(bb); 1722 | let key; 1723 | let value; 1724 | end_of_entry: while (!isAtEnd(bb)) { 1725 | let tag = readVarint32(bb); 1726 | switch (tag >>> 3) { 1727 | case 0: 1728 | break end_of_entry; 1729 | case 1: { 1730 | key = readVarint64(bb, /* unsigned */ true); 1731 | break; 1732 | } 1733 | case 2: { 1734 | value = readBytes(bb, readVarint32(bb)); 1735 | break; 1736 | } 1737 | default: 1738 | skipUnknownField(bb, tag & 7); 1739 | } 1740 | } 1741 | if (key === undefined || value === undefined) 1742 | throw new Error("Invalid data for map: field_uint64"); 1743 | values[longToString(key)] = value; 1744 | bb.limit = outerLimit; 1745 | break; 1746 | } 1747 | 1748 | // optional map field_sint64 = 3; 1749 | case 3: { 1750 | let values = message.field_sint64 || (message.field_sint64 = {}); 1751 | let outerLimit = pushTemporaryLength(bb); 1752 | let key; 1753 | let value; 1754 | end_of_entry: while (!isAtEnd(bb)) { 1755 | let tag = readVarint32(bb); 1756 | switch (tag >>> 3) { 1757 | case 0: 1758 | break end_of_entry; 1759 | case 1: { 1760 | key = readVarint64ZigZag(bb); 1761 | break; 1762 | } 1763 | case 2: { 1764 | value = readVarint64(bb, /* unsigned */ false); 1765 | break; 1766 | } 1767 | default: 1768 | skipUnknownField(bb, tag & 7); 1769 | } 1770 | } 1771 | if (key === undefined || value === undefined) 1772 | throw new Error("Invalid data for map: field_sint64"); 1773 | values[longToString(key)] = value; 1774 | bb.limit = outerLimit; 1775 | break; 1776 | } 1777 | 1778 | // optional map field_fixed64 = 4; 1779 | case 4: { 1780 | let values = message.field_fixed64 || (message.field_fixed64 = {}); 1781 | let outerLimit = pushTemporaryLength(bb); 1782 | let key; 1783 | let value; 1784 | end_of_entry: while (!isAtEnd(bb)) { 1785 | let tag = readVarint32(bb); 1786 | switch (tag >>> 3) { 1787 | case 0: 1788 | break end_of_entry; 1789 | case 1: { 1790 | key = readInt64(bb, /* unsigned */ true); 1791 | break; 1792 | } 1793 | case 2: { 1794 | value = readDouble(bb); 1795 | break; 1796 | } 1797 | default: 1798 | skipUnknownField(bb, tag & 7); 1799 | } 1800 | } 1801 | if (key === undefined || value === undefined) 1802 | throw new Error("Invalid data for map: field_fixed64"); 1803 | values[longToString(key)] = value; 1804 | bb.limit = outerLimit; 1805 | break; 1806 | } 1807 | 1808 | // optional map field_sfixed64 = 5; 1809 | case 5: { 1810 | let values = message.field_sfixed64 || (message.field_sfixed64 = {}); 1811 | let outerLimit = pushTemporaryLength(bb); 1812 | let key; 1813 | let value; 1814 | end_of_entry: while (!isAtEnd(bb)) { 1815 | let tag = readVarint32(bb); 1816 | switch (tag >>> 3) { 1817 | case 0: 1818 | break end_of_entry; 1819 | case 1: { 1820 | key = readInt64(bb, /* unsigned */ false); 1821 | break; 1822 | } 1823 | case 2: { 1824 | value = !!readByte(bb); 1825 | break; 1826 | } 1827 | default: 1828 | skipUnknownField(bb, tag & 7); 1829 | } 1830 | } 1831 | if (key === undefined || value === undefined) 1832 | throw new Error("Invalid data for map: field_sfixed64"); 1833 | values[longToString(key)] = value; 1834 | bb.limit = outerLimit; 1835 | break; 1836 | } 1837 | 1838 | // optional map field_bool = 6; 1839 | case 6: { 1840 | let values = message.field_bool || (message.field_bool = {}); 1841 | let outerLimit = pushTemporaryLength(bb); 1842 | let key; 1843 | let value; 1844 | end_of_entry: while (!isAtEnd(bb)) { 1845 | let tag = readVarint32(bb); 1846 | switch (tag >>> 3) { 1847 | case 0: 1848 | break end_of_entry; 1849 | case 1: { 1850 | key = !!readByte(bb); 1851 | break; 1852 | } 1853 | case 2: { 1854 | let valueLimit = pushTemporaryLength(bb); 1855 | value = _decodeNested(bb); 1856 | bb.limit = valueLimit; 1857 | break; 1858 | } 1859 | default: 1860 | skipUnknownField(bb, tag & 7); 1861 | } 1862 | } 1863 | if (key === undefined || value === undefined) 1864 | throw new Error("Invalid data for map: field_bool"); 1865 | values[key + ''] = value; 1866 | bb.limit = outerLimit; 1867 | break; 1868 | } 1869 | 1870 | default: 1871 | skipUnknownField(bb, tag & 7); 1872 | } 1873 | } 1874 | 1875 | return message; 1876 | } 1877 | 1878 | function pushTemporaryLength(bb) { 1879 | let length = readVarint32(bb); 1880 | let limit = bb.limit; 1881 | bb.limit = bb.offset + length; 1882 | return limit; 1883 | } 1884 | 1885 | function skipUnknownField(bb, type) { 1886 | switch (type) { 1887 | case 0: while (readByte(bb) & 0x80) { } break; 1888 | case 2: skip(bb, readVarint32(bb)); break; 1889 | case 5: skip(bb, 4); break; 1890 | case 1: skip(bb, 8); break; 1891 | default: throw new Error("Unimplemented type: " + type); 1892 | } 1893 | } 1894 | 1895 | function stringToLong(value) { 1896 | return { 1897 | low: value.charCodeAt(0) | (value.charCodeAt(1) << 16), 1898 | high: value.charCodeAt(2) | (value.charCodeAt(3) << 16), 1899 | unsigned: false, 1900 | }; 1901 | } 1902 | 1903 | function longToString(value) { 1904 | let low = value.low; 1905 | let high = value.high; 1906 | return String.fromCharCode( 1907 | low & 0xFFFF, 1908 | low >>> 16, 1909 | high & 0xFFFF, 1910 | high >>> 16); 1911 | } 1912 | 1913 | // The code below was modified from https://github.com/protobufjs/bytebuffer.js 1914 | // which is under the Apache License 2.0. 1915 | 1916 | let f32 = new Float32Array(1); 1917 | let f32_u8 = new Uint8Array(f32.buffer); 1918 | 1919 | let f64 = new Float64Array(1); 1920 | let f64_u8 = new Uint8Array(f64.buffer); 1921 | 1922 | function intToLong(value) { 1923 | value |= 0; 1924 | return { 1925 | low: value, 1926 | high: value >> 31, 1927 | unsigned: value >= 0, 1928 | }; 1929 | } 1930 | 1931 | let bbStack = []; 1932 | 1933 | function popByteBuffer() { 1934 | const bb = bbStack.pop(); 1935 | if (!bb) return { bytes: new Uint8Array(64), offset: 0, limit: 0 }; 1936 | bb.offset = bb.limit = 0; 1937 | return bb; 1938 | } 1939 | 1940 | function pushByteBuffer(bb) { 1941 | bbStack.push(bb); 1942 | } 1943 | 1944 | function wrapByteBuffer(bytes) { 1945 | return { bytes, offset: 0, limit: bytes.length }; 1946 | } 1947 | 1948 | function toUint8Array(bb) { 1949 | let bytes = bb.bytes; 1950 | let limit = bb.limit; 1951 | return bytes.length === limit ? bytes : bytes.subarray(0, limit); 1952 | } 1953 | 1954 | function skip(bb, offset) { 1955 | if (bb.offset + offset > bb.limit) { 1956 | throw new Error('Skip past limit'); 1957 | } 1958 | bb.offset += offset; 1959 | } 1960 | 1961 | function isAtEnd(bb) { 1962 | return bb.offset >= bb.limit; 1963 | } 1964 | 1965 | function grow(bb, count) { 1966 | let bytes = bb.bytes; 1967 | let offset = bb.offset; 1968 | let limit = bb.limit; 1969 | let finalOffset = offset + count; 1970 | if (finalOffset > bytes.length) { 1971 | let newBytes = new Uint8Array(finalOffset * 2); 1972 | newBytes.set(bytes); 1973 | bb.bytes = newBytes; 1974 | } 1975 | bb.offset = finalOffset; 1976 | if (finalOffset > limit) { 1977 | bb.limit = finalOffset; 1978 | } 1979 | return offset; 1980 | } 1981 | 1982 | function advance(bb, count) { 1983 | let offset = bb.offset; 1984 | if (offset + count > bb.limit) { 1985 | throw new Error('Read past limit'); 1986 | } 1987 | bb.offset += count; 1988 | return offset; 1989 | } 1990 | 1991 | function readBytes(bb, count) { 1992 | let offset = advance(bb, count); 1993 | return bb.bytes.subarray(offset, offset + count); 1994 | } 1995 | 1996 | function writeBytes(bb, buffer) { 1997 | let offset = grow(bb, buffer.length); 1998 | bb.bytes.set(buffer, offset); 1999 | } 2000 | 2001 | function readString(bb, count) { 2002 | // Sadly a hand-coded UTF8 decoder is much faster than subarray+TextDecoder in V8 2003 | let offset = advance(bb, count); 2004 | let fromCharCode = String.fromCharCode; 2005 | let bytes = bb.bytes; 2006 | let invalid = '\uFFFD'; 2007 | let text = ''; 2008 | 2009 | for (let i = 0; i < count; i++) { 2010 | let c1 = bytes[i + offset], c2, c3, c4, c; 2011 | 2012 | // 1 byte 2013 | if ((c1 & 0x80) === 0) { 2014 | text += fromCharCode(c1); 2015 | } 2016 | 2017 | // 2 bytes 2018 | else if ((c1 & 0xE0) === 0xC0) { 2019 | if (i + 1 >= count) text += invalid; 2020 | else { 2021 | c2 = bytes[i + offset + 1]; 2022 | if ((c2 & 0xC0) !== 0x80) text += invalid; 2023 | else { 2024 | c = ((c1 & 0x1F) << 6) | (c2 & 0x3F); 2025 | if (c < 0x80) text += invalid; 2026 | else { 2027 | text += fromCharCode(c); 2028 | i++; 2029 | } 2030 | } 2031 | } 2032 | } 2033 | 2034 | // 3 bytes 2035 | else if ((c1 & 0xF0) == 0xE0) { 2036 | if (i + 2 >= count) text += invalid; 2037 | else { 2038 | c2 = bytes[i + offset + 1]; 2039 | c3 = bytes[i + offset + 2]; 2040 | if (((c2 | (c3 << 8)) & 0xC0C0) !== 0x8080) text += invalid; 2041 | else { 2042 | c = ((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F); 2043 | if (c < 0x0800 || (c >= 0xD800 && c <= 0xDFFF)) text += invalid; 2044 | else { 2045 | text += fromCharCode(c); 2046 | i += 2; 2047 | } 2048 | } 2049 | } 2050 | } 2051 | 2052 | // 4 bytes 2053 | else if ((c1 & 0xF8) == 0xF0) { 2054 | if (i + 3 >= count) text += invalid; 2055 | else { 2056 | c2 = bytes[i + offset + 1]; 2057 | c3 = bytes[i + offset + 2]; 2058 | c4 = bytes[i + offset + 3]; 2059 | if (((c2 | (c3 << 8) | (c4 << 16)) & 0xC0C0C0) !== 0x808080) text += invalid; 2060 | else { 2061 | c = ((c1 & 0x07) << 0x12) | ((c2 & 0x3F) << 0x0C) | ((c3 & 0x3F) << 0x06) | (c4 & 0x3F); 2062 | if (c < 0x10000 || c > 0x10FFFF) text += invalid; 2063 | else { 2064 | c -= 0x10000; 2065 | text += fromCharCode((c >> 10) + 0xD800, (c & 0x3FF) + 0xDC00); 2066 | i += 3; 2067 | } 2068 | } 2069 | } 2070 | } 2071 | 2072 | else text += invalid; 2073 | } 2074 | 2075 | return text; 2076 | } 2077 | 2078 | function writeString(bb, text) { 2079 | // Sadly a hand-coded UTF8 encoder is much faster than TextEncoder+set in V8 2080 | let n = text.length; 2081 | let byteCount = 0; 2082 | 2083 | // Write the byte count first 2084 | for (let i = 0; i < n; i++) { 2085 | let c = text.charCodeAt(i); 2086 | if (c >= 0xD800 && c <= 0xDBFF && i + 1 < n) { 2087 | c = (c << 10) + text.charCodeAt(++i) - 0x35FDC00; 2088 | } 2089 | byteCount += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4; 2090 | } 2091 | writeVarint32(bb, byteCount); 2092 | 2093 | let offset = grow(bb, byteCount); 2094 | let bytes = bb.bytes; 2095 | 2096 | // Then write the bytes 2097 | for (let i = 0; i < n; i++) { 2098 | let c = text.charCodeAt(i); 2099 | if (c >= 0xD800 && c <= 0xDBFF && i + 1 < n) { 2100 | c = (c << 10) + text.charCodeAt(++i) - 0x35FDC00; 2101 | } 2102 | if (c < 0x80) { 2103 | bytes[offset++] = c; 2104 | } else { 2105 | if (c < 0x800) { 2106 | bytes[offset++] = ((c >> 6) & 0x1F) | 0xC0; 2107 | } else { 2108 | if (c < 0x10000) { 2109 | bytes[offset++] = ((c >> 12) & 0x0F) | 0xE0; 2110 | } else { 2111 | bytes[offset++] = ((c >> 18) & 0x07) | 0xF0; 2112 | bytes[offset++] = ((c >> 12) & 0x3F) | 0x80; 2113 | } 2114 | bytes[offset++] = ((c >> 6) & 0x3F) | 0x80; 2115 | } 2116 | bytes[offset++] = (c & 0x3F) | 0x80; 2117 | } 2118 | } 2119 | } 2120 | 2121 | function writeByteBuffer(bb, buffer) { 2122 | let offset = grow(bb, buffer.limit); 2123 | let from = bb.bytes; 2124 | let to = buffer.bytes; 2125 | 2126 | // This for loop is much faster than subarray+set on V8 2127 | for (let i = 0, n = buffer.limit; i < n; i++) { 2128 | from[i + offset] = to[i]; 2129 | } 2130 | } 2131 | 2132 | function readByte(bb) { 2133 | return bb.bytes[advance(bb, 1)]; 2134 | } 2135 | 2136 | function writeByte(bb, value) { 2137 | let offset = grow(bb, 1); 2138 | bb.bytes[offset] = value; 2139 | } 2140 | 2141 | function readFloat(bb) { 2142 | let offset = advance(bb, 4); 2143 | let bytes = bb.bytes; 2144 | 2145 | // Manual copying is much faster than subarray+set in V8 2146 | f32_u8[0] = bytes[offset++]; 2147 | f32_u8[1] = bytes[offset++]; 2148 | f32_u8[2] = bytes[offset++]; 2149 | f32_u8[3] = bytes[offset++]; 2150 | return f32[0]; 2151 | } 2152 | 2153 | function writeFloat(bb, value) { 2154 | let offset = grow(bb, 4); 2155 | let bytes = bb.bytes; 2156 | f32[0] = value; 2157 | 2158 | // Manual copying is much faster than subarray+set in V8 2159 | bytes[offset++] = f32_u8[0]; 2160 | bytes[offset++] = f32_u8[1]; 2161 | bytes[offset++] = f32_u8[2]; 2162 | bytes[offset++] = f32_u8[3]; 2163 | } 2164 | 2165 | function readDouble(bb) { 2166 | let offset = advance(bb, 8); 2167 | let bytes = bb.bytes; 2168 | 2169 | // Manual copying is much faster than subarray+set in V8 2170 | f64_u8[0] = bytes[offset++]; 2171 | f64_u8[1] = bytes[offset++]; 2172 | f64_u8[2] = bytes[offset++]; 2173 | f64_u8[3] = bytes[offset++]; 2174 | f64_u8[4] = bytes[offset++]; 2175 | f64_u8[5] = bytes[offset++]; 2176 | f64_u8[6] = bytes[offset++]; 2177 | f64_u8[7] = bytes[offset++]; 2178 | return f64[0]; 2179 | } 2180 | 2181 | function writeDouble(bb, value) { 2182 | let offset = grow(bb, 8); 2183 | let bytes = bb.bytes; 2184 | f64[0] = value; 2185 | 2186 | // Manual copying is much faster than subarray+set in V8 2187 | bytes[offset++] = f64_u8[0]; 2188 | bytes[offset++] = f64_u8[1]; 2189 | bytes[offset++] = f64_u8[2]; 2190 | bytes[offset++] = f64_u8[3]; 2191 | bytes[offset++] = f64_u8[4]; 2192 | bytes[offset++] = f64_u8[5]; 2193 | bytes[offset++] = f64_u8[6]; 2194 | bytes[offset++] = f64_u8[7]; 2195 | } 2196 | 2197 | function readInt32(bb) { 2198 | let offset = advance(bb, 4); 2199 | let bytes = bb.bytes; 2200 | return ( 2201 | bytes[offset] | 2202 | (bytes[offset + 1] << 8) | 2203 | (bytes[offset + 2] << 16) | 2204 | (bytes[offset + 3] << 24) 2205 | ); 2206 | } 2207 | 2208 | function writeInt32(bb, value) { 2209 | let offset = grow(bb, 4); 2210 | let bytes = bb.bytes; 2211 | bytes[offset] = value; 2212 | bytes[offset + 1] = value >> 8; 2213 | bytes[offset + 2] = value >> 16; 2214 | bytes[offset + 3] = value >> 24; 2215 | } 2216 | 2217 | function readInt64(bb, unsigned) { 2218 | return { 2219 | low: readInt32(bb), 2220 | high: readInt32(bb), 2221 | unsigned, 2222 | }; 2223 | } 2224 | 2225 | function writeInt64(bb, value) { 2226 | writeInt32(bb, value.low); 2227 | writeInt32(bb, value.high); 2228 | } 2229 | 2230 | function readVarint32(bb) { 2231 | let c = 0; 2232 | let value = 0; 2233 | let b; 2234 | do { 2235 | b = readByte(bb); 2236 | if (c < 32) value |= (b & 0x7F) << c; 2237 | c += 7; 2238 | } while (b & 0x80); 2239 | return value; 2240 | } 2241 | 2242 | function writeVarint32(bb, value) { 2243 | value >>>= 0; 2244 | while (value >= 0x80) { 2245 | writeByte(bb, (value & 0x7f) | 0x80); 2246 | value >>>= 7; 2247 | } 2248 | writeByte(bb, value); 2249 | } 2250 | 2251 | function readVarint64(bb, unsigned) { 2252 | let part0 = 0; 2253 | let part1 = 0; 2254 | let part2 = 0; 2255 | let b; 2256 | 2257 | b = readByte(bb); part0 = (b & 0x7F); if (b & 0x80) { 2258 | b = readByte(bb); part0 |= (b & 0x7F) << 7; if (b & 0x80) { 2259 | b = readByte(bb); part0 |= (b & 0x7F) << 14; if (b & 0x80) { 2260 | b = readByte(bb); part0 |= (b & 0x7F) << 21; if (b & 0x80) { 2261 | 2262 | b = readByte(bb); part1 = (b & 0x7F); if (b & 0x80) { 2263 | b = readByte(bb); part1 |= (b & 0x7F) << 7; if (b & 0x80) { 2264 | b = readByte(bb); part1 |= (b & 0x7F) << 14; if (b & 0x80) { 2265 | b = readByte(bb); part1 |= (b & 0x7F) << 21; if (b & 0x80) { 2266 | 2267 | b = readByte(bb); part2 = (b & 0x7F); if (b & 0x80) { 2268 | b = readByte(bb); part2 |= (b & 0x7F) << 7; 2269 | } 2270 | } 2271 | } 2272 | } 2273 | } 2274 | } 2275 | } 2276 | } 2277 | } 2278 | 2279 | return { 2280 | low: part0 | (part1 << 28), 2281 | high: (part1 >>> 4) | (part2 << 24), 2282 | unsigned, 2283 | }; 2284 | } 2285 | 2286 | function writeVarint64(bb, value) { 2287 | let part0 = value.low >>> 0; 2288 | let part1 = ((value.low >>> 28) | (value.high << 4)) >>> 0; 2289 | let part2 = value.high >>> 24; 2290 | 2291 | // ref: src/google/protobuf/io/coded_stream.cc 2292 | let size = 2293 | part2 === 0 ? 2294 | part1 === 0 ? 2295 | part0 < 1 << 14 ? 2296 | part0 < 1 << 7 ? 1 : 2 : 2297 | part0 < 1 << 21 ? 3 : 4 : 2298 | part1 < 1 << 14 ? 2299 | part1 < 1 << 7 ? 5 : 6 : 2300 | part1 < 1 << 21 ? 7 : 8 : 2301 | part2 < 1 << 7 ? 9 : 10; 2302 | 2303 | let offset = grow(bb, size); 2304 | let bytes = bb.bytes; 2305 | 2306 | switch (size) { 2307 | case 10: bytes[offset + 9] = (part2 >>> 7) & 0x01; 2308 | case 9: bytes[offset + 8] = size !== 9 ? part2 | 0x80 : part2 & 0x7F; 2309 | case 8: bytes[offset + 7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F; 2310 | case 7: bytes[offset + 6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F; 2311 | case 6: bytes[offset + 5] = size !== 6 ? (part1 >>> 7) | 0x80 : (part1 >>> 7) & 0x7F; 2312 | case 5: bytes[offset + 4] = size !== 5 ? part1 | 0x80 : part1 & 0x7F; 2313 | case 4: bytes[offset + 3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F; 2314 | case 3: bytes[offset + 2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F; 2315 | case 2: bytes[offset + 1] = size !== 2 ? (part0 >>> 7) | 0x80 : (part0 >>> 7) & 0x7F; 2316 | case 1: bytes[offset] = size !== 1 ? part0 | 0x80 : part0 & 0x7F; 2317 | } 2318 | } 2319 | 2320 | function readVarint32ZigZag(bb) { 2321 | let value = readVarint32(bb); 2322 | 2323 | // ref: src/google/protobuf/wire_format_lite.h 2324 | return (value >>> 1) ^ -(value & 1); 2325 | } 2326 | 2327 | function writeVarint32ZigZag(bb, value) { 2328 | // ref: src/google/protobuf/wire_format_lite.h 2329 | writeVarint32(bb, (value << 1) ^ (value >> 31)); 2330 | } 2331 | 2332 | function readVarint64ZigZag(bb) { 2333 | let value = readVarint64(bb, /* unsigned */ false); 2334 | let low = value.low; 2335 | let high = value.high; 2336 | let flip = -(low & 1); 2337 | 2338 | // ref: src/google/protobuf/wire_format_lite.h 2339 | return { 2340 | low: ((low >>> 1) | (high << 31)) ^ flip, 2341 | high: (high >>> 1) ^ flip, 2342 | unsigned: false, 2343 | }; 2344 | } 2345 | 2346 | function writeVarint64ZigZag(bb, value) { 2347 | let low = value.low; 2348 | let high = value.high; 2349 | let flip = high >> 31; 2350 | 2351 | // ref: src/google/protobuf/wire_format_lite.h 2352 | writeVarint64(bb, { 2353 | low: (low << 1) ^ flip, 2354 | high: ((high << 1) | (low >>> 31)) ^ flip, 2355 | unsigned: false, 2356 | }); 2357 | } 2358 | -------------------------------------------------------------------------------- /test.proto.es5.js: -------------------------------------------------------------------------------- 1 | exports.encodeEnum = { 2 | A: 0, 3 | B: 1, 4 | }; 5 | 6 | exports.decodeEnum = { 7 | 0: "A", 8 | 1: "B", 9 | }; 10 | 11 | exports.encodeNested = function (message) { 12 | var bb = popByteBuffer(); 13 | _encodeNested(message, bb); 14 | return toUint8Array(bb); 15 | } 16 | 17 | function _encodeNested(message, bb) { 18 | // optional float x = 1; 19 | var $x = message.x; 20 | if ($x !== undefined) { 21 | writeVarint32(bb, 13); 22 | writeFloat(bb, $x); 23 | } 24 | 25 | // optional float y = 2; 26 | var $y = message.y; 27 | if ($y !== undefined) { 28 | writeVarint32(bb, 21); 29 | writeFloat(bb, $y); 30 | } 31 | }; 32 | 33 | exports.decodeNested = function (binary) { 34 | return _decodeNested(wrapByteBuffer(binary)); 35 | } 36 | 37 | function _decodeNested(bb) { 38 | var message = {}; 39 | 40 | end_of_message: while (!isAtEnd(bb)) { 41 | var tag = readVarint32(bb); 42 | 43 | switch (tag >>> 3) { 44 | case 0: 45 | break end_of_message; 46 | 47 | // optional float x = 1; 48 | case 1: { 49 | message.x = readFloat(bb); 50 | break; 51 | } 52 | 53 | // optional float y = 2; 54 | case 2: { 55 | message.y = readFloat(bb); 56 | break; 57 | } 58 | 59 | default: 60 | skipUnknownField(bb, tag & 7); 61 | } 62 | } 63 | 64 | return message; 65 | }; 66 | 67 | exports.encodeOptional = function (message) { 68 | var bb = popByteBuffer(); 69 | _encodeOptional(message, bb); 70 | return toUint8Array(bb); 71 | } 72 | 73 | function _encodeOptional(message, bb) { 74 | // optional int32 field_int32 = 1; 75 | var $field_int32 = message.field_int32; 76 | if ($field_int32 !== undefined) { 77 | writeVarint32(bb, 8); 78 | writeVarint64(bb, intToLong($field_int32)); 79 | } 80 | 81 | // optional int64 field_int64 = 2; 82 | var $field_int64 = message.field_int64; 83 | if ($field_int64 !== undefined) { 84 | writeVarint32(bb, 16); 85 | writeVarint64(bb, $field_int64); 86 | } 87 | 88 | // optional uint32 field_uint32 = 3; 89 | var $field_uint32 = message.field_uint32; 90 | if ($field_uint32 !== undefined) { 91 | writeVarint32(bb, 24); 92 | writeVarint32(bb, $field_uint32); 93 | } 94 | 95 | // optional uint64 field_uint64 = 4; 96 | var $field_uint64 = message.field_uint64; 97 | if ($field_uint64 !== undefined) { 98 | writeVarint32(bb, 32); 99 | writeVarint64(bb, $field_uint64); 100 | } 101 | 102 | // optional sint32 field_sint32 = 5; 103 | var $field_sint32 = message.field_sint32; 104 | if ($field_sint32 !== undefined) { 105 | writeVarint32(bb, 40); 106 | writeVarint32ZigZag(bb, $field_sint32); 107 | } 108 | 109 | // optional sint64 field_sint64 = 6; 110 | var $field_sint64 = message.field_sint64; 111 | if ($field_sint64 !== undefined) { 112 | writeVarint32(bb, 48); 113 | writeVarint64ZigZag(bb, $field_sint64); 114 | } 115 | 116 | // optional bool field_bool = 7; 117 | var $field_bool = message.field_bool; 118 | if ($field_bool !== undefined) { 119 | writeVarint32(bb, 56); 120 | writeByte(bb, $field_bool ? 1 : 0); 121 | } 122 | 123 | // optional fixed64 field_fixed64 = 8; 124 | var $field_fixed64 = message.field_fixed64; 125 | if ($field_fixed64 !== undefined) { 126 | writeVarint32(bb, 65); 127 | writeInt64(bb, $field_fixed64); 128 | } 129 | 130 | // optional sfixed64 field_sfixed64 = 9; 131 | var $field_sfixed64 = message.field_sfixed64; 132 | if ($field_sfixed64 !== undefined) { 133 | writeVarint32(bb, 73); 134 | writeInt64(bb, $field_sfixed64); 135 | } 136 | 137 | // optional double field_double = 10; 138 | var $field_double = message.field_double; 139 | if ($field_double !== undefined) { 140 | writeVarint32(bb, 81); 141 | writeDouble(bb, $field_double); 142 | } 143 | 144 | // optional string field_string = 11; 145 | var $field_string = message.field_string; 146 | if ($field_string !== undefined) { 147 | writeVarint32(bb, 90); 148 | writeString(bb, $field_string); 149 | } 150 | 151 | // optional bytes field_bytes = 12; 152 | var $field_bytes = message.field_bytes; 153 | if ($field_bytes !== undefined) { 154 | writeVarint32(bb, 98); 155 | writeVarint32(bb, $field_bytes.length), writeBytes(bb, $field_bytes); 156 | } 157 | 158 | // optional fixed32 field_fixed32 = 13; 159 | var $field_fixed32 = message.field_fixed32; 160 | if ($field_fixed32 !== undefined) { 161 | writeVarint32(bb, 109); 162 | writeInt32(bb, $field_fixed32); 163 | } 164 | 165 | // optional sfixed32 field_sfixed32 = 14; 166 | var $field_sfixed32 = message.field_sfixed32; 167 | if ($field_sfixed32 !== undefined) { 168 | writeVarint32(bb, 117); 169 | writeInt32(bb, $field_sfixed32); 170 | } 171 | 172 | // optional float field_float = 15; 173 | var $field_float = message.field_float; 174 | if ($field_float !== undefined) { 175 | writeVarint32(bb, 125); 176 | writeFloat(bb, $field_float); 177 | } 178 | 179 | // optional Nested field_nested = 16; 180 | var $field_nested = message.field_nested; 181 | if ($field_nested !== undefined) { 182 | writeVarint32(bb, 130); 183 | var nested = popByteBuffer(); 184 | _encodeNested($field_nested, nested); 185 | writeVarint32(bb, nested.limit); 186 | writeByteBuffer(bb, nested); 187 | pushByteBuffer(nested); 188 | } 189 | }; 190 | 191 | exports.decodeOptional = function (binary) { 192 | return _decodeOptional(wrapByteBuffer(binary)); 193 | } 194 | 195 | function _decodeOptional(bb) { 196 | var message = {}; 197 | 198 | end_of_message: while (!isAtEnd(bb)) { 199 | var tag = readVarint32(bb); 200 | 201 | switch (tag >>> 3) { 202 | case 0: 203 | break end_of_message; 204 | 205 | // optional int32 field_int32 = 1; 206 | case 1: { 207 | message.field_int32 = readVarint32(bb); 208 | break; 209 | } 210 | 211 | // optional int64 field_int64 = 2; 212 | case 2: { 213 | message.field_int64 = readVarint64(bb, /* unsigned */ false); 214 | break; 215 | } 216 | 217 | // optional uint32 field_uint32 = 3; 218 | case 3: { 219 | message.field_uint32 = readVarint32(bb) >>> 0; 220 | break; 221 | } 222 | 223 | // optional uint64 field_uint64 = 4; 224 | case 4: { 225 | message.field_uint64 = readVarint64(bb, /* unsigned */ true); 226 | break; 227 | } 228 | 229 | // optional sint32 field_sint32 = 5; 230 | case 5: { 231 | message.field_sint32 = readVarint32ZigZag(bb); 232 | break; 233 | } 234 | 235 | // optional sint64 field_sint64 = 6; 236 | case 6: { 237 | message.field_sint64 = readVarint64ZigZag(bb); 238 | break; 239 | } 240 | 241 | // optional bool field_bool = 7; 242 | case 7: { 243 | message.field_bool = !!readByte(bb); 244 | break; 245 | } 246 | 247 | // optional fixed64 field_fixed64 = 8; 248 | case 8: { 249 | message.field_fixed64 = readInt64(bb, /* unsigned */ true); 250 | break; 251 | } 252 | 253 | // optional sfixed64 field_sfixed64 = 9; 254 | case 9: { 255 | message.field_sfixed64 = readInt64(bb, /* unsigned */ false); 256 | break; 257 | } 258 | 259 | // optional double field_double = 10; 260 | case 10: { 261 | message.field_double = readDouble(bb); 262 | break; 263 | } 264 | 265 | // optional string field_string = 11; 266 | case 11: { 267 | message.field_string = readString(bb, readVarint32(bb)); 268 | break; 269 | } 270 | 271 | // optional bytes field_bytes = 12; 272 | case 12: { 273 | message.field_bytes = readBytes(bb, readVarint32(bb)); 274 | break; 275 | } 276 | 277 | // optional fixed32 field_fixed32 = 13; 278 | case 13: { 279 | message.field_fixed32 = readInt32(bb) >>> 0; 280 | break; 281 | } 282 | 283 | // optional sfixed32 field_sfixed32 = 14; 284 | case 14: { 285 | message.field_sfixed32 = readInt32(bb); 286 | break; 287 | } 288 | 289 | // optional float field_float = 15; 290 | case 15: { 291 | message.field_float = readFloat(bb); 292 | break; 293 | } 294 | 295 | // optional Nested field_nested = 16; 296 | case 16: { 297 | var limit = pushTemporaryLength(bb); 298 | message.field_nested = _decodeNested(bb); 299 | bb.limit = limit; 300 | break; 301 | } 302 | 303 | default: 304 | skipUnknownField(bb, tag & 7); 305 | } 306 | } 307 | 308 | return message; 309 | }; 310 | 311 | exports.encodeRepeatedUnpacked = function (message) { 312 | var bb = popByteBuffer(); 313 | _encodeRepeatedUnpacked(message, bb); 314 | return toUint8Array(bb); 315 | } 316 | 317 | function _encodeRepeatedUnpacked(message, bb) { 318 | // repeated int32 field_int32 = 1; 319 | var array$field_int32 = message.field_int32; 320 | if (array$field_int32 !== undefined) { 321 | for (var i = 0; i < array$field_int32.length; i++) { 322 | var value = array$field_int32[i]; 323 | writeVarint32(bb, 8); 324 | writeVarint64(bb, intToLong(value)); 325 | } 326 | } 327 | 328 | // repeated int64 field_int64 = 2; 329 | var array$field_int64 = message.field_int64; 330 | if (array$field_int64 !== undefined) { 331 | for (var i = 0; i < array$field_int64.length; i++) { 332 | var value = array$field_int64[i]; 333 | writeVarint32(bb, 16); 334 | writeVarint64(bb, value); 335 | } 336 | } 337 | 338 | // repeated uint32 field_uint32 = 3; 339 | var array$field_uint32 = message.field_uint32; 340 | if (array$field_uint32 !== undefined) { 341 | for (var i = 0; i < array$field_uint32.length; i++) { 342 | var value = array$field_uint32[i]; 343 | writeVarint32(bb, 24); 344 | writeVarint32(bb, value); 345 | } 346 | } 347 | 348 | // repeated uint64 field_uint64 = 4; 349 | var array$field_uint64 = message.field_uint64; 350 | if (array$field_uint64 !== undefined) { 351 | for (var i = 0; i < array$field_uint64.length; i++) { 352 | var value = array$field_uint64[i]; 353 | writeVarint32(bb, 32); 354 | writeVarint64(bb, value); 355 | } 356 | } 357 | 358 | // repeated sint32 field_sint32 = 5; 359 | var array$field_sint32 = message.field_sint32; 360 | if (array$field_sint32 !== undefined) { 361 | for (var i = 0; i < array$field_sint32.length; i++) { 362 | var value = array$field_sint32[i]; 363 | writeVarint32(bb, 40); 364 | writeVarint32ZigZag(bb, value); 365 | } 366 | } 367 | 368 | // repeated sint64 field_sint64 = 6; 369 | var array$field_sint64 = message.field_sint64; 370 | if (array$field_sint64 !== undefined) { 371 | for (var i = 0; i < array$field_sint64.length; i++) { 372 | var value = array$field_sint64[i]; 373 | writeVarint32(bb, 48); 374 | writeVarint64ZigZag(bb, value); 375 | } 376 | } 377 | 378 | // repeated bool field_bool = 7; 379 | var array$field_bool = message.field_bool; 380 | if (array$field_bool !== undefined) { 381 | for (var i = 0; i < array$field_bool.length; i++) { 382 | var value = array$field_bool[i]; 383 | writeVarint32(bb, 56); 384 | writeByte(bb, value ? 1 : 0); 385 | } 386 | } 387 | 388 | // repeated fixed64 field_fixed64 = 8; 389 | var array$field_fixed64 = message.field_fixed64; 390 | if (array$field_fixed64 !== undefined) { 391 | for (var i = 0; i < array$field_fixed64.length; i++) { 392 | var value = array$field_fixed64[i]; 393 | writeVarint32(bb, 65); 394 | writeInt64(bb, value); 395 | } 396 | } 397 | 398 | // repeated sfixed64 field_sfixed64 = 9; 399 | var array$field_sfixed64 = message.field_sfixed64; 400 | if (array$field_sfixed64 !== undefined) { 401 | for (var i = 0; i < array$field_sfixed64.length; i++) { 402 | var value = array$field_sfixed64[i]; 403 | writeVarint32(bb, 73); 404 | writeInt64(bb, value); 405 | } 406 | } 407 | 408 | // repeated double field_double = 10; 409 | var array$field_double = message.field_double; 410 | if (array$field_double !== undefined) { 411 | for (var i = 0; i < array$field_double.length; i++) { 412 | var value = array$field_double[i]; 413 | writeVarint32(bb, 81); 414 | writeDouble(bb, value); 415 | } 416 | } 417 | 418 | // repeated string field_string = 11; 419 | var array$field_string = message.field_string; 420 | if (array$field_string !== undefined) { 421 | for (var i = 0; i < array$field_string.length; i++) { 422 | var value = array$field_string[i]; 423 | writeVarint32(bb, 90); 424 | writeString(bb, value); 425 | } 426 | } 427 | 428 | // repeated bytes field_bytes = 12; 429 | var array$field_bytes = message.field_bytes; 430 | if (array$field_bytes !== undefined) { 431 | for (var i = 0; i < array$field_bytes.length; i++) { 432 | var value = array$field_bytes[i]; 433 | writeVarint32(bb, 98); 434 | writeVarint32(bb, value.length), writeBytes(bb, value); 435 | } 436 | } 437 | 438 | // repeated fixed32 field_fixed32 = 13; 439 | var array$field_fixed32 = message.field_fixed32; 440 | if (array$field_fixed32 !== undefined) { 441 | for (var i = 0; i < array$field_fixed32.length; i++) { 442 | var value = array$field_fixed32[i]; 443 | writeVarint32(bb, 109); 444 | writeInt32(bb, value); 445 | } 446 | } 447 | 448 | // repeated sfixed32 field_sfixed32 = 14; 449 | var array$field_sfixed32 = message.field_sfixed32; 450 | if (array$field_sfixed32 !== undefined) { 451 | for (var i = 0; i < array$field_sfixed32.length; i++) { 452 | var value = array$field_sfixed32[i]; 453 | writeVarint32(bb, 117); 454 | writeInt32(bb, value); 455 | } 456 | } 457 | 458 | // repeated float field_float = 15; 459 | var array$field_float = message.field_float; 460 | if (array$field_float !== undefined) { 461 | for (var i = 0; i < array$field_float.length; i++) { 462 | var value = array$field_float[i]; 463 | writeVarint32(bb, 125); 464 | writeFloat(bb, value); 465 | } 466 | } 467 | 468 | // repeated Nested field_nested = 16; 469 | var array$field_nested = message.field_nested; 470 | if (array$field_nested !== undefined) { 471 | for (var i = 0; i < array$field_nested.length; i++) { 472 | var value = array$field_nested[i]; 473 | writeVarint32(bb, 130); 474 | var nested = popByteBuffer(); 475 | _encodeNested(value, nested); 476 | writeVarint32(bb, nested.limit); 477 | writeByteBuffer(bb, nested); 478 | pushByteBuffer(nested); 479 | } 480 | } 481 | }; 482 | 483 | exports.decodeRepeatedUnpacked = function (binary) { 484 | return _decodeRepeatedUnpacked(wrapByteBuffer(binary)); 485 | } 486 | 487 | function _decodeRepeatedUnpacked(bb) { 488 | var message = {}; 489 | 490 | end_of_message: while (!isAtEnd(bb)) { 491 | var tag = readVarint32(bb); 492 | 493 | switch (tag >>> 3) { 494 | case 0: 495 | break end_of_message; 496 | 497 | // repeated int32 field_int32 = 1; 498 | case 1: { 499 | var values = message.field_int32 || (message.field_int32 = []); 500 | if ((tag & 7) === 2) { 501 | var outerLimit = pushTemporaryLength(bb); 502 | while (!isAtEnd(bb)) { 503 | values.push(readVarint32(bb)); 504 | } 505 | bb.limit = outerLimit; 506 | } else { 507 | values.push(readVarint32(bb)); 508 | } 509 | break; 510 | } 511 | 512 | // repeated int64 field_int64 = 2; 513 | case 2: { 514 | var values = message.field_int64 || (message.field_int64 = []); 515 | if ((tag & 7) === 2) { 516 | var outerLimit = pushTemporaryLength(bb); 517 | while (!isAtEnd(bb)) { 518 | values.push(readVarint64(bb, /* unsigned */ false)); 519 | } 520 | bb.limit = outerLimit; 521 | } else { 522 | values.push(readVarint64(bb, /* unsigned */ false)); 523 | } 524 | break; 525 | } 526 | 527 | // repeated uint32 field_uint32 = 3; 528 | case 3: { 529 | var values = message.field_uint32 || (message.field_uint32 = []); 530 | if ((tag & 7) === 2) { 531 | var outerLimit = pushTemporaryLength(bb); 532 | while (!isAtEnd(bb)) { 533 | values.push(readVarint32(bb) >>> 0); 534 | } 535 | bb.limit = outerLimit; 536 | } else { 537 | values.push(readVarint32(bb) >>> 0); 538 | } 539 | break; 540 | } 541 | 542 | // repeated uint64 field_uint64 = 4; 543 | case 4: { 544 | var values = message.field_uint64 || (message.field_uint64 = []); 545 | if ((tag & 7) === 2) { 546 | var outerLimit = pushTemporaryLength(bb); 547 | while (!isAtEnd(bb)) { 548 | values.push(readVarint64(bb, /* unsigned */ true)); 549 | } 550 | bb.limit = outerLimit; 551 | } else { 552 | values.push(readVarint64(bb, /* unsigned */ true)); 553 | } 554 | break; 555 | } 556 | 557 | // repeated sint32 field_sint32 = 5; 558 | case 5: { 559 | var values = message.field_sint32 || (message.field_sint32 = []); 560 | if ((tag & 7) === 2) { 561 | var outerLimit = pushTemporaryLength(bb); 562 | while (!isAtEnd(bb)) { 563 | values.push(readVarint32ZigZag(bb)); 564 | } 565 | bb.limit = outerLimit; 566 | } else { 567 | values.push(readVarint32ZigZag(bb)); 568 | } 569 | break; 570 | } 571 | 572 | // repeated sint64 field_sint64 = 6; 573 | case 6: { 574 | var values = message.field_sint64 || (message.field_sint64 = []); 575 | if ((tag & 7) === 2) { 576 | var outerLimit = pushTemporaryLength(bb); 577 | while (!isAtEnd(bb)) { 578 | values.push(readVarint64ZigZag(bb)); 579 | } 580 | bb.limit = outerLimit; 581 | } else { 582 | values.push(readVarint64ZigZag(bb)); 583 | } 584 | break; 585 | } 586 | 587 | // repeated bool field_bool = 7; 588 | case 7: { 589 | var values = message.field_bool || (message.field_bool = []); 590 | if ((tag & 7) === 2) { 591 | var outerLimit = pushTemporaryLength(bb); 592 | while (!isAtEnd(bb)) { 593 | values.push(!!readByte(bb)); 594 | } 595 | bb.limit = outerLimit; 596 | } else { 597 | values.push(!!readByte(bb)); 598 | } 599 | break; 600 | } 601 | 602 | // repeated fixed64 field_fixed64 = 8; 603 | case 8: { 604 | var values = message.field_fixed64 || (message.field_fixed64 = []); 605 | if ((tag & 7) === 2) { 606 | var outerLimit = pushTemporaryLength(bb); 607 | while (!isAtEnd(bb)) { 608 | values.push(readInt64(bb, /* unsigned */ true)); 609 | } 610 | bb.limit = outerLimit; 611 | } else { 612 | values.push(readInt64(bb, /* unsigned */ true)); 613 | } 614 | break; 615 | } 616 | 617 | // repeated sfixed64 field_sfixed64 = 9; 618 | case 9: { 619 | var values = message.field_sfixed64 || (message.field_sfixed64 = []); 620 | if ((tag & 7) === 2) { 621 | var outerLimit = pushTemporaryLength(bb); 622 | while (!isAtEnd(bb)) { 623 | values.push(readInt64(bb, /* unsigned */ false)); 624 | } 625 | bb.limit = outerLimit; 626 | } else { 627 | values.push(readInt64(bb, /* unsigned */ false)); 628 | } 629 | break; 630 | } 631 | 632 | // repeated double field_double = 10; 633 | case 10: { 634 | var values = message.field_double || (message.field_double = []); 635 | if ((tag & 7) === 2) { 636 | var outerLimit = pushTemporaryLength(bb); 637 | while (!isAtEnd(bb)) { 638 | values.push(readDouble(bb)); 639 | } 640 | bb.limit = outerLimit; 641 | } else { 642 | values.push(readDouble(bb)); 643 | } 644 | break; 645 | } 646 | 647 | // repeated string field_string = 11; 648 | case 11: { 649 | var values = message.field_string || (message.field_string = []); 650 | values.push(readString(bb, readVarint32(bb))); 651 | break; 652 | } 653 | 654 | // repeated bytes field_bytes = 12; 655 | case 12: { 656 | var values = message.field_bytes || (message.field_bytes = []); 657 | values.push(readBytes(bb, readVarint32(bb))); 658 | break; 659 | } 660 | 661 | // repeated fixed32 field_fixed32 = 13; 662 | case 13: { 663 | var values = message.field_fixed32 || (message.field_fixed32 = []); 664 | if ((tag & 7) === 2) { 665 | var outerLimit = pushTemporaryLength(bb); 666 | while (!isAtEnd(bb)) { 667 | values.push(readInt32(bb) >>> 0); 668 | } 669 | bb.limit = outerLimit; 670 | } else { 671 | values.push(readInt32(bb) >>> 0); 672 | } 673 | break; 674 | } 675 | 676 | // repeated sfixed32 field_sfixed32 = 14; 677 | case 14: { 678 | var values = message.field_sfixed32 || (message.field_sfixed32 = []); 679 | if ((tag & 7) === 2) { 680 | var outerLimit = pushTemporaryLength(bb); 681 | while (!isAtEnd(bb)) { 682 | values.push(readInt32(bb)); 683 | } 684 | bb.limit = outerLimit; 685 | } else { 686 | values.push(readInt32(bb)); 687 | } 688 | break; 689 | } 690 | 691 | // repeated float field_float = 15; 692 | case 15: { 693 | var values = message.field_float || (message.field_float = []); 694 | if ((tag & 7) === 2) { 695 | var outerLimit = pushTemporaryLength(bb); 696 | while (!isAtEnd(bb)) { 697 | values.push(readFloat(bb)); 698 | } 699 | bb.limit = outerLimit; 700 | } else { 701 | values.push(readFloat(bb)); 702 | } 703 | break; 704 | } 705 | 706 | // repeated Nested field_nested = 16; 707 | case 16: { 708 | var limit = pushTemporaryLength(bb); 709 | var values = message.field_nested || (message.field_nested = []); 710 | values.push(_decodeNested(bb)); 711 | bb.limit = limit; 712 | break; 713 | } 714 | 715 | default: 716 | skipUnknownField(bb, tag & 7); 717 | } 718 | } 719 | 720 | return message; 721 | }; 722 | 723 | exports.encodeRepeatedPacked = function (message) { 724 | var bb = popByteBuffer(); 725 | _encodeRepeatedPacked(message, bb); 726 | return toUint8Array(bb); 727 | } 728 | 729 | function _encodeRepeatedPacked(message, bb) { 730 | // repeated int32 field_int32 = 1; 731 | var array$field_int32 = message.field_int32; 732 | if (array$field_int32 !== undefined) { 733 | var packed = popByteBuffer(); 734 | for (var i = 0; i < array$field_int32.length; i++) { 735 | var value = array$field_int32[i]; 736 | writeVarint64(packed, intToLong(value)); 737 | } 738 | writeVarint32(bb, 10); 739 | writeVarint32(bb, packed.offset); 740 | writeByteBuffer(bb, packed); 741 | pushByteBuffer(packed); 742 | } 743 | 744 | // repeated int64 field_int64 = 2; 745 | var array$field_int64 = message.field_int64; 746 | if (array$field_int64 !== undefined) { 747 | var packed = popByteBuffer(); 748 | for (var i = 0; i < array$field_int64.length; i++) { 749 | var value = array$field_int64[i]; 750 | writeVarint64(packed, value); 751 | } 752 | writeVarint32(bb, 18); 753 | writeVarint32(bb, packed.offset); 754 | writeByteBuffer(bb, packed); 755 | pushByteBuffer(packed); 756 | } 757 | 758 | // repeated uint32 field_uint32 = 3; 759 | var array$field_uint32 = message.field_uint32; 760 | if (array$field_uint32 !== undefined) { 761 | var packed = popByteBuffer(); 762 | for (var i = 0; i < array$field_uint32.length; i++) { 763 | var value = array$field_uint32[i]; 764 | writeVarint32(packed, value); 765 | } 766 | writeVarint32(bb, 26); 767 | writeVarint32(bb, packed.offset); 768 | writeByteBuffer(bb, packed); 769 | pushByteBuffer(packed); 770 | } 771 | 772 | // repeated uint64 field_uint64 = 4; 773 | var array$field_uint64 = message.field_uint64; 774 | if (array$field_uint64 !== undefined) { 775 | var packed = popByteBuffer(); 776 | for (var i = 0; i < array$field_uint64.length; i++) { 777 | var value = array$field_uint64[i]; 778 | writeVarint64(packed, value); 779 | } 780 | writeVarint32(bb, 34); 781 | writeVarint32(bb, packed.offset); 782 | writeByteBuffer(bb, packed); 783 | pushByteBuffer(packed); 784 | } 785 | 786 | // repeated sint32 field_sint32 = 5; 787 | var array$field_sint32 = message.field_sint32; 788 | if (array$field_sint32 !== undefined) { 789 | var packed = popByteBuffer(); 790 | for (var i = 0; i < array$field_sint32.length; i++) { 791 | var value = array$field_sint32[i]; 792 | writeVarint32ZigZag(packed, value); 793 | } 794 | writeVarint32(bb, 42); 795 | writeVarint32(bb, packed.offset); 796 | writeByteBuffer(bb, packed); 797 | pushByteBuffer(packed); 798 | } 799 | 800 | // repeated sint64 field_sint64 = 6; 801 | var array$field_sint64 = message.field_sint64; 802 | if (array$field_sint64 !== undefined) { 803 | var packed = popByteBuffer(); 804 | for (var i = 0; i < array$field_sint64.length; i++) { 805 | var value = array$field_sint64[i]; 806 | writeVarint64ZigZag(packed, value); 807 | } 808 | writeVarint32(bb, 50); 809 | writeVarint32(bb, packed.offset); 810 | writeByteBuffer(bb, packed); 811 | pushByteBuffer(packed); 812 | } 813 | 814 | // repeated bool field_bool = 7; 815 | var array$field_bool = message.field_bool; 816 | if (array$field_bool !== undefined) { 817 | var packed = popByteBuffer(); 818 | for (var i = 0; i < array$field_bool.length; i++) { 819 | var value = array$field_bool[i]; 820 | writeByte(packed, value ? 1 : 0); 821 | } 822 | writeVarint32(bb, 58); 823 | writeVarint32(bb, packed.offset); 824 | writeByteBuffer(bb, packed); 825 | pushByteBuffer(packed); 826 | } 827 | 828 | // repeated fixed64 field_fixed64 = 8; 829 | var array$field_fixed64 = message.field_fixed64; 830 | if (array$field_fixed64 !== undefined) { 831 | var packed = popByteBuffer(); 832 | for (var i = 0; i < array$field_fixed64.length; i++) { 833 | var value = array$field_fixed64[i]; 834 | writeInt64(packed, value); 835 | } 836 | writeVarint32(bb, 66); 837 | writeVarint32(bb, packed.offset); 838 | writeByteBuffer(bb, packed); 839 | pushByteBuffer(packed); 840 | } 841 | 842 | // repeated sfixed64 field_sfixed64 = 9; 843 | var array$field_sfixed64 = message.field_sfixed64; 844 | if (array$field_sfixed64 !== undefined) { 845 | var packed = popByteBuffer(); 846 | for (var i = 0; i < array$field_sfixed64.length; i++) { 847 | var value = array$field_sfixed64[i]; 848 | writeInt64(packed, value); 849 | } 850 | writeVarint32(bb, 74); 851 | writeVarint32(bb, packed.offset); 852 | writeByteBuffer(bb, packed); 853 | pushByteBuffer(packed); 854 | } 855 | 856 | // repeated double field_double = 10; 857 | var array$field_double = message.field_double; 858 | if (array$field_double !== undefined) { 859 | var packed = popByteBuffer(); 860 | for (var i = 0; i < array$field_double.length; i++) { 861 | var value = array$field_double[i]; 862 | writeDouble(packed, value); 863 | } 864 | writeVarint32(bb, 82); 865 | writeVarint32(bb, packed.offset); 866 | writeByteBuffer(bb, packed); 867 | pushByteBuffer(packed); 868 | } 869 | 870 | // repeated string field_string = 11; 871 | var array$field_string = message.field_string; 872 | if (array$field_string !== undefined) { 873 | for (var i = 0; i < array$field_string.length; i++) { 874 | var value = array$field_string[i]; 875 | writeVarint32(bb, 90); 876 | writeString(bb, value); 877 | } 878 | } 879 | 880 | // repeated bytes field_bytes = 12; 881 | var array$field_bytes = message.field_bytes; 882 | if (array$field_bytes !== undefined) { 883 | for (var i = 0; i < array$field_bytes.length; i++) { 884 | var value = array$field_bytes[i]; 885 | writeVarint32(bb, 98); 886 | writeVarint32(bb, value.length), writeBytes(bb, value); 887 | } 888 | } 889 | 890 | // repeated fixed32 field_fixed32 = 13; 891 | var array$field_fixed32 = message.field_fixed32; 892 | if (array$field_fixed32 !== undefined) { 893 | var packed = popByteBuffer(); 894 | for (var i = 0; i < array$field_fixed32.length; i++) { 895 | var value = array$field_fixed32[i]; 896 | writeInt32(packed, value); 897 | } 898 | writeVarint32(bb, 106); 899 | writeVarint32(bb, packed.offset); 900 | writeByteBuffer(bb, packed); 901 | pushByteBuffer(packed); 902 | } 903 | 904 | // repeated sfixed32 field_sfixed32 = 14; 905 | var array$field_sfixed32 = message.field_sfixed32; 906 | if (array$field_sfixed32 !== undefined) { 907 | var packed = popByteBuffer(); 908 | for (var i = 0; i < array$field_sfixed32.length; i++) { 909 | var value = array$field_sfixed32[i]; 910 | writeInt32(packed, value); 911 | } 912 | writeVarint32(bb, 114); 913 | writeVarint32(bb, packed.offset); 914 | writeByteBuffer(bb, packed); 915 | pushByteBuffer(packed); 916 | } 917 | 918 | // repeated float field_float = 15; 919 | var array$field_float = message.field_float; 920 | if (array$field_float !== undefined) { 921 | var packed = popByteBuffer(); 922 | for (var i = 0; i < array$field_float.length; i++) { 923 | var value = array$field_float[i]; 924 | writeFloat(packed, value); 925 | } 926 | writeVarint32(bb, 122); 927 | writeVarint32(bb, packed.offset); 928 | writeByteBuffer(bb, packed); 929 | pushByteBuffer(packed); 930 | } 931 | 932 | // repeated Nested field_nested = 16; 933 | var array$field_nested = message.field_nested; 934 | if (array$field_nested !== undefined) { 935 | for (var i = 0; i < array$field_nested.length; i++) { 936 | var value = array$field_nested[i]; 937 | writeVarint32(bb, 130); 938 | var nested = popByteBuffer(); 939 | _encodeNested(value, nested); 940 | writeVarint32(bb, nested.limit); 941 | writeByteBuffer(bb, nested); 942 | pushByteBuffer(nested); 943 | } 944 | } 945 | }; 946 | 947 | exports.decodeRepeatedPacked = function (binary) { 948 | return _decodeRepeatedPacked(wrapByteBuffer(binary)); 949 | } 950 | 951 | function _decodeRepeatedPacked(bb) { 952 | var message = {}; 953 | 954 | end_of_message: while (!isAtEnd(bb)) { 955 | var tag = readVarint32(bb); 956 | 957 | switch (tag >>> 3) { 958 | case 0: 959 | break end_of_message; 960 | 961 | // repeated int32 field_int32 = 1; 962 | case 1: { 963 | var values = message.field_int32 || (message.field_int32 = []); 964 | if ((tag & 7) === 2) { 965 | var outerLimit = pushTemporaryLength(bb); 966 | while (!isAtEnd(bb)) { 967 | values.push(readVarint32(bb)); 968 | } 969 | bb.limit = outerLimit; 970 | } else { 971 | values.push(readVarint32(bb)); 972 | } 973 | break; 974 | } 975 | 976 | // repeated int64 field_int64 = 2; 977 | case 2: { 978 | var values = message.field_int64 || (message.field_int64 = []); 979 | if ((tag & 7) === 2) { 980 | var outerLimit = pushTemporaryLength(bb); 981 | while (!isAtEnd(bb)) { 982 | values.push(readVarint64(bb, /* unsigned */ false)); 983 | } 984 | bb.limit = outerLimit; 985 | } else { 986 | values.push(readVarint64(bb, /* unsigned */ false)); 987 | } 988 | break; 989 | } 990 | 991 | // repeated uint32 field_uint32 = 3; 992 | case 3: { 993 | var values = message.field_uint32 || (message.field_uint32 = []); 994 | if ((tag & 7) === 2) { 995 | var outerLimit = pushTemporaryLength(bb); 996 | while (!isAtEnd(bb)) { 997 | values.push(readVarint32(bb) >>> 0); 998 | } 999 | bb.limit = outerLimit; 1000 | } else { 1001 | values.push(readVarint32(bb) >>> 0); 1002 | } 1003 | break; 1004 | } 1005 | 1006 | // repeated uint64 field_uint64 = 4; 1007 | case 4: { 1008 | var values = message.field_uint64 || (message.field_uint64 = []); 1009 | if ((tag & 7) === 2) { 1010 | var outerLimit = pushTemporaryLength(bb); 1011 | while (!isAtEnd(bb)) { 1012 | values.push(readVarint64(bb, /* unsigned */ true)); 1013 | } 1014 | bb.limit = outerLimit; 1015 | } else { 1016 | values.push(readVarint64(bb, /* unsigned */ true)); 1017 | } 1018 | break; 1019 | } 1020 | 1021 | // repeated sint32 field_sint32 = 5; 1022 | case 5: { 1023 | var values = message.field_sint32 || (message.field_sint32 = []); 1024 | if ((tag & 7) === 2) { 1025 | var outerLimit = pushTemporaryLength(bb); 1026 | while (!isAtEnd(bb)) { 1027 | values.push(readVarint32ZigZag(bb)); 1028 | } 1029 | bb.limit = outerLimit; 1030 | } else { 1031 | values.push(readVarint32ZigZag(bb)); 1032 | } 1033 | break; 1034 | } 1035 | 1036 | // repeated sint64 field_sint64 = 6; 1037 | case 6: { 1038 | var values = message.field_sint64 || (message.field_sint64 = []); 1039 | if ((tag & 7) === 2) { 1040 | var outerLimit = pushTemporaryLength(bb); 1041 | while (!isAtEnd(bb)) { 1042 | values.push(readVarint64ZigZag(bb)); 1043 | } 1044 | bb.limit = outerLimit; 1045 | } else { 1046 | values.push(readVarint64ZigZag(bb)); 1047 | } 1048 | break; 1049 | } 1050 | 1051 | // repeated bool field_bool = 7; 1052 | case 7: { 1053 | var values = message.field_bool || (message.field_bool = []); 1054 | if ((tag & 7) === 2) { 1055 | var outerLimit = pushTemporaryLength(bb); 1056 | while (!isAtEnd(bb)) { 1057 | values.push(!!readByte(bb)); 1058 | } 1059 | bb.limit = outerLimit; 1060 | } else { 1061 | values.push(!!readByte(bb)); 1062 | } 1063 | break; 1064 | } 1065 | 1066 | // repeated fixed64 field_fixed64 = 8; 1067 | case 8: { 1068 | var values = message.field_fixed64 || (message.field_fixed64 = []); 1069 | if ((tag & 7) === 2) { 1070 | var outerLimit = pushTemporaryLength(bb); 1071 | while (!isAtEnd(bb)) { 1072 | values.push(readInt64(bb, /* unsigned */ true)); 1073 | } 1074 | bb.limit = outerLimit; 1075 | } else { 1076 | values.push(readInt64(bb, /* unsigned */ true)); 1077 | } 1078 | break; 1079 | } 1080 | 1081 | // repeated sfixed64 field_sfixed64 = 9; 1082 | case 9: { 1083 | var values = message.field_sfixed64 || (message.field_sfixed64 = []); 1084 | if ((tag & 7) === 2) { 1085 | var outerLimit = pushTemporaryLength(bb); 1086 | while (!isAtEnd(bb)) { 1087 | values.push(readInt64(bb, /* unsigned */ false)); 1088 | } 1089 | bb.limit = outerLimit; 1090 | } else { 1091 | values.push(readInt64(bb, /* unsigned */ false)); 1092 | } 1093 | break; 1094 | } 1095 | 1096 | // repeated double field_double = 10; 1097 | case 10: { 1098 | var values = message.field_double || (message.field_double = []); 1099 | if ((tag & 7) === 2) { 1100 | var outerLimit = pushTemporaryLength(bb); 1101 | while (!isAtEnd(bb)) { 1102 | values.push(readDouble(bb)); 1103 | } 1104 | bb.limit = outerLimit; 1105 | } else { 1106 | values.push(readDouble(bb)); 1107 | } 1108 | break; 1109 | } 1110 | 1111 | // repeated string field_string = 11; 1112 | case 11: { 1113 | var values = message.field_string || (message.field_string = []); 1114 | values.push(readString(bb, readVarint32(bb))); 1115 | break; 1116 | } 1117 | 1118 | // repeated bytes field_bytes = 12; 1119 | case 12: { 1120 | var values = message.field_bytes || (message.field_bytes = []); 1121 | values.push(readBytes(bb, readVarint32(bb))); 1122 | break; 1123 | } 1124 | 1125 | // repeated fixed32 field_fixed32 = 13; 1126 | case 13: { 1127 | var values = message.field_fixed32 || (message.field_fixed32 = []); 1128 | if ((tag & 7) === 2) { 1129 | var outerLimit = pushTemporaryLength(bb); 1130 | while (!isAtEnd(bb)) { 1131 | values.push(readInt32(bb) >>> 0); 1132 | } 1133 | bb.limit = outerLimit; 1134 | } else { 1135 | values.push(readInt32(bb) >>> 0); 1136 | } 1137 | break; 1138 | } 1139 | 1140 | // repeated sfixed32 field_sfixed32 = 14; 1141 | case 14: { 1142 | var values = message.field_sfixed32 || (message.field_sfixed32 = []); 1143 | if ((tag & 7) === 2) { 1144 | var outerLimit = pushTemporaryLength(bb); 1145 | while (!isAtEnd(bb)) { 1146 | values.push(readInt32(bb)); 1147 | } 1148 | bb.limit = outerLimit; 1149 | } else { 1150 | values.push(readInt32(bb)); 1151 | } 1152 | break; 1153 | } 1154 | 1155 | // repeated float field_float = 15; 1156 | case 15: { 1157 | var values = message.field_float || (message.field_float = []); 1158 | if ((tag & 7) === 2) { 1159 | var outerLimit = pushTemporaryLength(bb); 1160 | while (!isAtEnd(bb)) { 1161 | values.push(readFloat(bb)); 1162 | } 1163 | bb.limit = outerLimit; 1164 | } else { 1165 | values.push(readFloat(bb)); 1166 | } 1167 | break; 1168 | } 1169 | 1170 | // repeated Nested field_nested = 16; 1171 | case 16: { 1172 | var limit = pushTemporaryLength(bb); 1173 | var values = message.field_nested || (message.field_nested = []); 1174 | values.push(_decodeNested(bb)); 1175 | bb.limit = limit; 1176 | break; 1177 | } 1178 | 1179 | default: 1180 | skipUnknownField(bb, tag & 7); 1181 | } 1182 | } 1183 | 1184 | return message; 1185 | }; 1186 | 1187 | exports.encodeEnumTest = function (message) { 1188 | var bb = popByteBuffer(); 1189 | _encodeEnumTest(message, bb); 1190 | return toUint8Array(bb); 1191 | } 1192 | 1193 | function _encodeEnumTest(message, bb) { 1194 | // optional Enum a = 1; 1195 | var $a = message.a; 1196 | if ($a !== undefined) { 1197 | writeVarint32(bb, 8); 1198 | writeVarint32(bb, exports.encodeEnum[$a]); 1199 | } 1200 | 1201 | // required Enum b = 2; 1202 | var $b = message.b; 1203 | if ($b !== undefined) { 1204 | writeVarint32(bb, 16); 1205 | writeVarint32(bb, exports.encodeEnum[$b]); 1206 | } 1207 | 1208 | // repeated Enum c = 3; 1209 | var array$c = message.c; 1210 | if (array$c !== undefined) { 1211 | var packed = popByteBuffer(); 1212 | for (var i = 0; i < array$c.length; i++) { 1213 | var value = array$c[i]; 1214 | writeVarint32(packed, exports.encodeEnum[value]); 1215 | } 1216 | writeVarint32(bb, 26); 1217 | writeVarint32(bb, packed.offset); 1218 | writeByteBuffer(bb, packed); 1219 | pushByteBuffer(packed); 1220 | } 1221 | }; 1222 | 1223 | exports.decodeEnumTest = function (binary) { 1224 | return _decodeEnumTest(wrapByteBuffer(binary)); 1225 | } 1226 | 1227 | function _decodeEnumTest(bb) { 1228 | var message = {}; 1229 | 1230 | end_of_message: while (!isAtEnd(bb)) { 1231 | var tag = readVarint32(bb); 1232 | 1233 | switch (tag >>> 3) { 1234 | case 0: 1235 | break end_of_message; 1236 | 1237 | // optional Enum a = 1; 1238 | case 1: { 1239 | message.a = exports.decodeEnum[readVarint32(bb)]; 1240 | break; 1241 | } 1242 | 1243 | // required Enum b = 2; 1244 | case 2: { 1245 | message.b = exports.decodeEnum[readVarint32(bb)]; 1246 | break; 1247 | } 1248 | 1249 | // repeated Enum c = 3; 1250 | case 3: { 1251 | var values = message.c || (message.c = []); 1252 | if ((tag & 7) === 2) { 1253 | var outerLimit = pushTemporaryLength(bb); 1254 | while (!isAtEnd(bb)) { 1255 | values.push(exports.decodeEnum[readVarint32(bb)]); 1256 | } 1257 | bb.limit = outerLimit; 1258 | } else { 1259 | values.push(exports.decodeEnum[readVarint32(bb)]); 1260 | } 1261 | break; 1262 | } 1263 | 1264 | default: 1265 | skipUnknownField(bb, tag & 7); 1266 | } 1267 | } 1268 | 1269 | if (message.b === undefined) 1270 | throw new Error("Missing required field: b"); 1271 | 1272 | return message; 1273 | }; 1274 | 1275 | exports.encodeMapTestIntAndString = function (message) { 1276 | var bb = popByteBuffer(); 1277 | _encodeMapTestIntAndString(message, bb); 1278 | return toUint8Array(bb); 1279 | } 1280 | 1281 | function _encodeMapTestIntAndString(message, bb) { 1282 | // optional map field_int32 = 1; 1283 | var map$field_int32 = message.field_int32; 1284 | if (map$field_int32 !== undefined) { 1285 | for (var key in map$field_int32) { 1286 | var nested = popByteBuffer(); 1287 | var value = map$field_int32[key]; 1288 | writeVarint32(nested, 8); 1289 | writeVarint64(nested, intToLong(+key)); 1290 | writeVarint32(nested, 18); 1291 | writeString(nested, value); 1292 | writeVarint32(bb, 10); 1293 | writeVarint32(bb, nested.offset); 1294 | writeByteBuffer(bb, nested); 1295 | pushByteBuffer(nested); 1296 | } 1297 | } 1298 | 1299 | // optional map field_uint32 = 2; 1300 | var map$field_uint32 = message.field_uint32; 1301 | if (map$field_uint32 !== undefined) { 1302 | for (var key in map$field_uint32) { 1303 | var nested = popByteBuffer(); 1304 | var value = map$field_uint32[key]; 1305 | writeVarint32(nested, 8); 1306 | writeVarint32(nested, +key); 1307 | writeVarint32(nested, 18); 1308 | writeVarint32(nested, value.length), writeBytes(nested, value); 1309 | writeVarint32(bb, 18); 1310 | writeVarint32(bb, nested.offset); 1311 | writeByteBuffer(bb, nested); 1312 | pushByteBuffer(nested); 1313 | } 1314 | } 1315 | 1316 | // optional map field_sint32 = 3; 1317 | var map$field_sint32 = message.field_sint32; 1318 | if (map$field_sint32 !== undefined) { 1319 | for (var key in map$field_sint32) { 1320 | var nested = popByteBuffer(); 1321 | var value = map$field_sint32[key]; 1322 | writeVarint32(nested, 8); 1323 | writeVarint32ZigZag(nested, +key); 1324 | writeVarint32(nested, 16); 1325 | writeVarint64(nested, value); 1326 | writeVarint32(bb, 26); 1327 | writeVarint32(bb, nested.offset); 1328 | writeByteBuffer(bb, nested); 1329 | pushByteBuffer(nested); 1330 | } 1331 | } 1332 | 1333 | // optional map field_string = 5; 1334 | var map$field_string = message.field_string; 1335 | if (map$field_string !== undefined) { 1336 | for (var key in map$field_string) { 1337 | var nested = popByteBuffer(); 1338 | var value = map$field_string[key]; 1339 | writeVarint32(nested, 10); 1340 | writeString(nested, key); 1341 | writeVarint32(nested, 17); 1342 | writeDouble(nested, value); 1343 | writeVarint32(bb, 42); 1344 | writeVarint32(bb, nested.offset); 1345 | writeByteBuffer(bb, nested); 1346 | pushByteBuffer(nested); 1347 | } 1348 | } 1349 | 1350 | // optional map field_fixed32 = 6; 1351 | var map$field_fixed32 = message.field_fixed32; 1352 | if (map$field_fixed32 !== undefined) { 1353 | for (var key in map$field_fixed32) { 1354 | var nested = popByteBuffer(); 1355 | var value = map$field_fixed32[key]; 1356 | writeVarint32(nested, 13); 1357 | writeInt32(nested, +key); 1358 | writeVarint32(nested, 16); 1359 | writeByte(nested, value ? 1 : 0); 1360 | writeVarint32(bb, 50); 1361 | writeVarint32(bb, nested.offset); 1362 | writeByteBuffer(bb, nested); 1363 | pushByteBuffer(nested); 1364 | } 1365 | } 1366 | 1367 | // optional map field_sfixed32 = 7; 1368 | var map$field_sfixed32 = message.field_sfixed32; 1369 | if (map$field_sfixed32 !== undefined) { 1370 | for (var key in map$field_sfixed32) { 1371 | var nested = popByteBuffer(); 1372 | var value = map$field_sfixed32[key]; 1373 | writeVarint32(nested, 13); 1374 | writeInt32(nested, +key); 1375 | writeVarint32(nested, 18); 1376 | var nestedValue = popByteBuffer(); 1377 | _encodeNested(value, nestedValue); 1378 | writeVarint32(nested, nestedValue.limit); 1379 | writeByteBuffer(nested, nestedValue); 1380 | pushByteBuffer(nestedValue); 1381 | writeVarint32(bb, 58); 1382 | writeVarint32(bb, nested.offset); 1383 | writeByteBuffer(bb, nested); 1384 | pushByteBuffer(nested); 1385 | } 1386 | } 1387 | }; 1388 | 1389 | exports.decodeMapTestIntAndString = function (binary) { 1390 | return _decodeMapTestIntAndString(wrapByteBuffer(binary)); 1391 | } 1392 | 1393 | function _decodeMapTestIntAndString(bb) { 1394 | var message = {}; 1395 | 1396 | end_of_message: while (!isAtEnd(bb)) { 1397 | var tag = readVarint32(bb); 1398 | 1399 | switch (tag >>> 3) { 1400 | case 0: 1401 | break end_of_message; 1402 | 1403 | // optional map field_int32 = 1; 1404 | case 1: { 1405 | var values = message.field_int32 || (message.field_int32 = {}); 1406 | var outerLimit = pushTemporaryLength(bb); 1407 | var key; 1408 | var value; 1409 | end_of_entry: while (!isAtEnd(bb)) { 1410 | var tag = readVarint32(bb); 1411 | switch (tag >>> 3) { 1412 | case 0: 1413 | break end_of_entry; 1414 | case 1: { 1415 | key = readVarint32(bb); 1416 | break; 1417 | } 1418 | case 2: { 1419 | value = readString(bb, readVarint32(bb)); 1420 | break; 1421 | } 1422 | default: 1423 | skipUnknownField(bb, tag & 7); 1424 | } 1425 | } 1426 | if (key === undefined || value === undefined) 1427 | throw new Error("Invalid data for map: field_int32"); 1428 | values[key] = value; 1429 | bb.limit = outerLimit; 1430 | break; 1431 | } 1432 | 1433 | // optional map field_uint32 = 2; 1434 | case 2: { 1435 | var values = message.field_uint32 || (message.field_uint32 = {}); 1436 | var outerLimit = pushTemporaryLength(bb); 1437 | var key; 1438 | var value; 1439 | end_of_entry: while (!isAtEnd(bb)) { 1440 | var tag = readVarint32(bb); 1441 | switch (tag >>> 3) { 1442 | case 0: 1443 | break end_of_entry; 1444 | case 1: { 1445 | key = readVarint32(bb) >>> 0; 1446 | break; 1447 | } 1448 | case 2: { 1449 | value = readBytes(bb, readVarint32(bb)); 1450 | break; 1451 | } 1452 | default: 1453 | skipUnknownField(bb, tag & 7); 1454 | } 1455 | } 1456 | if (key === undefined || value === undefined) 1457 | throw new Error("Invalid data for map: field_uint32"); 1458 | values[key] = value; 1459 | bb.limit = outerLimit; 1460 | break; 1461 | } 1462 | 1463 | // optional map field_sint32 = 3; 1464 | case 3: { 1465 | var values = message.field_sint32 || (message.field_sint32 = {}); 1466 | var outerLimit = pushTemporaryLength(bb); 1467 | var key; 1468 | var value; 1469 | end_of_entry: while (!isAtEnd(bb)) { 1470 | var tag = readVarint32(bb); 1471 | switch (tag >>> 3) { 1472 | case 0: 1473 | break end_of_entry; 1474 | case 1: { 1475 | key = readVarint32ZigZag(bb); 1476 | break; 1477 | } 1478 | case 2: { 1479 | value = readVarint64(bb, /* unsigned */ false); 1480 | break; 1481 | } 1482 | default: 1483 | skipUnknownField(bb, tag & 7); 1484 | } 1485 | } 1486 | if (key === undefined || value === undefined) 1487 | throw new Error("Invalid data for map: field_sint32"); 1488 | values[key] = value; 1489 | bb.limit = outerLimit; 1490 | break; 1491 | } 1492 | 1493 | // optional map field_string = 5; 1494 | case 5: { 1495 | var values = message.field_string || (message.field_string = {}); 1496 | var outerLimit = pushTemporaryLength(bb); 1497 | var key; 1498 | var value; 1499 | end_of_entry: while (!isAtEnd(bb)) { 1500 | var tag = readVarint32(bb); 1501 | switch (tag >>> 3) { 1502 | case 0: 1503 | break end_of_entry; 1504 | case 1: { 1505 | key = readString(bb, readVarint32(bb)); 1506 | break; 1507 | } 1508 | case 2: { 1509 | value = readDouble(bb); 1510 | break; 1511 | } 1512 | default: 1513 | skipUnknownField(bb, tag & 7); 1514 | } 1515 | } 1516 | if (key === undefined || value === undefined) 1517 | throw new Error("Invalid data for map: field_string"); 1518 | values[key] = value; 1519 | bb.limit = outerLimit; 1520 | break; 1521 | } 1522 | 1523 | // optional map field_fixed32 = 6; 1524 | case 6: { 1525 | var values = message.field_fixed32 || (message.field_fixed32 = {}); 1526 | var outerLimit = pushTemporaryLength(bb); 1527 | var key; 1528 | var value; 1529 | end_of_entry: while (!isAtEnd(bb)) { 1530 | var tag = readVarint32(bb); 1531 | switch (tag >>> 3) { 1532 | case 0: 1533 | break end_of_entry; 1534 | case 1: { 1535 | key = readInt32(bb) >>> 0; 1536 | break; 1537 | } 1538 | case 2: { 1539 | value = !!readByte(bb); 1540 | break; 1541 | } 1542 | default: 1543 | skipUnknownField(bb, tag & 7); 1544 | } 1545 | } 1546 | if (key === undefined || value === undefined) 1547 | throw new Error("Invalid data for map: field_fixed32"); 1548 | values[key] = value; 1549 | bb.limit = outerLimit; 1550 | break; 1551 | } 1552 | 1553 | // optional map field_sfixed32 = 7; 1554 | case 7: { 1555 | var values = message.field_sfixed32 || (message.field_sfixed32 = {}); 1556 | var outerLimit = pushTemporaryLength(bb); 1557 | var key; 1558 | var value; 1559 | end_of_entry: while (!isAtEnd(bb)) { 1560 | var tag = readVarint32(bb); 1561 | switch (tag >>> 3) { 1562 | case 0: 1563 | break end_of_entry; 1564 | case 1: { 1565 | key = readInt32(bb); 1566 | break; 1567 | } 1568 | case 2: { 1569 | var valueLimit = pushTemporaryLength(bb); 1570 | value = _decodeNested(bb); 1571 | bb.limit = valueLimit; 1572 | break; 1573 | } 1574 | default: 1575 | skipUnknownField(bb, tag & 7); 1576 | } 1577 | } 1578 | if (key === undefined || value === undefined) 1579 | throw new Error("Invalid data for map: field_sfixed32"); 1580 | values[key] = value; 1581 | bb.limit = outerLimit; 1582 | break; 1583 | } 1584 | 1585 | default: 1586 | skipUnknownField(bb, tag & 7); 1587 | } 1588 | } 1589 | 1590 | return message; 1591 | }; 1592 | 1593 | exports.encodeMapTestLongAndBool = function (message) { 1594 | var bb = popByteBuffer(); 1595 | _encodeMapTestLongAndBool(message, bb); 1596 | return toUint8Array(bb); 1597 | } 1598 | 1599 | function _encodeMapTestLongAndBool(message, bb) { 1600 | // optional map field_int64 = 1; 1601 | var map$field_int64 = message.field_int64; 1602 | if (map$field_int64 !== undefined) { 1603 | for (var key in map$field_int64) { 1604 | var nested = popByteBuffer(); 1605 | var value = map$field_int64[key]; 1606 | writeVarint32(nested, 8); 1607 | writeVarint64(nested, stringToLong(key)); 1608 | writeVarint32(nested, 18); 1609 | writeString(nested, value); 1610 | writeVarint32(bb, 10); 1611 | writeVarint32(bb, nested.offset); 1612 | writeByteBuffer(bb, nested); 1613 | pushByteBuffer(nested); 1614 | } 1615 | } 1616 | 1617 | // optional map field_uint64 = 2; 1618 | var map$field_uint64 = message.field_uint64; 1619 | if (map$field_uint64 !== undefined) { 1620 | for (var key in map$field_uint64) { 1621 | var nested = popByteBuffer(); 1622 | var value = map$field_uint64[key]; 1623 | writeVarint32(nested, 8); 1624 | writeVarint64(nested, stringToLong(key)); 1625 | writeVarint32(nested, 18); 1626 | writeVarint32(nested, value.length), writeBytes(nested, value); 1627 | writeVarint32(bb, 18); 1628 | writeVarint32(bb, nested.offset); 1629 | writeByteBuffer(bb, nested); 1630 | pushByteBuffer(nested); 1631 | } 1632 | } 1633 | 1634 | // optional map field_sint64 = 3; 1635 | var map$field_sint64 = message.field_sint64; 1636 | if (map$field_sint64 !== undefined) { 1637 | for (var key in map$field_sint64) { 1638 | var nested = popByteBuffer(); 1639 | var value = map$field_sint64[key]; 1640 | writeVarint32(nested, 8); 1641 | writeVarint64ZigZag(nested, stringToLong(key)); 1642 | writeVarint32(nested, 16); 1643 | writeVarint64(nested, value); 1644 | writeVarint32(bb, 26); 1645 | writeVarint32(bb, nested.offset); 1646 | writeByteBuffer(bb, nested); 1647 | pushByteBuffer(nested); 1648 | } 1649 | } 1650 | 1651 | // optional map field_fixed64 = 4; 1652 | var map$field_fixed64 = message.field_fixed64; 1653 | if (map$field_fixed64 !== undefined) { 1654 | for (var key in map$field_fixed64) { 1655 | var nested = popByteBuffer(); 1656 | var value = map$field_fixed64[key]; 1657 | writeVarint32(nested, 9); 1658 | writeInt64(nested, stringToLong(key)); 1659 | writeVarint32(nested, 17); 1660 | writeDouble(nested, value); 1661 | writeVarint32(bb, 34); 1662 | writeVarint32(bb, nested.offset); 1663 | writeByteBuffer(bb, nested); 1664 | pushByteBuffer(nested); 1665 | } 1666 | } 1667 | 1668 | // optional map field_sfixed64 = 5; 1669 | var map$field_sfixed64 = message.field_sfixed64; 1670 | if (map$field_sfixed64 !== undefined) { 1671 | for (var key in map$field_sfixed64) { 1672 | var nested = popByteBuffer(); 1673 | var value = map$field_sfixed64[key]; 1674 | writeVarint32(nested, 9); 1675 | writeInt64(nested, stringToLong(key)); 1676 | writeVarint32(nested, 16); 1677 | writeByte(nested, value ? 1 : 0); 1678 | writeVarint32(bb, 42); 1679 | writeVarint32(bb, nested.offset); 1680 | writeByteBuffer(bb, nested); 1681 | pushByteBuffer(nested); 1682 | } 1683 | } 1684 | 1685 | // optional map field_bool = 6; 1686 | var map$field_bool = message.field_bool; 1687 | if (map$field_bool !== undefined) { 1688 | for (var key in map$field_bool) { 1689 | var nested = popByteBuffer(); 1690 | var value = map$field_bool[key]; 1691 | writeVarint32(nested, 8); 1692 | writeByte(nested, key === "true" ? 1 : 0); 1693 | writeVarint32(nested, 18); 1694 | var nestedValue = popByteBuffer(); 1695 | _encodeNested(value, nestedValue); 1696 | writeVarint32(nested, nestedValue.limit); 1697 | writeByteBuffer(nested, nestedValue); 1698 | pushByteBuffer(nestedValue); 1699 | writeVarint32(bb, 50); 1700 | writeVarint32(bb, nested.offset); 1701 | writeByteBuffer(bb, nested); 1702 | pushByteBuffer(nested); 1703 | } 1704 | } 1705 | }; 1706 | 1707 | exports.decodeMapTestLongAndBool = function (binary) { 1708 | return _decodeMapTestLongAndBool(wrapByteBuffer(binary)); 1709 | } 1710 | 1711 | function _decodeMapTestLongAndBool(bb) { 1712 | var message = {}; 1713 | 1714 | end_of_message: while (!isAtEnd(bb)) { 1715 | var tag = readVarint32(bb); 1716 | 1717 | switch (tag >>> 3) { 1718 | case 0: 1719 | break end_of_message; 1720 | 1721 | // optional map field_int64 = 1; 1722 | case 1: { 1723 | var values = message.field_int64 || (message.field_int64 = {}); 1724 | var outerLimit = pushTemporaryLength(bb); 1725 | var key; 1726 | var value; 1727 | end_of_entry: while (!isAtEnd(bb)) { 1728 | var tag = readVarint32(bb); 1729 | switch (tag >>> 3) { 1730 | case 0: 1731 | break end_of_entry; 1732 | case 1: { 1733 | key = readVarint64(bb, /* unsigned */ false); 1734 | break; 1735 | } 1736 | case 2: { 1737 | value = readString(bb, readVarint32(bb)); 1738 | break; 1739 | } 1740 | default: 1741 | skipUnknownField(bb, tag & 7); 1742 | } 1743 | } 1744 | if (key === undefined || value === undefined) 1745 | throw new Error("Invalid data for map: field_int64"); 1746 | values[longToString(key)] = value; 1747 | bb.limit = outerLimit; 1748 | break; 1749 | } 1750 | 1751 | // optional map field_uint64 = 2; 1752 | case 2: { 1753 | var values = message.field_uint64 || (message.field_uint64 = {}); 1754 | var outerLimit = pushTemporaryLength(bb); 1755 | var key; 1756 | var value; 1757 | end_of_entry: while (!isAtEnd(bb)) { 1758 | var tag = readVarint32(bb); 1759 | switch (tag >>> 3) { 1760 | case 0: 1761 | break end_of_entry; 1762 | case 1: { 1763 | key = readVarint64(bb, /* unsigned */ true); 1764 | break; 1765 | } 1766 | case 2: { 1767 | value = readBytes(bb, readVarint32(bb)); 1768 | break; 1769 | } 1770 | default: 1771 | skipUnknownField(bb, tag & 7); 1772 | } 1773 | } 1774 | if (key === undefined || value === undefined) 1775 | throw new Error("Invalid data for map: field_uint64"); 1776 | values[longToString(key)] = value; 1777 | bb.limit = outerLimit; 1778 | break; 1779 | } 1780 | 1781 | // optional map field_sint64 = 3; 1782 | case 3: { 1783 | var values = message.field_sint64 || (message.field_sint64 = {}); 1784 | var outerLimit = pushTemporaryLength(bb); 1785 | var key; 1786 | var value; 1787 | end_of_entry: while (!isAtEnd(bb)) { 1788 | var tag = readVarint32(bb); 1789 | switch (tag >>> 3) { 1790 | case 0: 1791 | break end_of_entry; 1792 | case 1: { 1793 | key = readVarint64ZigZag(bb); 1794 | break; 1795 | } 1796 | case 2: { 1797 | value = readVarint64(bb, /* unsigned */ false); 1798 | break; 1799 | } 1800 | default: 1801 | skipUnknownField(bb, tag & 7); 1802 | } 1803 | } 1804 | if (key === undefined || value === undefined) 1805 | throw new Error("Invalid data for map: field_sint64"); 1806 | values[longToString(key)] = value; 1807 | bb.limit = outerLimit; 1808 | break; 1809 | } 1810 | 1811 | // optional map field_fixed64 = 4; 1812 | case 4: { 1813 | var values = message.field_fixed64 || (message.field_fixed64 = {}); 1814 | var outerLimit = pushTemporaryLength(bb); 1815 | var key; 1816 | var value; 1817 | end_of_entry: while (!isAtEnd(bb)) { 1818 | var tag = readVarint32(bb); 1819 | switch (tag >>> 3) { 1820 | case 0: 1821 | break end_of_entry; 1822 | case 1: { 1823 | key = readInt64(bb, /* unsigned */ true); 1824 | break; 1825 | } 1826 | case 2: { 1827 | value = readDouble(bb); 1828 | break; 1829 | } 1830 | default: 1831 | skipUnknownField(bb, tag & 7); 1832 | } 1833 | } 1834 | if (key === undefined || value === undefined) 1835 | throw new Error("Invalid data for map: field_fixed64"); 1836 | values[longToString(key)] = value; 1837 | bb.limit = outerLimit; 1838 | break; 1839 | } 1840 | 1841 | // optional map field_sfixed64 = 5; 1842 | case 5: { 1843 | var values = message.field_sfixed64 || (message.field_sfixed64 = {}); 1844 | var outerLimit = pushTemporaryLength(bb); 1845 | var key; 1846 | var value; 1847 | end_of_entry: while (!isAtEnd(bb)) { 1848 | var tag = readVarint32(bb); 1849 | switch (tag >>> 3) { 1850 | case 0: 1851 | break end_of_entry; 1852 | case 1: { 1853 | key = readInt64(bb, /* unsigned */ false); 1854 | break; 1855 | } 1856 | case 2: { 1857 | value = !!readByte(bb); 1858 | break; 1859 | } 1860 | default: 1861 | skipUnknownField(bb, tag & 7); 1862 | } 1863 | } 1864 | if (key === undefined || value === undefined) 1865 | throw new Error("Invalid data for map: field_sfixed64"); 1866 | values[longToString(key)] = value; 1867 | bb.limit = outerLimit; 1868 | break; 1869 | } 1870 | 1871 | // optional map field_bool = 6; 1872 | case 6: { 1873 | var values = message.field_bool || (message.field_bool = {}); 1874 | var outerLimit = pushTemporaryLength(bb); 1875 | var key; 1876 | var value; 1877 | end_of_entry: while (!isAtEnd(bb)) { 1878 | var tag = readVarint32(bb); 1879 | switch (tag >>> 3) { 1880 | case 0: 1881 | break end_of_entry; 1882 | case 1: { 1883 | key = !!readByte(bb); 1884 | break; 1885 | } 1886 | case 2: { 1887 | var valueLimit = pushTemporaryLength(bb); 1888 | value = _decodeNested(bb); 1889 | bb.limit = valueLimit; 1890 | break; 1891 | } 1892 | default: 1893 | skipUnknownField(bb, tag & 7); 1894 | } 1895 | } 1896 | if (key === undefined || value === undefined) 1897 | throw new Error("Invalid data for map: field_bool"); 1898 | values[key + ''] = value; 1899 | bb.limit = outerLimit; 1900 | break; 1901 | } 1902 | 1903 | default: 1904 | skipUnknownField(bb, tag & 7); 1905 | } 1906 | } 1907 | 1908 | return message; 1909 | }; 1910 | 1911 | function pushTemporaryLength(bb) { 1912 | var length = readVarint32(bb); 1913 | var limit = bb.limit; 1914 | bb.limit = bb.offset + length; 1915 | return limit; 1916 | } 1917 | 1918 | function skipUnknownField(bb, type) { 1919 | switch (type) { 1920 | case 0: while (readByte(bb) & 0x80) { } break; 1921 | case 2: skip(bb, readVarint32(bb)); break; 1922 | case 5: skip(bb, 4); break; 1923 | case 1: skip(bb, 8); break; 1924 | default: throw new Error("Unimplemented type: " + type); 1925 | } 1926 | } 1927 | 1928 | function stringToLong(value) { 1929 | return { 1930 | low: value.charCodeAt(0) | (value.charCodeAt(1) << 16), 1931 | high: value.charCodeAt(2) | (value.charCodeAt(3) << 16), 1932 | unsigned: false, 1933 | }; 1934 | } 1935 | 1936 | function longToString(value) { 1937 | var low = value.low; 1938 | var high = value.high; 1939 | return String.fromCharCode( 1940 | low & 0xFFFF, 1941 | low >>> 16, 1942 | high & 0xFFFF, 1943 | high >>> 16); 1944 | } 1945 | 1946 | // The code below was modified from https://github.com/protobufjs/bytebuffer.js 1947 | // which is under the Apache License 2.0. 1948 | 1949 | var f32 = new Float32Array(1); 1950 | var f32_u8 = new Uint8Array(f32.buffer); 1951 | 1952 | var f64 = new Float64Array(1); 1953 | var f64_u8 = new Uint8Array(f64.buffer); 1954 | 1955 | function intToLong(value) { 1956 | value |= 0; 1957 | return { 1958 | low: value, 1959 | high: value >> 31, 1960 | unsigned: value >= 0, 1961 | }; 1962 | } 1963 | 1964 | var bbStack = []; 1965 | 1966 | function popByteBuffer() { 1967 | const bb = bbStack.pop(); 1968 | if (!bb) return { bytes: new Uint8Array(64), offset: 0, limit: 0 }; 1969 | bb.offset = bb.limit = 0; 1970 | return bb; 1971 | } 1972 | 1973 | function pushByteBuffer(bb) { 1974 | bbStack.push(bb); 1975 | } 1976 | 1977 | function wrapByteBuffer(bytes) { 1978 | return { bytes, offset: 0, limit: bytes.length }; 1979 | } 1980 | 1981 | function toUint8Array(bb) { 1982 | var bytes = bb.bytes; 1983 | var limit = bb.limit; 1984 | return bytes.length === limit ? bytes : bytes.subarray(0, limit); 1985 | } 1986 | 1987 | function skip(bb, offset) { 1988 | if (bb.offset + offset > bb.limit) { 1989 | throw new Error('Skip past limit'); 1990 | } 1991 | bb.offset += offset; 1992 | } 1993 | 1994 | function isAtEnd(bb) { 1995 | return bb.offset >= bb.limit; 1996 | } 1997 | 1998 | function grow(bb, count) { 1999 | var bytes = bb.bytes; 2000 | var offset = bb.offset; 2001 | var limit = bb.limit; 2002 | var finalOffset = offset + count; 2003 | if (finalOffset > bytes.length) { 2004 | var newBytes = new Uint8Array(finalOffset * 2); 2005 | newBytes.set(bytes); 2006 | bb.bytes = newBytes; 2007 | } 2008 | bb.offset = finalOffset; 2009 | if (finalOffset > limit) { 2010 | bb.limit = finalOffset; 2011 | } 2012 | return offset; 2013 | } 2014 | 2015 | function advance(bb, count) { 2016 | var offset = bb.offset; 2017 | if (offset + count > bb.limit) { 2018 | throw new Error('Read past limit'); 2019 | } 2020 | bb.offset += count; 2021 | return offset; 2022 | } 2023 | 2024 | function readBytes(bb, count) { 2025 | var offset = advance(bb, count); 2026 | return bb.bytes.subarray(offset, offset + count); 2027 | } 2028 | 2029 | function writeBytes(bb, buffer) { 2030 | var offset = grow(bb, buffer.length); 2031 | bb.bytes.set(buffer, offset); 2032 | } 2033 | 2034 | function readString(bb, count) { 2035 | // Sadly a hand-coded UTF8 decoder is much faster than subarray+TextDecoder in V8 2036 | var offset = advance(bb, count); 2037 | var fromCharCode = String.fromCharCode; 2038 | var bytes = bb.bytes; 2039 | var invalid = '\uFFFD'; 2040 | var text = ''; 2041 | 2042 | for (var i = 0; i < count; i++) { 2043 | var c1 = bytes[i + offset], c2, c3, c4, c; 2044 | 2045 | // 1 byte 2046 | if ((c1 & 0x80) === 0) { 2047 | text += fromCharCode(c1); 2048 | } 2049 | 2050 | // 2 bytes 2051 | else if ((c1 & 0xE0) === 0xC0) { 2052 | if (i + 1 >= count) text += invalid; 2053 | else { 2054 | c2 = bytes[i + offset + 1]; 2055 | if ((c2 & 0xC0) !== 0x80) text += invalid; 2056 | else { 2057 | c = ((c1 & 0x1F) << 6) | (c2 & 0x3F); 2058 | if (c < 0x80) text += invalid; 2059 | else { 2060 | text += fromCharCode(c); 2061 | i++; 2062 | } 2063 | } 2064 | } 2065 | } 2066 | 2067 | // 3 bytes 2068 | else if ((c1 & 0xF0) == 0xE0) { 2069 | if (i + 2 >= count) text += invalid; 2070 | else { 2071 | c2 = bytes[i + offset + 1]; 2072 | c3 = bytes[i + offset + 2]; 2073 | if (((c2 | (c3 << 8)) & 0xC0C0) !== 0x8080) text += invalid; 2074 | else { 2075 | c = ((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F); 2076 | if (c < 0x0800 || (c >= 0xD800 && c <= 0xDFFF)) text += invalid; 2077 | else { 2078 | text += fromCharCode(c); 2079 | i += 2; 2080 | } 2081 | } 2082 | } 2083 | } 2084 | 2085 | // 4 bytes 2086 | else if ((c1 & 0xF8) == 0xF0) { 2087 | if (i + 3 >= count) text += invalid; 2088 | else { 2089 | c2 = bytes[i + offset + 1]; 2090 | c3 = bytes[i + offset + 2]; 2091 | c4 = bytes[i + offset + 3]; 2092 | if (((c2 | (c3 << 8) | (c4 << 16)) & 0xC0C0C0) !== 0x808080) text += invalid; 2093 | else { 2094 | c = ((c1 & 0x07) << 0x12) | ((c2 & 0x3F) << 0x0C) | ((c3 & 0x3F) << 0x06) | (c4 & 0x3F); 2095 | if (c < 0x10000 || c > 0x10FFFF) text += invalid; 2096 | else { 2097 | c -= 0x10000; 2098 | text += fromCharCode((c >> 10) + 0xD800, (c & 0x3FF) + 0xDC00); 2099 | i += 3; 2100 | } 2101 | } 2102 | } 2103 | } 2104 | 2105 | else text += invalid; 2106 | } 2107 | 2108 | return text; 2109 | } 2110 | 2111 | function writeString(bb, text) { 2112 | // Sadly a hand-coded UTF8 encoder is much faster than TextEncoder+set in V8 2113 | var n = text.length; 2114 | var byteCount = 0; 2115 | 2116 | // Write the byte count first 2117 | for (var i = 0; i < n; i++) { 2118 | var c = text.charCodeAt(i); 2119 | if (c >= 0xD800 && c <= 0xDBFF && i + 1 < n) { 2120 | c = (c << 10) + text.charCodeAt(++i) - 0x35FDC00; 2121 | } 2122 | byteCount += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4; 2123 | } 2124 | writeVarint32(bb, byteCount); 2125 | 2126 | var offset = grow(bb, byteCount); 2127 | var bytes = bb.bytes; 2128 | 2129 | // Then write the bytes 2130 | for (var i = 0; i < n; i++) { 2131 | var c = text.charCodeAt(i); 2132 | if (c >= 0xD800 && c <= 0xDBFF && i + 1 < n) { 2133 | c = (c << 10) + text.charCodeAt(++i) - 0x35FDC00; 2134 | } 2135 | if (c < 0x80) { 2136 | bytes[offset++] = c; 2137 | } else { 2138 | if (c < 0x800) { 2139 | bytes[offset++] = ((c >> 6) & 0x1F) | 0xC0; 2140 | } else { 2141 | if (c < 0x10000) { 2142 | bytes[offset++] = ((c >> 12) & 0x0F) | 0xE0; 2143 | } else { 2144 | bytes[offset++] = ((c >> 18) & 0x07) | 0xF0; 2145 | bytes[offset++] = ((c >> 12) & 0x3F) | 0x80; 2146 | } 2147 | bytes[offset++] = ((c >> 6) & 0x3F) | 0x80; 2148 | } 2149 | bytes[offset++] = (c & 0x3F) | 0x80; 2150 | } 2151 | } 2152 | } 2153 | 2154 | function writeByteBuffer(bb, buffer) { 2155 | var offset = grow(bb, buffer.limit); 2156 | var from = bb.bytes; 2157 | var to = buffer.bytes; 2158 | 2159 | // This for loop is much faster than subarray+set on V8 2160 | for (var i = 0, n = buffer.limit; i < n; i++) { 2161 | from[i + offset] = to[i]; 2162 | } 2163 | } 2164 | 2165 | function readByte(bb) { 2166 | return bb.bytes[advance(bb, 1)]; 2167 | } 2168 | 2169 | function writeByte(bb, value) { 2170 | var offset = grow(bb, 1); 2171 | bb.bytes[offset] = value; 2172 | } 2173 | 2174 | function readFloat(bb) { 2175 | var offset = advance(bb, 4); 2176 | var bytes = bb.bytes; 2177 | 2178 | // Manual copying is much faster than subarray+set in V8 2179 | f32_u8[0] = bytes[offset++]; 2180 | f32_u8[1] = bytes[offset++]; 2181 | f32_u8[2] = bytes[offset++]; 2182 | f32_u8[3] = bytes[offset++]; 2183 | return f32[0]; 2184 | } 2185 | 2186 | function writeFloat(bb, value) { 2187 | var offset = grow(bb, 4); 2188 | var bytes = bb.bytes; 2189 | f32[0] = value; 2190 | 2191 | // Manual copying is much faster than subarray+set in V8 2192 | bytes[offset++] = f32_u8[0]; 2193 | bytes[offset++] = f32_u8[1]; 2194 | bytes[offset++] = f32_u8[2]; 2195 | bytes[offset++] = f32_u8[3]; 2196 | } 2197 | 2198 | function readDouble(bb) { 2199 | var offset = advance(bb, 8); 2200 | var bytes = bb.bytes; 2201 | 2202 | // Manual copying is much faster than subarray+set in V8 2203 | f64_u8[0] = bytes[offset++]; 2204 | f64_u8[1] = bytes[offset++]; 2205 | f64_u8[2] = bytes[offset++]; 2206 | f64_u8[3] = bytes[offset++]; 2207 | f64_u8[4] = bytes[offset++]; 2208 | f64_u8[5] = bytes[offset++]; 2209 | f64_u8[6] = bytes[offset++]; 2210 | f64_u8[7] = bytes[offset++]; 2211 | return f64[0]; 2212 | } 2213 | 2214 | function writeDouble(bb, value) { 2215 | var offset = grow(bb, 8); 2216 | var bytes = bb.bytes; 2217 | f64[0] = value; 2218 | 2219 | // Manual copying is much faster than subarray+set in V8 2220 | bytes[offset++] = f64_u8[0]; 2221 | bytes[offset++] = f64_u8[1]; 2222 | bytes[offset++] = f64_u8[2]; 2223 | bytes[offset++] = f64_u8[3]; 2224 | bytes[offset++] = f64_u8[4]; 2225 | bytes[offset++] = f64_u8[5]; 2226 | bytes[offset++] = f64_u8[6]; 2227 | bytes[offset++] = f64_u8[7]; 2228 | } 2229 | 2230 | function readInt32(bb) { 2231 | var offset = advance(bb, 4); 2232 | var bytes = bb.bytes; 2233 | return ( 2234 | bytes[offset] | 2235 | (bytes[offset + 1] << 8) | 2236 | (bytes[offset + 2] << 16) | 2237 | (bytes[offset + 3] << 24) 2238 | ); 2239 | } 2240 | 2241 | function writeInt32(bb, value) { 2242 | var offset = grow(bb, 4); 2243 | var bytes = bb.bytes; 2244 | bytes[offset] = value; 2245 | bytes[offset + 1] = value >> 8; 2246 | bytes[offset + 2] = value >> 16; 2247 | bytes[offset + 3] = value >> 24; 2248 | } 2249 | 2250 | function readInt64(bb, unsigned) { 2251 | return { 2252 | low: readInt32(bb), 2253 | high: readInt32(bb), 2254 | unsigned, 2255 | }; 2256 | } 2257 | 2258 | function writeInt64(bb, value) { 2259 | writeInt32(bb, value.low); 2260 | writeInt32(bb, value.high); 2261 | } 2262 | 2263 | function readVarint32(bb) { 2264 | var c = 0; 2265 | var value = 0; 2266 | var b; 2267 | do { 2268 | b = readByte(bb); 2269 | if (c < 32) value |= (b & 0x7F) << c; 2270 | c += 7; 2271 | } while (b & 0x80); 2272 | return value; 2273 | } 2274 | 2275 | function writeVarint32(bb, value) { 2276 | value >>>= 0; 2277 | while (value >= 0x80) { 2278 | writeByte(bb, (value & 0x7f) | 0x80); 2279 | value >>>= 7; 2280 | } 2281 | writeByte(bb, value); 2282 | } 2283 | 2284 | function readVarint64(bb, unsigned) { 2285 | var part0 = 0; 2286 | var part1 = 0; 2287 | var part2 = 0; 2288 | var b; 2289 | 2290 | b = readByte(bb); part0 = (b & 0x7F); if (b & 0x80) { 2291 | b = readByte(bb); part0 |= (b & 0x7F) << 7; if (b & 0x80) { 2292 | b = readByte(bb); part0 |= (b & 0x7F) << 14; if (b & 0x80) { 2293 | b = readByte(bb); part0 |= (b & 0x7F) << 21; if (b & 0x80) { 2294 | 2295 | b = readByte(bb); part1 = (b & 0x7F); if (b & 0x80) { 2296 | b = readByte(bb); part1 |= (b & 0x7F) << 7; if (b & 0x80) { 2297 | b = readByte(bb); part1 |= (b & 0x7F) << 14; if (b & 0x80) { 2298 | b = readByte(bb); part1 |= (b & 0x7F) << 21; if (b & 0x80) { 2299 | 2300 | b = readByte(bb); part2 = (b & 0x7F); if (b & 0x80) { 2301 | b = readByte(bb); part2 |= (b & 0x7F) << 7; 2302 | } 2303 | } 2304 | } 2305 | } 2306 | } 2307 | } 2308 | } 2309 | } 2310 | } 2311 | 2312 | return { 2313 | low: part0 | (part1 << 28), 2314 | high: (part1 >>> 4) | (part2 << 24), 2315 | unsigned, 2316 | }; 2317 | } 2318 | 2319 | function writeVarint64(bb, value) { 2320 | var part0 = value.low >>> 0; 2321 | var part1 = ((value.low >>> 28) | (value.high << 4)) >>> 0; 2322 | var part2 = value.high >>> 24; 2323 | 2324 | // ref: src/google/protobuf/io/coded_stream.cc 2325 | var size = 2326 | part2 === 0 ? 2327 | part1 === 0 ? 2328 | part0 < 1 << 14 ? 2329 | part0 < 1 << 7 ? 1 : 2 : 2330 | part0 < 1 << 21 ? 3 : 4 : 2331 | part1 < 1 << 14 ? 2332 | part1 < 1 << 7 ? 5 : 6 : 2333 | part1 < 1 << 21 ? 7 : 8 : 2334 | part2 < 1 << 7 ? 9 : 10; 2335 | 2336 | var offset = grow(bb, size); 2337 | var bytes = bb.bytes; 2338 | 2339 | switch (size) { 2340 | case 10: bytes[offset + 9] = (part2 >>> 7) & 0x01; 2341 | case 9: bytes[offset + 8] = size !== 9 ? part2 | 0x80 : part2 & 0x7F; 2342 | case 8: bytes[offset + 7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F; 2343 | case 7: bytes[offset + 6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F; 2344 | case 6: bytes[offset + 5] = size !== 6 ? (part1 >>> 7) | 0x80 : (part1 >>> 7) & 0x7F; 2345 | case 5: bytes[offset + 4] = size !== 5 ? part1 | 0x80 : part1 & 0x7F; 2346 | case 4: bytes[offset + 3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F; 2347 | case 3: bytes[offset + 2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F; 2348 | case 2: bytes[offset + 1] = size !== 2 ? (part0 >>> 7) | 0x80 : (part0 >>> 7) & 0x7F; 2349 | case 1: bytes[offset] = size !== 1 ? part0 | 0x80 : part0 & 0x7F; 2350 | } 2351 | } 2352 | 2353 | function readVarint32ZigZag(bb) { 2354 | var value = readVarint32(bb); 2355 | 2356 | // ref: src/google/protobuf/wire_format_lite.h 2357 | return (value >>> 1) ^ -(value & 1); 2358 | } 2359 | 2360 | function writeVarint32ZigZag(bb, value) { 2361 | // ref: src/google/protobuf/wire_format_lite.h 2362 | writeVarint32(bb, (value << 1) ^ (value >> 31)); 2363 | } 2364 | 2365 | function readVarint64ZigZag(bb) { 2366 | var value = readVarint64(bb, /* unsigned */ false); 2367 | var low = value.low; 2368 | var high = value.high; 2369 | var flip = -(low & 1); 2370 | 2371 | // ref: src/google/protobuf/wire_format_lite.h 2372 | return { 2373 | low: ((low >>> 1) | (high << 31)) ^ flip, 2374 | high: (high >>> 1) ^ flip, 2375 | unsigned: false, 2376 | }; 2377 | } 2378 | 2379 | function writeVarint64ZigZag(bb, value) { 2380 | var low = value.low; 2381 | var high = value.high; 2382 | var flip = high >> 31; 2383 | 2384 | // ref: src/google/protobuf/wire_format_lite.h 2385 | writeVarint64(bb, { 2386 | low: (low << 1) ^ flip, 2387 | high: ((high << 1) | (low >>> 31)) ^ flip, 2388 | unsigned: false, 2389 | }); 2390 | } 2391 | --------------------------------------------------------------------------------