dexbot 1.4.11 → 1.4.13

package/claw/node_modules/bytebuffer/externs/minimal-env.js

@@ -0,0 +1,52 @@
+/**
+ * @param {string} moduleName
+ * @returns {?}
+ */
+function require(moduleName) {};
+
+/**
+ * @param {string} name
+ * @param {Array.<string>} deps
+ * @param {function(...[*])} f
+ */
+function define(name, deps, f) {};
+
+/**
+ * @param {number} size
+ * @constructor
+ * @extends Array
+ */
+function Buffer(size) {};
+
+/**
+ * @param {*} buf
+ * @return {boolean}
+ */
+Buffer.isBuffer = function(buf) {};
+
+/**
+ * @type {Object.<string,*>}
+ */
+var console = {};
+
+/**
+ * @param {string} s
+ */
+console.log = function(s) {};
+
+/**
+ * @type {*}
+ */
+var module = {};
+
+/**
+ * @param {...*} var_args
+ * @returns {string}
+ */
+String.fromCodePoint = function(var_args) {};
+
+/**
+ * @param {number} offset
+ * @returns {number}
+ */
+String.prototype.codePointAt = function(offset) {};

package/claw/node_modules/bytebuffer/index.js

@@ -0,0 +1 @@
+module.exports = require("./dist/bytebuffer-node.js");

package/claw/node_modules/bytebuffer/jsdoc.json

@@ -0,0 +1,13 @@
+{
+    "tags": {
+        "allowUnknownTags": true
+    },
+    "source": {
+        "include": ["dist/ByteBufferAB.js"]
+    },
+    "opts": {
+        "template": "templates/esoccer",
+        "destination": "docs"
+    },
+    "plugins": ["plugins/markdown"]
+}

package/claw/node_modules/bytebuffer/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "bytebuffer",
+  "version": "5.0.1",
+  "author": "Daniel Wirtz <dcode@dcode.io>",
+  "description": "The swiss army knife for binary data in JavaScript.",
+  "main": "dist/bytebuffer-node.js",
+  "browser": "dist/bytebuffer.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dcodeIO/bytebuffer.js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dcodeIO/bytebuffer.js/issues"
+  },
+  "keywords": [
+    "net",
+    "array",
+    "buffer",
+    "arraybuffer",
+    "typed array",
+    "bytebuffer",
+    "json",
+    "websocket",
+    "webrtc"
+  ],
+  "dependencies": {
+    "long": "~3"
+  },
+  "devDependencies": {
+    "closurecompiler": "~1",
+    "lxiv": "~0.2",
+    "metascript": "~0",
+    "pretty-hrtime": "^1.0.0",
+    "testjs": "~1",
+    "utfx": "^1.0.1"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=0.8"
+  },
+  "scripts": {
+    "prepublish": "npm test",
+    "test": "node node_modules/testjs/bin/testjs tests/suite.js",
+    "make": "npm run-script build && npm run-script compile && npm run-script compress && npm test",
+    "build": "node scripts/build.js",
+    "compile": "npm run-script compile-default && npm run-script compile-dataview",
+    "compile-default": "ccjs dist/bytebuffer.js --create_source_map=dist/bytebuffer.min.map --externs=externs/minimal-env.js --externs=node_modules/long/externs/long.js > dist/bytebuffer.min.js",
+    "compile-dataview": "ccjs dist/bytebuffer-dataview.js --create_source_map=dist/bytebuffer-dataview.min.map --externs=externs/minimal-env.js --externs=node_modules/long/externs/long.js > dist/bytebuffer-dataview.min.js",
+    "compress": "gzip -c -9 dist/bytebuffer.min.js > dist/bytebuffer.min.js.gz && gzip -c -9 dist/bytebuffer-dataview.min.js > dist/bytebuffer-dataview.min.js.gz"
+  }
+}

package/claw/node_modules/bytebuffer/scripts/build.js

