dexbot 1.4.12 → 1.4.14

package/claw/node_modules/bytebuffer/src/helpers.js

@@ -0,0 +1,143 @@
+// helpers
+//? if (NODE) {
+
+/**
+ * @type {!Buffer}
+ * @inner
+ */
+var EMPTY_BUFFER = new Buffer(0);
+//? } else {
+
+/**
+ * @type {!ArrayBuffer}
+ * @inner
+ */
+var EMPTY_BUFFER = new ArrayBuffer(0);
+//? }
+//? if (!INLINE) {
+
+/**
+ * Asserts that a value is an integer and returns the type-safe value.
+ * @param {number} value Value to assert
+ * @param {boolean=} unsigned Whether explicitly unsigned
+ * @returns {number} Type-safe value
+ * @throws {TypeError} If `value` is not an integer
+ * @inner
+ */
+function assertInteger(value, unsigned) {
+    if (typeof value !== 'number' || value % 1 !== 0)
+        throw TypeError("Illegal value: "+offset+" (not an integer)");
+    return unsigned ? value >>> 0 : value | 0;
+}
+
+/**
+ * Asserts that a value is an integer or Long.
+ * @param {number|!Long} value Value to assert
+ * @param {boolean=} unsigned Whether explicitly unsigned
+ * @returns {number|!Long} Type-safe value
+ * @throws {TypeError} If `value` is not an integer or Long
+ * @inner
+ */
+function assertLong(value, unsigned) {
+    if (typeof value === 'number') {
+        return Long.fromNumber(value, unsigned);
+    } else if (typeof value === 'string') {
+        return Long.fromString(value, unsigned);
+    } else if (value && value instanceof Long) {
+        if (typeof unsigned !== 'undefined') {
+            if (unsigned && !value.unsigned) return value.toUnsigned();
+            if (!unsigned && value.unsigned) return value.toSigned();
+        }
+        return value;
+    } else
+        throw TypeError("Illegal value: "+value+" (not an integer or Long)");
+}
+
+/**
+ * Asserts that `min <= offset <= cap-size` and returns the type-safe offset.
+ * @param {number} offset Offset to assert
+ * @param {number} min Minimum offset
+ * @param {number} cap Cap offset
+ * @param {number} size Required size in bytes
+ * @returns {number} Type-safe offset
+ * @throws {TypeError} If `offset` is not an integer
+ * @throws {RangeError} If `offset < min || offset > cap-size`
+ * @inner
+ */
+function assertOffset(offset, min, cap, size) {
+    if (typeof offset !== 'number' || offset % 1 !== 0)
+        throw TypeError("Illegal offset: "+offset+" (not an integer)");
+    offset = offset | 0;
+    if (offset < min || offset > cap-size)
+        throw RangeError("Illegal offset: "+min+" <= "+value+" <= "+cap+"-"+size);
+    return offset;
+}
+
+/**
+ * assertRange return value.
+ * @type {Array.<number>}
+ */
+var rangeVal = new Array(2);
+
+/**
+ * Asserts that `min <= begin <= end <= cap`. Updates `rangeVal` with the type-safe range.
+ * @param {number} begin Begin offset
+ * @param {number} end End offset
+ * @param {number} min Minimum offset
+ * @param {number} cap Cap offset
+ * @throws {TypeError} If `begin` or `end` is not an integer
+ * @throws {RangeError} If `begin < min || begin > end || end > cap`
+ * @inner
+ */
+function assertRange(begin, end, min, cap) {
+    if (typeof begin !== 'number' || begin % 1 !== 0)
+        throw TypeError("Illegal begin: "+begin+" (not a number)");
+    begin = begin | 0;
+    if (typeof end !== 'number' || end % 1 !== 0)
+        throw TypeError("Illegal end: "+range[1]+" (not a number)");
+    end = end | 0;
+    if (begin < min || begin > end || end > cap)
+        throw RangeError("Illegal range: "+min+" <= "+begin+" <= "+end+" <= "+cap);
+    rangeVal[0] = begin; rangeVal[1] = end;
+}
+//? }
+//? if (BASE64 || UTF8) {
+
+/**
+ * String.fromCharCode reference for compile-time renaming.
+ * @type {function(...number):string}
+ * @inner
+ */
+var stringFromCharCode = String.fromCharCode;
+
+/**
+ * Creates a source function for a string.
+ * @param {string} s String to read from
+ * @returns {function():number|null} Source function returning the next char code respectively `null` if there are
+ *  no more characters left.
+ * @throws {TypeError} If the argument is invalid
+ * @inner
+ */
+function stringSource(s) {
+    var i=0; return function() {
+        return i < s.length ? s.charCodeAt(i++) : null;
+    };
+}
+
+/**
+ * Creates a destination function for a string.
+ * @returns {function(number=):undefined|string} Destination function successively called with the next char code.
+ *  Returns the final string when called without arguments.
+ * @inner
+ */
+function stringDestination() {
+    var cs = [], ps = []; return function() {
+        if (arguments.length === 0)
+            return ps.join('')+stringFromCharCode.apply(String, cs);
+        if (cs.length + arguments.length > 1024)
+            ps.push(stringFromCharCode.apply(String, cs)),
+                cs.length = 0;
+        Array.prototype.push.apply(cs, arguments);
+    };
+}
+//? }

