dexbot 1.4.12 → 1.4.13

package/claw/node_modules/bytebuffer/src/types/ints/int32.js

@@ -0,0 +1,125 @@
+//? if (INT32) {
+// types/ints/int32
+
+/**
+ * Writes a 32bit signed integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @expose
+ */
+ByteBufferPrototype.writeInt32 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value');
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(4);
+    //? if (NODE || !DATAVIEW) {
+    //? WRITE_UINT32_ARRAY();
+    //? } else
+    this.view.setInt32(offset, value, this.littleEndian);
+    //? RELATIVE(4);
+    return this;
+};
+//? if (ALIASES) {
+
+/**
+ * Writes a 32bit signed integer. This is an alias of {@link ByteBuffer#writeInt32}.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @expose
+ */
+ByteBufferPrototype.writeInt = ByteBufferPrototype.writeInt32;
+//? }
+
+/**
+ * Reads a 32bit signed integer.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readInt32 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(4);
+    }
+    //? if (NODE || !DATAVIEW) {
+    var value = 0;
+    //? READ_UINT32_ARRAY();
+    value |= 0; // Cast to signed
+    //? } else
+    var value = this.view.getInt32(offset, this.littleEndian);
+    //? RELATIVE(4);
+    return value;
+};
+//? if (ALIASES) {
+
+/**
+ * Reads a 32bit signed integer. This is an alias of {@link ByteBuffer#readInt32}.
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readInt = ByteBufferPrototype.readInt32;
+//? }
+
+/**
+ * Writes a 32bit unsigned integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @expose
+ */
+ByteBufferPrototype.writeUint32 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value', true);
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(4);
+    //? if (NODE || !DATAVIEW) {
+    //? WRITE_UINT32_ARRAY();
+    //? } else
+    this.view.setUint32(offset, value, this.littleEndian);
+    //? RELATIVE(4);
+    return this;
+};
+
+/**
+ * Writes a 32bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint32}.
+ * @function
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @expose
+ */
+ByteBufferPrototype.writeUInt32 = ByteBufferPrototype.writeUint32;
+
+/**
+ * Reads a 32bit unsigned integer.
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readUint32 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(4);
+    }
+    //? if (NODE || !DATAVIEW) {
+    var value = 0;
+    //? READ_UINT32_ARRAY();
+    //? } else
+    var value = this.view.getUint32(offset, this.littleEndian);
+    //? RELATIVE(4);
+    return value;
+};
+
+/**
+ * Reads a 32bit unsigned integer. This is an alias of {@link ByteBuffer#readUint32}.
+ * @function
+ * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readUInt32 = ByteBufferPrototype.readUint32;
+
+//? }

package/claw/node_modules/bytebuffer/src/types/ints/int64.js

@@ -0,0 +1,194 @@
+//? if (INT64) {
+// types/ints/int64
+
+if (Long) {
+
+    /**
+     * Writes a 64bit signed integer.
+     * @param {number|!Long} value Value to write
+     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!ByteBuffer} this
+     * @expose
+     */
+    ByteBufferPrototype.writeInt64 = function(value, offset) {
+        //? RELATIVE();
+        if (!this.noAssert) {
+            //? ASSERT_LONG('value');
+            //? ASSERT_OFFSET();
+        }
+        //? LONG('value');
+        //? ENSURE_CAPACITY(8);
+        //? if (NODE || !DATAVIEW) {
+        var lo = value.low,
+            hi = value.high;
+        if (this.littleEndian) {
+            //? WRITE_UINT32_ARRAY('lo', undefined, undefined, true);
+            offset += 4;
+            //? WRITE_UINT32_ARRAY('hi', undefined, undefined, true);
+        } else {
+            //? WRITE_UINT32_ARRAY('hi', undefined, undefined, false);
+            offset += 4;
+            //? WRITE_UINT32_ARRAY('lo', undefined, undefined, false);
+        }
+        //? } else {
+        if (this.littleEndian) {
+            this.view.setInt32(offset  , value.low , true);
+            this.view.setInt32(offset+4, value.high, true);
+        } else {
+            this.view.setInt32(offset  , value.high, false);
+            this.view.setInt32(offset+4, value.low , false);
+        }
+        //? }
+        //? RELATIVE(8);
+        return this;
+    };
+    //? if (ALIASES) {
+
+    /**
+     * Writes a 64bit signed integer. This is an alias of {@link ByteBuffer#writeInt64}.
+     * @param {number|!Long} value Value to write
+     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!ByteBuffer} this
+     * @expose
+     */
+    ByteBufferPrototype.writeLong = ByteBufferPrototype.writeInt64;
+    //? }
+    
+    /**
+     * Reads a 64bit signed integer.
+     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!Long}
+     * @expose
+     */
+    ByteBufferPrototype.readInt64 = function(offset) {
+        //? RELATIVE();
+        if (!this.noAssert) {
+            //? ASSERT_OFFSET(8);
+        }
+        //? if (NODE || !DATAVIEW) {
+        var lo = 0,
+            hi = 0;
+        if (this.littleEndian) {
+            //? READ_UINT32_ARRAY('lo', undefined, undefined, true);
+            offset += 4;
+            //? READ_UINT32_ARRAY('hi', undefined, undefined, true);
+        } else {
+            //? READ_UINT32_ARRAY('hi', undefined, undefined, false);
+            offset += 4;
+            //? READ_UINT32_ARRAY('lo', undefined, undefined, false);
+        }
+        var value = new Long(lo, hi, false);
+        //? } else {
+        var value = this.littleEndian
+            ? new Long(this.view.getInt32(offset  , true ), this.view.getInt32(offset+4, true ), false)
+            : new Long(this.view.getInt32(offset+4, false), this.view.getInt32(offset  , false), false);
+        //? }
+        //? RELATIVE(8);
+        return value;
+    };
+    //? if (ALIASES) {
+
+    /**
+     * Reads a 64bit signed integer. This is an alias of {@link ByteBuffer#readInt64}.
+     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!Long}
+     * @expose
+     */
+    ByteBufferPrototype.readLong = ByteBufferPrototype.readInt64;
+    //? }
+    
+    /**
+     * Writes a 64bit unsigned integer.
+     * @param {number|!Long} value Value to write
+     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!ByteBuffer} this
+     * @expose
+     */
+    ByteBufferPrototype.writeUint64 = function(value, offset) {
+        //? RELATIVE();
+        if (!this.noAssert) {
+            //? ASSERT_LONG('value');
+            //? ASSERT_OFFSET();
+        }
+        //? LONG('value');
+        //? ENSURE_CAPACITY(8);
+        //? if (NODE || !DATAVIEW) {
+        var lo = value.low,
+            hi = value.high;
+        if (this.littleEndian) {
+            //? WRITE_UINT32_ARRAY('lo', undefined, undefined, true);
+            offset += 4;
+            //? WRITE_UINT32_ARRAY('hi', undefined, undefined, true);
+        } else {
+            //? WRITE_UINT32_ARRAY('hi', undefined, undefined, false);
+            offset += 4;
+            //? WRITE_UINT32_ARRAY('lo', undefined, undefined, false);
+        }
+        //? } else {
+        if (this.littleEndian) {
+            this.view.setInt32(offset  , value.low , true);
+            this.view.setInt32(offset+4, value.high, true);
+        } else {
+            this.view.setInt32(offset  , value.high, false);
+            this.view.setInt32(offset+4, value.low , false);
+        }
+        //? }
+        //? RELATIVE(8);
+        return this;
+    };
+
+    /**
+     * Writes a 64bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint64}.
+     * @function
+     * @param {number|!Long} value Value to write
+     * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!ByteBuffer} this
+     * @expose
+     */
+    ByteBufferPrototype.writeUInt64 = ByteBufferPrototype.writeUint64;
+    
+    /**
+     * Reads a 64bit unsigned integer.
+     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!Long}
+     * @expose
+     */
+    ByteBufferPrototype.readUint64 = function(offset) {
+        //? RELATIVE();
+        if (!this.noAssert) {
+            //? ASSERT_OFFSET(8);
+        }
+        //? if (NODE || !DATAVIEW) {
+        var lo = 0,
+            hi = 0;
+        if (this.littleEndian) {
+            //? READ_UINT32_ARRAY('lo', undefined, undefined, true);
+            offset += 4;
+            //? READ_UINT32_ARRAY('hi', undefined, undefined, true);
+        } else {
+            //? READ_UINT32_ARRAY('hi', undefined, undefined, false);
+            offset += 4;
+            //? READ_UINT32_ARRAY('lo', undefined, undefined, false);
+        }
+        var value = new Long(lo, hi, true);
+        //? } else {
+        var value = this.littleEndian
+            ? new Long(this.view.getInt32(offset  , true ), this.view.getInt32(offset+4, true ), true)
+            : new Long(this.view.getInt32(offset+4, false), this.view.getInt32(offset  , false), true);
+        //? }
+        //? RELATIVE(8);
+        return value;
+    };
+
+    /**
+     * Reads a 64bit unsigned integer. This is an alias of {@link ByteBuffer#readUint64}.
+     * @function
+     * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
+     * @returns {!Long}
+     * @expose
+     */
+    ByteBufferPrototype.readUInt64 = ByteBufferPrototype.readUint64;
+    
+} // Long
+
+//? }

