dexbot 1.4.12 → 1.4.13

package/claw/node_modules/bytebuffer/src/types/strings/utf8string.js

@@ -0,0 +1,214 @@
+//? if (UTF8STRING && UTF8) {
+// types/strings/utf8string
+
+/**
+ * Metrics representing number of UTF8 characters. Evaluates to `c`.
+ * @type {string}
+ * @const
+ * @expose
+ */
+ByteBuffer.METRICS_CHARS = 'c';
+
+/**
+ * Metrics representing number of bytes. Evaluates to `b`.
+ * @type {string}
+ * @const
+ * @expose
+ */
+ByteBuffer.METRICS_BYTES = 'b';
+
+/**
+ * Writes an UTF8 encoded string.
+ * @param {string} str String to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.
+ * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.
+ * @expose
+ */
+ByteBufferPrototype.writeUTF8String = function(str, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET();
+    }
+    var k;
+    //? if (NODE) {
+    k = Buffer.byteLength(str, "utf8");
+    //? ENSURE_CAPACITY('k');
+    offset += this.buffer.write(str, offset, k, "utf8");
+    if (relative) {
+        this.offset = offset;
+        return this;
+    }
+    return k;
+    //? } else {
+    var start = offset;
+    k = utfx.calculateUTF16asUTF8(stringSource(str))[1];
+    //? ENSURE_CAPACITY('k');
+    utfx.encodeUTF16toUTF8(stringSource(str), function(b) {
+        //? if (DATAVIEW)
+        this.view.setUint8(offset++, b);
+        //? else
+        this.view[offset++] = b;
+    }.bind(this));
+    if (relative) {
+        this.offset = offset;
+        return this;
+    }
+    return offset - start;
+    //? }
+};
+//? if (ALIASES) {
+
+/**
+ * Writes an UTF8 encoded string. This is an alias of {@link ByteBuffer#writeUTF8String}.
+ * @function
+ * @param {string} str String to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.
+ * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.
+ * @expose
+ */
+ByteBufferPrototype.writeString = ByteBufferPrototype.writeUTF8String;
+//? }
+
+/**
+ * Calculates the number of UTF8 characters of a string. JavaScript itself uses UTF-16, so that a string's
+ *  `length` property does not reflect its actual UTF8 size if it contains code points larger than 0xFFFF.
+ * @param {string} str String to calculate
+ * @returns {number} Number of UTF8 characters
+ * @expose
+ */
+ByteBuffer.calculateUTF8Chars = function(str) {
+    return utfx.calculateUTF16asUTF8(stringSource(str))[0];
+};
+
+/**
+ * Calculates the number of UTF8 bytes of a string.
+ * @param {string} str String to calculate
+ * @returns {number} Number of UTF8 bytes
+ * @expose
+ */
+ByteBuffer.calculateUTF8Bytes = function(str) {
+    //? if (NODE) {
+    if (typeof str !== 'string')
+        throw TypeError("Illegal argument: "+(typeof str));
+    return Buffer.byteLength(str, "utf8");
+    //? } else
+    return utfx.calculateUTF16asUTF8(stringSource(str))[1];
+};
+//? if (ALIASES) {
+
+/**
+ * Calculates the number of UTF8 bytes of a string. This is an alias of {@link ByteBuffer.calculateUTF8Bytes}.
+ * @function
+ * @param {string} str String to calculate
+ * @returns {number} Number of UTF8 bytes
+ * @expose
+ */
+ByteBuffer.calculateString = ByteBuffer.calculateUTF8Bytes;
+//? }
+
+/**
+ * Reads an UTF8 encoded string.
+ * @param {number} length Number of characters or bytes to read.
+ * @param {string=} metrics Metrics specifying what `length` is meant to count. Defaults to
+ *  {@link ByteBuffer.METRICS_CHARS}.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  read if omitted.
+ * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
+ *  read and the actual number of bytes read.
+ * @expose
+ */
+ByteBufferPrototype.readUTF8String = function(length, metrics, offset) {
+    if (typeof metrics === 'number') {
+        offset = metrics;
+        metrics = undefined;
+    }
+    //? RELATIVE();
+    if (typeof metrics === 'undefined') metrics = ByteBuffer.METRICS_CHARS;
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('length');
+        //? ASSERT_OFFSET();
+    }
+    var i = 0,
+        start = offset,
+        //? if (NODE)
+        temp,
+        sd;
+    if (metrics === ByteBuffer.METRICS_CHARS) { // The same for node and the browser
+        sd = stringDestination();
+        utfx.decodeUTF8(function() {
+            //? if (NODE)
+            return i < length && offset < this.limit ? this.buffer[offset++] : null;
+            //? else if (DATAVIEW)
+            return i < length && offset < this.limit ? this.view.getUint8(offset++) : null;
+            //? else
+            return i < length && offset < this.limit ? this.view[offset++] : null;
+        }.bind(this), function(cp) {
+            ++i; utfx.UTF8toUTF16(cp, sd);
+        });
+        if (i !== length)
+            throw RangeError("Illegal range: Truncated data, "+i+" == "+length);
+        if (relative) {
+            this.offset = offset;
+            return sd();
+        } else {
+            return {
+                "string": sd(),
+                "length": offset - start
+            };
+        }
+    } else if (metrics === ByteBuffer.METRICS_BYTES) {
+        if (!this.noAssert) {
+            //? ASSERT_OFFSET('length');
+        }
+        //? if (NODE) {
+        temp = this.buffer.toString("utf8", offset, offset+length);
+        if (relative) {
+            this.offset += length;
+            return temp;
+        } else {
+            return {
+                'string': temp,
+                'length': length
+            };
+        }
+        //? } else {
+        var k = offset + length;
+        utfx.decodeUTF8toUTF16(function() {
+            //? if (DATAVIEW)
+            return offset < k ? this.view.getUint8(offset++) : null;
+            //? else
+            return offset < k ? this.view[offset++] : null;
+        }.bind(this), sd = stringDestination(), this.noAssert);
+        if (offset !== k)
+            throw RangeError("Illegal range: Truncated data, "+offset+" == "+k);
+        if (relative) {
+            this.offset = offset;
+            return sd();
+        } else {
+            return {
+                'string': sd(),
+                'length': offset - start
+            };
+        }
+        //? }
+    } else
+        throw TypeError("Unsupported metrics: "+metrics);
+};
+//? if (ALIASES) {
+
+/**
+ * Reads an UTF8 encoded string. This is an alias of {@link ByteBuffer#readUTF8String}.
+ * @function
+ * @param {number} length Number of characters or bytes to read
+ * @param {number=} metrics Metrics specifying what `n` is meant to count. Defaults to
+ *  {@link ByteBuffer.METRICS_CHARS}.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  read if omitted.
+ * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
+ *  read and the actual number of bytes read.
+ * @expose
+ */
+ByteBufferPrototype.readString = ByteBufferPrototype.readUTF8String;
+//? }
+
+//? }