package/claw/node_modules/bytebuffer/src/macros.js

@@ -0,0 +1,222 @@
+//?...
+// Welcome to the crazy world of MetaScript! Tell it what you need, it will not moan, and there it is.
+
+// Substitute for the backing buffer's capacity
+CAPACITY = NODE ? 'this.buffer.length' : 'this.buffer.byteLength';
+
+// Asserts that a variable is an integer
+ASSERT_INTEGER = function(varValue, unsigned) {
+    if (VERBOSE_MS) writeln(__+'// <ASSERT_INTEGER>');
+    if (INLINE) {
+        writeln(__+'if (typeof '+varValue+' !== \'number\' || '+varValue+' % 1 !== 0)');
+        writeln(__+'    throw TypeError("Illegal '+varValue+': "+'+varValue+'+" (not an integer)");');
+        writeln(__+varValue+' '+(unsigned ? '>>>' : '|')+'= 0;');
+    } else {
+        writeln(__+varValue+' = assertInteger('+varValue+(typeof unsigned !== 'undefined' ? ', '+unsigned : '')+');');
+    }
+    if (VERBOSE_MS) writeln(__+'// </ASSERT_INTEGER>');
+};
+
+// Asserts that a variable is a number or Long
+ASSERT_LONG = function(varValue, unsigned) {
+    if (typeof varValue === 'undefined') varValue = 'value';
+    if (VERBOSE_MS) writeln(__+'// <ASSERT_LONG>');
+    if (INLINE) {
+        writeln(__+'if (typeof '+varValue+' === \'number\')');
+        writeln(__+'    '+varValue+' = Long.fromNumber('+varValue+');');
+        writeln(__+'else if (typeof '+varValue+' === \'string\')');
+        writeln(__+'    '+varValue+' = Long.fromString('+varValue+');');
+        if (typeof unsigned !== 'undefined') { // When explicitly specified only
+            writeln(__+'else if ('+varValue+' && '+varValue+' instanceof Long)');
+            if (unsigned) {
+                writeln(__+'    if (!'+varValue+'.unsigned) '+varValue+' = '+varValue+'.toUnsigned();');
+            } else {
+                writeln(__+'    if ('+varValue+'.unsigned) '+varValue+' = '+varValue+'.toSigned();');
+            }
+            writeln(__+'else');
+        } else {
+            writeln(__+'else if (!('+varValue+' && '+varValue+' instanceof Long))');
+        }
+        writeln(__+'    throw TypeError("Illegal '+varValue+': "+'+varValue+'+" (not an integer or Long)");');
+    } else {
+        writeln(__+varValue+' = assertLong('+varValue+(typeof unsigned !== 'undefined' ? ', '+unsigned : '')+');');
+    }
+    if (VERBOSE_MS) writeln(__+'// </ASSERT_LONG>');
+};
+
+// Casts a variable to a Long if necessary
+LONG = function(varValue, unsigned) {
+    if (typeof varValue === 'undefined') varValue = 'value';
+    if (VERBOSE_MS) writeln(__+'// <LONG'+(typeof unsigned === 'boolean' ? ' unsigned='+unsigned : '')+'>');
+    writeln(__+'if (typeof '+varValue+' === \'number\')');
+    writeln(__+'    '+varValue+' = Long.fromNumber('+varValue+(typeof unsigned === 'boolean' ? ', '+unsigned : '')+');');
+    writeln(__+'else if (typeof '+varValue+' === \'string\')');
+    writeln(__+'    '+varValue+' = Long.fromString('+varValue+(typeof unsigned === 'boolean' ? ', '+unsigned : '')+');');
+    if (typeof unsigned === 'boolean') {
+        writeln(__+'else if ('+varValue+'.unsigned !== '+unsigned+') '+varValue+' = '+varValue+'.'+(unsigned ? 'toUnsigned' : 'toSigned')+'();');
+    }
+    if (VERBOSE_MS) writeln(__+'// </LONG>');
+};
+
+// Asserts that an offset is valid
+ASSERT_OFFSET = function(size, varOffset) {
+    if (typeof size      === 'undefined') size      = 0;
+    if (typeof varOffset === 'undefined') varOffset = 'offset';
+    if (VERBOSE_MS) writeln(__+'// <ASSERT_OFFSET>');
+    if (INLINE) {
+        writeln(__+'if (typeof '+varOffset+' !== \'number\' || '+varOffset+' % 1 !== 0)');
+        writeln(__+'    throw TypeError("Illegal '+varOffset+': "+'+varOffset+'+" (not an integer)");');
+        writeln(__+varOffset+' >>>= 0;');
+        writeln(__+'if ('+varOffset+' < 0 || '+varOffset+' + '+size+' > '+CAPACITY+')');
+        writeln(__+'    throw RangeError("Illegal '+varOffset+': 0 <= "+'+varOffset+'+" (+"+'+size+'+") <= "+'+CAPACITY+');');
+    } else {
+        writeln(__+varOffset+' = assertOffset('+varOffset+', 0, '+CAPACITY+', '+size+');');
+    }
+    if (VERBOSE_MS) writeln(__+'// </ASSERT_OFFSET>');
+};
+
+// Asserts that a range is valid
+ASSERT_RANGE = function(varBegin, varEnd) {
+    if (typeof varBegin === 'undefined') varBegin = 'begin';
+    if (typeof varEnd   === 'undefined') varEnd   = 'end';
+    if (VERBOSE_MS) writeln(__+'// <ASSERT_RANGE>');
+    if (INLINE) {
+        writeln(__+'if (typeof '+varBegin+' !== \'number\' || '+varBegin+' % 1 !== 0)');
+        writeln(__+'    throw TypeError("Illegal '+varBegin+': Not an integer");');
+        writeln(__+varBegin+' >>>= 0;');
+        writeln(__+'if (typeof '+varEnd+' !== \'number\' || '+varEnd+' % 1 !== 0)');
+        writeln(__+'    throw TypeError("Illegal '+varEnd+': Not an integer");');
+        writeln(__+varEnd+' >>>= 0;');
+        writeln(__+'if ('+varBegin+' < 0 || '+varBegin+' > '+varEnd+' || '+varEnd+' > '+CAPACITY+')');
+        writeln(__+'    throw RangeError("Illegal range: 0 <= "+'+varBegin+'+" <= "+'+varEnd+'+" <= "+'+CAPACITY+');');
+    } else {
+        writeln(__+'assertRange('+varBegin+', '+varEnd+', 0, '+CAPACITY+');');
+        writeln(__+varBegin+' = rangeVal[0]; '+varEnd+' = rangeVal[1];');
+    }
+    if (VERBOSE_MS) writeln(__+'// </ASSERT_RANGE>');
+};
+
+// ENSURE_CAPACITY counter in case that multiple calls are used in a single method
+var ECN = 0;
+
+// Ensures that a ByteBuffer is backed by a buffer that takes `size` additional capacity
+ENSURE_CAPACITY = function(size, varOffset) {
+    if (typeof varOffset === 'undefined') varOffset = 'offset';
+    if (VERBOSE_MS) writeln(__+'// <ENSURE_CAPACITY size='+size+'>');
+    if (INLINE) {
+        writeln(__+varOffset+' += '+size+';');
+        writeln(__+'var capacity'+ECN+' = '+CAPACITY+';');
+        writeln(__+'if ('+varOffset+' > capacity'+ECN+')');
+        writeln(__+'    this.resize((capacity'+ECN+' *= 2) > '+varOffset+' ? capacity'+ECN+' : '+varOffset+');');
+        writeln(__+varOffset+' -= '+size+';');
+    } else {
+        writeln(__+'this.ensureCapacity('+varOffset+'+'+size+');');
+    }
+    if (VERBOSE_MS) writeln(__+'// </ENSURE_CAPACITY>');
+    ++ECN;
+};
+
+// Sets up a relative operation if `size` is omitted, else increases offset by `size`
+RELATIVE = function(size, varOffset, varRelOffset) {
+    if (VERBOSE_MS) writeln(__+'// <RELATIVE'+(typeof size !== 'undefined' ? ' size='+size : '')+'>');
+    if (typeof size === 'undefined') {
+        if (typeof varOffset === 'undefined') varOffset = "offset";
+        if (typeof varRelOffset === 'undefined') varRelOffset = "this.offset";
+        writeln(__+'var relative = typeof '+varOffset+' === \'undefined\';');
+        writeln(__+'if (relative) '+varOffset+' = '+varRelOffset+';');
+    } else {
+        if (typeof varOffset === 'undefined') varOffset = "this.offset";
+        writeln(__+'if (relative) this.offset += '+size+';');
+    }
+    if (VERBOSE_MS) writeln(__+'// </RELATIVE>');
+};
+
+// Reads an uint32 from an array
+READ_UINT32_ARRAY = function(varValue, varOffset, varTarget, varEndian) {
+    if (typeof varValue  === 'undefined') varValue = 'value';
+    if (typeof varOffset === 'undefined') varOffset = 'offset';
+    if (typeof varTarget === 'undefined') varTarget = NODE ? 'this.buffer' : 'this.view';
+    var ____ = typeof varEndian !== 'boolean' ? '    ' : '';
+    if (VERBOSE_MS) writeln(__+'// <READ_UINT32'+(typeof varEndian === 'boolean' ? ' le='+varEndian : '')+'>');
+    if (NODE || !DATAVIEW) {
+        if (typeof varEndian !== 'boolean')
+            writeln(__+'if ('+(varEndian || 'this.littleEndian')+') {');
+        if (typeof varEndian !== 'boolean' || varEndian === true) {
+            writeln(__+____+varValue+'  = '+varTarget+'['+varOffset+'+2] << 16;');
+            writeln(__+____+varValue+' |= '+varTarget+'['+varOffset+'+1] <<  8;');
+            writeln(__+____+varValue+' |= '+varTarget+'['+varOffset+'  ];');
+            writeln(__+____+varValue+' += '+varTarget+'['+varOffset+'+3] << 24 >>> 0;');
+        }
+        if (typeof varEndian !== 'boolean')
+            writeln(__+'} else {');
+        if (typeof varEndian !== 'boolean' || varEndian === false) {
+            writeln(__+____+varValue+'  = '+varTarget+'['+varOffset+'+1] << 16;');
+            writeln(__+____+varValue+' |= '+varTarget+'['+varOffset+'+2] <<  8;');
+            writeln(__+____+varValue+' |= '+varTarget+'['+varOffset+'+3];');
+            writeln(__+____+varValue+' += '+varTarget+'['+varOffset+'  ] << 24 >>> 0;');
+        }
+        if (typeof varEndian !== 'boolean')
+            writeln(__+'}');
+    } else {
+        writeln(__+varTarget+'.getUint32('+varOffset+', '+varEndian+');');
+    }
+    if (VERBOSE_MS) writeln(__+'// </READ_UINT32>');
+};
+
+// Writes an uint32 to an array
+WRITE_UINT32_ARRAY = function(varValue, varOffset, varTarget, varEndian) {
+    if (typeof varValue  === 'undefined') varValue = 'value';
+    if (typeof varOffset === 'undefined') varOffset = 'offset';
+    if (typeof varTarget === 'undefined') varTarget = NODE ? 'this.buffer' : 'this.view';
+    var ____ = typeof varEndian !== 'boolean' ? '    ' : '';
+    if (VERBOSE_MS) writeln(__+'// <WRITE_UINT32'+(typeof varEndian === 'boolean' ? ' le='+varEndian : '')+'>');
+    if (NODE || !DATAVIEW) {
+        if (typeof varEndian !== 'boolean')
+            writeln(__+'if ('+(varEndian || 'this.littleEndian')+') {');
+        if (typeof varEndian !== 'boolean' || varEndian === true) {
+            writeln(__+____+varTarget+'['+varOffset+'+3] = ('+varValue+' >>> 24) & 0xFF;');
+            writeln(__+____+varTarget+'['+varOffset+'+2] = ('+varValue+' >>> 16) & 0xFF;');
+            writeln(__+____+varTarget+'['+varOffset+'+1] = ('+varValue+' >>>  8) & 0xFF;');
+            writeln(__+____+varTarget+'['+varOffset+'  ] =  '+varValue+'         & 0xFF;');
+        }
+        if (typeof varEndian !== 'boolean')
+            writeln(__+'} else {');
+        if (typeof varEndian !== 'boolean' || varEndian === false) {
+            writeln(__+____+varTarget+'['+varOffset+'  ] = ('+varValue+' >>> 24) & 0xFF;');
+            writeln(__+____+varTarget+'['+varOffset+'+1] = ('+varValue+' >>> 16) & 0xFF;');
+            writeln(__+____+varTarget+'['+varOffset+'+2] = ('+varValue+' >>>  8) & 0xFF;');
+            writeln(__+____+varTarget+'['+varOffset+'+3] =  '+varValue+'         & 0xFF;');
+        }
+        if (typeof varEndian !== 'boolean')
+            writeln(__+'}');
+    } else {
+        writeln(__+varTarget+'.setUint32('+varValue+', '+varOffset+', '+varEndian+');');
+    }
+    if (VERBOSE_MS) writeln(__+'// </WRITE_UINT32>');
+};
+
+SET = function(varValue, varOffset, varTarget) { // with varTarget referencing a ByteBuffer
+    if (typeof varValue  === 'undefined') varValue = 'value';
+    if (typeof varOffset === 'undefined') varOffset = 'offset';
+    if (typeof varTarget === 'undefined') varTarget = 'this';
+    if (NODE) {
+        writeln(__+varTarget+'.buffer['+varOffset+'] = '+varValue+';');
+    } else if (DATAVIEW) {
+        writeln(__+varTarget+'.view.setUint8('+varValue+', '+varOffset+');');
+    } else {
+        writeln(__+varTarget+'.view['+varOffset+'] = '+varValue+';');
+    }
+};
+
+GET = function(varOffset, varTarget) { // with varTarget referencing a ByteBuffer
+    if (typeof varOffset === 'undefined') varOffset = 'offset';
+    if (typeof varTarget === 'undefined') varTarget = 'this';
+    if (NODE) {
+        write(varTarget+'.buffer['+varOffset+']');
+    } else if (DATAVIEW) {
+        write(varTarget+'.view.getUint8('+varOffset+')');
+    } else {
+        write(varTarget+'.view['+varOffset+']');
+    }
+};
+//?.