package/claw/node_modules/bytebuffer/src/types/ints/int8.js

@@ -0,0 +1,137 @@
+//? if (INT8) {
+// types/ints/int8
+
+/**
+ * Writes an 8bit signed integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeInt8 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value');
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(1);
+    //? if (NODE)
+    this.buffer[offset] = value;
+    //? else if (DATAVIEW)
+    this.view.setInt8(offset, value);
+    //? else
+    this.view[offset] = value;
+    //? RELATIVE(1);
+    return this;
+};
+
+/**
+ * Writes an 8bit signed integer. This is an alias of {@link ByteBuffer#writeInt8}.
+ * @function
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeByte = ByteBufferPrototype.writeInt8;
+
+/**
+ * Reads an 8bit signed integer.
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readInt8 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(1);
+    }
+    //? if (NODE) {
+    var value = this.buffer[offset];
+    if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed
+    //? } else if (DATAVIEW) {
+    var value = this.view.getInt8(offset);
+    //? } else {
+    var value = this.view[offset];
+    if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed
+    //? }
+    //? RELATIVE(1);
+    return value;
+};
+//? if (ALIASES) {
+
+/**
+ * Reads an 8bit signed integer. This is an alias of {@link ByteBuffer#readInt8}.
+ * @function
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readByte = ByteBufferPrototype.readInt8;
+//? }
+
+/**
+ * Writes an 8bit unsigned integer.
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeUint8 = function(value, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_INTEGER('value', true);
+        //? ASSERT_OFFSET();
+    }
+    //? ENSURE_CAPACITY(1);
+    //? if (NODE)
+    this.buffer[offset] = value;
+    //? else if (DATAVIEW)
+    this.view.setUint8(offset, value);
+    //? else
+    this.view[offset] = value;
+    //? RELATIVE(1);
+    return this;
+};
+
+/**
+ * Writes an 8bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint8}.
+ * @function
+ * @param {number} value Value to write
+ * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {!ByteBuffer} this
+ * @expose
+ */
+ByteBufferPrototype.writeUInt8 = ByteBufferPrototype.writeUint8;
+
+/**
+ * Reads an 8bit unsigned integer.
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readUint8 = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(1);
+    }
+    //? if (NODE)
+    var value = this.buffer[offset];
+    //? else if (DATAVIEW)
+    var value = this.view.getUint8(offset);
+    //? else
+    var value = this.view[offset];
+    //? RELATIVE(1);
+    return value;
+};
+
+/**
+ * Reads an 8bit unsigned integer. This is an alias of {@link ByteBuffer#readUint8}.
+ * @function
+ * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
+ * @returns {number} Value read
+ * @expose
+ */
+ByteBufferPrototype.readUInt8 = ByteBufferPrototype.readUint8;
+
+//? }

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

