summaryrefslogtreecommitdiff
path: root/node_modules/node-forge/lib/util.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/node-forge/lib/util.js')
-rw-r--r--node_modules/node-forge/lib/util.js2652
1 files changed, 2652 insertions, 0 deletions
diff --git a/node_modules/node-forge/lib/util.js b/node_modules/node-forge/lib/util.js
new file mode 100644
index 0000000..aaede5a
--- /dev/null
+++ b/node_modules/node-forge/lib/util.js
@@ -0,0 +1,2652 @@
+/**
+ * Utility functions for web applications.
+ *
+ * @author Dave Longley
+ *
+ * Copyright (c) 2010-2018 Digital Bazaar, Inc.
+ */
+var forge = require('./forge');
+var baseN = require('./baseN');
+
+/* Utilities API */
+var util = module.exports = forge.util = forge.util || {};
+
+// define setImmediate and nextTick
+(function() {
+ // use native nextTick (unless we're in webpack)
+ // webpack (or better node-libs-browser polyfill) sets process.browser.
+ // this way we can detect webpack properly
+ if(typeof process !== 'undefined' && process.nextTick && !process.browser) {
+ util.nextTick = process.nextTick;
+ if(typeof setImmediate === 'function') {
+ util.setImmediate = setImmediate;
+ } else {
+ // polyfill setImmediate with nextTick, older versions of node
+ // (those w/o setImmediate) won't totally starve IO
+ util.setImmediate = util.nextTick;
+ }
+ return;
+ }
+
+ // polyfill nextTick with native setImmediate
+ if(typeof setImmediate === 'function') {
+ util.setImmediate = function() { return setImmediate.apply(undefined, arguments); };
+ util.nextTick = function(callback) {
+ return setImmediate(callback);
+ };
+ return;
+ }
+
+ /* Note: A polyfill upgrade pattern is used here to allow combining
+ polyfills. For example, MutationObserver is fast, but blocks UI updates,
+ so it needs to allow UI updates periodically, so it falls back on
+ postMessage or setTimeout. */
+
+ // polyfill with setTimeout
+ util.setImmediate = function(callback) {
+ setTimeout(callback, 0);
+ };
+
+ // upgrade polyfill to use postMessage
+ if(typeof window !== 'undefined' &&
+ typeof window.postMessage === 'function') {
+ var msg = 'forge.setImmediate';
+ var callbacks = [];
+ util.setImmediate = function(callback) {
+ callbacks.push(callback);
+ // only send message when one hasn't been sent in
+ // the current turn of the event loop
+ if(callbacks.length === 1) {
+ window.postMessage(msg, '*');
+ }
+ };
+ function handler(event) {
+ if(event.source === window && event.data === msg) {
+ event.stopPropagation();
+ var copy = callbacks.slice();
+ callbacks.length = 0;
+ copy.forEach(function(callback) {
+ callback();
+ });
+ }
+ }
+ window.addEventListener('message', handler, true);
+ }
+
+ // upgrade polyfill to use MutationObserver
+ if(typeof MutationObserver !== 'undefined') {
+ // polyfill with MutationObserver
+ var now = Date.now();
+ var attr = true;
+ var div = document.createElement('div');
+ var callbacks = [];
+ new MutationObserver(function() {
+ var copy = callbacks.slice();
+ callbacks.length = 0;
+ copy.forEach(function(callback) {
+ callback();
+ });
+ }).observe(div, {attributes: true});
+ var oldSetImmediate = util.setImmediate;
+ util.setImmediate = function(callback) {
+ if(Date.now() - now > 15) {
+ now = Date.now();
+ oldSetImmediate(callback);
+ } else {
+ callbacks.push(callback);
+ // only trigger observer when it hasn't been triggered in
+ // the current turn of the event loop
+ if(callbacks.length === 1) {
+ div.setAttribute('a', attr = !attr);
+ }
+ }
+ };
+ }
+
+ util.nextTick = util.setImmediate;
+})();
+
+// check if running under Node.js
+util.isNodejs =
+ typeof process !== 'undefined' && process.versions && process.versions.node;
+
+
+// 'self' will also work in Web Workers (instance of WorkerGlobalScope) while
+// it will point to `window` in the main thread.
+// To remain compatible with older browsers, we fall back to 'window' if 'self'
+// is not available.
+util.globalScope = (function() {
+ if(util.isNodejs) {
+ return global;
+ }
+
+ return typeof self === 'undefined' ? window : self;
+})();
+
+// define isArray
+util.isArray = Array.isArray || function(x) {
+ return Object.prototype.toString.call(x) === '[object Array]';
+};
+
+// define isArrayBuffer
+util.isArrayBuffer = function(x) {
+ return typeof ArrayBuffer !== 'undefined' && x instanceof ArrayBuffer;
+};
+
+// define isArrayBufferView
+util.isArrayBufferView = function(x) {
+ return x && util.isArrayBuffer(x.buffer) && x.byteLength !== undefined;
+};
+
+/**
+ * Ensure a bits param is 8, 16, 24, or 32. Used to validate input for
+ * algorithms where bit manipulation, JavaScript limitations, and/or algorithm
+ * design only allow for byte operations of a limited size.
+ *
+ * @param n number of bits.
+ *
+ * Throw Error if n invalid.
+ */
+function _checkBitsParam(n) {
+ if(!(n === 8 || n === 16 || n === 24 || n === 32)) {
+ throw new Error('Only 8, 16, 24, or 32 bits supported: ' + n);
+ }
+}
+
+// TODO: set ByteBuffer to best available backing
+util.ByteBuffer = ByteStringBuffer;
+
+/** Buffer w/BinaryString backing */
+
+/**
+ * Constructor for a binary string backed byte buffer.
+ *
+ * @param [b] the bytes to wrap (either encoded as string, one byte per
+ * character, or as an ArrayBuffer or Typed Array).
+ */
+function ByteStringBuffer(b) {
+ // TODO: update to match DataBuffer API
+
+ // the data in this buffer
+ this.data = '';
+ // the pointer for reading from this buffer
+ this.read = 0;
+
+ if(typeof b === 'string') {
+ this.data = b;
+ } else if(util.isArrayBuffer(b) || util.isArrayBufferView(b)) {
+ if(typeof Buffer !== 'undefined' && b instanceof Buffer) {
+ this.data = b.toString('binary');
+ } else {
+ // convert native buffer to forge buffer
+ // FIXME: support native buffers internally instead
+ var arr = new Uint8Array(b);
+ try {
+ this.data = String.fromCharCode.apply(null, arr);
+ } catch(e) {
+ for(var i = 0; i < arr.length; ++i) {
+ this.putByte(arr[i]);
+ }
+ }
+ }
+ } else if(b instanceof ByteStringBuffer ||
+ (typeof b === 'object' && typeof b.data === 'string' &&
+ typeof b.read === 'number')) {
+ // copy existing buffer
+ this.data = b.data;
+ this.read = b.read;
+ }
+
+ // used for v8 optimization
+ this._constructedStringLength = 0;
+}
+util.ByteStringBuffer = ByteStringBuffer;
+
+/* Note: This is an optimization for V8-based browsers. When V8 concatenates
+ a string, the strings are only joined logically using a "cons string" or
+ "constructed/concatenated string". These containers keep references to one
+ another and can result in very large memory usage. For example, if a 2MB
+ string is constructed by concatenating 4 bytes together at a time, the
+ memory usage will be ~44MB; so ~22x increase. The strings are only joined
+ together when an operation requiring their joining takes place, such as
+ substr(). This function is called when adding data to this buffer to ensure
+ these types of strings are periodically joined to reduce the memory
+ footprint. */
+var _MAX_CONSTRUCTED_STRING_LENGTH = 4096;
+util.ByteStringBuffer.prototype._optimizeConstructedString = function(x) {
+ this._constructedStringLength += x;
+ if(this._constructedStringLength > _MAX_CONSTRUCTED_STRING_LENGTH) {
+ // this substr() should cause the constructed string to join
+ this.data.substr(0, 1);
+ this._constructedStringLength = 0;
+ }
+};
+
+/**
+ * Gets the number of bytes in this buffer.
+ *
+ * @return the number of bytes in this buffer.
+ */
+util.ByteStringBuffer.prototype.length = function() {
+ return this.data.length - this.read;
+};
+
+/**
+ * Gets whether or not this buffer is empty.
+ *
+ * @return true if this buffer is empty, false if not.
+ */
+util.ByteStringBuffer.prototype.isEmpty = function() {
+ return this.length() <= 0;
+};
+
+/**
+ * Puts a byte in this buffer.
+ *
+ * @param b the byte to put.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putByte = function(b) {
+ return this.putBytes(String.fromCharCode(b));
+};
+
+/**
+ * Puts a byte in this buffer N times.
+ *
+ * @param b the byte to put.
+ * @param n the number of bytes of value b to put.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.fillWithByte = function(b, n) {
+ b = String.fromCharCode(b);
+ var d = this.data;
+ while(n > 0) {
+ if(n & 1) {
+ d += b;
+ }
+ n >>>= 1;
+ if(n > 0) {
+ b += b;
+ }
+ }
+ this.data = d;
+ this._optimizeConstructedString(n);
+ return this;
+};
+
+/**
+ * Puts bytes in this buffer.
+ *
+ * @param bytes the bytes (as a binary encoded string) to put.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putBytes = function(bytes) {
+ this.data += bytes;
+ this._optimizeConstructedString(bytes.length);
+ return this;
+};
+
+/**
+ * Puts a UTF-16 encoded string into this buffer.
+ *
+ * @param str the string to put.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putString = function(str) {
+ return this.putBytes(util.encodeUtf8(str));
+};
+
+/**
+ * Puts a 16-bit integer in this buffer in big-endian order.
+ *
+ * @param i the 16-bit integer.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putInt16 = function(i) {
+ return this.putBytes(
+ String.fromCharCode(i >> 8 & 0xFF) +
+ String.fromCharCode(i & 0xFF));
+};
+
+/**
+ * Puts a 24-bit integer in this buffer in big-endian order.
+ *
+ * @param i the 24-bit integer.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putInt24 = function(i) {
+ return this.putBytes(
+ String.fromCharCode(i >> 16 & 0xFF) +
+ String.fromCharCode(i >> 8 & 0xFF) +
+ String.fromCharCode(i & 0xFF));
+};
+
+/**
+ * Puts a 32-bit integer in this buffer in big-endian order.
+ *
+ * @param i the 32-bit integer.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putInt32 = function(i) {
+ return this.putBytes(
+ String.fromCharCode(i >> 24 & 0xFF) +
+ String.fromCharCode(i >> 16 & 0xFF) +
+ String.fromCharCode(i >> 8 & 0xFF) +
+ String.fromCharCode(i & 0xFF));
+};
+
+/**
+ * Puts a 16-bit integer in this buffer in little-endian order.
+ *
+ * @param i the 16-bit integer.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putInt16Le = function(i) {
+ return this.putBytes(
+ String.fromCharCode(i & 0xFF) +
+ String.fromCharCode(i >> 8 & 0xFF));
+};
+
+/**
+ * Puts a 24-bit integer in this buffer in little-endian order.
+ *
+ * @param i the 24-bit integer.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putInt24Le = function(i) {
+ return this.putBytes(
+ String.fromCharCode(i & 0xFF) +
+ String.fromCharCode(i >> 8 & 0xFF) +
+ String.fromCharCode(i >> 16 & 0xFF));
+};
+
+/**
+ * Puts a 32-bit integer in this buffer in little-endian order.
+ *
+ * @param i the 32-bit integer.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putInt32Le = function(i) {
+ return this.putBytes(
+ String.fromCharCode(i & 0xFF) +
+ String.fromCharCode(i >> 8 & 0xFF) +
+ String.fromCharCode(i >> 16 & 0xFF) +
+ String.fromCharCode(i >> 24 & 0xFF));
+};
+
+/**
+ * Puts an n-bit integer in this buffer in big-endian order.
+ *
+ * @param i the n-bit integer.
+ * @param n the number of bits in the integer (8, 16, 24, or 32).
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putInt = function(i, n) {
+ _checkBitsParam(n);
+ var bytes = '';
+ do {
+ n -= 8;
+ bytes += String.fromCharCode((i >> n) & 0xFF);
+ } while(n > 0);
+ return this.putBytes(bytes);
+};
+
+/**
+ * Puts a signed n-bit integer in this buffer in big-endian order. Two's
+ * complement representation is used.
+ *
+ * @param i the n-bit integer.
+ * @param n the number of bits in the integer (8, 16, 24, or 32).
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putSignedInt = function(i, n) {
+ // putInt checks n
+ if(i < 0) {
+ i += 2 << (n - 1);
+ }
+ return this.putInt(i, n);
+};
+
+/**
+ * Puts the given buffer into this buffer.
+ *
+ * @param buffer the buffer to put into this one.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.putBuffer = function(buffer) {
+ return this.putBytes(buffer.getBytes());
+};
+
+/**
+ * Gets a byte from this buffer and advances the read pointer by 1.
+ *
+ * @return the byte.
+ */
+util.ByteStringBuffer.prototype.getByte = function() {
+ return this.data.charCodeAt(this.read++);
+};
+
+/**
+ * Gets a uint16 from this buffer in big-endian order and advances the read
+ * pointer by 2.
+ *
+ * @return the uint16.
+ */
+util.ByteStringBuffer.prototype.getInt16 = function() {
+ var rval = (
+ this.data.charCodeAt(this.read) << 8 ^
+ this.data.charCodeAt(this.read + 1));
+ this.read += 2;
+ return rval;
+};
+
+/**
+ * Gets a uint24 from this buffer in big-endian order and advances the read
+ * pointer by 3.
+ *
+ * @return the uint24.
+ */
+util.ByteStringBuffer.prototype.getInt24 = function() {
+ var rval = (
+ this.data.charCodeAt(this.read) << 16 ^
+ this.data.charCodeAt(this.read + 1) << 8 ^
+ this.data.charCodeAt(this.read + 2));
+ this.read += 3;
+ return rval;
+};
+
+/**
+ * Gets a uint32 from this buffer in big-endian order and advances the read
+ * pointer by 4.
+ *
+ * @return the word.
+ */
+util.ByteStringBuffer.prototype.getInt32 = function() {
+ var rval = (
+ this.data.charCodeAt(this.read) << 24 ^
+ this.data.charCodeAt(this.read + 1) << 16 ^
+ this.data.charCodeAt(this.read + 2) << 8 ^
+ this.data.charCodeAt(this.read + 3));
+ this.read += 4;
+ return rval;
+};
+
+/**
+ * Gets a uint16 from this buffer in little-endian order and advances the read
+ * pointer by 2.
+ *
+ * @return the uint16.
+ */
+util.ByteStringBuffer.prototype.getInt16Le = function() {
+ var rval = (
+ this.data.charCodeAt(this.read) ^
+ this.data.charCodeAt(this.read + 1) << 8);
+ this.read += 2;
+ return rval;
+};
+
+/**
+ * Gets a uint24 from this buffer in little-endian order and advances the read
+ * pointer by 3.
+ *
+ * @return the uint24.
+ */
+util.ByteStringBuffer.prototype.getInt24Le = function() {
+ var rval = (
+ this.data.charCodeAt(this.read) ^
+ this.data.charCodeAt(this.read + 1) << 8 ^
+ this.data.charCodeAt(this.read + 2) << 16);
+ this.read += 3;
+ return rval;
+};
+
+/**
+ * Gets a uint32 from this buffer in little-endian order and advances the read
+ * pointer by 4.
+ *
+ * @return the word.
+ */
+util.ByteStringBuffer.prototype.getInt32Le = function() {
+ var rval = (
+ this.data.charCodeAt(this.read) ^
+ this.data.charCodeAt(this.read + 1) << 8 ^
+ this.data.charCodeAt(this.read + 2) << 16 ^
+ this.data.charCodeAt(this.read + 3) << 24);
+ this.read += 4;
+ return rval;
+};
+
+/**
+ * Gets an n-bit integer from this buffer in big-endian order and advances the
+ * read pointer by ceil(n/8).
+ *
+ * @param n the number of bits in the integer (8, 16, 24, or 32).
+ *
+ * @return the integer.
+ */
+util.ByteStringBuffer.prototype.getInt = function(n) {
+ _checkBitsParam(n);
+ var rval = 0;
+ do {
+ // TODO: Use (rval * 0x100) if adding support for 33 to 53 bits.
+ rval = (rval << 8) + this.data.charCodeAt(this.read++);
+ n -= 8;
+ } while(n > 0);
+ return rval;
+};
+
+/**
+ * Gets a signed n-bit integer from this buffer in big-endian order, using
+ * two's complement, and advances the read pointer by n/8.
+ *
+ * @param n the number of bits in the integer (8, 16, 24, or 32).
+ *
+ * @return the integer.
+ */
+util.ByteStringBuffer.prototype.getSignedInt = function(n) {
+ // getInt checks n
+ var x = this.getInt(n);
+ var max = 2 << (n - 2);
+ if(x >= max) {
+ x -= max << 1;
+ }
+ return x;
+};
+
+/**
+ * Reads bytes out as a binary encoded string and clears them from the
+ * buffer. Note that the resulting string is binary encoded (in node.js this
+ * encoding is referred to as `binary`, it is *not* `utf8`).
+ *
+ * @param count the number of bytes to read, undefined or null for all.
+ *
+ * @return a binary encoded string of bytes.
+ */
+util.ByteStringBuffer.prototype.getBytes = function(count) {
+ var rval;
+ if(count) {
+ // read count bytes
+ count = Math.min(this.length(), count);
+ rval = this.data.slice(this.read, this.read + count);
+ this.read += count;
+ } else if(count === 0) {
+ rval = '';
+ } else {
+ // read all bytes, optimize to only copy when needed
+ rval = (this.read === 0) ? this.data : this.data.slice(this.read);
+ this.clear();
+ }
+ return rval;
+};
+
+/**
+ * Gets a binary encoded string of the bytes from this buffer without
+ * modifying the read pointer.
+ *
+ * @param count the number of bytes to get, omit to get all.
+ *
+ * @return a string full of binary encoded characters.
+ */
+util.ByteStringBuffer.prototype.bytes = function(count) {
+ return (typeof(count) === 'undefined' ?
+ this.data.slice(this.read) :
+ this.data.slice(this.read, this.read + count));
+};
+
+/**
+ * Gets a byte at the given index without modifying the read pointer.
+ *
+ * @param i the byte index.
+ *
+ * @return the byte.
+ */
+util.ByteStringBuffer.prototype.at = function(i) {
+ return this.data.charCodeAt(this.read + i);
+};
+
+/**
+ * Puts a byte at the given index without modifying the read pointer.
+ *
+ * @param i the byte index.
+ * @param b the byte to put.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.setAt = function(i, b) {
+ this.data = this.data.substr(0, this.read + i) +
+ String.fromCharCode(b) +
+ this.data.substr(this.read + i + 1);
+ return this;
+};
+
+/**
+ * Gets the last byte without modifying the read pointer.
+ *
+ * @return the last byte.
+ */
+util.ByteStringBuffer.prototype.last = function() {
+ return this.data.charCodeAt(this.data.length - 1);
+};
+
+/**
+ * Creates a copy of this buffer.
+ *
+ * @return the copy.
+ */
+util.ByteStringBuffer.prototype.copy = function() {
+ var c = util.createBuffer(this.data);
+ c.read = this.read;
+ return c;
+};
+
+/**
+ * Compacts this buffer.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.compact = function() {
+ if(this.read > 0) {
+ this.data = this.data.slice(this.read);
+ this.read = 0;
+ }
+ return this;
+};
+
+/**
+ * Clears this buffer.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.clear = function() {
+ this.data = '';
+ this.read = 0;
+ return this;
+};
+
+/**
+ * Shortens this buffer by triming bytes off of the end of this buffer.
+ *
+ * @param count the number of bytes to trim off.
+ *
+ * @return this buffer.
+ */
+util.ByteStringBuffer.prototype.truncate = function(count) {
+ var len = Math.max(0, this.length() - count);
+ this.data = this.data.substr(this.read, len);
+ this.read = 0;
+ return this;
+};
+
+/**
+ * Converts this buffer to a hexadecimal string.
+ *
+ * @return a hexadecimal string.
+ */
+util.ByteStringBuffer.prototype.toHex = function() {
+ var rval = '';
+ for(var i = this.read; i < this.data.length; ++i) {
+ var b = this.data.charCodeAt(i);
+ if(b < 16) {
+ rval += '0';
+ }
+ rval += b.toString(16);
+ }
+ return rval;
+};
+
+/**
+ * Converts this buffer to a UTF-16 string (standard JavaScript string).
+ *
+ * @return a UTF-16 string.
+ */
+util.ByteStringBuffer.prototype.toString = function() {
+ return util.decodeUtf8(this.bytes());
+};
+
+/** End Buffer w/BinaryString backing */
+
+/** Buffer w/UInt8Array backing */
+
+/**
+ * FIXME: Experimental. Do not use yet.
+ *
+ * Constructor for an ArrayBuffer-backed byte buffer.
+ *
+ * The buffer may be constructed from a string, an ArrayBuffer, DataView, or a
+ * TypedArray.
+ *
+ * If a string is given, its encoding should be provided as an option,
+ * otherwise it will default to 'binary'. A 'binary' string is encoded such
+ * that each character is one byte in length and size.
+ *
+ * If an ArrayBuffer, DataView, or TypedArray is given, it will be used
+ * *directly* without any copying. Note that, if a write to the buffer requires
+ * more space, the buffer will allocate a new backing ArrayBuffer to
+ * accommodate. The starting read and write offsets for the buffer may be
+ * given as options.
+ *
+ * @param [b] the initial bytes for this buffer.
+ * @param options the options to use:
+ * [readOffset] the starting read offset to use (default: 0).
+ * [writeOffset] the starting write offset to use (default: the
+ * length of the first parameter).
+ * [growSize] the minimum amount, in bytes, to grow the buffer by to
+ * accommodate writes (default: 1024).
+ * [encoding] the encoding ('binary', 'utf8', 'utf16', 'hex') for the
+ * first parameter, if it is a string (default: 'binary').
+ */
+function DataBuffer(b, options) {
+ // default options
+ options = options || {};
+
+ // pointers for read from/write to buffer
+ this.read = options.readOffset || 0;
+ this.growSize = options.growSize || 1024;
+
+ var isArrayBuffer = util.isArrayBuffer(b);
+ var isArrayBufferView = util.isArrayBufferView(b);
+ if(isArrayBuffer || isArrayBufferView) {
+ // use ArrayBuffer directly
+ if(isArrayBuffer) {
+ this.data = new DataView(b);
+ } else {
+ // TODO: adjust read/write offset based on the type of view
+ // or specify that this must be done in the options ... that the
+ // offsets are byte-based
+ this.data = new DataView(b.buffer, b.byteOffset, b.byteLength);
+ }
+ this.write = ('writeOffset' in options ?
+ options.writeOffset : this.data.byteLength);
+ return;
+ }
+
+ // initialize to empty array buffer and add any given bytes using putBytes
+ this.data = new DataView(new ArrayBuffer(0));
+ this.write = 0;
+
+ if(b !== null && b !== undefined) {
+ this.putBytes(b);
+ }
+
+ if('writeOffset' in options) {
+ this.write = options.writeOffset;
+ }
+}
+util.DataBuffer = DataBuffer;
+
+/**
+ * Gets the number of bytes in this buffer.
+ *
+ * @return the number of bytes in this buffer.
+ */
+util.DataBuffer.prototype.length = function() {
+ return this.write - this.read;
+};
+
+/**
+ * Gets whether or not this buffer is empty.
+ *
+ * @return true if this buffer is empty, false if not.
+ */
+util.DataBuffer.prototype.isEmpty = function() {
+ return this.length() <= 0;
+};
+
+/**
+ * Ensures this buffer has enough empty space to accommodate the given number
+ * of bytes. An optional parameter may be given that indicates a minimum
+ * amount to grow the buffer if necessary. If the parameter is not given,
+ * the buffer will be grown by some previously-specified default amount
+ * or heuristic.
+ *
+ * @param amount the number of bytes to accommodate.
+ * @param [growSize] the minimum amount, in bytes, to grow the buffer by if
+ * necessary.
+ */
+util.DataBuffer.prototype.accommodate = function(amount, growSize) {
+ if(this.length() >= amount) {
+ return this;
+ }
+ growSize = Math.max(growSize || this.growSize, amount);
+
+ // grow buffer
+ var src = new Uint8Array(
+ this.data.buffer, this.data.byteOffset, this.data.byteLength);
+ var dst = new Uint8Array(this.length() + growSize);
+ dst.set(src);
+ this.data = new DataView(dst.buffer);
+
+ return this;
+};
+
+/**
+ * Puts a byte in this buffer.
+ *
+ * @param b the byte to put.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putByte = function(b) {
+ this.accommodate(1);
+ this.data.setUint8(this.write++, b);
+ return this;
+};
+
+/**
+ * Puts a byte in this buffer N times.
+ *
+ * @param b the byte to put.
+ * @param n the number of bytes of value b to put.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.fillWithByte = function(b, n) {
+ this.accommodate(n);
+ for(var i = 0; i < n; ++i) {
+ this.data.setUint8(b);
+ }
+ return this;
+};
+
+/**
+ * Puts bytes in this buffer. The bytes may be given as a string, an
+ * ArrayBuffer, a DataView, or a TypedArray.
+ *
+ * @param bytes the bytes to put.
+ * @param [encoding] the encoding for the first parameter ('binary', 'utf8',
+ * 'utf16', 'hex'), if it is a string (default: 'binary').
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putBytes = function(bytes, encoding) {
+ if(util.isArrayBufferView(bytes)) {
+ var src = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+ var len = src.byteLength - src.byteOffset;
+ this.accommodate(len);
+ var dst = new Uint8Array(this.data.buffer, this.write);
+ dst.set(src);
+ this.write += len;
+ return this;
+ }
+
+ if(util.isArrayBuffer(bytes)) {
+ var src = new Uint8Array(bytes);
+ this.accommodate(src.byteLength);
+ var dst = new Uint8Array(this.data.buffer);
+ dst.set(src, this.write);
+ this.write += src.byteLength;
+ return this;
+ }
+
+ // bytes is a util.DataBuffer or equivalent
+ if(bytes instanceof util.DataBuffer ||
+ (typeof bytes === 'object' &&
+ typeof bytes.read === 'number' && typeof bytes.write === 'number' &&
+ util.isArrayBufferView(bytes.data))) {
+ var src = new Uint8Array(bytes.data.byteLength, bytes.read, bytes.length());
+ this.accommodate(src.byteLength);
+ var dst = new Uint8Array(bytes.data.byteLength, this.write);
+ dst.set(src);
+ this.write += src.byteLength;
+ return this;
+ }
+
+ if(bytes instanceof util.ByteStringBuffer) {
+ // copy binary string and process as the same as a string parameter below
+ bytes = bytes.data;
+ encoding = 'binary';
+ }
+
+ // string conversion
+ encoding = encoding || 'binary';
+ if(typeof bytes === 'string') {
+ var view;
+
+ // decode from string
+ if(encoding === 'hex') {
+ this.accommodate(Math.ceil(bytes.length / 2));
+ view = new Uint8Array(this.data.buffer, this.write);
+ this.write += util.binary.hex.decode(bytes, view, this.write);
+ return this;
+ }
+ if(encoding === 'base64') {
+ this.accommodate(Math.ceil(bytes.length / 4) * 3);
+ view = new Uint8Array(this.data.buffer, this.write);
+ this.write += util.binary.base64.decode(bytes, view, this.write);
+ return this;
+ }
+
+ // encode text as UTF-8 bytes
+ if(encoding === 'utf8') {
+ // encode as UTF-8 then decode string as raw binary
+ bytes = util.encodeUtf8(bytes);
+ encoding = 'binary';
+ }
+
+ // decode string as raw binary
+ if(encoding === 'binary' || encoding === 'raw') {
+ // one byte per character
+ this.accommodate(bytes.length);
+ view = new Uint8Array(this.data.buffer, this.write);
+ this.write += util.binary.raw.decode(view);
+ return this;
+ }
+
+ // encode text as UTF-16 bytes
+ if(encoding === 'utf16') {
+ // two bytes per character
+ this.accommodate(bytes.length * 2);
+ view = new Uint16Array(this.data.buffer, this.write);
+ this.write += util.text.utf16.encode(view);
+ return this;
+ }
+
+ throw new Error('Invalid encoding: ' + encoding);
+ }
+
+ throw Error('Invalid parameter: ' + bytes);
+};
+
+/**
+ * Puts the given buffer into this buffer.
+ *
+ * @param buffer the buffer to put into this one.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putBuffer = function(buffer) {
+ this.putBytes(buffer);
+ buffer.clear();
+ return this;
+};
+
+/**
+ * Puts a string into this buffer.
+ *
+ * @param str the string to put.
+ * @param [encoding] the encoding for the string (default: 'utf16').
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putString = function(str) {
+ return this.putBytes(str, 'utf16');
+};
+
+/**
+ * Puts a 16-bit integer in this buffer in big-endian order.
+ *
+ * @param i the 16-bit integer.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putInt16 = function(i) {
+ this.accommodate(2);
+ this.data.setInt16(this.write, i);
+ this.write += 2;
+ return this;
+};
+
+/**
+ * Puts a 24-bit integer in this buffer in big-endian order.
+ *
+ * @param i the 24-bit integer.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putInt24 = function(i) {
+ this.accommodate(3);
+ this.data.setInt16(this.write, i >> 8 & 0xFFFF);
+ this.data.setInt8(this.write, i >> 16 & 0xFF);
+ this.write += 3;
+ return this;
+};
+
+/**
+ * Puts a 32-bit integer in this buffer in big-endian order.
+ *
+ * @param i the 32-bit integer.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putInt32 = function(i) {
+ this.accommodate(4);
+ this.data.setInt32(this.write, i);
+ this.write += 4;
+ return this;
+};
+
+/**
+ * Puts a 16-bit integer in this buffer in little-endian order.
+ *
+ * @param i the 16-bit integer.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putInt16Le = function(i) {
+ this.accommodate(2);
+ this.data.setInt16(this.write, i, true);
+ this.write += 2;
+ return this;
+};
+
+/**
+ * Puts a 24-bit integer in this buffer in little-endian order.
+ *
+ * @param i the 24-bit integer.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putInt24Le = function(i) {
+ this.accommodate(3);
+ this.data.setInt8(this.write, i >> 16 & 0xFF);
+ this.data.setInt16(this.write, i >> 8 & 0xFFFF, true);
+ this.write += 3;
+ return this;
+};
+
+/**
+ * Puts a 32-bit integer in this buffer in little-endian order.
+ *
+ * @param i the 32-bit integer.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putInt32Le = function(i) {
+ this.accommodate(4);
+ this.data.setInt32(this.write, i, true);
+ this.write += 4;
+ return this;
+};
+
+/**
+ * Puts an n-bit integer in this buffer in big-endian order.
+ *
+ * @param i the n-bit integer.
+ * @param n the number of bits in the integer (8, 16, 24, or 32).
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putInt = function(i, n) {
+ _checkBitsParam(n);
+ this.accommodate(n / 8);
+ do {
+ n -= 8;
+ this.data.setInt8(this.write++, (i >> n) & 0xFF);
+ } while(n > 0);
+ return this;
+};
+
+/**
+ * Puts a signed n-bit integer in this buffer in big-endian order. Two's
+ * complement representation is used.
+ *
+ * @param i the n-bit integer.
+ * @param n the number of bits in the integer.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.putSignedInt = function(i, n) {
+ _checkBitsParam(n);
+ this.accommodate(n / 8);
+ if(i < 0) {
+ i += 2 << (n - 1);
+ }
+ return this.putInt(i, n);
+};
+
+/**
+ * Gets a byte from this buffer and advances the read pointer by 1.
+ *
+ * @return the byte.
+ */
+util.DataBuffer.prototype.getByte = function() {
+ return this.data.getInt8(this.read++);
+};
+
+/**
+ * Gets a uint16 from this buffer in big-endian order and advances the read
+ * pointer by 2.
+ *
+ * @return the uint16.
+ */
+util.DataBuffer.prototype.getInt16 = function() {
+ var rval = this.data.getInt16(this.read);
+ this.read += 2;
+ return rval;
+};
+
+/**
+ * Gets a uint24 from this buffer in big-endian order and advances the read
+ * pointer by 3.
+ *
+ * @return the uint24.
+ */
+util.DataBuffer.prototype.getInt24 = function() {
+ var rval = (
+ this.data.getInt16(this.read) << 8 ^
+ this.data.getInt8(this.read + 2));
+ this.read += 3;
+ return rval;
+};
+
+/**
+ * Gets a uint32 from this buffer in big-endian order and advances the read
+ * pointer by 4.
+ *
+ * @return the word.
+ */
+util.DataBuffer.prototype.getInt32 = function() {
+ var rval = this.data.getInt32(this.read);
+ this.read += 4;
+ return rval;
+};
+
+/**
+ * Gets a uint16 from this buffer in little-endian order and advances the read
+ * pointer by 2.
+ *
+ * @return the uint16.
+ */
+util.DataBuffer.prototype.getInt16Le = function() {
+ var rval = this.data.getInt16(this.read, true);
+ this.read += 2;
+ return rval;
+};
+
+/**
+ * Gets a uint24 from this buffer in little-endian order and advances the read
+ * pointer by 3.
+ *
+ * @return the uint24.
+ */
+util.DataBuffer.prototype.getInt24Le = function() {
+ var rval = (
+ this.data.getInt8(this.read) ^
+ this.data.getInt16(this.read + 1, true) << 8);
+ this.read += 3;
+ return rval;
+};
+
+/**
+ * Gets a uint32 from this buffer in little-endian order and advances the read
+ * pointer by 4.
+ *
+ * @return the word.
+ */
+util.DataBuffer.prototype.getInt32Le = function() {
+ var rval = this.data.getInt32(this.read, true);
+ this.read += 4;
+ return rval;
+};
+
+/**
+ * Gets an n-bit integer from this buffer in big-endian order and advances the
+ * read pointer by n/8.
+ *
+ * @param n the number of bits in the integer (8, 16, 24, or 32).
+ *
+ * @return the integer.
+ */
+util.DataBuffer.prototype.getInt = function(n) {
+ _checkBitsParam(n);
+ var rval = 0;
+ do {
+ // TODO: Use (rval * 0x100) if adding support for 33 to 53 bits.
+ rval = (rval << 8) + this.data.getInt8(this.read++);
+ n -= 8;
+ } while(n > 0);
+ return rval;
+};
+
+/**
+ * Gets a signed n-bit integer from this buffer in big-endian order, using
+ * two's complement, and advances the read pointer by n/8.
+ *
+ * @param n the number of bits in the integer (8, 16, 24, or 32).
+ *
+ * @return the integer.
+ */
+util.DataBuffer.prototype.getSignedInt = function(n) {
+ // getInt checks n
+ var x = this.getInt(n);
+ var max = 2 << (n - 2);
+ if(x >= max) {
+ x -= max << 1;
+ }
+ return x;
+};
+
+/**
+ * Reads bytes out as a binary encoded string and clears them from the
+ * buffer.
+ *
+ * @param count the number of bytes to read, undefined or null for all.
+ *
+ * @return a binary encoded string of bytes.
+ */
+util.DataBuffer.prototype.getBytes = function(count) {
+ // TODO: deprecate this method, it is poorly named and
+ // this.toString('binary') replaces it
+ // add a toTypedArray()/toArrayBuffer() function
+ var rval;
+ if(count) {
+ // read count bytes
+ count = Math.min(this.length(), count);
+ rval = this.data.slice(this.read, this.read + count);
+ this.read += count;
+ } else if(count === 0) {
+ rval = '';
+ } else {
+ // read all bytes, optimize to only copy when needed
+ rval = (this.read === 0) ? this.data : this.data.slice(this.read);
+ this.clear();
+ }
+ return rval;
+};
+
+/**
+ * Gets a binary encoded string of the bytes from this buffer without
+ * modifying the read pointer.
+ *
+ * @param count the number of bytes to get, omit to get all.
+ *
+ * @return a string full of binary encoded characters.
+ */
+util.DataBuffer.prototype.bytes = function(count) {
+ // TODO: deprecate this method, it is poorly named, add "getString()"
+ return (typeof(count) === 'undefined' ?
+ this.data.slice(this.read) :
+ this.data.slice(this.read, this.read + count));
+};
+
+/**
+ * Gets a byte at the given index without modifying the read pointer.
+ *
+ * @param i the byte index.
+ *
+ * @return the byte.
+ */
+util.DataBuffer.prototype.at = function(i) {
+ return this.data.getUint8(this.read + i);
+};
+
+/**
+ * Puts a byte at the given index without modifying the read pointer.
+ *
+ * @param i the byte index.
+ * @param b the byte to put.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.setAt = function(i, b) {
+ this.data.setUint8(i, b);
+ return this;
+};
+
+/**
+ * Gets the last byte without modifying the read pointer.
+ *
+ * @return the last byte.
+ */
+util.DataBuffer.prototype.last = function() {
+ return this.data.getUint8(this.write - 1);
+};
+
+/**
+ * Creates a copy of this buffer.
+ *
+ * @return the copy.
+ */
+util.DataBuffer.prototype.copy = function() {
+ return new util.DataBuffer(this);
+};
+
+/**
+ * Compacts this buffer.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.compact = function() {
+ if(this.read > 0) {
+ var src = new Uint8Array(this.data.buffer, this.read);
+ var dst = new Uint8Array(src.byteLength);
+ dst.set(src);
+ this.data = new DataView(dst);
+ this.write -= this.read;
+ this.read = 0;
+ }
+ return this;
+};
+
+/**
+ * Clears this buffer.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.clear = function() {
+ this.data = new DataView(new ArrayBuffer(0));
+ this.read = this.write = 0;
+ return this;
+};
+
+/**
+ * Shortens this buffer by triming bytes off of the end of this buffer.
+ *
+ * @param count the number of bytes to trim off.
+ *
+ * @return this buffer.
+ */
+util.DataBuffer.prototype.truncate = function(count) {
+ this.write = Math.max(0, this.length() - count);
+ this.read = Math.min(this.read, this.write);
+ return this;
+};
+
+/**
+ * Converts this buffer to a hexadecimal string.
+ *
+ * @return a hexadecimal string.
+ */
+util.DataBuffer.prototype.toHex = function() {
+ var rval = '';
+ for(var i = this.read; i < this.data.byteLength; ++i) {
+ var b = this.data.getUint8(i);
+ if(b < 16) {
+ rval += '0';
+ }
+ rval += b.toString(16);
+ }
+ return rval;
+};
+
+/**
+ * Converts this buffer to a string, using the given encoding. If no
+ * encoding is given, 'utf8' (UTF-8) is used.
+ *
+ * @param [encoding] the encoding to use: 'binary', 'utf8', 'utf16', 'hex',
+ * 'base64' (default: 'utf8').
+ *
+ * @return a string representation of the bytes in this buffer.
+ */
+util.DataBuffer.prototype.toString = function(encoding) {
+ var view = new Uint8Array(this.data, this.read, this.length());
+ encoding = encoding || 'utf8';
+
+ // encode to string
+ if(encoding === 'binary' || encoding === 'raw') {
+ return util.binary.raw.encode(view);
+ }
+ if(encoding === 'hex') {
+ return util.binary.hex.encode(view);
+ }
+ if(encoding === 'base64') {
+ return util.binary.base64.encode(view);
+ }
+
+ // decode to text
+ if(encoding === 'utf8') {
+ return util.text.utf8.decode(view);
+ }
+ if(encoding === 'utf16') {
+ return util.text.utf16.decode(view);
+ }
+
+ throw new Error('Invalid encoding: ' + encoding);
+};
+
+/** End Buffer w/UInt8Array backing */
+
+/**
+ * Creates a buffer that stores bytes. A value may be given to populate the
+ * buffer with data. This value can either be string of encoded bytes or a
+ * regular string of characters. When passing a string of binary encoded
+ * bytes, the encoding `raw` should be given. This is also the default. When
+ * passing a string of characters, the encoding `utf8` should be given.
+ *
+ * @param [input] a string with encoded bytes to store in the buffer.
+ * @param [encoding] (default: 'raw', other: 'utf8').
+ */
+util.createBuffer = function(input, encoding) {
+ // TODO: deprecate, use new ByteBuffer() instead
+ encoding = encoding || 'raw';
+ if(input !== undefined && encoding === 'utf8') {
+ input = util.encodeUtf8(input);
+ }
+ return new util.ByteBuffer(input);
+};
+
+/**
+ * Fills a string with a particular value. If you want the string to be a byte
+ * string, pass in String.fromCharCode(theByte).
+ *
+ * @param c the character to fill the string with, use String.fromCharCode
+ * to fill the string with a byte value.
+ * @param n the number of characters of value c to fill with.
+ *
+ * @return the filled string.
+ */
+util.fillString = function(c, n) {
+ var s = '';
+ while(n > 0) {
+ if(n & 1) {
+ s += c;
+ }
+ n >>>= 1;
+ if(n > 0) {
+ c += c;
+ }
+ }
+ return s;
+};
+
+/**
+ * Performs a per byte XOR between two byte strings and returns the result as a
+ * string of bytes.
+ *
+ * @param s1 first string of bytes.
+ * @param s2 second string of bytes.
+ * @param n the number of bytes to XOR.
+ *
+ * @return the XOR'd result.
+ */
+util.xorBytes = function(s1, s2, n) {
+ var s3 = '';
+ var b = '';
+ var t = '';
+ var i = 0;
+ var c = 0;
+ for(; n > 0; --n, ++i) {
+ b = s1.charCodeAt(i) ^ s2.charCodeAt(i);
+ if(c >= 10) {
+ s3 += t;
+ t = '';
+ c = 0;
+ }
+ t += String.fromCharCode(b);
+ ++c;
+ }
+ s3 += t;
+ return s3;
+};
+
+/**
+ * Converts a hex string into a 'binary' encoded string of bytes.
+ *
+ * @param hex the hexadecimal string to convert.
+ *
+ * @return the binary-encoded string of bytes.
+ */
+util.hexToBytes = function(hex) {
+ // TODO: deprecate: "Deprecated. Use util.binary.hex.decode instead."
+ var rval = '';
+ var i = 0;
+ if(hex.length & 1 == 1) {
+ // odd number of characters, convert first character alone
+ i = 1;
+ rval += String.fromCharCode(parseInt(hex[0], 16));
+ }
+ // convert 2 characters (1 byte) at a time
+ for(; i < hex.length; i += 2) {
+ rval += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+ }
+ return rval;
+};
+
+/**
+ * Converts a 'binary' encoded string of bytes to hex.
+ *
+ * @param bytes the byte string to convert.
+ *
+ * @return the string of hexadecimal characters.
+ */
+util.bytesToHex = function(bytes) {
+ // TODO: deprecate: "Deprecated. Use util.binary.hex.encode instead."
+ return util.createBuffer(bytes).toHex();
+};
+
+/**
+ * Converts an 32-bit integer to 4-big-endian byte string.
+ *
+ * @param i the integer.
+ *
+ * @return the byte string.
+ */
+util.int32ToBytes = function(i) {
+ return (
+ String.fromCharCode(i >> 24 & 0xFF) +
+ String.fromCharCode(i >> 16 & 0xFF) +
+ String.fromCharCode(i >> 8 & 0xFF) +
+ String.fromCharCode(i & 0xFF));
+};
+
+// base64 characters, reverse mapping
+var _base64 =
+ 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+var _base64Idx = [
+/*43 -43 = 0*/
+/*'+', 1, 2, 3,'/' */
+ 62, -1, -1, -1, 63,
+
+/*'0','1','2','3','4','5','6','7','8','9' */
+ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+
+/*15, 16, 17,'=', 19, 20, 21 */
+ -1, -1, -1, 64, -1, -1, -1,
+
+/*65 - 43 = 22*/
+/*'A','B','C','D','E','F','G','H','I','J','K','L','M', */
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+
+/*'N','O','P','Q','R','S','T','U','V','W','X','Y','Z' */
+ 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
+
+/*91 - 43 = 48 */
+/*48, 49, 50, 51, 52, 53 */
+ -1, -1, -1, -1, -1, -1,
+
+/*97 - 43 = 54*/
+/*'a','b','c','d','e','f','g','h','i','j','k','l','m' */
+ 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
+
+/*'n','o','p','q','r','s','t','u','v','w','x','y','z' */
+ 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
+];
+
+// base58 characters (Bitcoin alphabet)
+var _base58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+/**
+ * Base64 encodes a 'binary' encoded string of bytes.
+ *
+ * @param input the binary encoded string of bytes to base64-encode.
+ * @param maxline the maximum number of encoded characters per line to use,
+ * defaults to none.
+ *
+ * @return the base64-encoded output.
+ */
+util.encode64 = function(input, maxline) {
+ // TODO: deprecate: "Deprecated. Use util.binary.base64.encode instead."
+ var line = '';
+ var output = '';
+ var chr1, chr2, chr3;
+ var i = 0;
+ while(i < input.length) {
+ chr1 = input.charCodeAt(i++);
+ chr2 = input.charCodeAt(i++);
+ chr3 = input.charCodeAt(i++);
+
+ // encode 4 character group
+ line += _base64.charAt(chr1 >> 2);
+ line += _base64.charAt(((chr1 & 3) << 4) | (chr2 >> 4));
+ if(isNaN(chr2)) {
+ line += '==';
+ } else {
+ line += _base64.charAt(((chr2 & 15) << 2) | (chr3 >> 6));
+ line += isNaN(chr3) ? '=' : _base64.charAt(chr3 & 63);
+ }
+
+ if(maxline && line.length > maxline) {
+ output += line.substr(0, maxline) + '\r\n';
+ line = line.substr(maxline);
+ }
+ }
+ output += line;
+ return output;
+};
+
+/**
+ * Base64 decodes a string into a 'binary' encoded string of bytes.
+ *
+ * @param input the base64-encoded input.
+ *
+ * @return the binary encoded string.
+ */
+util.decode64 = function(input) {
+ // TODO: deprecate: "Deprecated. Use util.binary.base64.decode instead."
+
+ // remove all non-base64 characters
+ input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
+
+ var output = '';
+ var enc1, enc2, enc3, enc4;
+ var i = 0;
+
+ while(i < input.length) {
+ enc1 = _base64Idx[input.charCodeAt(i++) - 43];
+ enc2 = _base64Idx[input.charCodeAt(i++) - 43];
+ enc3 = _base64Idx[input.charCodeAt(i++) - 43];
+ enc4 = _base64Idx[input.charCodeAt(i++) - 43];
+
+ output += String.fromCharCode((enc1 << 2) | (enc2 >> 4));
+ if(enc3 !== 64) {
+ // decoded at least 2 bytes
+ output += String.fromCharCode(((enc2 & 15) << 4) | (enc3 >> 2));
+ if(enc4 !== 64) {
+ // decoded 3 bytes
+ output += String.fromCharCode(((enc3 & 3) << 6) | enc4);
+ }
+ }
+ }
+
+ return output;
+};
+
+/**
+ * Encodes the given string of characters (a standard JavaScript
+ * string) as a binary encoded string where the bytes represent
+ * a UTF-8 encoded string of characters. Non-ASCII characters will be
+ * encoded as multiple bytes according to UTF-8.
+ *
+ * @param str a standard string of characters to encode.
+ *
+ * @return the binary encoded string.
+ */
+util.encodeUtf8 = function(str) {
+ return unescape(encodeURIComponent(str));
+};
+
+/**
+ * Decodes a binary encoded string that contains bytes that
+ * represent a UTF-8 encoded string of characters -- into a
+ * string of characters (a standard JavaScript string).
+ *
+ * @param str the binary encoded string to decode.
+ *
+ * @return the resulting standard string of characters.
+ */
+util.decodeUtf8 = function(str) {
+ return decodeURIComponent(escape(str));
+};
+
+// binary encoding/decoding tools
+// FIXME: Experimental. Do not use yet.
+util.binary = {
+ raw: {},
+ hex: {},
+ base64: {},
+ base58: {},
+ baseN : {
+ encode: baseN.encode,
+ decode: baseN.decode
+ }
+};
+
+/**
+ * Encodes a Uint8Array as a binary-encoded string. This encoding uses
+ * a value between 0 and 255 for each character.
+ *
+ * @param bytes the Uint8Array to encode.
+ *
+ * @return the binary-encoded string.
+ */
+util.binary.raw.encode = function(bytes) {
+ return String.fromCharCode.apply(null, bytes);
+};
+
+/**
+ * Decodes a binary-encoded string to a Uint8Array. This encoding uses
+ * a value between 0 and 255 for each character.
+ *
+ * @param str the binary-encoded string to decode.
+ * @param [output] an optional Uint8Array to write the output to; if it
+ * is too small, an exception will be thrown.
+ * @param [offset] the start offset for writing to the output (default: 0).
+ *
+ * @return the Uint8Array or the number of bytes written if output was given.
+ */
+util.binary.raw.decode = function(str, output, offset) {
+ var out = output;
+ if(!out) {
+ out = new Uint8Array(str.length);
+ }
+ offset = offset || 0;
+ var j = offset;
+ for(var i = 0; i < str.length; ++i) {
+ out[j++] = str.charCodeAt(i);
+ }
+ return output ? (j - offset) : out;
+};
+
+/**
+ * Encodes a 'binary' string, ArrayBuffer, DataView, TypedArray, or
+ * ByteBuffer as a string of hexadecimal characters.
+ *
+ * @param bytes the bytes to convert.
+ *
+ * @return the string of hexadecimal characters.
+ */
+util.binary.hex.encode = util.bytesToHex;
+
+/**
+ * Decodes a hex-encoded string to a Uint8Array.
+ *
+ * @param hex the hexadecimal string to convert.
+ * @param [output] an optional Uint8Array to write the output to; if it
+ * is too small, an exception will be thrown.
+ * @param [offset] the start offset for writing to the output (default: 0).
+ *
+ * @return the Uint8Array or the number of bytes written if output was given.
+ */
+util.binary.hex.decode = function(hex, output, offset) {
+ var out = output;
+ if(!out) {
+ out = new Uint8Array(Math.ceil(hex.length / 2));
+ }
+ offset = offset || 0;
+ var i = 0, j = offset;
+ if(hex.length & 1) {
+ // odd number of characters, convert first character alone
+ i = 1;
+ out[j++] = parseInt(hex[0], 16);
+ }
+ // convert 2 characters (1 byte) at a time
+ for(; i < hex.length; i += 2) {
+ out[j++] = parseInt(hex.substr(i, 2), 16);
+ }
+ return output ? (j - offset) : out;
+};
+
+/**
+ * Base64-encodes a Uint8Array.
+ *
+ * @param input the Uint8Array to encode.
+ * @param maxline the maximum number of encoded characters per line to use,
+ * defaults to none.
+ *
+ * @return the base64-encoded output string.
+ */
+util.binary.base64.encode = function(input, maxline) {
+ var line = '';
+ var output = '';
+ var chr1, chr2, chr3;
+ var i = 0;
+ while(i < input.byteLength) {
+ chr1 = input[i++];
+ chr2 = input[i++];
+ chr3 = input[i++];
+
+ // encode 4 character group
+ line += _base64.charAt(chr1 >> 2);
+ line += _base64.charAt(((chr1 & 3) << 4) | (chr2 >> 4));
+ if(isNaN(chr2)) {
+ line += '==';
+ } else {
+ line += _base64.charAt(((chr2 & 15) << 2) | (chr3 >> 6));
+ line += isNaN(chr3) ? '=' : _base64.charAt(chr3 & 63);
+ }
+
+ if(maxline && line.length > maxline) {
+ output += line.substr(0, maxline) + '\r\n';
+ line = line.substr(maxline);
+ }
+ }
+ output += line;
+ return output;
+};
+
+/**
+ * Decodes a base64-encoded string to a Uint8Array.
+ *
+ * @param input the base64-encoded input string.
+ * @param [output] an optional Uint8Array to write the output to; if it
+ * is too small, an exception will be thrown.
+ * @param [offset] the start offset for writing to the output (default: 0).
+ *
+ * @return the Uint8Array or the number of bytes written if output was given.
+ */
+util.binary.base64.decode = function(input, output, offset) {
+ var out = output;
+ if(!out) {
+ out = new Uint8Array(Math.ceil(input.length / 4) * 3);
+ }
+
+ // remove all non-base64 characters
+ input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
+
+ offset = offset || 0;
+ var enc1, enc2, enc3, enc4;
+ var i = 0, j = offset;
+
+ while(i < input.length) {
+ enc1 = _base64Idx[input.charCodeAt(i++) - 43];
+ enc2 = _base64Idx[input.charCodeAt(i++) - 43];
+ enc3 = _base64Idx[input.charCodeAt(i++) - 43];
+ enc4 = _base64Idx[input.charCodeAt(i++) - 43];
+
+ out[j++] = (enc1 << 2) | (enc2 >> 4);
+ if(enc3 !== 64) {
+ // decoded at least 2 bytes
+ out[j++] = ((enc2 & 15) << 4) | (enc3 >> 2);
+ if(enc4 !== 64) {
+ // decoded 3 bytes
+ out[j++] = ((enc3 & 3) << 6) | enc4;
+ }
+ }
+ }
+
+ // make sure result is the exact decoded length
+ return output ? (j - offset) : out.subarray(0, j);
+};
+
+// add support for base58 encoding/decoding with Bitcoin alphabet
+util.binary.base58.encode = function(input, maxline) {
+ return util.binary.baseN.encode(input, _base58, maxline);
+};
+util.binary.base58.decode = function(input, maxline) {
+ return util.binary.baseN.decode(input, _base58, maxline);
+};
+
+// text encoding/decoding tools
+// FIXME: Experimental. Do not use yet.
+util.text = {
+ utf8: {},
+ utf16: {}
+};
+
+/**
+ * Encodes the given string as UTF-8 in a Uint8Array.
+ *
+ * @param str the string to encode.
+ * @param [output] an optional Uint8Array to write the output to; if it
+ * is too small, an exception will be thrown.
+ * @param [offset] the start offset for writing to the output (default: 0).
+ *
+ * @return the Uint8Array or the number of bytes written if output was given.
+ */
+util.text.utf8.encode = function(str, output, offset) {
+ str = util.encodeUtf8(str);
+ var out = output;
+ if(!out) {
+ out = new Uint8Array(str.length);
+ }
+ offset = offset || 0;
+ var j = offset;
+ for(var i = 0; i < str.length; ++i) {
+ out[j++] = str.charCodeAt(i);
+ }
+ return output ? (j - offset) : out;
+};
+
+/**
+ * Decodes the UTF-8 contents from a Uint8Array.
+ *
+ * @param bytes the Uint8Array to decode.
+ *
+ * @return the resulting string.
+ */
+util.text.utf8.decode = function(bytes) {
+ return util.decodeUtf8(String.fromCharCode.apply(null, bytes));
+};
+
+/**
+ * Encodes the given string as UTF-16 in a Uint8Array.
+ *
+ * @param str the string to encode.
+ * @param [output] an optional Uint8Array to write the output to; if it
+ * is too small, an exception will be thrown.
+ * @param [offset] the start offset for writing to the output (default: 0).
+ *
+ * @return the Uint8Array or the number of bytes written if output was given.
+ */
+util.text.utf16.encode = function(str, output, offset) {
+ var out = output;
+ if(!out) {
+ out = new Uint8Array(str.length * 2);
+ }
+ var view = new Uint16Array(out.buffer);
+ offset = offset || 0;
+ var j = offset;
+ var k = offset;
+ for(var i = 0; i < str.length; ++i) {
+ view[k++] = str.charCodeAt(i);
+ j += 2;
+ }
+ return output ? (j - offset) : out;
+};
+
+/**
+ * Decodes the UTF-16 contents from a Uint8Array.
+ *
+ * @param bytes the Uint8Array to decode.
+ *
+ * @return the resulting string.
+ */
+util.text.utf16.decode = function(bytes) {
+ return String.fromCharCode.apply(null, new Uint16Array(bytes.buffer));
+};
+
+/**
+ * Deflates the given data using a flash interface.
+ *
+ * @param api the flash interface.
+ * @param bytes the data.
+ * @param raw true to return only raw deflate data, false to include zlib
+ * header and trailer.
+ *
+ * @return the deflated data as a string.
+ */
+util.deflate = function(api, bytes, raw) {
+ bytes = util.decode64(api.deflate(util.encode64(bytes)).rval);
+
+ // strip zlib header and trailer if necessary
+ if(raw) {
+ // zlib header is 2 bytes (CMF,FLG) where FLG indicates that
+ // there is a 4-byte DICT (alder-32) block before the data if
+ // its 5th bit is set
+ var start = 2;
+ var flg = bytes.charCodeAt(1);
+ if(flg & 0x20) {
+ start = 6;
+ }
+ // zlib trailer is 4 bytes of adler-32
+ bytes = bytes.substring(start, bytes.length - 4);
+ }
+
+ return bytes;
+};
+
+/**
+ * Inflates the given data using a flash interface.
+ *
+ * @param api the flash interface.
+ * @param bytes the data.
+ * @param raw true if the incoming data has no zlib header or trailer and is
+ * raw DEFLATE data.
+ *
+ * @return the inflated data as a string, null on error.
+ */
+util.inflate = function(api, bytes, raw) {
+ // TODO: add zlib header and trailer if necessary/possible
+ var rval = api.inflate(util.encode64(bytes)).rval;
+ return (rval === null) ? null : util.decode64(rval);
+};
+
+/**
+ * Sets a storage object.
+ *
+ * @param api the storage interface.
+ * @param id the storage ID to use.
+ * @param obj the storage object, null to remove.
+ */
+var _setStorageObject = function(api, id, obj) {
+ if(!api) {
+ throw new Error('WebStorage not available.');
+ }
+
+ var rval;
+ if(obj === null) {
+ rval = api.removeItem(id);
+ } else {
+ // json-encode and base64-encode object
+ obj = util.encode64(JSON.stringify(obj));
+ rval = api.setItem(id, obj);
+ }
+
+ // handle potential flash error
+ if(typeof(rval) !== 'undefined' && rval.rval !== true) {
+ var error = new Error(rval.error.message);
+ error.id = rval.error.id;
+ error.name = rval.error.name;
+ throw error;
+ }
+};
+
+/**
+ * Gets a storage object.
+ *
+ * @param api the storage interface.
+ * @param id the storage ID to use.
+ *
+ * @return the storage object entry or null if none exists.
+ */
+var _getStorageObject = function(api, id) {
+ if(!api) {
+ throw new Error('WebStorage not available.');
+ }
+
+ // get the existing entry
+ var rval = api.getItem(id);
+
+ /* Note: We check api.init because we can't do (api == localStorage)
+ on IE because of "Class doesn't support Automation" exception. Only
+ the flash api has an init method so this works too, but we need a
+ better solution in the future. */
+
+ // flash returns item wrapped in an object, handle special case
+ if(api.init) {
+ if(rval.rval === null) {
+ if(rval.error) {
+ var error = new Error(rval.error.message);
+ error.id = rval.error.id;
+ error.name = rval.error.name;
+ throw error;
+ }
+ // no error, but also no item
+ rval = null;
+ } else {
+ rval = rval.rval;
+ }
+ }
+
+ // handle decoding
+ if(rval !== null) {
+ // base64-decode and json-decode data
+ rval = JSON.parse(util.decode64(rval));
+ }
+
+ return rval;
+};
+
+/**
+ * Stores an item in local storage.
+ *
+ * @param api the storage interface.
+ * @param id the storage ID to use.
+ * @param key the key for the item.
+ * @param data the data for the item (any javascript object/primitive).
+ */
+var _setItem = function(api, id, key, data) {
+ // get storage object
+ var obj = _getStorageObject(api, id);
+ if(obj === null) {
+ // create a new storage object
+ obj = {};
+ }
+ // update key
+ obj[key] = data;
+
+ // set storage object
+ _setStorageObject(api, id, obj);
+};
+
+/**
+ * Gets an item from local storage.
+ *
+ * @param api the storage interface.
+ * @param id the storage ID to use.
+ * @param key the key for the item.
+ *
+ * @return the item.
+ */
+var _getItem = function(api, id, key) {
+ // get storage object
+ var rval = _getStorageObject(api, id);
+ if(rval !== null) {
+ // return data at key
+ rval = (key in rval) ? rval[key] : null;
+ }
+
+ return rval;
+};
+
+/**
+ * Removes an item from local storage.
+ *
+ * @param api the storage interface.
+ * @param id the storage ID to use.
+ * @param key the key for the item.
+ */
+var _removeItem = function(api, id, key) {
+ // get storage object
+ var obj = _getStorageObject(api, id);
+ if(obj !== null && key in obj) {
+ // remove key
+ delete obj[key];
+
+ // see if entry has no keys remaining
+ var empty = true;
+ for(var prop in obj) {
+ empty = false;
+ break;
+ }
+ if(empty) {
+ // remove entry entirely if no keys are left
+ obj = null;
+ }
+
+ // set storage object
+ _setStorageObject(api, id, obj);
+ }
+};
+
+/**
+ * Clears the local disk storage identified by the given ID.
+ *
+ * @param api the storage interface.
+ * @param id the storage ID to use.
+ */
+var _clearItems = function(api, id) {
+ _setStorageObject(api, id, null);
+};
+
+/**
+ * Calls a storage function.
+ *
+ * @param func the function to call.
+ * @param args the arguments for the function.
+ * @param location the location argument.
+ *
+ * @return the return value from the function.
+ */
+var _callStorageFunction = function(func, args, location) {
+ var rval = null;
+
+ // default storage types
+ if(typeof(location) === 'undefined') {
+ location = ['web', 'flash'];
+ }
+
+ // apply storage types in order of preference
+ var type;
+ var done = false;
+ var exception = null;
+ for(var idx in location) {
+ type = location[idx];
+ try {
+ if(type === 'flash' || type === 'both') {
+ if(args[0] === null) {
+ throw new Error('Flash local storage not available.');
+ }
+ rval = func.apply(this, args);
+ done = (type === 'flash');
+ }
+ if(type === 'web' || type === 'both') {
+ args[0] = localStorage;
+ rval = func.apply(this, args);
+ done = true;
+ }
+ } catch(ex) {
+ exception = ex;
+ }
+ if(done) {
+ break;
+ }
+ }
+
+ if(!done) {
+ throw exception;
+ }
+
+ return rval;
+};
+
+/**
+ * Stores an item on local disk.
+ *
+ * The available types of local storage include 'flash', 'web', and 'both'.
+ *
+ * The type 'flash' refers to flash local storage (SharedObject). In order
+ * to use flash local storage, the 'api' parameter must be valid. The type
+ * 'web' refers to WebStorage, if supported by the browser. The type 'both'
+ * refers to storing using both 'flash' and 'web', not just one or the
+ * other.
+ *
+ * The location array should list the storage types to use in order of
+ * preference:
+ *
+ * ['flash']: flash only storage
+ * ['web']: web only storage
+ * ['both']: try to store in both
+ * ['flash','web']: store in flash first, but if not available, 'web'
+ * ['web','flash']: store in web first, but if not available, 'flash'
+ *
+ * The location array defaults to: ['web', 'flash']
+ *
+ * @param api the flash interface, null to use only WebStorage.
+ * @param id the storage ID to use.
+ * @param key the key for the item.
+ * @param data the data for the item (any javascript object/primitive).
+ * @param location an array with the preferred types of storage to use.
+ */
+util.setItem = function(api, id, key, data, location) {
+ _callStorageFunction(_setItem, arguments, location);
+};
+
+/**
+ * Gets an item on local disk.
+ *
+ * Set setItem() for details on storage types.
+ *
+ * @param api the flash interface, null to use only WebStorage.
+ * @param id the storage ID to use.
+ * @param key the key for the item.
+ * @param location an array with the preferred types of storage to use.
+ *
+ * @return the item.
+ */
+util.getItem = function(api, id, key, location) {
+ return _callStorageFunction(_getItem, arguments, location);
+};
+
+/**
+ * Removes an item on local disk.
+ *
+ * Set setItem() for details on storage types.
+ *
+ * @param api the flash interface.
+ * @param id the storage ID to use.
+ * @param key the key for the item.
+ * @param location an array with the preferred types of storage to use.
+ */
+util.removeItem = function(api, id, key, location) {
+ _callStorageFunction(_removeItem, arguments, location);
+};
+
+/**
+ * Clears the local disk storage identified by the given ID.
+ *
+ * Set setItem() for details on storage types.
+ *
+ * @param api the flash interface if flash is available.
+ * @param id the storage ID to use.
+ * @param location an array with the preferred types of storage to use.
+ */
+util.clearItems = function(api, id, location) {
+ _callStorageFunction(_clearItems, arguments, location);
+};
+
+/**
+ * Check if an object is empty.
+ *
+ * Taken from:
+ * http://stackoverflow.com/questions/679915/how-do-i-test-for-an-empty-javascript-object-from-json/679937#679937
+ *
+ * @param object the object to check.
+ */
+util.isEmpty = function(obj) {
+ for(var prop in obj) {
+ if(obj.hasOwnProperty(prop)) {
+ return false;
+ }
+ }
+ return true;
+};
+
+/**
+ * Format with simple printf-style interpolation.
+ *
+ * %%: literal '%'
+ * %s,%o: convert next argument into a string.
+ *
+ * @param format the string to format.
+ * @param ... arguments to interpolate into the format string.
+ */
+util.format = function(format) {
+ var re = /%./g;
+ // current match
+ var match;
+ // current part
+ var part;
+ // current arg index
+ var argi = 0;
+ // collected parts to recombine later
+ var parts = [];
+ // last index found
+ var last = 0;
+ // loop while matches remain
+ while((match = re.exec(format))) {
+ part = format.substring(last, re.lastIndex - 2);
+ // don't add empty strings (ie, parts between %s%s)
+ if(part.length > 0) {
+ parts.push(part);
+ }
+ last = re.lastIndex;
+ // switch on % code
+ var code = match[0][1];
+ switch(code) {
+ case 's':
+ case 'o':
+ // check if enough arguments were given
+ if(argi < arguments.length) {
+ parts.push(arguments[argi++ + 1]);
+ } else {
+ parts.push('<?>');
+ }
+ break;
+ // FIXME: do proper formating for numbers, etc
+ //case 'f':
+ //case 'd':
+ case '%':
+ parts.push('%');
+ break;
+ default:
+ parts.push('<%' + code + '?>');
+ }
+ }
+ // add trailing part of format string
+ parts.push(format.substring(last));
+ return parts.join('');
+};
+
+/**
+ * Formats a number.
+ *
+ * http://snipplr.com/view/5945/javascript-numberformat--ported-from-php/
+ */
+util.formatNumber = function(number, decimals, dec_point, thousands_sep) {
+ // http://kevin.vanzonneveld.net
+ // + original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
+ // + improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+ // + bugfix by: Michael White (http://crestidg.com)
+ // + bugfix by: Benjamin Lupton
+ // + bugfix by: Allan Jensen (http://www.winternet.no)
+ // + revised by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
+ // * example 1: number_format(1234.5678, 2, '.', '');
+ // * returns 1: 1234.57
+
+ var n = number, c = isNaN(decimals = Math.abs(decimals)) ? 2 : decimals;
+ var d = dec_point === undefined ? ',' : dec_point;
+ var t = thousands_sep === undefined ?
+ '.' : thousands_sep, s = n < 0 ? '-' : '';
+ var i = parseInt((n = Math.abs(+n || 0).toFixed(c)), 10) + '';
+ var j = (i.length > 3) ? i.length % 3 : 0;
+ return s + (j ? i.substr(0, j) + t : '') +
+ i.substr(j).replace(/(\d{3})(?=\d)/g, '$1' + t) +
+ (c ? d + Math.abs(n - i).toFixed(c).slice(2) : '');
+};
+
+/**
+ * Formats a byte size.
+ *
+ * http://snipplr.com/view/5949/format-humanize-file-byte-size-presentation-in-javascript/
+ */
+util.formatSize = function(size) {
+ if(size >= 1073741824) {
+ size = util.formatNumber(size / 1073741824, 2, '.', '') + ' GiB';
+ } else if(size >= 1048576) {
+ size = util.formatNumber(size / 1048576, 2, '.', '') + ' MiB';
+ } else if(size >= 1024) {
+ size = util.formatNumber(size / 1024, 0) + ' KiB';
+ } else {
+ size = util.formatNumber(size, 0) + ' bytes';
+ }
+ return size;
+};
+
+/**
+ * Converts an IPv4 or IPv6 string representation into bytes (in network order).
+ *
+ * @param ip the IPv4 or IPv6 address to convert.
+ *
+ * @return the 4-byte IPv6 or 16-byte IPv6 address or null if the address can't
+ * be parsed.
+ */
+util.bytesFromIP = function(ip) {
+ if(ip.indexOf('.') !== -1) {
+ return util.bytesFromIPv4(ip);
+ }
+ if(ip.indexOf(':') !== -1) {
+ return util.bytesFromIPv6(ip);
+ }
+ return null;
+};
+
+/**
+ * Converts an IPv4 string representation into bytes (in network order).
+ *
+ * @param ip the IPv4 address to convert.
+ *
+ * @return the 4-byte address or null if the address can't be parsed.
+ */
+util.bytesFromIPv4 = function(ip) {
+ ip = ip.split('.');
+ if(ip.length !== 4) {
+ return null;
+ }
+ var b = util.createBuffer();
+ for(var i = 0; i < ip.length; ++i) {
+ var num = parseInt(ip[i], 10);
+ if(isNaN(num)) {
+ return null;
+ }
+ b.putByte(num);
+ }
+ return b.getBytes();
+};
+
+/**
+ * Converts an IPv6 string representation into bytes (in network order).
+ *
+ * @param ip the IPv6 address to convert.
+ *
+ * @return the 16-byte address or null if the address can't be parsed.
+ */
+util.bytesFromIPv6 = function(ip) {
+ var blanks = 0;
+ ip = ip.split(':').filter(function(e) {
+ if(e.length === 0) ++blanks;
+ return true;
+ });
+ var zeros = (8 - ip.length + blanks) * 2;
+ var b = util.createBuffer();
+ for(var i = 0; i < 8; ++i) {
+ if(!ip[i] || ip[i].length === 0) {
+ b.fillWithByte(0, zeros);
+ zeros = 0;
+ continue;
+ }
+ var bytes = util.hexToBytes(ip[i]);
+ if(bytes.length < 2) {
+ b.putByte(0);
+ }
+ b.putBytes(bytes);
+ }
+ return b.getBytes();
+};
+
+/**
+ * Converts 4-bytes into an IPv4 string representation or 16-bytes into
+ * an IPv6 string representation. The bytes must be in network order.
+ *
+ * @param bytes the bytes to convert.
+ *
+ * @return the IPv4 or IPv6 string representation if 4 or 16 bytes,
+ * respectively, are given, otherwise null.
+ */
+util.bytesToIP = function(bytes) {
+ if(bytes.length === 4) {
+ return util.bytesToIPv4(bytes);
+ }
+ if(bytes.length === 16) {
+ return util.bytesToIPv6(bytes);
+ }
+ return null;
+};
+
+/**
+ * Converts 4-bytes into an IPv4 string representation. The bytes must be
+ * in network order.
+ *
+ * @param bytes the bytes to convert.
+ *
+ * @return the IPv4 string representation or null for an invalid # of bytes.
+ */
+util.bytesToIPv4 = function(bytes) {
+ if(bytes.length !== 4) {
+ return null;
+ }
+ var ip = [];
+ for(var i = 0; i < bytes.length; ++i) {
+ ip.push(bytes.charCodeAt(i));
+ }
+ return ip.join('.');
+};
+
+/**
+ * Converts 16-bytes into an IPv16 string representation. The bytes must be
+ * in network order.
+ *
+ * @param bytes the bytes to convert.
+ *
+ * @return the IPv16 string representation or null for an invalid # of bytes.
+ */
+util.bytesToIPv6 = function(bytes) {
+ if(bytes.length !== 16) {
+ return null;
+ }
+ var ip = [];
+ var zeroGroups = [];
+ var zeroMaxGroup = 0;
+ for(var i = 0; i < bytes.length; i += 2) {
+ var hex = util.bytesToHex(bytes[i] + bytes[i + 1]);
+ // canonicalize zero representation
+ while(hex[0] === '0' && hex !== '0') {
+ hex = hex.substr(1);
+ }
+ if(hex === '0') {
+ var last = zeroGroups[zeroGroups.length - 1];
+ var idx = ip.length;
+ if(!last || idx !== last.end + 1) {
+ zeroGroups.push({start: idx, end: idx});
+ } else {
+ last.end = idx;
+ if((last.end - last.start) >
+ (zeroGroups[zeroMaxGroup].end - zeroGroups[zeroMaxGroup].start)) {
+ zeroMaxGroup = zeroGroups.length - 1;
+ }
+ }
+ }
+ ip.push(hex);
+ }
+ if(zeroGroups.length > 0) {
+ var group = zeroGroups[zeroMaxGroup];
+ // only shorten group of length > 0
+ if(group.end - group.start > 0) {
+ ip.splice(group.start, group.end - group.start + 1, '');
+ if(group.start === 0) {
+ ip.unshift('');
+ }
+ if(group.end === 7) {
+ ip.push('');
+ }
+ }
+ }
+ return ip.join(':');
+};
+
+/**
+ * Estimates the number of processes that can be run concurrently. If
+ * creating Web Workers, keep in mind that the main JavaScript process needs
+ * its own core.
+ *
+ * @param options the options to use:
+ * update true to force an update (not use the cached value).
+ * @param callback(err, max) called once the operation completes.
+ */
+util.estimateCores = function(options, callback) {
+ if(typeof options === 'function') {
+ callback = options;
+ options = {};
+ }
+ options = options || {};
+ if('cores' in util && !options.update) {
+ return callback(null, util.cores);
+ }
+ if(typeof navigator !== 'undefined' &&
+ 'hardwareConcurrency' in navigator &&
+ navigator.hardwareConcurrency > 0) {
+ util.cores = navigator.hardwareConcurrency;
+ return callback(null, util.cores);
+ }
+ if(typeof Worker === 'undefined') {
+ // workers not available
+ util.cores = 1;
+ return callback(null, util.cores);
+ }
+ if(typeof Blob === 'undefined') {
+ // can't estimate, default to 2
+ util.cores = 2;
+ return callback(null, util.cores);
+ }
+
+ // create worker concurrency estimation code as blob
+ var blobUrl = URL.createObjectURL(new Blob(['(',
+ function() {
+ self.addEventListener('message', function(e) {
+ // run worker for 4 ms
+ var st = Date.now();
+ var et = st + 4;
+ while(Date.now() < et);
+ self.postMessage({st: st, et: et});
+ });
+ }.toString(),
+ ')()'], {type: 'application/javascript'}));
+
+ // take 5 samples using 16 workers
+ sample([], 5, 16);
+
+ function sample(max, samples, numWorkers) {
+ if(samples === 0) {
+ // get overlap average
+ var avg = Math.floor(max.reduce(function(avg, x) {
+ return avg + x;
+ }, 0) / max.length);
+ util.cores = Math.max(1, avg);
+ URL.revokeObjectURL(blobUrl);
+ return callback(null, util.cores);
+ }
+ map(numWorkers, function(err, results) {
+ max.push(reduce(numWorkers, results));
+ sample(max, samples - 1, numWorkers);
+ });
+ }
+
+ function map(numWorkers, callback) {
+ var workers = [];
+ var results = [];
+ for(var i = 0; i < numWorkers; ++i) {
+ var worker = new Worker(blobUrl);
+ worker.addEventListener('message', function(e) {
+ results.push(e.data);
+ if(results.length === numWorkers) {
+ for(var i = 0; i < numWorkers; ++i) {
+ workers[i].terminate();
+ }
+ callback(null, results);
+ }
+ });
+ workers.push(worker);
+ }
+ for(var i = 0; i < numWorkers; ++i) {
+ workers[i].postMessage(i);
+ }
+ }
+
+ function reduce(numWorkers, results) {
+ // find overlapping time windows
+ var overlaps = [];
+ for(var n = 0; n < numWorkers; ++n) {
+ var r1 = results[n];
+ var overlap = overlaps[n] = [];
+ for(var i = 0; i < numWorkers; ++i) {
+ if(n === i) {
+ continue;
+ }
+ var r2 = results[i];
+ if((r1.st > r2.st && r1.st < r2.et) ||
+ (r2.st > r1.st && r2.st < r1.et)) {
+ overlap.push(i);
+ }
+ }
+ }
+ // get maximum overlaps ... don't include overlapping worker itself
+ // as the main JS process was also being scheduled during the work and
+ // would have to be subtracted from the estimate anyway
+ return overlaps.reduce(function(max, overlap) {
+ return Math.max(max, overlap.length);
+ }, 0);
+ }
+};
generated by cgit v1.2.3 (git 2.39.1) at 2025-10-27 04:27:31 +0000