package/claw/node_modules/bytebuffer/src/methods/append.js

@@ -0,0 +1,58 @@
+/**
+ * Appends some data to this ByteBuffer. This will overwrite any contents behind the specified offset up to the appended
+ *  data's length.
+//? if (NODE) {
+ * @param {!ByteBuffer|!Buffer|!ArrayBuffer|!Uint8Array|string} source Data to append. If `source` is a ByteBuffer, its
+ * offsets will be modified according to the performed read operation.
+//? } else {
+ * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string} source Data to append. If `source` is a ByteBuffer, its offsets
+ *  will be modified according to the performed read operation.
+//? }
+ * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8")
+ * @param {number=} offset Offset to append at. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  written if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ * @example A relative `<01 02>03.append(<04 05>)` will result in `<01 02 04 05>, 04 05|`
+ * @example An absolute `<01 02>03.append(04 05>, 1)` will result in `<01 04>05, 04 05|`
+ */
+ByteBufferPrototype.append = function(source, encoding, offset) {
+    if (typeof encoding === 'number' || typeof encoding !== 'string') {
+        offset = encoding;
+        encoding = undefined;
+    }
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET();
+    }
+    if (!(source instanceof ByteBuffer))
+        source = ByteBuffer.wrap(source, encoding);
+    var length = source.limit - source.offset;
+    if (length <= 0) return this; // Nothing to append
+    //? ENSURE_CAPACITY('length');
+    //? if (NODE)
+    source.buffer.copy(this.buffer, offset, source.offset, source.limit);
+    //? else if (DATAVIEW)
+    new Uint8Array(this.buffer, offset).set(new Uint8Array(source.buffer).subarray(source.offset, source.limit));
+    //? else
+    this.view.set(source.view.subarray(source.offset, source.limit), offset);
+    source.offset += length;
+    //? RELATIVE('length');
+    return this;
+};
+
+/**
+ * Appends this ByteBuffer's contents to another ByteBuffer. This will overwrite any contents at and after the
+    specified offset up to the length of this ByteBuffer's data.
+ * @param {!ByteBuffer} target Target ByteBuffer
+ * @param {number=} offset Offset to append to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
+ *  read if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ * @see ByteBuffer#append
+ */
+ByteBufferPrototype.appendTo = function(target, offset) {
+    target.append(this, offset);
+    return this;
+};
+