@@ -0,0 +1,110 @@
+//? if (CSTRING) {
+// types/strings/cstring
+
+/**
+ * Writes a NULL-terminated UTF8 encoded string. For this to work the specified string must not contain any NULL
+ *  characters itself.
+ * @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
+ *  contained in `str` + 1 if omitted.
+ * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written
+ * @expose
+ */
+ByteBufferPrototype.writeCString = function(str, offset) {
+    //? RELATIVE();
+    var i,
+        k = str.length;
+    if (!this.noAssert) {
+        if (typeof str !== 'string')
+            throw TypeError("Illegal str: Not a string");
+        for (i=0; i<k; ++i) {
+            if (str.charCodeAt(i) === 0)
+                throw RangeError("Illegal str: Contains NULL-characters");
+        }
+        //? ASSERT_OFFSET();
+    }
+    // UTF8 strings do not contain zero bytes in between except for the zero character, so:
+    //? if (NODE) {
+    k = Buffer.byteLength(str, "utf8");
+    //? ENSURE_CAPACITY('k+1');
+    offset += this.buffer.write(str, offset, k, "utf8");
+    this.buffer[offset++] = 0;
+    //? } else {
+    k = utfx.calculateUTF16asUTF8(stringSource(str))[1];
+    //? ENSURE_CAPACITY('k+1');
+    utfx.encodeUTF16toUTF8(stringSource(str), function(b) {
+        //? if (DATAVIEW)
+        this.view.setUint8(offset++, b);
+        //? else
+        this.view[offset++] = b;
+    }.bind(this));
+    //? if (DATAVIEW)
+    this.view.setUint8(offset++, 0);
+    //? else
+    this.view[offset++] = 0;
+    //? }
+    if (relative) {
+        this.offset = offset;
+        return this;
+    }
+    return k;
+};
+
+/**
+ * Reads a NULL-terminated UTF8 encoded string. For this to work the string read must not contain any NULL characters
+ *  itself.
+ * @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.readCString = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(1);
+    }
+    var start = offset,
+        temp;
+    // UTF8 strings do not contain zero bytes in between except for the zero character itself, so:
+    //? if (NODE) {
+    do {
+        if (offset >= this.buffer.length)
+            throw RangeError("Index out of range: "+offset+" <= "+this.buffer.length);
+        temp = this.buffer[offset++];
+    } while (temp !== 0);
+    var str = this.buffer.toString("utf8", start, offset-1);
+    if (relative) {
+        this.offset = offset;
+        return str;
+    } else {
+        return {
+            "string": str,
+            "length": offset - start
+        };
+    }
+    //? } else { // getUint8 asserts on its own
+    var sd, b = -1;
+    utfx.decodeUTF8toUTF16(function() {
+        if (b === 0) return null;
+        if (offset >= this.limit)
+            throw RangeError("Illegal range: Truncated data, "+offset+" < "+this.limit);
+        //? if (DATAVIEW)
+        b = this.view.getUint8(offset++);
+        //? else
+        b = this.view[offset++];
+        return b === 0 ? null : b;
+    }.bind(this), sd = stringDestination(), true);
+    if (relative) {
+        this.offset = offset;
+        return sd();
+    } else {
+        return {
+            "string": sd(),
+            "length": offset - start
+        };
+    }
+    //? }
+};
+
+//? }

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

@@ -0,0 +1,81 @@
+//? if (ISTRING) {
+// types/strings/istring
+
+/**
+ * Writes a length as uint32 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.writeIString = function(str, offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        if (typeof str !== 'string')
+            throw TypeError("Illegal str: Not a string");
+        //? ASSERT_OFFSET();
+    }
+    var start = offset,
+        k;
+    //? if (NODE) {
+    k = Buffer.byteLength(str, "utf8");
+    //? ENSURE_CAPACITY('4+k');
+    //? WRITE_UINT32_ARRAY('k');
+    offset += 4;
+    offset += this.buffer.write(str, offset, k, "utf8");
+    //? } else {
+    k = utfx.calculateUTF16asUTF8(stringSource(str), this.noAssert)[1];
+    //? ENSURE_CAPACITY('4+k');
+    //? if (DATAVIEW)
+    this.view.setUint32(offset, k, this.littleEndian);
+    //? else
+    //? WRITE_UINT32_ARRAY('k');
+    offset += 4;
+    utfx.encodeUTF16toUTF8(stringSource(str), function(b) {
+        //? if (DATAVIEW)
+        this.view.setUint8(offset++, b);
+        //? else
+        this.view[offset++] = b;
+    }.bind(this));
+    if (offset !== start + 4 + k)
+        throw RangeError("Illegal range: Truncated data, "+offset+" == "+(offset+4+k));
+    //? }
+    if (relative) {
+        this.offset = offset;
+        return this;
+    }
+    return offset - start;
+};
+
+/**
+ * Reads a length as uint32 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.readIString = function(offset) {
+    //? RELATIVE();
+    if (!this.noAssert) {
+        //? ASSERT_OFFSET(4);
+    }
+    var start = offset;
+    var len = this.readUint32(offset);
+    var str = this.readUTF8String(len, ByteBuffer.METRICS_BYTES, offset += 4);
+    offset += str['length'];
+    if (relative) {
+        this.offset = offset;
+        return str['string'];
+    } else {
+        return {
+            'string': str['string'],
+            'length': offset - start
+        };
+    }
+};
+
+//? }