package/claw/node_modules/bytebuffer/src/types/strings/vstring.js

@@ -0,0 +1,78 @@
+//? if (VSTRING && VARINTS && VARINT32) {
+// types/strings/vstring
+
+/**
+ * Writes a length as varint32 prefixed UTF8 encoded string.
+ * @param {string} str String to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  written if omitted.
+ * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written
+ * @expose
+ * @see ByteBuffer#writeVarint32
+ */
+ByteBufferPrototype.writeVString = function(str, offset) {
+    //? RELATIVE()
+    if (!this.noAssert) {
+        if (typeof str !== 'string')
+            throw TypeError("Illegal str: Not a string");
+        //? ASSERT_OFFSET();
+    }
+    var start = offset,
+        k, l;
+    //? if (NODE) {
+    k = Buffer.byteLength(str, "utf8");
+    l = ByteBuffer.calculateVarint32(k);
+    //? ENSURE_CAPACITY('l+k');
+    offset += this.writeVarint32(k, offset);
+    offset += this.buffer.write(str, offset, k, "utf8");
+    //? } else {
+    k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];
+    l = ByteBuffer.calculateVarint32(k);
+    //? ENSURE_CAPACITY('l+k');
+    offset += this.writeVarint32(k, offset);
+    utfx.encodeUTF16toUTF8(stringSource(str), function(b) {
+        //? if (DATAVIEW)
+        this.view.setUint8(offset++, b);
+        //? else
+        this.view[offset++] = b;
+    }.bind(this));
+    if (offset !== start+k+l)
+        throw RangeError("Illegal range: Truncated data, "+offset+" == "+(offset+k+l));
+    //? }
+    if (relative) {
+        this.offset = offset;
+        return this;
+    }
+    return offset - start;
+};
+
+/**
+ * Reads a length as varint32 prefixed UTF8 encoded string.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  read if omitted.
+ * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
+ *  read and the actual number of bytes read.
+ * @expose
+ * @see ByteBuffer#readVarint32
+ */
+ByteBufferPrototype.readVString = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(1);
+    }
+    var start = offset;
+    var len = this.readVarint32(offset);
+    var str = this.readUTF8String(len['value'], ByteBuffer.METRICS_BYTES, offset += len['length']);
+    offset += str['length'];
+    if (relative) {
+        this.offset = offset;
+        return str['string'];
+    } else {
+        return {
+            'string': str['string'],
+            'length': offset - start
+        };
+    }
+};
+
+//? }