package/claw/node_modules/bytebuffer/src/methods/assert.js

@@ -0,0 +1,12 @@
+/**
+ * Enables or disables assertions of argument types and offsets. Assertions are enabled by default but you can opt to
+ *  disable them if your code already makes sure that everything is valid.
+ * @param {boolean} assert `true` to enable assertions, otherwise `false`
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.assert = function(assert) {
+    this.noAssert = !assert;
+    return this;
+};
+

package/claw/node_modules/bytebuffer/src/methods/capacity.js

@@ -0,0 +1,8 @@
+/**
+ * Gets the capacity of this ByteBuffer's backing buffer.
+ * @returns {number} Capacity of the backing buffer
+ * @expose
+ */
+ByteBufferPrototype.capacity = function() {
+    return /*?= CAPACITY */;
+};

package/claw/node_modules/bytebuffer/src/methods/clear.js

@@ -0,0 +1,13 @@
+/**
+ * Clears this ByteBuffer's offsets by setting {@link ByteBuffer#offset} to `0` and {@link ByteBuffer#limit} to the
+ *  backing buffer's capacity. Discards {@link ByteBuffer#markedOffset}.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.clear = function() {
+    this.offset = 0;
+    this.limit = /*?= CAPACITY */;
+    this.markedOffset = -1;
+    return this;
+};
+

