Simulator first commit

node_modules/bytebuffer/src/methods/static/accessor.js

@@ -0,0 +1,13 @@
+/**
+ * Gets the accessor type.
+ * @returns {Function} `Buffer` under node.js, `Uint8Array` respectively `DataView` in the browser (classes)
+ * @expose
+ */
+ByteBuffer.accessor = function() {
+    //? if (NODE)
+    return Buffer;
+    //? else if (DATAVIEW)
+    return DataView;
+    //? else
+    return Uint8Array;
+};

node_modules/bytebuffer/src/methods/static/allocate.js

@@ -0,0 +1,14 @@
+/**
+ * Allocates a new ByteBuffer backed by a buffer of the specified capacity.
+ * @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}.
+ * @returns {!ByteBuffer}
+ * @expose
+ */
+ByteBuffer.allocate = function(capacity, littleEndian, noAssert) {
+    return new ByteBuffer(capacity, littleEndian, noAssert);
+};
+

node_modules/bytebuffer/src/methods/static/concat.js

@@ -0,0 +1,55 @@
+/**
+ * Concatenates multiple ByteBuffers into one.
+//? if (NODE) {
+ * @param {!Array.<!ByteBuffer|!Buffer|!ArrayBuffer|!Uint8Array|string>} buffers Buffers to concatenate
+//? } else {
+ * @param {!Array.<!ByteBuffer|!ArrayBuffer|!Uint8Array|string>} buffers Buffers to concatenate
+//? }
+ * @param {(string|boolean)=} encoding String encoding if `buffers` contains a string ("base64", "hex", "binary",
+ *  defaults to "utf8")
+ * @param {boolean=} littleEndian Whether to use little or big endian byte order for the resulting ByteBuffer. Defaults
+ *  to {@link ByteBuffer.DEFAULT_ENDIAN}.
+ * @param {boolean=} noAssert Whether to skip assertions of offsets and values for the resulting ByteBuffer. Defaults to
+ *  {@link ByteBuffer.DEFAULT_NOASSERT}.
+ * @returns {!ByteBuffer} Concatenated ByteBuffer
+ * @expose
+ */
+ByteBuffer.concat = function(buffers, encoding, littleEndian, noAssert) {
+    if (typeof encoding === 'boolean' || typeof encoding !== 'string') {
+        noAssert = littleEndian;
+        littleEndian = encoding;
+        encoding = undefined;
+    }
+    var capacity = 0;
+    for (var i=0, k=buffers.length, length; i<k; ++i) {
+        if (!ByteBuffer.isByteBuffer(buffers[i]))
+            buffers[i] = ByteBuffer.wrap(buffers[i], encoding);
+        length = buffers[i].limit - buffers[i].offset;
+        if (length > 0) capacity += length;
+    }
+    if (capacity === 0)
+        return new ByteBuffer(0, littleEndian, noAssert);
+    var bb = new ByteBuffer(capacity, littleEndian, noAssert),
+        bi;
+    //? if (!NODE && DATAVIEW)
+    var view = new Uint8Array(bb.buffer);
+    i=0; while (i<k) {
+        bi = buffers[i++];
+        length = bi.limit - bi.offset;
+        if (length <= 0) continue;
+        //? if (NODE) {
+        bi.buffer.copy(bb.buffer, bb.offset, bi.offset, bi.limit);
+        bb.offset += length;
+        //? } else {
+        //? if (DATAVIEW)
+        view.set(new Uint8Array(bi.buffer).subarray(bi.offset, bi.limit), bb.offset);
+        //? else
+        bb.view.set(bi.view.subarray(bi.offset, bi.limit), bb.offset);
+        bb.offset += length;
+        //? }
+    }
+    bb.limit = bb.offset;
+    bb.offset = 0;
+    return bb;
+};
+

node_modules/bytebuffer/src/methods/static/isByteBuffer.js

@@ -0,0 +1,9 @@
+/**
+ * Tests if the specified type is a ByteBuffer.
+ * @param {*} bb ByteBuffer to test
+ * @returns {boolean} `true` if it is a ByteBuffer, otherwise `false`
+ * @expose
+ */
+ByteBuffer.isByteBuffer = function(bb) {
+    return (bb && bb["__isByteBuffer__"]) === true;
+};

node_modules/bytebuffer/src/methods/static/type.js

@@ -0,0 +1,11 @@
+/**
+ * Gets the backing buffer type.
+ * @returns {Function} `Buffer` under node.js, `ArrayBuffer` in the browser (classes)
+ * @expose
+ */
+ByteBuffer.type = function() {
+    //? if (NODE)
+    return Buffer;
+    //? else
+    return ArrayBuffer;
+};

node_modules/bytebuffer/src/methods/static/wrap.js

