https://xn--90afccar8afg8b5b.xn--p1ai/bitrix/js/pull/protobuf/protobuf.js?1626983971274055

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/**

1516 * Runtime message from/to plain object converters.
1517 * @namespace
1518 */
1519var converter = exports;
1520
1521var Enum = require(15),
1522    util = require(37);
1523
1524/**
1525 * Generates a partial value fromObject conveter.
1526 * @param {Codegen} gen Codegen instance
1527 * @param {Field} field Reflected field
1528 * @param {number} fieldIndex Field index
1529 * @param {string} prop Property reference
1530 * @returns {Codegen} Codegen instance
1531 * @ignore
1532 */
1533function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
1534    /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
1535    if (field.resolvedType) {
1536        if (field.resolvedType instanceof Enum) { gen
1537            ("switch(d%s){", prop);
1538            for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) {
1539                if (field.repeated && values[keys[i]] === field.typeDefault) gen
1540                ("default:");
1541                gen
1542                ("case%j:", keys[i])
1543                ("case %i:", values[keys[i]])
1544                    ("m%s=%j", prop, values[keys[i]])
1545                    ("break");
1546            } gen
1547            ("}");
1548        } else gen
1549            ("if(typeof d%s!==\"object\")", prop)
1550                ("throw TypeError(%j)", field.fullName + ": object expected")
1551            ("m%s=types[%i].fromObject(d%s)", prop, fieldIndex, prop);
1552    } else {
1553        var isUnsigned = false;
1554        switch (field.type) {
1555            case "double":
1556            case "float": gen
1557                ("m%s=Number(d%s)", prop, prop); // also catches "NaN", "Infinity"
1558                break;
1559            case "uint32":
1560            case "fixed32": gen
1561                ("m%s=d%s>>>0", prop, prop);
1562                break;
1563            case "int32":
1564            case "sint32":
1565            case "sfixed32": gen
1566                ("m%s=d%s|0", prop, prop);
1567                break;
1568            case "uint64":
1569                isUnsigned = true;
1570                // eslint-disable-line no-fallthrough
1571            case "int64":
1572            case "sint64":
1573            case "fixed64":
1574            case "sfixed64": gen
1575                ("if(util.Long)")
1576                    ("(m%s=util.Long.fromValue(d%s)).unsigned=%j", prop, prop, isUnsigned)
1577                ("else if(typeof d%s===\"string\")", prop)
1578                    ("m%s=parseInt(d%s,10)", prop, prop)
1579                ("else if(typeof d%s===\"number\")", prop)
1580                    ("m%s=d%s", prop, prop)
1581                ("else if(typeof d%s===\"object\")", prop)
1582                    ("m%s=new util.LongBits(d%s.low>>>0,d%s.high>>>0).toNumber(%s)", prop, prop, prop, isUnsigned ? "true" : "");
1583                break;
1584            case "bytes": gen
1585                ("if(typeof d%s===\"string\")", prop)
1586                    ("util.base64.decode(d%s,m%s=util.newBuffer(util.base64.length(d%s)),0)", prop, prop, prop)
1587                ("else if(d%s.length)", prop)
1588                    ("m%s=d%s", prop, prop);
1589                break;
1590            case "string": gen
1591                ("m%s=String(d%s)", prop, prop);
1592                break;
1593            case "bool": gen
1594                ("m%s=Boolean(d%s)", prop, prop);
1595                break;
1596            /* default: gen
1597                ("m%s=d%s", prop, prop);
1598                break; */
1599        }
1600    }
1601    return gen;
1602    /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
1603}
1604
1605/**
1606 * Generates a plain object to runtime message converter specific to the specified message type.
1607 * @param {Type} mtype Message type
1608 * @returns {Codegen} Codegen instance
1609 */
1610converter.fromObject = function fromObject(mtype) {
1611    /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
1612    var fields = mtype.fieldsArray;
1613    var gen = util.codegen(["d"], mtype.name + "$fromObject")
1614    ("if(d instanceof this.ctor)")
1615        ("return d");
1616    if (!fields.length) return gen
1617    ("return new this.ctor");
1618    gen
1619    ("var m=new this.ctor");
1620    for (var i = 0; i < fields.length; ++i) {
1621        var field  = fields[i].resolve(),
1622            prop   = util.safeProp(field.name);
1623
1624        // Map fields
1625        if (field.map) { gen
1626    ("if(d%s){", prop)
1627        ("if(typeof d%s!==\"object\")", prop)
1628            ("throw TypeError(%j)", field.fullName + ": object expected")
1629        ("m%s={}", prop)
1630        ("for(var ks=Object.keys(d%s),i=0;i<ks.length;++i){", prop);
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/**
1707 * Generates a runtime message to plain object converter specific to the specified message type.
1708 * @param {Type} mtype Message type
1709 * @returns {Codegen} Codegen instance
1710 */
1711converter.toObject = function toObject(mtype) {
1712    /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
1713    var fields = mtype.fieldsArray.slice().sort(util.compareFieldsById);
1714    if (!fields.length)
1715        return util.codegen()("return {}");
1716    var gen = util.codegen(["m", "o"], mtype.name + "$toObject")
1717    ("if(!o)")
1718        ("o={}")
1719    ("var d={}");
1720
1721    var repeatedFields = [],
1722        mapFields = [],
1723        normalFields = [],
1724        i = 0;
1725    for (; i < fields.length; ++i)
1726        if (!fields[i].partOf)
1727            ( fields[i].resolve().repeated ? repeatedFields
1728            : fields[i].map ? mapFields
1729            : normalFields).push(fields[i]);
1730
1731    if (repeatedFields.length) { gen
1732    ("if(o.arrays||o.defaults){");
1733        for (i = 0; i < repeatedFields.length; ++i) gen
1734        ("d%s=[]", util.safeProp(repeatedFields[i].name));
1735        gen
1736    ("}");
1737    }
1738
1739    if (mapFields.length) { gen
1740    ("if(o.objects||o.defaults){");
1741        for (i = 0; i < mapFields.length; ++i) gen
1742        ("d%s={}", util.safeProp(mapFields[i].name));
1743        gen
1744    ("}");
1745    }
1746
1747    if (normalFields.length) { gen
1748    ("if(o.defaults){");
1749        for (i = 0; i < normalFields.length; ++i) {
1750            var field = normalFields[i],
1751                prop  = util.safeProp(field.name);
1752            if (field.resolvedType instanceof Enum) gen
1753        ("d%s=o.enums===String?%j:%j", prop, field.resolvedType.valuesById[field.typeDefault], field.typeDefault);
1754            else if (field.long) gen
1755        ("if(util.Long){")
1756            ("var n=new util.Long(%i,%i,%j)", field.typeDefault.low, field.typeDefault.high, field.typeDefault.unsigned)
1757            ("d%s=o.longs===String?n.toString():o.longs===Number?n.toNumber():n", prop)
1758        ("}else")
1759            ("d%s=o.longs===String?%j:%i", prop, field.typeDefault.toString(), field.typeDefault.toNumber());
1760            else if (field.bytes) gen
1761        ("d%s=o.bytes===String?%j:%s", prop, String.fromCharCode.apply(String, field.typeDefault), "[" + Array.prototype.slice.call(field.typeDefault).join(",") + "]");
1762            else gen
1763        ("d%s=%j", prop, field.typeDefault); // also messages (=null)
1764        } gen
1765    ("}");
1766    }
1767    var hasKs2 = false;
1768    for (i = 0; i < fields.length; ++i) {
1769        var field = fields[i],
1770            index = mtype._fieldsArray.indexOf(field),
1771            prop  = util.safeProp(field.name);
1772        if (field.map) {
1773            if (!hasKs2) { hasKs2 = true; gen
1774    ("var ks2");
1775            } gen
1776    ("if(m%s&&(ks2=Object.keys(m%s)).length){", prop, prop)
1777        ("d%s={}", prop)
1778        ("for(var j=0;j<ks2.length;++j){");
1779            genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[ks2[j]]")
1780        ("}");
1781        } else if (field.repeated) { gen
1782    ("if(m%s&&m%s.length){", prop, prop)
1783        ("d%s=[]", prop)
1784        ("for(var j=0;j<m%s.length;++j){", prop);
1785            genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[j]")
1786        ("}");
1787        } else { gen
1788    ("if(m%s!=null&&m.hasOwnProperty(%j)){", prop, field.name); // !== undefined && !== null
1789        genValuePartial_toObject(gen, field, /* sorted */ index, prop);
1790        if (field.partOf) gen
1791        ("if(o.oneofs)")
1792            ("d%s=%j", util.safeProp(field.partOf.name), field.name);
1793        }
1794        gen
1795    ("}");
1796    }
1797    return gen
1798    ("return d");
1799    /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
1800};
1801
1802},{"15":15,"37":37}],13:[function(require,module,exports){
1803"use strict";
1804module.exports = decoder;
1805
1806var Enum    = require(15),
1807    types   = require(36),
1808    util    = require(37);
1809
1810function missing(field) {
1811    return "missing required '" + field.name + "'";
1812}
1813
1814/**
1815 * Generates a decoder specific to the specified message type.
1816 * @param {Type} mtype Message type
1817 * @returns {Codegen} Codegen instance
1818 */
1819function decoder(mtype) {
1820    /* eslint-disable no-unexpected-multiline */
1821    var gen = util.codegen(["r", "l"], mtype.name + "$decode")
1822    ("if(!(r instanceof Reader))")
1823        ("r=Reader.create(r)")
1824    ("var c=l===undefined?r.len:r.pos+l,m=new this.ctor" + (mtype.fieldsArray.filter(function(field) { return field.map; }).length ? ",k" : ""))
1825    ("while(r.pos<c){")
1826        ("var t=r.uint32()");
1827    if (mtype.group) gen
1828        ("if((t&7)===4)")
1829            ("break");
1830    gen
1831        ("switch(t>>>3){");
1832
1833    var i = 0;
1834    for (; i < /* initializes */ mtype.fieldsArray.length; ++i) {
1835        var field = mtype._fieldsArray[i].resolve(),
1836            type  = field.resolvedType instanceof Enum ? "int32" : field.type,
1837            ref   = "m" + util.safeProp(field.name); gen
1838            ("case %i:", field.id);
1839
1840        // Map fields
1841        if (field.map) { gen
1842                ("r.skip().pos++") // assumes id 1 + key wireType

1946    // "when a message is serialized its known fields should be written sequentially by field number"
1947    var fields = /* initializes */ mtype.fieldsArray.slice().sort(util.compareFieldsById);
1948
1949    for (var i = 0; i < fields.length; ++i) {
1950        var field    = fields[i].resolve(),
1951            index    = mtype._fieldsArray.indexOf(field),
1952            type     = field.resolvedType instanceof Enum ? "int32" : field.type,
1953            wireType = types.basic[type];
1954            ref      = "m" + util.safeProp(field.name);
1955
1956        // Map fields
1957        if (field.map) {
1958            gen
1959    ("if(%s!=null&&m.hasOwnProperty(%j)){", ref, field.name) // !== undefined && !== null
1960        ("for(var ks=Object.keys(%s),i=0;i<ks.length;++i){", ref)
1961            ("w.uint32(%i).fork().uint32(%i).%s(ks[i])", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType], field.keyType);
1962            if (wireType === undefined) gen
1963            ("types[%i].encode(%s[ks[i]],w.uint32(18).fork()).ldelim().ldelim()", index, ref); // can't be groups
1964            else gen
1965            (".uint32(%i).%s(%s[ks[i]]).ldelim()", 16 | wireType, type, ref);
1966            gen
1967        ("}")
1968    ("}");
1969
1970            // Repeated fields
1971        } else if (field.repeated) { gen
1972    ("if(%s!=null&&%s.length){", ref, ref); // !== undefined && !== null
1973
1974            // Packed repeated
1975            if (field.packed && types.packed[type] !== undefined) { gen
1976
1977        ("w.uint32(%i).fork()", (field.id << 3 | 2) >>> 0)
1978        ("for(var i=0;i<%s.length;++i)", ref)
1979            ("w.%s(%s[i])", type, ref)
1980        ("w.ldelim()");
1981
1982            // Non-packed
1983            } else { gen
1984
1985        ("for(var i=0;i<%s.length;++i)", ref);
1986                if (wireType === undefined)
1987            genTypePartial(gen, field, index, ref + "[i]");
1988                else gen
1989            ("w.uint32(%i).%s(%s[i])", (field.id << 3 | wireType) >>> 0, type, ref);
1990
1991            } gen
1992    ("}");
1993
1994        // Non-repeated
1995        } else {
1996            if (field.optional) gen
1997    ("if(%s!=null&&m.hasOwnProperty(%j))", ref, field.name); // !== undefined && !== null
1998
1999            if (wireType === undefined)
2000        genTypePartial(gen, field, index, ref);
2001            else gen
2002        ("w.uint32(%i).%s(%s)", (field.id << 3 | wireType) >>> 0, type, ref);
2003
2004        }
2005    }
2006
2007    return gen
2008    ("return w");
2009    /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
2010}
2011},{"15":15,"36":36,"37":37}],15:[function(require,module,exports){
2012"use strict";
2013module.exports = Enum;
2014
2015// extends ReflectionObject
2016var ReflectionObject = require(24);
2017((Enum.prototype = Object.create(ReflectionObject.prototype)).constructor = Enum).className = "Enum";
2018
2019var Namespace = require(23),
2020    util = require(37);
2021
2022/**
2023 * Constructs a new enum instance.
2024 * @classdesc Reflected enum.
2025 * @extends ReflectionObject
2026 * @constructor
2027 * @param {string} name Unique name within its namespace
2028 * @param {Object.<string,number>} [values] Enum values as an object, by name
2029 * @param {Object.<string,*>} [options] Declared options
2030 * @param {string} [comment] The comment for this enum
2031 * @param {Object.<string,string>} [comments] The value comments for this enum
2032 */
2033function Enum(name, values, options, comment, comments) {
2034    ReflectionObject.call(this, name, options);
2035
2036    if (values && typeof values !== "object")
2037        throw TypeError("values must be an object");
2038
2039    /**
2040     * Enum values by id.
2041     * @type {Object.<number,string>}
2042     */
2043    this.valuesById = {};
2044
2045    /**
2046     * Enum values by name.
2047     * @type {Object.<string,number>}
2048     */
2049    this.values = Object.create(this.valuesById); // toJSON, marker
2050
2051    /**
2052     * Enum comment text.
2053     * @type {string|null}
2054     */
2055    this.comment = comment;
2056
2057    /**
2058     * Value comment texts, if any.
2059     * @type {Object.<string,string>}
2060     */
2061    this.comments = comments || {};
2062
2063    /**
2064     * Reserved ranges, if any.
2065     * @type {Array.<number[]|string>}
2066     */
2067    this.reserved = undefined; // toJSON
2068

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};