package/claw/node_modules/bytebuffer/src/methods/clone.js

@@ -0,0 +1,34 @@
+/**
+ * Creates a cloned instance of this ByteBuffer, preset with this ByteBuffer's values for {@link ByteBuffer#offset},
+ *  {@link ByteBuffer#markedOffset} and {@link ByteBuffer#limit}.
+ * @param {boolean=} copy Whether to copy the backing buffer or to return another view on the same, defaults to `false`
+ * @returns {!ByteBuffer} Cloned instance
+ * @expose
+ */
+ByteBufferPrototype.clone = function(copy) {
+    var bb = new ByteBuffer(0, this.littleEndian, this.noAssert);
+    if (copy) {
+        //? if (NODE) {
+        var buffer = new Buffer(this.buffer.length);
+        this.buffer.copy(buffer);
+        bb.buffer = buffer;
+        //? } else {
+        bb.buffer = new ArrayBuffer(this.buffer.byteLength);
+        //? if (DATAVIEW) {
+        new Uint8Array(bb.buffer).set(this.buffer);
+        bb.view = new DataView(bb.buffer);
+        //? } else {
+        bb.view = new Uint8Array(bb.buffer);
+        //? }
+        //? }
+    } else {
+        bb.buffer = this.buffer;
+        //? if (!NODE)
+        bb.view = this.view;
+    }
+    bb.offset = this.offset;
+    bb.markedOffset = this.markedOffset;
+    bb.limit = this.limit;
+    return bb;
+};
+