package/claw/node_modules/bytebuffer/src/types/varints/varint32.js

@@ -0,0 +1,164 @@
+//? if (VARINT32) {
+// types/varints/varint32
+
+/**
+ * Maximum number of bytes required to store a 32bit base 128 variable-length integer.
+ * @type {number}
+ * @const
+ * @expose
+ */
+ByteBuffer.MAX_VARINT32_BYTES = 5;
+
+/**
+ * Calculates the actual number of bytes required to store a 32bit base 128 variable-length integer.
+ * @param {number} value Value to encode
+ * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT32_BYTES}
+ * @expose
+ */
+ByteBuffer.calculateVarint32 = function(value) {
+    // ref: src/google/protobuf/io/coded_stream.cc
+    value = value >>> 0;
+         if (value < 1 << 7 ) return 1;
+    else if (value < 1 << 14) return 2;
+    else if (value < 1 << 21) return 3;
+    else if (value < 1 << 28) return 4;
+    else                      return 5;
+};
+
+/**
+ * Zigzag encodes a signed 32bit integer so that it can be effectively used with varint encoding.
+ * @param {number} n Signed 32bit integer
+ * @returns {number} Unsigned zigzag encoded 32bit integer
+ * @expose
+ */
+ByteBuffer.zigZagEncode32 = function(n) {
+    return (((n |= 0) << 1) ^ (n >> 31)) >>> 0; // ref: src/google/protobuf/wire_format_lite.h
+};
+
+/**
+ * Decodes a zigzag encoded signed 32bit integer.
+ * @param {number} n Unsigned zigzag encoded 32bit integer
+ * @returns {number} Signed 32bit integer
+ * @expose
+ */
+ByteBuffer.zigZagDecode32 = function(n) {
+    return ((n >>> 1) ^ -(n & 1)) | 0; // // ref: src/google/protobuf/wire_format_lite.h
+};
+
+/**
+ * Writes a 32bit base 128 variable-length integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  written if omitted.
+ * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written
+ * @expose
+ */
+ByteBufferPrototype.writeVarint32 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value');
+        //? ASSERT_OFFSET();
+    }
+    var size = ByteBuffer.calculateVarint32(value),
+        b;
+    //? ENSURE_CAPACITY('size');
+    value >>>= 0;
+    while (value >= 0x80) {
+        b = (value & 0x7f) | 0x80;
+        //? if (NODE)
+        this.buffer[offset++] = b;
+        //? else if (DATAVIEW)
+        this.view.setUint8(offset++, b);
+        //? else
+        this.view[offset++] = b;
+        value >>>= 7;
+    }
+    //? if (NODE)
+    this.buffer[offset++] = value;
+    //? else if (DATAVIEW)
+    this.view.setUint8(offset++, value);
+    //? else
+    this.view[offset++] = value;
+    if (relative) {
+        this.offset = offset;
+        return this;
+    }
+    return size;
+};
+
+/**
+ * Writes a zig-zag encoded (signed) 32bit base 128 variable-length integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  written if omitted.
+ * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written
+ * @expose
+ */
+ByteBufferPrototype.writeVarint32ZigZag = function(value, offset) {
+    return this.writeVarint32(ByteBuffer.zigZagEncode32(value), offset);
+};
+
+/**
+ * Reads a 32bit base 128 variable-length integer.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  written if omitted.
+ * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read
+ *  and the actual number of bytes read.
+ * @throws {Error} If it's not a valid varint. Has a property `truncated = true` if there is not enough data available
+ *  to fully decode the varint.
+ * @expose
+ */
+ByteBufferPrototype.readVarint32 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(1);
+    }
+    var c = 0,
+        value = 0 >>> 0,
+        b;
+    do {
+        if (!this.noAssert && offset > this.limit) {
+            var err = Error("Truncated");
+            err['truncated'] = true;
+            throw err;
+        }
+        //? if (NODE)
+        b = this.buffer[offset++];
+        //? else if (DATAVIEW)
+        b = this.view.getUint8(offset++);
+        //? else
+        b = this.view[offset++];
+        if (c < 5)
+            value |= (b & 0x7f) << (7*c);
+        ++c;
+    } while ((b & 0x80) !== 0);
+    value |= 0;
+    if (relative) {
+        this.offset = offset;
+        return value;
+    }
+    return {
+        "value": value,
+        "length": c
+    };
+};
+
+/**
+ * Reads a zig-zag encoded (signed) 32bit base 128 variable-length integer.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  written if omitted.
+ * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read
+ *  and the actual number of bytes read.
+ * @throws {Error} If it's not a valid varint
+ * @expose
+ */
+ByteBufferPrototype.readVarint32ZigZag = function(offset) {
+    var val = this.readVarint32(offset);
+    if (typeof val === 'object')
+        val["value"] = ByteBuffer.zigZagDecode32(val["value"]);
+    else
+        val = ByteBuffer.zigZagDecode32(val);
+    return val;
+};
+
+//? }

