pixel-react 1.15.21 → 1.15.23

package/lib/node_modules/node-forge/lib/util.js

@@ -0,0 +1,2565 @@
+import { commonjsGlobal } from '../../../_virtual/_commonjsHelpers.js';
+import { __module as util } from '../../../_virtual/util.js';
+import { __require as requireForge } from './forge.js';
+import { __require as requireBaseN } from './baseN.js';
+
+/**
+ * Utility functions for web applications.
+ *
+ * @author Dave Longley
+ *
+ * Copyright (c) 2010-2018 Digital Bazaar, Inc.
+ */
+var hasRequiredUtil;
+function requireUtil() {
+  if (hasRequiredUtil) return util.exports;
+  hasRequiredUtil = 1;
+  var forge = requireForge();
+  var baseN = requireBaseN();
+
+  /* Utilities API */
+  var util$1 = util.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$1.nextTick = process.nextTick;
+      if (typeof setImmediate === 'function') {
+        util$1.setImmediate = setImmediate;
+      } else {
+        // polyfill setImmediate with nextTick, older versions of node
+        // (those w/o setImmediate) won't totally starve IO
+        util$1.setImmediate = util$1.nextTick;
+      }
+      return;
+    }
+
+    // polyfill nextTick with native setImmediate
+    if (typeof setImmediate === 'function') {
+      util$1.setImmediate = function () {
+        return setImmediate.apply(undefined, arguments);
+      };
+      util$1.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$1.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$1.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$1.setImmediate;
+      util$1.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$1.nextTick = util$1.setImmediate;
+  })();
+
+  // check if running under Node.js
+  util$1.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$1.globalScope = function () {
+    if (util$1.isNodejs) {
+      return commonjsGlobal;
+    }
+    return typeof self === 'undefined' ? window : self;
+  }();
+
+  // define isArray
+  util$1.isArray = Array.isArray || function (x) {
+    return Object.prototype.toString.call(x) === '[object Array]';
+  };
+
+  // define isArrayBuffer
+  util$1.isArrayBuffer = function (x) {
+    return typeof ArrayBuffer !== 'undefined' && x instanceof ArrayBuffer;
+  };
+
+  // define isArrayBufferView
+  util$1.isArrayBufferView = function (x) {
+    return x && util$1.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$1.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$1.isArrayBuffer(b) || util$1.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$1.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$1.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$1.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$1.ByteStringBuffer.prototype.isEmpty = function () {
+    return this.length() <= 0;
+  };
+
+  /**
+   * Puts a byte in this buffer.
+   *
+   * @param b the byte to put.
+   *
+   * @return this buffer.
+   */
+  util$1.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$1.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$1.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$1.ByteStringBuffer.prototype.putString = function (str) {
+    return this.putBytes(util$1.encodeUtf8(str));
+  };
+
+  /**
+   * Puts a 16-bit integer in this buffer in big-endian order.
+   *
+   * @param i the 16-bit integer.
+   *
+   * @return this buffer.
+   */
+  util$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.ByteStringBuffer.prototype.last = function () {
+    return this.data.charCodeAt(this.data.length - 1);
+  };
+
+  /**
+   * Creates a copy of this buffer.
+   *
+   * @return the copy.
+   */
+  util$1.ByteStringBuffer.prototype.copy = function () {
+    var c = util$1.createBuffer(this.data);
+    c.read = this.read;
+    return c;
+  };
+
+  /**
+   * Compacts this buffer.
+   *
+   * @return this buffer.
+   */
+  util$1.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$1.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$1.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$1.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$1.ByteStringBuffer.prototype.toString = function () {
+    return util$1.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$1.isArrayBuffer(b);
+    var isArrayBufferView = util$1.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$1.DataBuffer = DataBuffer;
+
+  /**
+   * Gets the number of bytes in this buffer.
+   *
+   * @return the number of bytes in this buffer.
+   */
+  util$1.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$1.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$1.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$1.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$1.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$1.DataBuffer.prototype.putBytes = function (bytes, encoding) {
+    if (util$1.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$1.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$1.DataBuffer || typeof bytes === 'object' && typeof bytes.read === 'number' && typeof bytes.write === 'number' && util$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.DataBuffer.prototype.last = function () {
+    return this.data.getUint8(this.write - 1);
+  };
+
+  /**
+   * Creates a copy of this buffer.
+   *
+   * @return the copy.
+   */
+  util$1.DataBuffer.prototype.copy = function () {
+    return new util$1.DataBuffer(this);
+  };
+
+  /**
+   * Compacts this buffer.
+   *
+   * @return this buffer.
+   */
+  util$1.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$1.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$1.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$1.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$1.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$1.binary.raw.encode(view);
+    }
+    if (encoding === 'hex') {
+      return util$1.binary.hex.encode(view);
+    }
+    if (encoding === 'base64') {
+      return util$1.binary.base64.encode(view);
+    }
+
+    // decode to text
+    if (encoding === 'utf8') {
+      return util$1.text.utf8.decode(view);
+    }
+    if (encoding === 'utf16') {
+      return util$1.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$1.createBuffer = function (input, encoding) {
+    // TODO: deprecate, use new ByteBuffer() instead
+    encoding = encoding || 'raw';
+    if (input !== undefined && encoding === 'utf8') {
+      input = util$1.encodeUtf8(input);
+    }
+    return new util$1.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$1.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$1.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$1.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$1.bytesToHex = function (bytes) {
+    // TODO: deprecate: "Deprecated. Use util.binary.hex.encode instead."
+    return util$1.createBuffer(bytes).toHex();
+  };
+
+  /**
+   * Converts an 32-bit integer to 4-big-endian byte string.
+   *
+   * @param i the integer.
+   *
+   * @return the byte string.
+   */
+  util$1.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$1.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$1.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$1.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$1.decodeUtf8 = function (str) {
+    return decodeURIComponent(escape(str));
+  };
+
+  // binary encoding/decoding tools
+  // FIXME: Experimental. Do not use yet.
+  util$1.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$1.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$1.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$1.binary.hex.encode = util$1.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$1.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$1.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$1.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$1.binary.base58.encode = function (input, maxline) {
+    return util$1.binary.baseN.encode(input, _base58, maxline);
+  };
+  util$1.binary.base58.decode = function (input, maxline) {
+    return util$1.binary.baseN.decode(input, _base58, maxline);
+  };
+
+  // text encoding/decoding tools
+  // FIXME: Experimental. Do not use yet.
+  util$1.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$1.text.utf8.encode = function (str, output, offset) {
+    str = util$1.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$1.text.utf8.decode = function (bytes) {
+    return util$1.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$1.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$1.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$1.deflate = function (api, bytes, raw) {
+    bytes = util$1.decode64(api.deflate(util$1.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$1.inflate = function (api, bytes, raw) {
+    // TODO: add zlib header and trailer if necessary/possible
+    var rval = api.inflate(util$1.encode64(bytes)).rval;
+    return rval === null ? null : util$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.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$1.formatSize = function (size) {
+    if (size >= 1073741824) {
+      size = util$1.formatNumber(size / 1073741824, 2, '.', '') + ' GiB';
+    } else if (size >= 1048576) {
+      size = util$1.formatNumber(size / 1048576, 2, '.', '') + ' MiB';
+    } else if (size >= 1024) {
+      size = util$1.formatNumber(size / 1024, 0) + ' KiB';
+    } else {
+      size = util$1.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$1.bytesFromIP = function (ip) {
+    if (ip.indexOf('.') !== -1) {
+      return util$1.bytesFromIPv4(ip);
+    }
+    if (ip.indexOf(':') !== -1) {
+      return util$1.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$1.bytesFromIPv4 = function (ip) {
+    ip = ip.split('.');
+    if (ip.length !== 4) {
+      return null;
+    }
+    var b = util$1.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$1.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$1.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$1.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$1.bytesToIP = function (bytes) {
+    if (bytes.length === 4) {
+      return util$1.bytesToIPv4(bytes);
+    }
+    if (bytes.length === 16) {
+      return util$1.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$1.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$1.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$1.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$1.estimateCores = function (options, callback) {
+    if (typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+    options = options || {};
+    if ('cores' in util$1 && !options.update) {
+      return callback(null, util$1.cores);
+    }
+    if (typeof navigator !== 'undefined' && 'hardwareConcurrency' in navigator && navigator.hardwareConcurrency > 0) {
+      util$1.cores = navigator.hardwareConcurrency;
+      return callback(null, util$1.cores);
+    }
+    if (typeof Worker === 'undefined') {
+      // workers not available
+      util$1.cores = 1;
+      return callback(null, util$1.cores);
+    }
+    if (typeof Blob === 'undefined') {
+      // can't estimate, default to 2
+      util$1.cores = 2;
+      return callback(null, util$1.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;
+        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$1.cores = Math.max(1, avg);
+        URL.revokeObjectURL(blobUrl);
+        return callback(null, util$1.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);
+    }
+  };
+  return util.exports;
+}
+
+export { requireUtil as __require };
+//# sourceMappingURL=util.js.map