package/claw/node_modules/bytebuffer/src/methods/compact.js

@@ -0,0 +1,49 @@
+/**
+ * Compacts this ByteBuffer to be backed by a {@link ByteBuffer#buffer} of its contents' length. Contents are the bytes
+ *  between {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. Will set `offset = 0` and `limit = capacity` and
+ *  adapt {@link ByteBuffer#markedOffset} to the same relative position if set.
+ * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}
+ * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.compact = function(begin, end) {
+    if (typeof begin === 'undefined') begin = this.offset;
+    if (typeof end === 'undefined') end = this.limit;
+    if (!this.noAssert) {
+        //? ASSERT_RANGE();
+    }
+    if (begin === 0 && end === /*?= CAPACITY */)
+        return this; // Already compacted
+    var len = end - begin;
+    if (len === 0) {
+        this.buffer = EMPTY_BUFFER;
+        //? if (!NODE)
+        this.view = null;
+        if (this.markedOffset >= 0) this.markedOffset -= begin;
+        this.offset = 0;
+        this.limit = 0;
+        return this;
+    }
+    //? if (NODE) {
+    var buffer = new Buffer(len);
+    this.buffer.copy(buffer, 0, begin, end);
+    this.buffer = buffer;
+    //? } else if (DATAVIEW) {
+    var buffer = new ArrayBuffer(len);
+    new Uint8Array(buffer).set(new Uint8Array(this.buffer).subarray(begin, end));
+    this.buffer = buffer;
+    this.view = new DataView(buffer);
+    //? } else {
+    var buffer = new ArrayBuffer(len);
+    var view = new Uint8Array(buffer);
+    view.set(this.view.subarray(begin, end));
+    this.buffer = buffer;
+    this.view = view;
+    //? }
+    if (this.markedOffset >= 0) this.markedOffset -= begin;
+    this.offset = 0;
+    this.limit = len;
+    return this;
+};
+