@@ -0,0 +1,113 @@
+/*
+ Copyright 2013 Daniel Wirtz <dcode@dcode.io>
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+var MetaScript = require("metascript"),
+    path = require("path"),
+    fs = require("fs");
+
+var rootDir = path.join(__dirname, ".."),
+    srcDir  = path.join(__dirname, "..", "src"),
+    distDir = path.join(__dirname, "..", "dist"),
+    pkg = require(path.join(rootDir, "package.json")),
+    filename;
+
+var scope = {
+    VERSION    : pkg.version,           // Version
+    
+    // Encodings
+    
+    ENCODINGS  : true,                  // Include encodings in general (catches all)
+    BASE64     : true,                  // Include base64 encoding
+    BINARY     : true,                  // Include binary encoding
+    DEBUG      : true,                  // Include debug encoding
+    HEX        : true,                  // Include hex encoding
+    UTF8       : true,                  // Include utf8 encoding (required for STRINGS)
+    
+    // Primitive types
+
+    BYTES      : true,                  // Include bytes
+    INTS       : true,                  // Include int types in general (catches all)
+    INT8       : true,                  // Include int8/uint8
+    INT16      : true,                  // Include int16/uint16
+    INT32      : true,                  // Include int32/uint32
+    INT64      : true,                  // Include int64/uint64 with Long.js
+    
+    FLOATS     : true,                  // Include float types in general (catches all)
+    FLOAT32    : true,                  // Include float32
+    FLOAT64    : true,                  // Include float64
+    
+    // Varint encoding
+    
+    VARINTS    : true,                  // Include varint encoding in general (catches all)
+    VARINT32   : true,                  // Include varint32/zigZagVarint32
+    VARINT64   : true,                  // Include varint64/zigZagVarint32 with Long.js
+    
+    // String support
+    
+    STRINGS    : true,                  // Include string support in general (catches all)
+    UTF8STRING : true,                  // Include UTF8 encoded strings
+    CSTRING    : true,                  // Include C-like null terminated strings
+    VSTRING    : true,                  // Include varint32 length prefixed strings
+    ISTRING    : true,                  // Include uint32 length prefixed strings
+    
+    // Other
+    
+    ALIASES    : true,                  // Include aliases like writeByte, writeShort ..
+    INLINE     : true,                  // Inline any assertion code
+    VERBOSE_MS : false                  // Include MetaScript details as comments
+};
+
+// Optimize for size  : INLINE=false, ALIASES=false, VERBOSE_MS=false, WHATEVERYOUDONTNEED=false
+// Optimize for speed : INLINE=true
+
+if (!scope.UTF8) scope.STRINGS = false;
+
+// Build node version using Buffers
+scope.NODE = true;
+console.log("Building bytebuffer-node with scope", JSON.stringify(scope, null, 2));
+fs.writeFileSync(
+    path.join(distDir, "bytebuffer-node.js"),
+    MetaScript.transform(fs.readFileSync(filename = path.join(srcDir, "wrap-node.js")), filename, scope, srcDir)
+);
+
+// Build browser version using Typed Arrays
+scope.NODE = false;
+scope.DATAVIEW = false;
+delete scope.BUFFERVIEW;
+console.log("Building bytebuffer.js with scope", JSON.stringify(scope, null, 2));
+fs.writeFileSync(
+    path.join(distDir, "bytebuffer.js"),
+    MetaScript.transform(fs.readFileSync(filename = path.join(srcDir, "wrap.js")), filename, scope)
+);
+
+// Build alternative browser version using a DataView
+scope.NODE = false;
+scope.DATAVIEW = true;
+console.log("Building bytebuffer-dataview with scope", JSON.stringify(scope, null, 2));
+fs.writeFileSync(
+    path.join(distDir, "bytebuffer-dataview.js"),
+    MetaScript.transform(fs.readFileSync(filename = path.join(srcDir, "wrap.js")), filename, scope)
+);
+
+// Update bower.json
+scope = { VERSION: pkg.version };
+console.log("Updating bower.json with scope", JSON.stringify(scope, null, 2));
+fs.writeFileSync(
+    path.join(rootDir, "bower.json"),
+    MetaScript.transform(fs.readFileSync(filename = path.join(srcDir, "bower.json")), filename, scope, srcDir)
+);
+
+console.log("Done");

package/claw/node_modules/bytebuffer/src/bower.json

@@ -0,0 +1,12 @@
+{
+    "name": "bytebuffer",
+    "version": "/*?= VERSION */",
+    "author": "Daniel Wirtz <dcode@dcode.io>",
+    "description": "A full-featured ByteBuffer implementation using typed arrays.",
+    "main": "dist/bytebuffer.js",
+    "keywords": ["net", "array", "buffer", "arraybuffer", "typed array", "bytebuffer", "json", "websocket", "webrtc"],
+    "dependencies": {
+        "long": "latest"
+    },
+    "license": "Apache-2.0"
+}

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