@@ -0,0 +1,125 @@
+/**
+ * Wraps a buffer or a string. Sets the allocated ByteBuffer's {@link ByteBuffer#offset} to `0` and its
+ *  {@link ByteBuffer#limit} to the length of the wrapped data.
+//? if (NODE) {
+ * @param {!ByteBuffer|!Buffer|!ArrayBuffer|!Uint8Array|string|!Array.<number>} buffer Anything that can be wrapped
+//? } else {
+ * @param {!ByteBuffer|!ArrayBuffer|!Uint8Array|string|!Array.<number>} buffer Anything that can be wrapped
+//? }
+ * @param {(string|boolean)=} encoding String encoding if `buffer` is a string ("base64", "hex", "binary", defaults to
+ *  "utf8")
+ * @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}.
+ * @returns {!ByteBuffer} A ByteBuffer wrapping `buffer`
+ * @expose
+ */
+ByteBuffer.wrap = function(buffer, encoding, littleEndian, noAssert) {
+    if (typeof encoding !== 'string') {
+        noAssert = littleEndian;
+        littleEndian = encoding;
+        encoding = undefined;
+    }
+    if (typeof buffer === 'string') {
+        if (typeof encoding === 'undefined')
+            encoding = "utf8";
+        switch (encoding) {
+            //? if (BASE64) {
+            case "base64":
+                return ByteBuffer.fromBase64(buffer, littleEndian);
+            //? } if (HEX) {
+            case "hex":
+                return ByteBuffer.fromHex(buffer, littleEndian);
+            //? } if (BINARY) {
+            case "binary":
+                return ByteBuffer.fromBinary(buffer, littleEndian);
+            //? } if (UTF8) {
+            case "utf8":
+                return ByteBuffer.fromUTF8(buffer, littleEndian);
+            //? } if (DEBUG) {
+            case "debug":
+                return ByteBuffer.fromDebug(buffer, littleEndian);
+            //? }
+            default:
+                throw Error("Unsupported encoding: "+encoding);
+        }
+    }
+    if (buffer === null || typeof buffer !== 'object')
+        throw TypeError("Illegal buffer");
+    var bb;
+    if (ByteBuffer.isByteBuffer(buffer)) {
+        bb = ByteBufferPrototype.clone.call(buffer);
+        bb.markedOffset = -1;
+        return bb;
+    }
+    //? if (NODE) {
+    var i = 0,
+        k = 0,
+        b;
+    if (buffer instanceof Uint8Array) { // Extract bytes from Uint8Array
+        b = new Buffer(buffer.length);
+        if (memcpy) { // Fast
+            memcpy(b, 0, buffer.buffer, buffer.byteOffset, buffer.byteOffset + buffer.length);
+        } else { // Slow
+            for (i=0, k=buffer.length; i<k; ++i)
+                b[i] = buffer[i];
+        }
+        buffer = b;
+    } else if (buffer instanceof ArrayBuffer) { // Convert ArrayBuffer to Buffer
+        b = new Buffer(buffer.byteLength);
+        if (memcpy) { // Fast
+            memcpy(b, 0, buffer, 0, buffer.byteLength);
+        } else { // Slow
+            buffer = new Uint8Array(buffer);
+            for (i=0, k=buffer.length; i<k; ++i) {
+                b[i] = buffer[i];
+            }
+        }
+        buffer = b;
+    } else if (!(buffer instanceof Buffer)) { // Create from octets if it is an error, otherwise fail
+        if (Object.prototype.toString.call(buffer) !== "[object Array]")
+            throw TypeError("Illegal buffer");
+        buffer = new Buffer(buffer);
+    }
+    bb = new ByteBuffer(0, littleEndian, noAssert);
+    if (buffer.length > 0) { // Avoid references to more than one EMPTY_BUFFER
+        bb.buffer = buffer;
+        bb.limit = buffer.length;
+    }
+    //? } else {
+    if (buffer instanceof Uint8Array) { // Extract ArrayBuffer from Uint8Array
+        bb = new ByteBuffer(0, littleEndian, noAssert);
+        if (buffer.length > 0) { // Avoid references to more than one EMPTY_BUFFER
+            bb.buffer = buffer.buffer;
+            bb.offset = buffer.byteOffset;
+            bb.limit = buffer.byteOffset + buffer.byteLength;
+            //? if (DATAVIEW)
+            bb.view = new DataView(buffer.buffer);
+            //? else
+            bb.view = new Uint8Array(buffer.buffer);
+        }
+    } else if (buffer instanceof ArrayBuffer) { // Reuse ArrayBuffer
+        bb = new ByteBuffer(0, littleEndian, noAssert);
+        if (buffer.byteLength > 0) {
+            bb.buffer = buffer;
+            bb.offset = 0;
+            bb.limit = buffer.byteLength;
+            //? if (DATAVIEW)
+            bb.view = buffer.byteLength > 0 ? new DataView(buffer) : null;
+            //? else
+            bb.view = buffer.byteLength > 0 ? new Uint8Array(buffer) : null;
+        }
+    } else if (Object.prototype.toString.call(buffer) === "[object Array]") { // Create from octets
+        bb = new ByteBuffer(buffer.length, littleEndian, noAssert);
+        bb.limit = buffer.length;
+        for (var i=0; i<buffer.length; ++i)
+            //? if (DATAVIEW)
+            bb.view.setUint8(i, buffer[i]);
+            //? else
+            bb.view[i] = buffer[i];
+    } else
+        throw TypeError("Illegal buffer"); // Otherwise fail
+    //? }
+    return bb;
+};