package/claw/node_modules/bytebuffer/src/methods/copy.js

@@ -0,0 +1,73 @@
+/**
+ * Creates a copy of this ByteBuffer's contents. Contents are the bytes between {@link ByteBuffer#offset} and
+ *  {@link ByteBuffer#limit}.
+ * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.
+ * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.
+ * @returns {!ByteBuffer} Copy
+ * @expose
+ */
+ByteBufferPrototype.copy = function(begin, end) {
+    if (typeof begin === 'undefined') begin = this.offset;
+    if (typeof end === 'undefined') end = this.limit;
+    if (!this.noAssert) {
+        //? ASSERT_RANGE();
+    }
+    if (begin === end)
+        return new ByteBuffer(0, this.littleEndian, this.noAssert);
+    var capacity = end - begin,
+        bb = new ByteBuffer(capacity, this.littleEndian, this.noAssert);
+    bb.offset = 0;
+    bb.limit = capacity;
+    if (bb.markedOffset >= 0) bb.markedOffset -= begin;
+    this.copyTo(bb, 0, begin, end);
+    return bb;
+};
+
+/**
+ * Copies this ByteBuffer's contents to another ByteBuffer. Contents are the bytes between {@link ByteBuffer#offset} and
+ *  {@link ByteBuffer#limit}.
+ * @param {!ByteBuffer} target Target ByteBuffer
+ * @param {number=} targetOffset Offset to copy to. Will use and increase the target's {@link ByteBuffer#offset}
+ *  by the number of bytes copied if omitted.
+ * @param {number=} sourceOffset Offset to start copying from. Will use and increase {@link ByteBuffer#offset} by the
+ *  number of bytes copied if omitted.
+ * @param {number=} sourceLimit Offset to end copying from, defaults to {@link ByteBuffer#limit}
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.copyTo = function(target, targetOffset, sourceOffset, sourceLimit) {
+    var relative,
+        targetRelative;
+    if (!this.noAssert) {
+        if (!ByteBuffer.isByteBuffer(target))
+            throw TypeError("Illegal target: Not a ByteBuffer");
+    }
+    targetOffset = (targetRelative = typeof targetOffset === 'undefined') ? target.offset : targetOffset | 0;
+    sourceOffset = (relative = typeof sourceOffset === 'undefined') ? this.offset : sourceOffset | 0;
+    sourceLimit = typeof sourceLimit === 'undefined' ? this.limit : sourceLimit | 0;
+
+    //? var TARGET_CAPACITY = NODE ? 'target.buffer.length' : 'target.buffer.byteLength';
+    if (targetOffset < 0 || targetOffset > /*?= TARGET_CAPACITY */)
+        throw RangeError("Illegal target range: 0 <= "+targetOffset+" <= "+/*?= TARGET_CAPACITY */);
+    if (sourceOffset < 0 || sourceLimit > /*?= CAPACITY */)
+        throw RangeError("Illegal source range: 0 <= "+sourceOffset+" <= "+/*?= CAPACITY */);
+
+    var len = sourceLimit - sourceOffset;
+    if (len === 0)
+        return target; // Nothing to copy
+
+    target.ensureCapacity(targetOffset + len);
+
+    //? if (NODE)
+    this.buffer.copy(target.buffer, targetOffset, sourceOffset, sourceLimit);
+    //? else if (DATAVIEW)
+    new Uint8Array(target.buffer).set(new Uint8Array(this.buffer).subarray(sourceOffset, sourceLimit), targetOffset);
+    //? else
+    target.view.set(this.view.subarray(sourceOffset, sourceLimit), targetOffset);
+
+    if (relative) this.offset += len;
+    if (targetRelative) target.offset += len;
+
+    return this;
+};
+

package/claw/node_modules/bytebuffer/src/methods/ensureCapacity.js

@@ -0,0 +1,15 @@
+/**
+ * Makes sure that this ByteBuffer is backed by a {@link ByteBuffer#buffer} of at least the specified capacity. If the
+ *  current capacity is exceeded, it will be doubled. If double the current capacity is less than the required capacity,
+ *  the required capacity will be used instead.
+ * @param {number} capacity Required capacity
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.ensureCapacity = function(capacity) {
+    var current = /*?= CAPACITY */;
+    if (current < capacity)
+        return this.resize((current *= 2) > capacity ? current : capacity);
+    return this;
+};
+