@@ -0,0 +1,220 @@
+//? include("macros.js");
+/**
+ * Constructs a new ByteBuffer.
+ * @class The swiss army knife for binary data in JavaScript.
+ * @exports ByteBuffer
+ * @constructor
+ * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.
+ * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
+ *  {@link ByteBuffer.DEFAULT_ENDIAN}.
+ * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
+ *  {@link ByteBuffer.DEFAULT_NOASSERT}.
+ * @expose
+ */
+var ByteBuffer = function(capacity, littleEndian, noAssert) {
+    if (typeof capacity === 'undefined')
+        capacity = ByteBuffer.DEFAULT_CAPACITY;
+    if (typeof littleEndian === 'undefined')
+        littleEndian = ByteBuffer.DEFAULT_ENDIAN;
+    if (typeof noAssert === 'undefined')
+        noAssert = ByteBuffer.DEFAULT_NOASSERT;
+    if (!noAssert) {
+        capacity = capacity | 0;
+        if (capacity < 0)
+            throw RangeError("Illegal capacity");
+        littleEndian = !!littleEndian;
+        noAssert = !!noAssert;
+    }
+    //? if (NODE) {
+    
+    /**
+     * Backing node Buffer.
+     * @type {!Buffer}
+     * @expose
+     */
+    this.buffer = capacity === 0 ? EMPTY_BUFFER : new Buffer(capacity);
+    //? } else {
+    
+    /**
+     * Backing ArrayBuffer.
+     * @type {!ArrayBuffer}
+     * @expose
+     */
+    this.buffer = capacity === 0 ? EMPTY_BUFFER : new ArrayBuffer(capacity);
+
+    //? if (DATAVIEW) {
+    /**
+     * DataView utilized to manipulate the backing buffer. Becomes `null` if the backing buffer has a capacity of `0`.
+     * @type {?DataView}
+     * @expose
+     */
+    this.view = capacity === 0 ? null : new DataView(this.buffer);
+    //? } else {
+    /**
+     * Uint8Array utilized to manipulate the backing buffer. Becomes `null` if the backing buffer has a capacity of `0`.
+     * @type {?Uint8Array}
+     * @expose
+     */
+    this.view = capacity === 0 ? null : new Uint8Array(this.buffer);
+    //? }
+    //? }
+    
+    /**
+     * Absolute read/write offset.
+     * @type {number}
+     * @expose
+     * @see ByteBuffer#flip
+     * @see ByteBuffer#clear
+     */
+    this.offset = 0;
+
+    /**
+     * Marked offset.
+     * @type {number}
+     * @expose
+     * @see ByteBuffer#mark
+     * @see ByteBuffer#reset
+     */
+    this.markedOffset = -1;
+
+    /**
+     * Absolute limit of the contained data. Set to the backing buffer's capacity upon allocation.
+     * @type {number}
+     * @expose
+     * @see ByteBuffer#flip
+     * @see ByteBuffer#clear
+     */
+    this.limit = capacity;
+
+    /**
+     * Whether to use little endian byte order, defaults to `false` for big endian.
+     * @type {boolean}
+     * @expose
+     */
+    this.littleEndian = littleEndian;
+
+    /**
+     * Whether to skip assertions of offsets and values, defaults to `false`.
+     * @type {boolean}
+     * @expose
+     */
+    this.noAssert = noAssert;
+};
+
+/**
+ * ByteBuffer version.
+ * @type {string}
+ * @const
+ * @expose
+ */
+ByteBuffer.VERSION = "/*?= VERSION */";
+
+/**
+ * Little endian constant that can be used instead of its boolean value. Evaluates to `true`.
+ * @type {boolean}
+ * @const
+ * @expose
+ */
+ByteBuffer.LITTLE_ENDIAN = true;
+
+/**
+ * Big endian constant that can be used instead of its boolean value. Evaluates to `false`.
+ * @type {boolean}
+ * @const
+ * @expose
+ */
+ByteBuffer.BIG_ENDIAN = false;
+
+/**
+ * Default initial capacity of `16`.
+ * @type {number}
+ * @expose
+ */
+ByteBuffer.DEFAULT_CAPACITY = 16;
+
+/**
+ * Default endianess of `false` for big endian.
+ * @type {boolean}
+ * @expose
+ */
+ByteBuffer.DEFAULT_ENDIAN = ByteBuffer.BIG_ENDIAN;
+
+/**
+ * Default no assertions flag of `false`.
+ * @type {boolean}
+ * @expose
+ */
+ByteBuffer.DEFAULT_NOASSERT = false;
+//? if (NODE) {
+
+/**
+ * A `Long` class for representing a 64-bit two's-complement integer value.
+ * @type {!Long}
+ * @const
+ * @see https://npmjs.org/package/long
+ * @expose
+ */
+ByteBuffer.Long = Long;
+//? } else {
+
+/**
+ * A `Long` class for representing a 64-bit two's-complement integer value. May be `null` if Long.js has not been loaded
+ *  and int64 support is not available.
+ * @type {?Long}
+ * @const
+ * @see https://github.com/dcodeIO/long.js
+ * @expose
+ */
+ByteBuffer.Long = Long || null;
+//? }
+
+/**
+ * @alias ByteBuffer.prototype
+ * @inner
+ */
+var ByteBufferPrototype = ByteBuffer.prototype;
+
+/**
+ * An indicator used to reliably determine if an object is a ByteBuffer or not.
+ * @type {boolean}
+ * @const
+ * @expose
+ * @private
+ */
+ByteBufferPrototype.__isByteBuffer__;
+
+Object.defineProperty(ByteBufferPrototype, "__isByteBuffer__", {
+    value: true,
+    enumerable: false,
+    configurable: false
+});
+
+//? include("helpers.js");
+
+//? include("methods/static/*.js");
+//? if (BYTES) {
+
+//? include("types/bytes/*.js");
+//? }
+//? if (INTS) {
+
+//? include("types/ints/*.js");
+//? }
+//? if (FLOATS) {
+
+//? include("types/floats/float*.js");
+//? }
+//? if (VARINTS) {
+
+//? include("types/varints/*.js");
+//? }
+//? if (UTF8 && STRINGS) {
+
+//? include("types/strings/*.js");
+//? }
+
+//? include("methods/*.js");
+//? if (ENCODINGS) {
+
+//? include("encodings/*.js");
+//? }

