https://www.1c-bitrix.ru/bitrix/js/pull/protobuf/protobuf.js?1703578952274055

1/*!
2 * protobuf.js v6.8.6 (c) 2016, daniel wirtz
3 * compiled mon, 26 feb 2018 11:35:34 utc
4 * licensed under the bsd-3-clause license
5 * see: https://github.com/dcodeio/protobuf.js for details
6 *
7 * Modify list for integration with Bitrix Framework:
8 * - removed integration with RequireJS and AMD package builders;
9 */
10(function(global,undefined){"use strict";(function prelude(modules, cache, entries) {
11
12    // This is the prelude used to bundle protobuf.js for the browser. Wraps up the CommonJS
13    // sources through a conflict-free require shim and is again wrapped within an iife that
14    // provides a unified `global` and a minification-friendly `undefined` var plus a global
15    // "use strict" directive so that minification can remove the directives of each module.
16
17    function $require(name) {
18        var $module = cache[name];
19        if (!$module)
20            modules[name][0].call($module = cache[name] = { exports: {} }, $require, $module, $module.exports);
21        return $module.exports;
22    }
23
24    // Expose globally
25    var protobuf = global.protobuf = $require(entries[0]);
26
27    // Be nice to AMD
28    /*if (typeof define === "function" && define.amd)
29        define(["long"], function(Long) {
30            if (Long && Long.isLong) {
31                protobuf.util.Long = Long;
32                protobuf.configure();
33            }
34            return protobuf;
35        });*/
36
37    // Be nice to CommonJS
38    /*if (typeof module === "object" && module && module.exports)
39        module.exports = protobuf;*/
40
41})/* end of prelude */({1:[function(require,module,exports){
42"use strict";
43module.exports = asPromise;
44
45/**
46 * Callback as used by {@link util.asPromise}.
47 * @typedef asPromiseCallback
48 * @type {function}
49 * @param {Error|null} error Error, if any
50 * @param {...*} params Additional arguments
51 * @returns {undefined}
52 */
53
54/**
55 * Returns a promise from a node-style callback function.
56 * @memberof util
57 * @param {asPromiseCallback} fn Function to call
58 * @param {*} ctx Function context
59 * @param {...*} params Function arguments
60 * @returns {Promise<*>} Promisified function
61 */
62function asPromise(fn, ctx/*, varargs */) {
63    var params  = new Array(arguments.length - 1),
64        offset  = 0,
65        index   = 2,
66        pending = true;
67    while (index < arguments.length)
68        params[offset++] = arguments[index++];
69    return new Promise(function executor(resolve, reject) {
70        params[offset] = function callback(err/*, varargs */) {
71            if (pending) {
72                pending = false;
73                if (err)
74                    reject(err);
75                else {
76                    var params = new Array(arguments.length - 1),
77                        offset = 0;
78                    while (offset < params.length)
79                        params[offset++] = arguments[offset];
80                    resolve.apply(null, params);
81                }
82            }
83        };
84        try {
85            fn.apply(ctx || null, params);
86        } catch (err) {
87            if (pending) {
88                pending = false;
89                reject(err);
90            }
91        }
92    });
93}
94
95},{}],2:[function(require,module,exports){
96"use strict";
97
98/**
99 * A minimal base64 implementation for number arrays.
100 * @memberof util
101 * @namespace
102 */
103var base64 = exports;
104
105/**
106 * Calculates the byte length of a base64 encoded string.
107 * @param {string} string Base64 encoded string
108 * @returns {number} Byte length
109 */
110base64.length = function length(string) {
111    var p = string.length;
112    if (!p)
113        return 0;
114    var n = 0;
115    while (--p % 4 > 1 && string.charAt(p) === "=")
116        ++n;
117    return Math.ceil(string.length * 3) / 4 - n;
118};
119
120// Base64 encoding table
121var b64 = new Array(64);
122
123// Base64 decoding table
124var s64 = new Array(123);
125
126// 65..90, 97..122, 48..57, 43, 47
127for (var i = 0; i < 64;)
128    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
129
130/**
131 * Encodes a buffer to a base64 encoded string.
132 * @param {Uint8Array} buffer Source buffer
133 * @param {number} start Source start
134 * @param {number} end Source end
135 * @returns {string} Base64 encoded string
136 */
137base64.encode = function encode(buffer, start, end) {
138    var parts = null,
139        chunk = [];
140    var i = 0, // output index
141        j = 0, // goto index
142        t;     // temporary
143    while (start < end) {
144        var b = buffer[start++];
145        switch (j) {
146            case 0:
147                chunk[i++] = b64[b >> 2];
148                t = (b & 3) << 4;
149                j = 1;
150                break;
151            case 1:
152                chunk[i++] = b64[t | b >> 4];
153                t = (b & 15) << 2;
154                j = 2;
155                break;
156            case 2:
157                chunk[i++] = b64[t | b >> 6];
158                chunk[i++] = b64[b & 63];
159                j = 0;
160                break;
161        }
162        if (i > 8191) {
163            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
164            i = 0;
165        }
166    }
167    if (j) {
168        chunk[i++] = b64[t];
169        chunk[i++] = 61;
170        if (j === 1)
171            chunk[i++] = 61;
172    }
173    if (parts) {
174        if (i)
175            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
176        return parts.join("");
177    }
178    return String.fromCharCode.apply(String, chunk.slice(0, i));
179};
180
181var invalidEncoding = "invalid encoding";
182
183/**
184 * Decodes a base64 encoded string to a buffer.
185 * @param {string} string Source string
186 * @param {Uint8Array} buffer Destination buffer
187 * @param {number} offset Destination offset
188 * @returns {number} Number of bytes written
189 * @throws {Error} If encoding is invalid
190 */
191base64.decode = function decode(string, buffer, offset) {
192    var start = offset;
193    var j = 0, // goto index
194        t;     // temporary
195    for (var i = 0; i < string.length;) {
196        var c = string.charCodeAt(i++);
197        if (c === 61 && j > 1)
198            break;
199        if ((c = s64[c]) === undefined)
200            throw Error(invalidEncoding);
201        switch (j) {
202            case 0:
203                t = c;
204                j = 1;
205                break;
206            case 1:
207                buffer[offset++] = t << 2 | (c & 48) >> 4;
208                t = c;
209                j = 2;
210                break;
211            case 2:
212                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
213                t = c;
214                j = 3;
215                break;
216            case 3:
217                buffer[offset++] = (t & 3) << 6 | c;
218                j = 0;
219                break;
220        }
221    }
222    if (j === 1)
223        throw Error(invalidEncoding);
224    return offset - start;
225};
226
227/**
228 * Tests if the specified string appears to be base64 encoded.
229 * @param {string} string String to test
230 * @returns {boolean} `true` if probably base64 encoded, otherwise false
231 */
232base64.test = function test(string) {
233    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
234};
235
236},{}],3:[function(require,module,exports){
237"use strict";
238module.exports = codegen;
239
240/**
241 * Begins generating a function.
242 * @memberof util
243 * @param {string[]} functionParams Function parameter names
244 * @param {string} [functionName] Function name if not anonymous
245 * @returns {Codegen} Appender that appends code to the function's body
246 */
247function codegen(functionParams, functionName) {
248
249    /* istanbul ignore if */
250    if (typeof functionParams === "string") {
251        functionName = functionParams;
252        functionParams = undefined;
253    }
254
255    var body = [];
256
257    /**
258     * Appends code to the function's body or finishes generation.
259     * @typedef Codegen
260     * @type {function}
261     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any
262     * @param {...*} [formatParams] Format parameters
263     * @returns {Codegen|Function} Itself or the generated function if finished
264     * @throws {Error} If format parameter counts do not match
265     */
266
267    function Codegen(formatStringOrScope) {
268        // note that explicit array handling below makes this ~50% faster
269
270        // finish the function
271        if (typeof formatStringOrScope !== "string") {
272            var source = toString();
273            if (codegen.verbose)
274                console.log("codegen: " + source); // eslint-disable-line no-console
275            source = "return " + source;
276            if (formatStringOrScope) {
277                var scopeKeys   = Object.keys(formatStringOrScope),
278                    scopeParams = new Array(scopeKeys.length + 1),
279                    scopeValues = new Array(scopeKeys.length),
280                    scopeOffset = 0;
281                while (scopeOffset < scopeKeys.length) {
282                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];
283                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];
284                }
285                scopeParams[scopeOffset] = source;
286                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func
287            }
288            return Function(source)(); // eslint-disable-line no-new-func
289        }
290
291        // otherwise append to body
292        var formatParams = new Array(arguments.length - 1),
293            formatOffset = 0;
294        while (formatOffset < formatParams.length)
295            formatParams[formatOffset] = arguments[++formatOffset];
296        formatOffset = 0;
297        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {
298            var value = formatParams[formatOffset++];
299            switch ($1) {
300                case "d": case "f": return String(Number(value));
301                case "i": return String(Math.floor(value));
302                case "j": return JSON.stringify(value);
303                case "s": return String(value);
304            }
305            return "%";
306        });
307        if (formatOffset !== formatParams.length)
308            throw Error("parameter count mismatch");
309        body.push(formatStringOrScope);
310        return Codegen;
311    }
312
313    function toString(functionNameOverride) {
314        return "function " + (functionNameOverride || functionName || "") + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
315    }
316
317    Codegen.toString = toString;
318    return Codegen;
319}
320
321/**
322 * Begins generating a function.
323 * @memberof util
324 * @function codegen
325 * @param {string} [functionName] Function name if not anonymous
326 * @returns {Codegen} Appender that appends code to the function's body
327 * @variation 2
328 */
329
330/**
331 * When set to `true`, codegen will log generated code to console. Useful for debugging.
332 * @name util.codegen.verbose
333 * @type {boolean}
334 */
335codegen.verbose = false;
336
337},{}],4:[function(require,module,exports){
338"use strict";
339module.exports = EventEmitter;
340
341/**
342 * Constructs a new event emitter instance.
343 * @classdesc A minimal event emitter.
344 * @memberof util
345 * @constructor
346 */
347function EventEmitter() {
348
349    /**
350     * Registered listeners.
351     * @type {Object.<string,*>}
352     * @private
353     */
354    this._listeners = {};
355}
356
357/**
358 * Registers an event listener.
359 * @param {string} evt Event name
360 * @param {function} fn Listener
361 * @param {*} [ctx] Listener context
362 * @returns {util.EventEmitter} `this`
363 */
364EventEmitter.prototype.on = function on(evt, fn, ctx) {
365    (this._listeners[evt] || (this._listeners[evt] = [])).push({
366        fn  : fn,
367        ctx : ctx || this
368    });

369    return this;
370};
371
372/**
373 * Removes an event listener or any matching listeners if arguments are omitted.
374 * @param {string} [evt] Event name. Removes all listeners if omitted.
375 * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
376 * @returns {util.EventEmitter} `this`
377 */
378EventEmitter.prototype.off = function off(evt, fn) {
379    if (evt === undefined)
380        this._listeners = {};
381    else {
382        if (fn === undefined)
383            this._listeners[evt] = [];
384        else {
385            var listeners = this._listeners[evt];
386            for (var i = 0; i < listeners.length;)
387                if (listeners[i].fn === fn)
388                    listeners.splice(i, 1);
389                else
390                    ++i;
391        }
392    }
393    return this;
394};
395
396/**
397 * Emits an event by calling its listeners with the specified arguments.
398 * @param {string} evt Event name
399 * @param {...*} args Arguments
400 * @returns {util.EventEmitter} `this`
401 */
402EventEmitter.prototype.emit = function emit(evt) {
403    var listeners = this._listeners[evt];
404    if (listeners) {
405        var args = [],
406            i = 1;
407        for (; i < arguments.length;)
408            args.push(arguments[i++]);
409        for (i = 0; i < listeners.length;)
410            listeners[i].fn.apply(listeners[i++].ctx, args);
411    }
412    return this;
413};
414
415},{}],5:[function(require,module,exports){
416"use strict";
417module.exports = fetch;
418
419var asPromise = require(1),
420    inquire   = require(7);
421
422var fs = inquire("fs");
423
424/**
425 * Node-style callback as used by {@link util.fetch}.
426 * @typedef FetchCallback
427 * @type {function}
428 * @param {?Error} error Error, if any, otherwise `null`
429 * @param {string} [contents] File contents, if there hasn't been an error
430 * @returns {undefined}
431 */
432
433/**
434 * Options as used by {@link util.fetch}.
435 * @typedef FetchOptions
436 * @type {Object}
437 * @property {boolean} [binary=false] Whether expecting a binary response
438 * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest
439 */
440
441/**
442 * Fetches the contents of a file.
443 * @memberof util
444 * @param {string} filename File path or url
445 * @param {FetchOptions} options Fetch options
446 * @param {FetchCallback} callback Callback function
447 * @returns {undefined}
448 */
449function fetch(filename, options, callback) {
450    if (typeof options === "function") {
451        callback = options;
452        options = {};
453    } else if (!options)
454        options = {};
455
456    if (!callback)
457        return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this
458
459    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.
460    if (!options.xhr && fs && fs.readFile)
461        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {
462            return err && typeof XMLHttpRequest !== "undefined"
463                ? fetch.xhr(filename, options, callback)
464                : err
465                ? callback(err)
466                : callback(null, options.binary ? contents : contents.toString("utf8"));
467        });
468
469    // use the XHR version otherwise.
470    return fetch.xhr(filename, options, callback);
471}
472
473/**
474 * Fetches the contents of a file.
475 * @name util.fetch
476 * @function
477 * @param {string} path File path or url
478 * @param {FetchCallback} callback Callback function
479 * @returns {undefined}
480 * @variation 2
481 */
482
483/**
484 * Fetches the contents of a file.
485 * @name util.fetch
486 * @function
487 * @param {string} path File path or url
488 * @param {FetchOptions} [options] Fetch options
489 * @returns {Promise<string|Uint8Array>} Promise
490 * @variation 3
491 */
492
493/**/
494fetch.xhr = function fetch_xhr(filename, options, callback) {
495    var xhr = new XMLHttpRequest();
496    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {
497
498        if (xhr.readyState !== 4)
499            return undefined;
500
501        // local cors security errors return status 0 / empty string, too. afaik this cannot be
502        // reliably distinguished from an actually empty file for security reasons. feel free
503        // to send a pull request if you are aware of a solution.
504        if (xhr.status !== 0 && xhr.status !== 200)
505            return callback(Error("status " + xhr.status));
506
507        // if binary data is expected, make sure that some sort of array is returned, even if
508        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.
509        if (options.binary) {
510            var buffer = xhr.response;
511            if (!buffer) {
512                buffer = [];
513                for (var i = 0; i < xhr.responseText.length; ++i)
514                    buffer.push(xhr.responseText.charCodeAt(i) & 255);
515            }
516            return callback(null, typeof Uint8Array !== "undefined" ? new Uint8Array(buffer) : buffer);
517        }
518        return callback(null, xhr.responseText);
519    };
520
521    if (options.binary) {
522        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers
523        if ("overrideMimeType" in xhr)
524            xhr.overrideMimeType("text/plain;

524 charset=x-user-defined");
525        xhr.responseType = "arraybuffer";
526    }
527
528    xhr.open("GET", filename);
529    xhr.send();
530};
531
532},{"1":1,"7":7}],6:[function(require,module,exports){
533"use strict";
534
535module.exports = factory(factory);
536
537/**
538 * Reads / writes floats / doubles from / to buffers.
539 * @name util.float
540 * @namespace
541 */
542
543/**
544 * Writes a 32 bit float to a buffer using little endian byte order.
545 * @name util.float.writeFloatLE
546 * @function
547 * @param {number} val Value to write
548 * @param {Uint8Array} buf Target buffer
549 * @param {number} pos Target buffer offset
550 * @returns {undefined}
551 */
552
553/**
554 * Writes a 32 bit float to a buffer using big endian byte order.
555 * @name util.float.writeFloatBE
556 * @function
557 * @param {number} val Value to write
558 * @param {Uint8Array} buf Target buffer
559 * @param {number} pos Target buffer offset
560 * @returns {undefined}
561 */
562
563/**
564 * Reads a 32 bit float from a buffer using little endian byte order.
565 * @name util.float.readFloatLE
566 * @function
567 * @param {Uint8Array} buf Source buffer
568 * @param {number} pos Source buffer offset
569 * @returns {number} Value read
570 */
571
572/**
573 * Reads a 32 bit float from a buffer using big endian byte order.
574 * @name util.float.readFloatBE
575 * @function
576 * @param {Uint8Array} buf Source buffer
577 * @param {number} pos Source buffer offset
578 * @returns {number} Value read
579 */
580
581/**
582 * Writes a 64 bit double to a buffer using little endian byte order.
583 * @name util.float.writeDoubleLE
584 * @function
585 * @param {number} val Value to write
586 * @param {Uint8Array} buf Target buffer
587 * @param {number} pos Target buffer offset
588 * @returns {undefined}
589 */
590
591/**
592 * Writes a 64 bit double to a buffer using big endian byte order.
593 * @name util.float.writeDoubleBE
594 * @function
595 * @param {number} val Value to write
596 * @param {Uint8Array} buf Target buffer
597 * @param {number} pos Target buffer offset
598 * @returns {undefined}
599 */
600
601/**
602 * Reads a 64 bit double from a buffer using little endian byte order.
603 * @name util.float.readDoubleLE
604 * @function
605 * @param {Uint8Array} buf Source buffer
606 * @param {number} pos Source buffer offset
607 * @returns {number} Value read
608 */
609
610/**
611 * Reads a 64 bit double from a buffer using big endian byte order.
612 * @name util.float.readDoubleBE
613 * @function
614 * @param {Uint8Array} buf Source buffer
615 * @param {number} pos Source buffer offset
616 * @returns {number} Value read
617 */
618
619// Factory function for the purpose of node-based testing in modified global environments
620function factory(exports) {
621
622    // float: typed array
623    if (typeof Float32Array !== "undefined") (function() {
624
625        var f32 = new Float32Array([ -0 ]),
626            f8b = new Uint8Array(f32.buffer),
627            le  = f8b[3] === 128;
628
629        function writeFloat_f32_cpy(val, buf, pos) {
630            f32[0] = val;
631            buf[pos    ] = f8b[0];
632            buf[pos + 1] = f8b[1];
633            buf[pos + 2] = f8b[2];
634            buf[pos + 3] = f8b[3];
635        }
636
637        function writeFloat_f32_rev(val, buf, pos) {
638            f32[0] = val;
639            buf[pos    ] = f8b[3];
640            buf[pos + 1] = f8b[2];
641            buf[pos + 2] = f8b[1];
642            buf[pos + 3] = f8b[0];
643        }
644
645        /* istanbul ignore next */
646        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
647        /* istanbul ignore next */
648        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
649
650        function readFloat_f32_cpy(buf, pos) {
651            f8b[0] = buf[pos    ];
652            f8b[1] = buf[pos + 1];
653            f8b[2] = buf[pos + 2];
654            f8b[3] = buf[pos + 3];
655            return f32[0];
656        }
657
658        function readFloat_f32_rev(buf, pos) {
659            f8b[3] = buf[pos    ];
660            f8b[2] = buf[pos + 1];
661            f8b[1] = buf[pos + 2];
662            f8b[0] = buf[pos + 3];
663            return f32[0];
664        }
665
666        /* istanbul ignore next */
667        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
668        /* istanbul ignore next */
669        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
670
671    // float: ieee754
672    })(); else (function() {
673
674        function writeFloat_ieee754(writeUint, val, buf, pos) {
675            var sign = val < 0 ? 1 : 0;
676            if (sign)
677                val = -val;
678            if (val === 0)
679                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);
680            else if (isNaN(val))
681                writeUint(2143289344, buf, pos);
682            else if (val > 3.4028234663852886e+38) // +-Infinity
683                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);
684            else if (val < 1.1754943508222875e-38) // denormal
685                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);
686            else {
687                var exponent = Math.floor(Math.log(val) / Math.LN2),
688                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
689                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
690            }
691        }
692
693        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
694        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
695
696        function readFloat_ieee754(readUint, buf, pos) {
697            var uint = readUint(buf, pos),
698                sign = (uint >> 31) * 2 + 1,
699                exponent = uint >>> 23 & 255,
700                mantissa = uint & 8388607;
701            return exponent === 255
702                ? mantissa
703                ? NaN
704                : sign * Infinity
705                : exponent === 0 // denormal
706                ? sign * 1.401298464324817e-45 * mantissa
707                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
708        }
709
710        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
711        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
712
713    })();
714
715    // double: typed array
716    if (typeof Float64Array !== "undefined") (function() {
717
718        var f64 = new Float64Array([-0]),
719            f8b = new Uint8Array(f64.buffer),
720            le  = f8b[7] === 128;
721
722        function writeDouble_f64_cpy(val, buf, pos) {
723            f64[0] = val;
724            buf[pos    ] = f8b[0];
725            buf[pos + 1] = f8b[1];
726            buf[pos + 2] = f8b[2];
727            buf[pos + 3] = f8b[3];
728            buf[pos + 4] = f8b[4];
729            buf[pos + 5] = f8b[5];
730            buf[pos + 6] = f8b[6];
731            buf[pos + 7] = f8b[7];
732        }
733
734        function writeDouble_f64_rev(val, buf, pos) {
735            f64[0] = val;
736            buf[pos    ] = f8b[7];
737            buf[pos + 1] = f8b[6];
738            buf[pos + 2] = f8b[5];
739            buf[pos + 3] = f8b[4];
740            buf[pos + 4] = f8b[3];
741            buf[pos + 5] = f8b[2];
742            buf[pos + 6] = f8b[1];
743            buf[pos + 7] = f8b[0];
744        }
745
746        /* istanbul ignore next */
747        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
748        /* istanbul ignore next */
749        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
750
751        function readDouble_f64_cpy(buf, pos) {
752            f8b[0] = buf[pos    ];
753            f8b[1] = buf[pos + 1];
754            f8b[2] = buf[pos + 2];
755            f8b[3] = buf[pos + 3];
756            f8b[4] = buf[pos + 4];
757            f8b[5] = buf[pos + 5];
758            f8b[6] = buf[pos + 6];
759            f8b[7] = buf[pos + 7];
760            return f64[0];
761        }
762
763        function readDouble_f64_rev(buf, pos) {
764            f8b[7] = buf[pos    ];
765            f8b[6] = buf[pos + 1];
766            f8b[5] = buf[pos + 2];
767            f8b[4] = buf[pos + 3];
768            f8b[3] = buf[pos + 4];
769            f8b[2] = buf[pos + 5];
770            f8b[1] = buf[pos + 6];
771            f8b[0] = buf[pos + 7];
772            return f64[0];
773        }
774
775        /* istanbul ignore next */
776        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
777        /* istanbul ignore next */
778        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
779
780    // double: ieee754
781    })(); else (function() {
782
783        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
784            var sign = val < 0 ? 1 : 0;
785            if (sign)
786                val = -val;
787            if (val === 0) {
788                writeUint(0, buf, pos + off0);
789                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);
790            } else if (isNaN(val)) {
791                writeUint(0, buf, pos + off0);
792                writeUint(2146959360, buf, pos + off1);
793            } else if (val > 1.7976931348623157e+308) { // +-Infinity
794                writeUint(0, buf, pos + off0);
795                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
796            } else {
797                var mantissa;
798                if (val < 2.2250738585072014e-308) { // denormal
799                    mantissa = val / 5e-324;
800                    writeUint(mantissa >>> 0, buf, pos + off0);
801                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
802                } else {
803                    var exponent = Math.floor(Math.log(val) / Math.LN2);
804                    if (exponent === 1024)
805                        exponent = 1023;
806                    mantissa = val * Math.pow(2, -exponent);
807                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
808                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
809                }
810            }
811        }
812
813        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
814        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
815
816        function readDouble_ieee754(readUint, off0, off1, buf, pos) {
817            var lo = readUint(buf, pos + off0),
818                hi = readUint(buf, pos + off1);
819            var sign = (hi >> 31) * 2 + 1,
820                exponent = hi >>> 20 & 2047,
821                mantissa = 4294967296 * (hi & 1048575) + lo;
822            return exponent === 2047
823                ? mantissa
824                ? NaN
825                : sign * Infinity
826                : exponent === 0 // denormal
827                ? sign * 5e-324 * mantissa
828                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
829        }
830
831        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
832        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
833
834    })();
835
836    return exports;
837}
838
839// uint helpers
840
841function writeUintLE(val, buf, pos) {
842    buf[pos    ] =  val        & 255;
843    buf[pos + 1] =  val >>> 8  & 255;
844    buf[pos + 2] =  val >>> 16 & 255;
845    buf[pos + 3] =  val >>> 24;
846}
847
848function writeUintBE(val, buf, pos) {
849    buf[pos    ] =  val >>> 24;
850    buf[pos + 1] =  val >>> 16 & 255;
851    buf[pos + 2] =  val >>> 8  & 255;
852    buf[pos + 3] =  val        & 255;
853}
854
855function readUintLE(buf, pos) {
856    return (buf[pos    ]
857          | buf[pos + 1] << 8
858          | buf[pos + 2] << 16
859          | buf[pos + 3] << 24) >>> 0;
860}
861
862function readUintBE(buf, pos) {
863    return (buf[pos    ] << 24
864          | buf[pos + 1] << 16
865          | buf[pos + 2] << 8
866          | buf[pos + 3]) >>> 0;
867}
868
869},{}],7:[function(require,module,exports){
870"use strict";
871module.exports = inquire;
872
873/**
874 * Requires a module only if available.
875 * @memberof util
876 * @param {string} moduleName Module to require
877 * @returns {?Object} Required module if available and not empty, otherwise `null`
878 */
879function inquire(moduleName) {
880    try {
881        var mod = eval("quire".replace(/^/,"re"))(moduleName); // eslint-disable-line no-eval
882        if (mod && (mod.length || Object.keys(mod).length))
883            return mod;
884    } catch (e) {} // eslint-disable-line no-empty
885    return null;
886}
887
888},{}],8:[function(require,module,exports){
889"use strict";
890
891/**
892 * A minimal path module to resolve Unix, Windows and URL paths alike.
893 * @memberof util
894 * @namespace
895 */
896var path = exports;
897
898var isAbsolute =
899/**
900 * Tests if the specified path is absolute.
901 * @param {string} path Path to test
902 * @returns {boolean} `true` if path is absolute
903 */
904path.isAbsolute = function isAbsolute(path) {
905    return /^(?:\/|\w+:)/.test(path);
906};
907
908var normalize =
909/**
910 * Normalizes the specified path.
911 * @param {string} path Path to normalize
912 * @returns {string} Normalized path
913 */
914path.normalize = function normalize(path) {
915    path = path.replace(/\\/g, "/")
916               .replace(/\/{2,}/g, "/");
917    var parts    = path.split("/"),
918        absolute = isAbsolute(path),
919        prefix   = "";
920    if (absolute)
921        prefix = parts.shift() + "/";
922    for (var i = 0; i < parts.length;) {
923        if (parts[i] === "..") {
924            if (i > 0 && parts[i - 1] !== "..")
925                parts.splice(--i, 2);
926            else if (absolute)
927                parts.splice(i, 1);
928            else
929                ++i;
930        } else if (parts[i] === ".")
931            parts.splice(i, 1);
932        else
933            ++i;
934    }
935    return prefix + parts.join("/");
936};
937
938/**
939 * Resolves the specified include path against the specified origin path.
940 * @param {string} originPath Path to the origin file
941 * @param {string} includePath Include path relative to origin path
942 * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized
943 * @returns {string} Path to the include file
944 */
945path.resolve = function resolve(originPath, includePath, alreadyNormalized) {
946    if (!alreadyNormalized)
947        includePath = normalize(includePath);
948    if (isAbsolute(includePath))
949        return includePath;
950    if (!alreadyNormalized)
951        originPath = normalize(originPath);
952    return (originPath = originPath.replace(/(?:\/|^)[^/]+$/, "")).length ? normalize(originPath + "/" + includePath) : includePath;
953};

1146// Not provided because of limited use (feel free to discuss or to provide yourself):
1147//
1148// google/protobuf/descriptor.proto
1149// google/protobuf/source_context.proto
1150// google/protobuf/type.proto
1151//
1152// Stripped and pre-parsed versions of these non-bundled files are instead available as part of
1153// the repository or package within the google/protobuf directory.
1154
1155common("any", {
1156
1157    /**
1158     * Properties of a google.protobuf.Any message.
1159     * @interface IAny
1160     * @type {Object}
1161     * @property {string} [typeUrl]
1162     * @property {Uint8Array} [bytes]
1163     * @memberof common
1164     */
1165    Any: {
1166        fields: {
1167            type_url: {
1168                type: "string",
1169                id: 1
1170            },
1171            value: {
1172                type: "bytes",
1173                id: 2
1174            }
1175        }
1176    }
1177});
1178
1179var timeType;
1180
1181common("duration", {
1182
1183    /**
1184     * Properties of a google.protobuf.Duration message.
1185     * @interface IDuration
1186     * @type {Object}
1187     * @property {number|Long} [seconds]
1188     * @property {number} [nanos]
1189     * @memberof common
1190     */
1191    Duration: timeType = {
1192        fields: {
1193            seconds: {
1194                type: "int64",
1195                id: 1
1196            },
1197            nanos: {
1198                type: "int32",
1199                id: 2
1200            }
1201        }
1202    }
1203});
1204
1205common("timestamp", {
1206
1207    /**
1208     * Properties of a google.protobuf.Timestamp message.
1209     * @interface ITimestamp
1210     * @type {Object}
1211     * @property {number|Long} [seconds]
1212     * @property {number} [nanos]
1213     * @memberof common
1214     */
1215    Timestamp: timeType
1216});
1217
1218common("empty", {
1219
1220    /**
1221     * Properties of a google.protobuf.Empty message.
1222     * @interface IEmpty
1223     * @memberof common
1224     */
1225    Empty: {
1226        fields: {}
1227    }
1228});
1229
1230common("struct", {
1231
1232    /**
1233     * Properties of a google.protobuf.Struct message.
1234     * @interface IStruct
1235     * @type {Object}
1236     * @property {Object.<string,IValue>} [fields]
1237     * @memberof common
1238     */
1239    Struct: {
1240        fields: {
1241            fields: {
1242                keyType: "string",
1243                type: "Value",
1244                id: 1
1245            }
1246        }
1247    },
1248
1249    /**
1250     * Properties of a google.protobuf.Value message.
1251     * @interface IValue
1252     * @type {Object}
1253     * @property {string} [kind]
1254     * @property {0} [nullValue]
1255     * @property {number} [numberValue]
1256     * @property {string} [stringValue]
1257     * @property {boolean} [boolValue]
1258     * @property {IStruct} [structValue]
1259     * @property {IListValue} [listValue]
1260     * @memberof common
1261     */
1262    Value: {
1263        oneofs: {
1264            kind: {
1265                oneof: [
1266                    "nullValue",
1267                    "numberValue",
1268                    "stringValue",
1269                    "boolValue",
1270                    "structValue",
1271                    "listValue"
1272                ]
1273            }
1274        },
1275        fields: {
1276            nullValue: {
1277                type: "NullValue",
1278                id: 1
1279            },
1280            numberValue: {
1281                type: "double",
1282                id: 2
1283            },
1284            stringValue: {
1285                type: "string",
1286                id: 3
1287            },
1288            boolValue: {
1289                type: "bool",
1290                id: 4
1291            },
1292            structValue: {
1293                type: "Struct",
1294                id: 5
1295            },
1296            listValue: {
1297                type: "ListValue",
1298                id: 6
1299            }
1300        }
1301    },
1302
1303    NullValue: {
1304        values: {
1305            NULL_VALUE: 0
1306        }
1307    },
1308
1309    /**
1310     * Properties of a google.protobuf.ListValue message.
1311     * @interface IListValue
1312     * @type {Object}
1313     * @property {Array.<IValue>} [values]
1314     * @memberof common
1315     */
1316    ListValue: {
1317        fields: {
1318            values: {
1319                rule: "repeated",
1320                type: "Value",
1321                id: 1
1322            }
1323        }
1324    }
1325});
1326
1327common("wrappers", {
1328
1329    /**
1330     * Properties of a google.protobuf.DoubleValue message.
1331     * @interface IDoubleValue
1332     * @type {Object}
1333     * @property {number} [value]
1334     * @memberof common
1335     */
1336    DoubleValue: {
1337        fields: {
1338            value: {
1339                type: "double",
1340                id: 1
1341            }
1342        }
1343    },
1344
1345    /**
1346     * Properties of a google.protobuf.FloatValue message.
1347     * @interface IFloatValue
1348     * @type {Object}
1349     * @property {number} [value]
1350     * @memberof common
1351     */
1352    FloatValue: {
1353        fields: {
1354            value: {
1355                type: "float",
1356                id: 1
1357            }
1358        }
1359    },
1360
1361    /**
1362     * Properties of a google.protobuf.Int64Value message.
1363     * @interface IInt64Value
1364     * @type {Object}
1365     * @property {number|Long} [value]
1366     * @memberof common
1367     */
1368    Int64Value: {
1369        fields: {
1370            value: {
1371                type: "int64",
1372                id: 1
1373            }
1374        }
1375    },
1376
1377    /**
1378     * Properties of a google.protobuf.UInt64Value message.
1379     * @interface IUInt64Value
1380     * @type {Object}
1381     * @property {number|Long} [value]
1382     * @memberof common
1383     */
1384    UInt64Value: {
1385        fields: {
1386            value: {
1387                type: "uint64",
1388                id: 1
1389            }
1390        }
1391    },
1392
1393    /**
1394     * Properties of a google.protobuf.Int32Value message.
1395     * @interface IInt32Value
1396     * @type {Object}
1397     * @property {number} [value]
1398     * @memberof common
1399     */
1400    Int32Value: {
1401        fields: {
1402            value: {
1403                type: "int32",
1404                id: 1
1405            }
1406        }
1407    },
1408
1409    /**
1410     * Properties of a google.protobuf.UInt32Value message.
1411     * @interface IUInt32Value
1412     * @type {Object}
1413     * @property {number} [value]
1414     * @memberof common
1415     */
1416    UInt32Value: {
1417        fields: {
1418            value: {
1419                type: "uint32",
1420                id: 1
1421            }
1422        }
1423    },
1424
1425    /**
1426     * Properties of a google.protobuf.BoolValue message.
1427     * @interface IBoolValue
1428     * @type {Object}
1429     * @property {boolean} [value]
1430     * @memberof common
1431     */
1432    BoolValue: {
1433        fields: {
1434            value: {
1435                type: "bool",
1436                id: 1
1437            }
1438        }
1439    },
1440
1441    /**
1442     * Properties of a google.protobuf.StringValue message.
1443     * @interface IStringValue
1444     * @type {Object}
1445     * @property {string} [value]
1446     * @memberof common
1447     */
1448    StringValue: {
1449        fields: {
1450            value: {
1451                type: "string",
1452                id: 1
1453            }
1454        }
1455    },
1456
1457    /**
1458     * Properties of a google.protobuf.BytesValue message.
1459     * @interface IBytesValue
1460     * @type {Object}
1461     * @property {Uint8Array} [value]
1462     * @memberof common
1463     */
1464    BytesValue: {
1465        fields: {
1466            value: {
1467                type: "bytes",
1468                id: 1
1469            }
1470        }
1471    }
1472});
1473
1474common("field_mask", {
1475
1476    /**
1477     * Properties of a google.protobuf.FieldMask message.
1478     * @interface IDoubleValue
1479     * @type {Object}
1480     * @property {number} [value]
1481     * @memberof common
1482     */
1483    FieldMask: {
1484        fields: {
1485            paths: {
1486                rule: "repeated",
1487                type: "string",
1488                id: 1
1489            }
1490        }
1491    }
1492});
1493
1494/**
1495 * Gets the root definition of the specified common proto file.
1496 *
1497 * Bundled definitions are:
1498 * - google/protobuf/any.proto
1499 * - google/protobuf/duration.proto
1500 * - google/protobuf/empty.proto
1501 * - google/protobuf/field_mask.proto
1502 * - google/protobuf/struct.proto
1503 * - google/protobuf/timestamp.proto
1504 * - google/protobuf/wrappers.proto
1505 *
1506 * @param {string} file Proto file name
1507 * @returns {INamespace|null} Root definition or `null` if not defined
1508 */
1509common.get = function get(file) {
1510    return common[file] || null;
1511};
1512
1513},{}],12:[function(require,module,exports){
1514"use strict";
1515/**

1631            genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[ks[i]]")
1632        ("}")
1633    ("}");
1634
1635        // Repeated fields
1636        } else if (field.repeated) { gen
1637    ("if(d%s){", prop)
1638        ("if(!Array.isArray(d%s))", prop)
1639            ("throw TypeError(%j)", field.fullName + ": array expected")
1640        ("m%s=[]", prop)
1641        ("for(var i=0;i<d%s.length;++i){", prop);
1642            genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]")
1643        ("}")
1644    ("}");
1645
1646        // Non-repeated fields
1647        } else {
1648            if (!(field.resolvedType instanceof Enum)) gen // no need to test for null/undefined if an enum (uses switch)
1649    ("if(d%s!=null){", prop); // !== undefined && !== null
1650        genValuePartial_fromObject(gen, field, /* not sorted */ i, prop);
1651            if (!(field.resolvedType instanceof Enum)) gen
1652    ("}");
1653        }
1654    } return gen
1655    ("return m");
1656    /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
1657};
1658
1659/**
1660 * Generates a partial value toObject converter.
1661 * @param {Codegen} gen Codegen instance
1662 * @param {Field} field Reflected field
1663 * @param {number} fieldIndex Field index
1664 * @param {string} prop Property reference
1665 * @returns {Codegen} Codegen instance
1666 * @ignore
1667 */
1668function genValuePartial_toObject(gen, field, fieldIndex, prop) {
1669    /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
1670    if (field.resolvedType) {
1671        if (field.resolvedType instanceof Enum) gen
1672            ("d%s=o.enums===String?types[%i].values[m%s]:m%s", prop, fieldIndex, prop, prop);
1673        else gen
1674            ("d%s=types[%i].toObject(m%s,o)", prop, fieldIndex, prop);
1675    } else {
1676        var isUnsigned = false;
1677        switch (field.type) {
1678            case "double":
1679            case "float": gen
1680            ("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", prop, prop, prop, prop);
1681                break;
1682            case "uint64":
1683                isUnsigned = true;
1684                // eslint-disable-line no-fallthrough
1685            case "int64":
1686            case "sint64":
1687            case "fixed64":
1688            case "sfixed64": gen
1689            ("if(typeof m%s===\"number\")", prop)
1690                ("d%s=o.longs===String?String(m%s):m%s", prop, prop, prop)
1691            ("else") // Long-like
1692                ("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s", prop, prop, prop, prop, isUnsigned ? "true": "", prop);
1693                break;
1694            case "bytes": gen
1695            ("d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s", prop, prop, prop, prop, prop);
1696                break;
1697            default: gen
1698            ("d%s=m%s", prop, prop);
1699                break;
1700        }
1701    }
1702    return gen;
1703    /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
1704}
1705
1706/**

2228 Created field
2229 * @throws {TypeError} If arguments are invalid
2230 */
2231Field.fromJSON = function fromJSON(name, json) {
2232    return new Field(name, json.id, json.type, json.rule, json.extend, json.options, json.comment);
2233};
2234
2235/**
2236 * Not an actual constructor. Use {@link Field} instead.
2237 * @classdesc Base class of all reflected message fields. This is not an actual class but here for the sake of having consistent type definitions.
2238 * @exports FieldBase
2239 * @extends ReflectionObject
2240 * @constructor
2241 * @param {string} name Unique name within its namespace
2242 * @param {number} id Unique id within its namespace
2243 * @param {string} type Value type
2244 * @param {string|Object.<string,*>} [rule="optional"] Field rule
2245 * @param {string|Object.<string,*>} [extend] Extended type if different from parent
2246 * @param {Object.<string,*>} [options] Declared options
2247 * @param {string} [comment] Comment associated with this field
2248 */
2249function Field(name, id, type, rule, extend, options, comment) {
2250
2251    if (util.isObject(rule)) {
2252        comment = extend;
2253        options = rule;
2254        rule = extend = undefined;
2255    } else if (util.isObject(extend)) {
2256        comment = options;
2257        options = extend;
2258        extend = undefined;
2259    }
2260
2261    ReflectionObject.call(this, name, options);
2262
2263    if (!util.isInteger(id) || id < 0)
2264        throw TypeError("id must be a non-negative integer");
2265
2266    if (!util.isString(type))
2267        throw TypeError("type must be a string");
2268
2269    if (rule !== undefined && !ruleRe.test(rule = rule.toString().toLowerCase()))
2270        throw TypeError("rule must be a string rule");
2271
2272    if (extend !== undefined && !util.isString(extend))
2273        throw TypeError("extend must be a string");
2274
2275    /**
2276     * Field rule, if any.
2277     * @type {string|undefined}
2278     */
2279    this.rule = rule && rule !== "optional" ? rule : undefined; // toJSON
2280
2281    /**
2282     * Field type.
2283     * @type {string}
2284     */
2285    this.type = type; // toJSON
2286
2287    /**
2288     * Unique field id.
2289     * @type {number}
2290     */
2291    this.id = id; // toJSON, marker
2292
2293    /**
2294     * Extended type if different from parent.
2295     * @type {string|undefined}
2296     */
2297    this.extend = extend || undefined; // toJSON
2298
2299    /**
2300     * Whether this field is required.
2301     * @type {boolean}
2302     */
2303    this.required = rule === "required";
2304
2305    /**
2306     * Whether this field is optional.
2307     * @type {boolean}
2308     */
2309    this.optional = !this.required;
2310
2311    /**
2312     * Whether this field is repeated.
2313     * @type {boolean}
2314     */
2315    this.repeated = rule === "repeated";
2316
2317    /**
2318     * Whether this field is a map or not.
2319     * @type {boolean}
2320     */
2321    this.map = false;
2322
2323    /**
2324     * Message this field belongs to.
2325     * @type {Type|null}
2326     */
2327    this.message = null;
2328
2329    /**
2330     * OneOf this field belongs to, if any,
2331     * @type {OneOf|null}
2332     */
2333    this.partOf = null;
2334
2335    /**
2336     * The field type's default value.
2337     * @type {*}
2338     */
2339    this.typeDefault = null;
2340
2341    /**
2342     * The field's default value on prototypes.
2343     * @type {*}
2344     */
2345    this.defaultValue = null;
2346
2347    /**
2348     * Whether this field's value should be treated as a long.
2349     * @type {boolean}
2350     */
2351    this.long = util.Long ? types.long[type] !== undefined : /* istanbul ignore next */ false;
2352
2353    /**
2354     * Whether this field's value is a buffer.
2355     * @type {boolean}
2356     */
2357    this.bytes = type === "bytes";
2358
2359    /**
2360     * Resolved type if not a basic type.
2361     * @type {Type|Enum|null}
2362     */
2363    this.resolvedType = null;
2364
2365    /**
2366     * Sister-field within the extended type if a declaring extension field.
2367     * @type {Field|null}
2368     */
2369    this.extensionField = null;
2370
2371    /**
2372     * Sister-field within the declaring namespace if an extended field.
2373     * @type {Field|null}
2374     */
2375    this.declaringField = null;
2376
2377    /**
2378     * Internally remembers whether this field is packed.
2379     * @type {boolean|null}
2380     * @private
2381     */

2548
2549/**
2550 * Field decorator (TypeScript).
2551 * @name Field.d
2552 * @function
2553 * @param {number} fieldId Field id
2554 * @param {Constructor<T>|string} fieldType Field type
2555 * @param {"optional"|"required"|"repeated"} [fieldRule="optional"] Field rule
2556 * @returns {FieldDecorator} Decorator function
2557 * @template T extends Message<T>
2558 * @variation 2
2559 */
2560// like Field.d but without a default value
2561
2562Field._configure = function configure(Type_) {
2563    Type = Type_;
2564};
2565
2566},{"15":15,"24":24,"36":36,"37":37}],17:[function(require,module,exports){
2567"use strict";
2568var protobuf = module.exports = require(18);
2569
2570protobuf.build = "light";
2571
2572/**
2573 * A node-style callback as used by {@link load} and {@link Root#load}.
2574 * @typedef LoadCallback
2575 * @type {function}
2576 * @param {Error|null} error Error, if any, otherwise `null`
2577 * @param {Root} [root] Root, if there hasn't been an error
2578 * @returns {undefined}
2579 */
2580
2581/**
2582 * Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.
2583 * @param {string|string[]} filename One or multiple files to load
2584 * @param {Root} root Root namespace, defaults to create a new one if omitted.
2585 * @param {LoadCallback} callback Callback function
2586 * @returns {undefined}
2587 * @see {@link Root#load}
2588 */
2589function load(filename, root, callback) {
2590    if (typeof root === "function") {
2591        callback = root;
2592        root = new protobuf.Root();
2593    } else if (!root)
2594        root = new protobuf.Root();
2595    return root.load(filename, callback);
2596}
2597
2598/**
2599 * Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.
2600 * @name load
2601 * @function
2602 * @param {string|string[]} filename One or multiple files to load
2603 * @param {LoadCallback} callback Callback function
2604 * @returns {undefined}
2605 * @see {@link Root#load}
2606 * @variation 2
2607 */
2608// function load(filename:string, callback:LoadCallback):undefined
2609
2610/**
2611 * Loads one or multiple .proto or preprocessed .json files into a common root namespace and returns a promise.
2612 * @name load
2613 * @function
2614 * @param {string|string[]} filename One or multiple files to load
2615 * @param {Root} [root] Root namespace, defaults to create a new one if omitted.
2616 * @returns {Promise<Root>} Promise
2617 * @see {@link Root#load}
2618 * @variation 3
2619 */
2620// function load(filename:string, [root:Root]):Promise<Root>
2621
2622protobuf.load = load;
2623
2624/**
2625 * Synchronously loads one or multiple .proto or preprocessed .json files into a common root namespace (node only).
2626 * @param {string|string[]} filename One or multiple files to load
2627 * @param {Root} [root] Root namespace, defaults to create a new one if omitted.
2628 * @returns {Root} Root namespace
2629 * @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invali

2629d
2630 * @see {@link Root#loadSync}
2631 */
2632function loadSync(filename, root) {
2633    if (!root)
2634        root = new protobuf.Root();
2635    return root.loadSync(filename);
2636}
2637
2638protobuf.loadSync = loadSync;
2639
2640// Serialization
2641protobuf.encoder          = require(14);
2642protobuf.decoder          = require(13);
2643protobuf.verifier         = require(40);
2644protobuf.converter        = require(12);
2645
2646// Reflection
2647protobuf.ReflectionObject = require(24);
2648protobuf.Namespace        = require(23);
2649protobuf.Root             = require(29);
2650protobuf.Enum             = require(15);
2651protobuf.Type             = require(35);
2652protobuf.Field            = require(16);
2653protobuf.OneOf            = require(25);
2654protobuf.MapField         = require(20);
2655protobuf.Service          = require(33);
2656protobuf.Method           = require(22);
2657
2658// Runtime
2659protobuf.Message          = require(21);
2660protobuf.wrappers         = require(41);
2661
2662// Utility
2663protobuf.types            = require(36);
2664protobuf.util             = require(37);
2665
2666// Configure reflection
2667protobuf.ReflectionObject._configure(protobuf.Root);
2668protobuf.Namespace._configure(protobuf.Type, protobuf.Service);
2669protobuf.Root._configure(protobuf.Type);
2670protobuf.Field._configure(protobuf.Type);
2671
2672},{"12":12,"13":13,"14":14,"15":15,"16":16,"18":18,"20":20,"21":21,"22":22,"23":23,"24":24,"25":25,"29":29,"33":33,"35":35,"36":36,"37":37,"40":40,"41":41}],18:[function(require,module,exports){
2673"use strict";
2674var protobuf = exports;
2675
2676/**
2677 * Build type, one of `"full"`, `"light"` or `"minimal"`.
2678 * @name build
2679 * @type {string}
2680 * @const
2681 */
2682protobuf.build = "minimal";
2683
2684// Serialization
2685protobuf.Writer       = require(42);
2686protobuf.BufferWriter = require(43);
2687protobuf.Reader       = require(27);
2688protobuf.BufferReader = require(28);
2689
2690// Utility
2691protobuf.util         = require(39);
2692protobuf.rpc          = require(31);
2693protobuf.roots        = require(30);
2694protobuf.configure    = configure;
2695
2696/* istanbul ignore next */
2697/**
2698 * Reconfigures the library according to the environment.
2699 * @returns {undefined}
2700 */
2701function configure() {
2702    protobuf.Reader._configure(protobuf.BufferReader);
2703    protobuf.util._configure();
2704}
2705
2706// Configure serialization
2707protobuf.Writer._configure(protobuf.BufferWriter);
2708configure();
2709
2710},{"27":27,"28":28,"30":30,"31":31,"39":39,"42":42,"43":43}],19:[function(require,module,exports){
2711"use strict";
2712var protobuf = module.exports = require(17);
2713
2714protobuf.build = "full";
2715
2716// Parser
2717protobuf.tokenize         = require(34);
2718protobuf.parse            = require(26);
2719protobuf.common           = require(11);
2720
2721// Configure parser
2722protobuf.Root._configure(protobuf.Type, protobuf.parse, protobuf.common);
2723
2724},{"11":11,"17":17,"26":26,"34":34}],20:[function(require,module,exports){
2725"use strict";
2726module.exports = MapField;
2727
2728// extends Field
2729var Field = require(16);
2730((MapField.prototype = Object.create(Field.prototype)).constructor = MapField).className = "MapField";
2731
2732var types   = require(36),
2733    util    = require(37);
2734
2735/**
2736 * Constructs a new map field instance.
2737 * @classdesc Reflected map field.
2738 * @extends FieldBase
2739 * @constructor
2740 * @param {string} name Unique name within its namespace
2741 * @param {number} id Unique id within its namespace
2742 * @param {string} keyType Key type
2743 * @param {string} type Value type
2744 * @param {Object.<string,*>} [options] Declared options
2745 * @param {string} [comment] Comment associated with this field
2746 */
2747function MapField(name, id, keyType, type, options, comment) {
2748    Field.call(this, name, id, type, undefined, undefined, options, comment);
2749
2750    /* istanbul ignore if */
2751    if (!util.isString(keyType))
2752        throw TypeError("keyType must be a string");
2753
2754    /**
2755     * Key type.
2756     * @type {string}
2757     */
2758    this.keyType = keyType; // toJSON, marker
2759
2760    /**
2761     * Resolved key type if not a basic type.
2762     * @type {ReflectionObject|null}
2763     */
2764    this.resolvedKeyType = null;
2765
2766    // Overrides Field#map
2767    this.map = true;
2768}
2769
2770/**
2771 * Map field descriptor.
2772 * @interface IMapField
2773 * @extends {IField}
2774 * @property {string} keyType Key type
2775 */
2776
2777/**
2778 * Extension map field descriptor.
2779 * @interface IExtensionMapField
2780 * @extends IMapField
2781 * @property {string} extend Extended type
2782 */
2783
2784/**
2785 * Constructs a map field from a map field descriptor.
2786 * @param {string} name Field name
2787 * @param {IMapField} json Map field descriptor
2788 * @returns {MapField} Created map field
2789 * @throws {TypeError} If arguments are invalid
2790 */
2791MapField.fromJSON = function fromJSON(name, json) {
2792    return new MapField(name, json.id, json.keyType, json.type, json.options, json.comment);
2793};
2794
2795/**
2796 * Converts this map field to a map field descriptor.
2797 * @param {IToJSONOptions} [toJSONOptions] JSON conversion options
2798 * @returns {IMapField} Map field descriptor
2799 */
2800MapField.prototype.toJSON = function toJSON(toJSONOptions) {
2801    var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
2802    return util.toObject([
2803        "keyType" , this.keyType,
2804        "type"    , this.type,
2805        "id"      , this.id,
2806        "extend"  , this.extend,
2807        "options" , this.options,
2808        "comment" , keepComments ? this.comment : undefined
2809    ]);
2810};
2811
2812/**
2813 * @override
2814 */
2815MapField.prototype.resolve = function resolve() {
2816    if (this.resolved)
2817        return this;
2818
2819    // Besides a value type, map fields have a key type that may be "any scalar type except for floating point types and bytes"
2820    if (types.mapKey[this.keyType] === undefined)
2821        throw Error("invalid key type: " + this.keyType);
2822
2823    return Field.prototype.resolve.call(this);
2824};
2825
2826/**
2827 * Map field decorator (TypeScript).
2828 * @name MapField.d
2829 * @function
2830 * @param {number} fieldId Field id
2831 * @param {"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"bool"|"string"} fieldKeyType Field key type
2832 * @param {"double"|"float"|"int32"|"uint32"|"sint32"|"fixed32"|"sfixed32"|"int64"|"uint64"|"sint64"|"fixed64"|"sfixed64"|"bool"|"string"|"bytes"|Object|Constructor<{}>} fieldValueType Field value type
2833 * @returns {FieldDecorator} Decorator function
2834 * @template T extends { [key: string]: number | Long | string | boolean | Uint8Array | Buffer | number[] | Message<{}> }
2835 */
2836MapField.d = function decorateMapField(fieldId, fieldKeyType, fieldValueType) {
2837
2838    // submessage value: decorate the submessage and use its name as the type
2839    if (typeof fieldValueType === "function")
2840        fieldValueType = util.decorateType(fieldValueType).name;
2841
2842    // enum reference value: create a reflected copy of the enum and keep reuseing it
2843    else if (fieldValueType && typeof fieldValueType === "object")
2844        fieldValueType = util.decorateEnum(fieldValueType).name;
2845
2846    return function mapFieldDecorator(prototype, fieldName) {
2847        util.decorateType(prototype.constructor)
2848            .add(new MapField(fieldName, fieldId, fieldKeyType, fieldValueType));
2849    };
2850};