package/claw/node_modules/bytebuffer/src/types/varints/varint64.js

@@ -0,0 +1,208 @@
+//? if (VARINT64) {
+// types/varints/varint64
+
+if (Long) {
+    
+    /**
+     * Maximum number of bytes required to store a 64bit base 128 variable-length integer.
+     * @type {number}
+     * @const
+     * @expose
+     */
+    ByteBuffer.MAX_VARINT64_BYTES = 10;
+    
+    /**
+     * Calculates the actual number of bytes required to store a 64bit base 128 variable-length integer.
+     * @param {number|!Long} value Value to encode
+     * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT64_BYTES}
+     * @expose
+     */
+    ByteBuffer.calculateVarint64 = function(value) {
+        //? LONG('value');
+        // ref: src/google/protobuf/io/coded_stream.cc
+        var part0 = value.toInt() >>> 0,
+            part1 = value.shiftRightUnsigned(28).toInt() >>> 0,
+            part2 = value.shiftRightUnsigned(56).toInt() >>> 0;
+        if (part2 == 0) {
+            if (part1 == 0) {
+                if (part0 < 1 << 14)
+                    return part0 < 1 << 7 ? 1 : 2;
+                else
+                    return part0 < 1 << 21 ? 3 : 4;
+            } else {
+                if (part1 < 1 << 14)
+                    return part1 < 1 << 7 ? 5 : 6;
+                else
+                    return part1 < 1 << 21 ? 7 : 8;
+            }
+        } else
+            return part2 < 1 << 7 ? 9 : 10;
+    };
+    
+    /**
+     * Zigzag encodes a signed 64bit integer so that it can be effectively used with varint encoding.
+     * @param {number|!Long} value Signed long
+     * @returns {!Long} Unsigned zigzag encoded long
+     * @expose
+     */
+    ByteBuffer.zigZagEncode64 = function(value) {
+        //? LONG('value', false);
+        // ref: src/google/protobuf/wire_format_lite.h
+        return value.shiftLeft(1).xor(value.shiftRight(63)).toUnsigned();
+    };
+    
+    /**
+     * Decodes a zigzag encoded signed 64bit integer.
+     * @param {!Long|number} value Unsigned zigzag encoded long or JavaScript number
+     * @returns {!Long} Signed long
+     * @expose
+     */
+    ByteBuffer.zigZagDecode64 = function(value) {
+        //? LONG('value', false);
+        // ref: src/google/protobuf/wire_format_lite.h
+        return value.shiftRightUnsigned(1).xor(value.and(Long.ONE).toSigned().negate()).toSigned();
+    };
+    
+    /**
+     * Writes a 64bit base 128 variable-length integer.
+     * @param {number|Long} value Value to write
+     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+     *  written if omitted.
+     * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.
+     * @expose
+     */
+    ByteBufferPrototype.writeVarint64 = function(value, offset) {
+        //? RELATIVE();
+        if (!this.noAssert) {
+            //? ASSERT_LONG('value');
+            //? ASSERT_OFFSET();
+        }
+        //? LONG('value', false);
+        var size = ByteBuffer.calculateVarint64(value),
+            part0 = value.toInt() >>> 0,
+            part1 = value.shiftRightUnsigned(28).toInt() >>> 0,
+            part2 = value.shiftRightUnsigned(56).toInt() >>> 0;
+        //? ENSURE_CAPACITY('size');
+        switch (size) {
+        //? if (NODE || !DATAVIEW) { var dst = NODE ? 'this.buffer' : 'this.view';
+            case 10: /*?= dst */[offset+9] = (part2 >>>  7) & 0x01;
+            case 9 : /*?= dst */[offset+8] = size !== 9 ? (part2       ) | 0x80 : (part2       ) & 0x7F;
+            case 8 : /*?= dst */[offset+7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F;
+            case 7 : /*?= dst */[offset+6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F;
+            case 6 : /*?= dst */[offset+5] = size !== 6 ? (part1 >>>  7) | 0x80 : (part1 >>>  7) & 0x7F;
+            case 5 : /*?= dst */[offset+4] = size !== 5 ? (part1       ) | 0x80 : (part1       ) & 0x7F;
+            case 4 : /*?= dst */[offset+3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F;
+            case 3 : /*?= dst */[offset+2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F;
+            case 2 : /*?= dst */[offset+1] = size !== 2 ? (part0 >>>  7) | 0x80 : (part0 >>>  7) & 0x7F;
+            case 1 : /*?= dst */[offset  ] = size !== 1 ? (part0       ) | 0x80 : (part0       ) & 0x7F;
+        //? } else {
+            case 10: this.view.setUint8(offset+9, (part2 >>>  7) & 0x01);
+            case 9 : this.view.setUint8(offset+8, size !== 9 ? (part2       ) | 0x80 : (part2       ) & 0x7F);
+            case 8 : this.view.setUint8(offset+7, size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F);
+            case 7 : this.view.setUint8(offset+6, size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F);
+            case 6 : this.view.setUint8(offset+5, size !== 6 ? (part1 >>>  7) | 0x80 : (part1 >>>  7) & 0x7F);
+            case 5 : this.view.setUint8(offset+4, size !== 5 ? (part1       ) | 0x80 : (part1       ) & 0x7F);
+            case 4 : this.view.setUint8(offset+3, size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F);
+            case 3 : this.view.setUint8(offset+2, size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F);
+            case 2 : this.view.setUint8(offset+1, size !== 2 ? (part0 >>>  7) | 0x80 : (part0 >>>  7) & 0x7F);
+            case 1 : this.view.setUint8(offset  , size !== 1 ? (part0       ) | 0x80 : (part0       ) & 0x7F);
+        //? }
+        }
+        if (relative) {
+            this.offset += size;
+            return this;
+        } else {
+            return size;
+        }
+    };
+
+    /**
+     * Writes a zig-zag encoded 64bit base 128 variable-length integer.
+     * @param {number|Long} value Value to write
+     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+     *  written if omitted.
+     * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.
+     * @expose
+     */
+    ByteBufferPrototype.writeVarint64ZigZag = function(value, offset) {
+        return this.writeVarint64(ByteBuffer.zigZagEncode64(value), offset);
+    };
+    
+    /**
+     * Reads a 64bit base 128 variable-length integer. Requires Long.js.
+     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+     *  read if omitted.
+     * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and
+     *  the actual number of bytes read.
+     * @throws {Error} If it's not a valid varint
+     * @expose
+     */
+    ByteBufferPrototype.readVarint64 = function(offset) {
+        //? RELATIVE(); 
+        if (!this.noAssert) {
+            //? ASSERT_OFFSET(1);
+        }
+        // ref: src/google/protobuf/io/coded_stream.cc
+        var start = offset,
+            part0 = 0,
+            part1 = 0,
+            part2 = 0,
+            b  = 0;
+    //? if (NODE || !DATAVIEW) { var dst = NODE ? 'this.buffer' : 'this.view';
+        b = /*?= dst */[offset++]; part0  = (b & 0x7F)      ; if ( b & 0x80                                                   ) {
+        b = /*?= dst */[offset++]; part0 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
+        b = /*?= dst */[offset++]; part0 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
+        b = /*?= dst */[offset++]; part0 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
+        b = /*?= dst */[offset++]; part1  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
+        b = /*?= dst */[offset++]; part1 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
+        b = /*?= dst */[offset++]; part1 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
+        b = /*?= dst */[offset++]; part1 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
+        b = /*?= dst */[offset++]; part2  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
+        b = /*?= dst */[offset++]; part2 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
+        throw Error("Buffer overrun"); }}}}}}}}}}
+    //? } else { // Asserts on its own
+        b = this.view.getUint8(offset++); part0  = (b & 0x7F)      ; if (b & 0x80) {
+        b = this.view.getUint8(offset++); part0 |= (b & 0x7F) <<  7; if (b & 0x80) {
+        b = this.view.getUint8(offset++); part0 |= (b & 0x7F) << 14; if (b & 0x80) {
+        b = this.view.getUint8(offset++); part0 |= (b & 0x7F) << 21; if (b & 0x80) {
+        b = this.view.getUint8(offset++); part1  = (b & 0x7F)      ; if (b & 0x80) {
+        b = this.view.getUint8(offset++); part1 |= (b & 0x7F) <<  7; if (b & 0x80) {
+        b = this.view.getUint8(offset++); part1 |= (b & 0x7F) << 14; if (b & 0x80) {
+        b = this.view.getUint8(offset++); part1 |= (b & 0x7F) << 21; if (b & 0x80) {
+        b = this.view.getUint8(offset++); part2  = (b & 0x7F)      ; if (b & 0x80) {
+        b = this.view.getUint8(offset++); part2 |= (b & 0x7F) <<  7; if (b & 0x80) {
+        throw Error("Buffer overrun"); }}}}}}}}}}
+    //? }
+        var value = Long.fromBits(part0 | (part1 << 28), (part1 >>> 4) | (part2) << 24, false);
+        if (relative) {
+            this.offset = offset;
+            return value;
+        } else {
+            return {
+                'value': value,
+                'length': offset-start
+            };
+        }
+    };
+
+    /**
+     * Reads a zig-zag encoded 64bit base 128 variable-length integer. Requires Long.js.
+     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+     *  read if omitted.
+     * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and
+     *  the actual number of bytes read.
+     * @throws {Error} If it's not a valid varint
+     * @expose
+     */
+    ByteBufferPrototype.readVarint64ZigZag = function(offset) {
+        var val = this.readVarint64(offset);
+        if (val && val['value'] instanceof Long)
+            val["value"] = ByteBuffer.zigZagDecode64(val["value"]);
+        else
+            val = ByteBuffer.zigZagDecode64(val);
+        return val;
+    };
+    
+} // Long
+
+//? }