package/claw/node_modules/bytebuffer/src/encodings/base64.js

@@ -0,0 +1,88 @@
+//? if (BASE64) {
+//? if (!NODE) {
+// lxiv-embeddable
+
+//? include("../../node_modules/lxiv/dist/lxiv-embeddable.js");
+
+//? }
+// encodings/base64
+
+/**
+ * Encodes this ByteBuffer's contents to a base64 encoded string.
+ * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}.
+ * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}.
+ * @returns {string} Base64 encoded string
+ * @throws {RangeError} If `begin` or `end` is out of bounds
+ * @expose
+ */
+ByteBufferPrototype.toBase64 = function(begin, end) {
+    if (typeof begin === 'undefined')
+        begin = this.offset;
+    if (typeof end === 'undefined')
+        end = this.limit;
+    begin = begin | 0; end = end | 0;
+    if (begin < 0 || end > this.capacity || begin > end)
+        throw RangeError("begin, end");
+    //? if (NODE)
+    return this.buffer.toString("base64", begin, end);
+    //? else {
+    var sd; lxiv.encode(function() {
+        //? if (DATAVIEW)
+        return begin < end ? this.view.getUint8(begin++) : null;
+        //? else
+        return begin < end ? this.view[begin++] : null;
+    }.bind(this), sd = stringDestination());
+    return sd();
+    //? }
+};
+
+/**
+ * Decodes a base64 encoded string to a ByteBuffer.
+ * @param {string} str String to decode
+ * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
+ *  {@link ByteBuffer.DEFAULT_ENDIAN}.
+ * @returns {!ByteBuffer} ByteBuffer
+ * @expose
+ */
+ByteBuffer.fromBase64 = function(str, littleEndian) {
+    //? if (NODE) {
+    return ByteBuffer.wrap(new Buffer(str, "base64"), littleEndian);
+    //? } else {
+    if (typeof str !== 'string')
+        throw TypeError("str");
+    var bb = new ByteBuffer(str.length/4*3, littleEndian),
+        i = 0;
+    lxiv.decode(stringSource(str), function(b) {
+        //? if (DATAVIEW)
+        bb.view.setUint8(i++, b);
+        //? else
+        bb.view[i++] = b;
+    });
+    bb.limit = i;
+    //? }
+    return bb;
+};
+
+/**
+ * Encodes a binary string to base64 like `window.btoa` does.
+ * @param {string} str Binary string
+ * @returns {string} Base64 encoded string
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa
+ * @expose
+ */
+ByteBuffer.btoa = function(str) {
+    return ByteBuffer.fromBinary(str).toBase64();
+};
+
+/**
+ * Decodes a base64 encoded string to binary like `window.atob` does.
+ * @param {string} b64 Base64 encoded string
+ * @returns {string} Binary string
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.atob
+ * @expose
+ */
+ByteBuffer.atob = function(b64) {
+    return ByteBuffer.fromBase64(b64).toBinary();
+};
+
+//? }

package/claw/node_modules/bytebuffer/src/encodings/binary.js

@@ -0,0 +1,74 @@
+//? if (BINARY) {
+// encodings/binary
+
+/**
+ * Encodes this ByteBuffer to a binary encoded string, that is using only characters 0x00-0xFF as bytes.
+ * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.
+ * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.
+ * @returns {string} Binary encoded string
+ * @throws {RangeError} If `offset > limit`
+ * @expose
+ */
+ByteBufferPrototype.toBinary = function(begin, end) {
+    if (typeof begin === 'undefined')
+        begin = this.offset;
+    if (typeof end === 'undefined')
+        end = this.limit;
+    begin |= 0; end |= 0;
+    if (begin < 0 || end > this.capacity() || begin > end)
+        throw RangeError("begin, end");
+    //? if (NODE)
+    return this.buffer.toString("binary", begin, end);
+    //? else {
+    if (begin === end)
+        return "";
+    var chars = [],
+        parts = [];
+    while (begin < end) {
+        //? if (NODE)
+        chars.push(this.buffer[begin++]);
+        //? else if (DATAVIEW)
+        chars.push(this.view.getUint8(begin++));
+        //? else
+        chars.push(this.view[begin++]);
+        if (chars.length >= 1024)
+            parts.push(String.fromCharCode.apply(String, chars)),
+            chars = [];
+    }
+    return parts.join('') + String.fromCharCode.apply(String, chars);
+    //? }
+};
+
+/**
+ * Decodes a binary encoded string, that is using only characters 0x00-0xFF as bytes, to a ByteBuffer.
+ * @param {string} str String to decode
+ * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
+ *  {@link ByteBuffer.DEFAULT_ENDIAN}.
+ * @returns {!ByteBuffer} ByteBuffer
+ * @expose
+ */
+ByteBuffer.fromBinary = function(str, littleEndian) {
+    //? if (NODE) {
+    return ByteBuffer.wrap(new Buffer(str, "binary"), littleEndian);
+    //? } else {
+    if (typeof str !== 'string')
+        throw TypeError("str");
+    var i = 0,
+        k = str.length,
+        charCode,
+        bb = new ByteBuffer(k, littleEndian);
+    while (i<k) {
+        charCode = str.charCodeAt(i);
+        if (charCode > 0xff)
+            throw RangeError("illegal char code: "+charCode);
+        //? if (DATAVIEW)
+        bb.view.setUint8(i++, charCode);
+        //? else
+        bb.view[i++] = charCode;
+    }
+    bb.limit = k;
+    //? }
+    return bb;
+};
+
+//? }