web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/node_modules/@protobufjs/aspromise/index.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var aspromise;
+var hasRequiredAspromise;
+function requireAspromise() {
+  if (hasRequiredAspromise) return aspromise;
+  hasRequiredAspromise = 1;
+  aspromise = asPromise;
+
+  /**
+   * Callback as used by {@link util.asPromise}.
+   * @typedef asPromiseCallback
+   * @type {function}
+   * @param {Error|null} error Error, if any
+   * @param {...*} params Additional arguments
+   * @returns {undefined}
+   */
+
+  /**
+   * Returns a promise from a node-style callback function.
+   * @memberof util
+   * @param {asPromiseCallback} fn Function to call
+   * @param {*} ctx Function context
+   * @param {...*} params Function arguments
+   * @returns {Promise<*>} Promisified function
+   */
+  function asPromise(fn, ctx /*, varargs */) {
+    var params = new Array(arguments.length - 1),
+      offset = 0,
+      index = 2,
+      pending = true;
+    while (index < arguments.length) params[offset++] = arguments[index++];
+    return new Promise(function executor(resolve, reject) {
+      params[offset] = function callback(err /*, varargs */) {
+        if (pending) {
+          pending = false;
+          if (err) reject(err);else {
+            var params = new Array(arguments.length - 1),
+              offset = 0;
+            while (offset < params.length) params[offset++] = arguments[offset];
+            resolve.apply(null, params);
+          }
+        }
+      };
+      try {
+        fn.apply(ctx || null, params);
+      } catch (err) {
+        if (pending) {
+          pending = false;
+          reject(err);
+        }
+      }
+    });
+  }
+  return aspromise;
+}
+
+exports.__require = requireAspromise;

package/dist/cjs/node_modules/@protobufjs/base64/index.js

@@ -0,0 +1,146 @@
+'use strict';
+
+var index = require('../../../_virtual/index10.js');
+
+var hasRequiredBase64;
+function requireBase64() {
+  if (hasRequiredBase64) return index.__exports;
+  hasRequiredBase64 = 1;
+  (function (exports) {
+
+    /**
+     * A minimal base64 implementation for number arrays.
+     * @memberof util
+     * @namespace
+     */
+    var base64 = exports;
+
+    /**
+     * Calculates the byte length of a base64 encoded string.
+     * @param {string} string Base64 encoded string
+     * @returns {number} Byte length
+     */
+    base64.length = function length(string) {
+      var p = string.length;
+      if (!p) return 0;
+      var n = 0;
+      while (--p % 4 > 1 && string.charAt(p) === "=") ++n;
+      return Math.ceil(string.length * 3) / 4 - n;
+    };
+
+    // Base64 encoding table
+    var b64 = new Array(64);
+
+    // Base64 decoding table
+    var s64 = new Array(123);
+
+    // 65..90, 97..122, 48..57, 43, 47
+    for (var i = 0; i < 64;) s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
+
+    /**
+     * Encodes a buffer to a base64 encoded string.
+     * @param {Uint8Array} buffer Source buffer
+     * @param {number} start Source start
+     * @param {number} end Source end
+     * @returns {string} Base64 encoded string
+     */
+    base64.encode = function encode(buffer, start, end) {
+      var parts = null,
+        chunk = [];
+      var i = 0,
+        // output index
+        j = 0,
+        // goto index
+        t; // temporary
+      while (start < end) {
+        var b = buffer[start++];
+        switch (j) {
+          case 0:
+            chunk[i++] = b64[b >> 2];
+            t = (b & 3) << 4;
+            j = 1;
+            break;
+          case 1:
+            chunk[i++] = b64[t | b >> 4];
+            t = (b & 15) << 2;
+            j = 2;
+            break;
+          case 2:
+            chunk[i++] = b64[t | b >> 6];
+            chunk[i++] = b64[b & 63];
+            j = 0;
+            break;
+        }
+        if (i > 8191) {
+          (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
+          i = 0;
+        }
+      }
+      if (j) {
+        chunk[i++] = b64[t];
+        chunk[i++] = 61;
+        if (j === 1) chunk[i++] = 61;
+      }
+      if (parts) {
+        if (i) parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));
+        return parts.join("");
+      }
+      return String.fromCharCode.apply(String, chunk.slice(0, i));
+    };
+    var invalidEncoding = "invalid encoding";
+
+    /**
+     * Decodes a base64 encoded string to a buffer.
+     * @param {string} string Source string
+     * @param {Uint8Array} buffer Destination buffer
+     * @param {number} offset Destination offset
+     * @returns {number} Number of bytes written
+     * @throws {Error} If encoding is invalid
+     */
+    base64.decode = function decode(string, buffer, offset) {
+      var start = offset;
+      var j = 0,
+        // goto index
+        t; // temporary
+      for (var i = 0; i < string.length;) {
+        var c = string.charCodeAt(i++);
+        if (c === 61 && j > 1) break;
+        if ((c = s64[c]) === undefined) throw Error(invalidEncoding);
+        switch (j) {
+          case 0:
+            t = c;
+            j = 1;
+            break;
+          case 1:
+            buffer[offset++] = t << 2 | (c & 48) >> 4;
+            t = c;
+            j = 2;
+            break;
+          case 2:
+            buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+            t = c;
+            j = 3;
+            break;
+          case 3:
+            buffer[offset++] = (t & 3) << 6 | c;
+            j = 0;
+            break;
+        }
+      }
+      if (j === 1) throw Error(invalidEncoding);
+      return offset - start;
+    };
+
+    /**
+     * Tests if the specified string appears to be base64 encoded.
+     * @param {string} string String to test
+     * @returns {boolean} `true` if probably base64 encoded, otherwise false
+     */
+    base64.test = function test(string) {
+      return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);
+    };
+  })(index.__exports);
+  return index.__exports;
+}
+
+exports.__require = requireBase64;

package/dist/cjs/node_modules/@protobufjs/eventemitter/index.js

@@ -0,0 +1,75 @@
+'use strict';
+
+var eventemitter;
+var hasRequiredEventemitter;
+function requireEventemitter() {
+  if (hasRequiredEventemitter) return eventemitter;
+  hasRequiredEventemitter = 1;
+  eventemitter = EventEmitter;
+
+  /**
+   * Constructs a new event emitter instance.
+   * @classdesc A minimal event emitter.
+   * @memberof util
+   * @constructor
+   */
+  function EventEmitter() {
+    /**
+     * Registered listeners.
+     * @type {Object.<string,*>}
+     * @private
+     */
+    this._listeners = {};
+  }
+
+  /**
+   * Registers an event listener.
+   * @param {string} evt Event name
+   * @param {function} fn Listener
+   * @param {*} [ctx] Listener context
+   * @returns {util.EventEmitter} `this`
+   */
+  EventEmitter.prototype.on = function on(evt, fn, ctx) {
+    (this._listeners[evt] || (this._listeners[evt] = [])).push({
+      fn: fn,
+      ctx: ctx || this
+    });
+    return this;
+  };
+
+  /**
+   * Removes an event listener or any matching listeners if arguments are omitted.
+   * @param {string} [evt] Event name. Removes all listeners if omitted.
+   * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.
+   * @returns {util.EventEmitter} `this`
+   */
+  EventEmitter.prototype.off = function off(evt, fn) {
+    if (evt === undefined) this._listeners = {};else {
+      if (fn === undefined) this._listeners[evt] = [];else {
+        var listeners = this._listeners[evt];
+        for (var i = 0; i < listeners.length;) if (listeners[i].fn === fn) listeners.splice(i, 1);else ++i;
+      }
+    }
+    return this;
+  };
+
+  /**
+   * Emits an event by calling its listeners with the specified arguments.
+   * @param {string} evt Event name
+   * @param {...*} args Arguments
+   * @returns {util.EventEmitter} `this`
+   */
+  EventEmitter.prototype.emit = function emit(evt) {
+    var listeners = this._listeners[evt];
+    if (listeners) {
+      var args = [],
+        i = 1;
+      for (; i < arguments.length;) args.push(arguments[i++]);
+      for (i = 0; i < listeners.length;) listeners[i].fn.apply(listeners[i++].ctx, args);
+    }
+    return this;
+  };
+  return eventemitter;
+}
+
+exports.__require = requireEventemitter;

package/dist/cjs/node_modules/@protobufjs/float/index.js

@@ -0,0 +1,298 @@
+'use strict';
+
+var float;
+var hasRequiredFloat;
+function requireFloat() {
+  if (hasRequiredFloat) return float;
+  hasRequiredFloat = 1;
+  float = factory(factory);
+
+  /**
+   * Reads / writes floats / doubles from / to buffers.
+   * @name util.float
+   * @namespace
+   */
+
+  /**
+   * Writes a 32 bit float to a buffer using little endian byte order.
+   * @name util.float.writeFloatLE
+   * @function
+   * @param {number} val Value to write
+   * @param {Uint8Array} buf Target buffer
+   * @param {number} pos Target buffer offset
+   * @returns {undefined}
+   */
+
+  /**
+   * Writes a 32 bit float to a buffer using big endian byte order.
+   * @name util.float.writeFloatBE
+   * @function
+   * @param {number} val Value to write
+   * @param {Uint8Array} buf Target buffer
+   * @param {number} pos Target buffer offset
+   * @returns {undefined}
+   */
+
+  /**
+   * Reads a 32 bit float from a buffer using little endian byte order.
+   * @name util.float.readFloatLE
+   * @function
+   * @param {Uint8Array} buf Source buffer
+   * @param {number} pos Source buffer offset
+   * @returns {number} Value read
+   */
+
+  /**
+   * Reads a 32 bit float from a buffer using big endian byte order.
+   * @name util.float.readFloatBE
+   * @function
+   * @param {Uint8Array} buf Source buffer
+   * @param {number} pos Source buffer offset
+   * @returns {number} Value read
+   */
+
+  /**
+   * Writes a 64 bit double to a buffer using little endian byte order.
+   * @name util.float.writeDoubleLE
+   * @function
+   * @param {number} val Value to write
+   * @param {Uint8Array} buf Target buffer
+   * @param {number} pos Target buffer offset
+   * @returns {undefined}
+   */
+
+  /**
+   * Writes a 64 bit double to a buffer using big endian byte order.
+   * @name util.float.writeDoubleBE
+   * @function
+   * @param {number} val Value to write
+   * @param {Uint8Array} buf Target buffer
+   * @param {number} pos Target buffer offset
+   * @returns {undefined}
+   */
+
+  /**
+   * Reads a 64 bit double from a buffer using little endian byte order.
+   * @name util.float.readDoubleLE
+   * @function
+   * @param {Uint8Array} buf Source buffer
+   * @param {number} pos Source buffer offset
+   * @returns {number} Value read
+   */
+
+  /**
+   * Reads a 64 bit double from a buffer using big endian byte order.
+   * @name util.float.readDoubleBE
+   * @function
+   * @param {Uint8Array} buf Source buffer
+   * @param {number} pos Source buffer offset
+   * @returns {number} Value read
+   */
+
+  // Factory function for the purpose of node-based testing in modified global environments
+  function factory(exports) {
+    // float: typed array
+    if (typeof Float32Array !== "undefined") (function () {
+      var f32 = new Float32Array([-0]),
+        f8b = new Uint8Array(f32.buffer),
+        le = f8b[3] === 128;
+      function writeFloat_f32_cpy(val, buf, pos) {
+        f32[0] = val;
+        buf[pos] = f8b[0];
+        buf[pos + 1] = f8b[1];
+        buf[pos + 2] = f8b[2];
+        buf[pos + 3] = f8b[3];
+      }
+      function writeFloat_f32_rev(val, buf, pos) {
+        f32[0] = val;
+        buf[pos] = f8b[3];
+        buf[pos + 1] = f8b[2];
+        buf[pos + 2] = f8b[1];
+        buf[pos + 3] = f8b[0];
+      }
+
+      /* istanbul ignore next */
+      exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
+      /* istanbul ignore next */
+      exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
+      function readFloat_f32_cpy(buf, pos) {
+        f8b[0] = buf[pos];
+        f8b[1] = buf[pos + 1];
+        f8b[2] = buf[pos + 2];
+        f8b[3] = buf[pos + 3];
+        return f32[0];
+      }
+      function readFloat_f32_rev(buf, pos) {
+        f8b[3] = buf[pos];
+        f8b[2] = buf[pos + 1];
+        f8b[1] = buf[pos + 2];
+        f8b[0] = buf[pos + 3];
+        return f32[0];
+      }
+
+      /* istanbul ignore next */
+      exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
+      /* istanbul ignore next */
+      exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;
+
+      // float: ieee754
+    })();else (function () {
+      function writeFloat_ieee754(writeUint, val, buf, pos) {
+        var sign = val < 0 ? 1 : 0;
+        if (sign) val = -val;
+        if (val === 0) writeUint(1 / val > 0 ? /* positive */0 : /* negative 0 */2147483648, buf, pos);else if (isNaN(val)) writeUint(2143289344, buf, pos);else if (val > 3.4028234663852886e+38)
+          // +-Infinity
+          writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);else if (val < 1.1754943508222875e-38)
+          // denormal
+          writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);else {
+          var exponent = Math.floor(Math.log(val) / Math.LN2),
+            mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
+          writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);
+        }
+      }
+      exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
+      exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
+      function readFloat_ieee754(readUint, buf, pos) {
+        var uint = readUint(buf, pos),
+          sign = (uint >> 31) * 2 + 1,
+          exponent = uint >>> 23 & 255,
+          mantissa = uint & 8388607;
+        return exponent === 255 ? mantissa ? NaN : sign * Infinity : exponent === 0 // denormal
+        ? sign * 1.401298464324817e-45 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
+      }
+      exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
+      exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);
+    })();
+
+    // double: typed array
+    if (typeof Float64Array !== "undefined") (function () {
+      var f64 = new Float64Array([-0]),
+        f8b = new Uint8Array(f64.buffer),
+        le = f8b[7] === 128;
+      function writeDouble_f64_cpy(val, buf, pos) {
+        f64[0] = val;
+        buf[pos] = f8b[0];
+        buf[pos + 1] = f8b[1];
+        buf[pos + 2] = f8b[2];
+        buf[pos + 3] = f8b[3];
+        buf[pos + 4] = f8b[4];
+        buf[pos + 5] = f8b[5];
+        buf[pos + 6] = f8b[6];
+        buf[pos + 7] = f8b[7];
+      }
+      function writeDouble_f64_rev(val, buf, pos) {
+        f64[0] = val;
+        buf[pos] = f8b[7];
+        buf[pos + 1] = f8b[6];
+        buf[pos + 2] = f8b[5];
+        buf[pos + 3] = f8b[4];
+        buf[pos + 4] = f8b[3];
+        buf[pos + 5] = f8b[2];
+        buf[pos + 6] = f8b[1];
+        buf[pos + 7] = f8b[0];
+      }
+
+      /* istanbul ignore next */
+      exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
+      /* istanbul ignore next */
+      exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
+      function readDouble_f64_cpy(buf, pos) {
+        f8b[0] = buf[pos];
+        f8b[1] = buf[pos + 1];
+        f8b[2] = buf[pos + 2];
+        f8b[3] = buf[pos + 3];
+        f8b[4] = buf[pos + 4];
+        f8b[5] = buf[pos + 5];
+        f8b[6] = buf[pos + 6];
+        f8b[7] = buf[pos + 7];
+        return f64[0];
+      }
+      function readDouble_f64_rev(buf, pos) {
+        f8b[7] = buf[pos];
+        f8b[6] = buf[pos + 1];
+        f8b[5] = buf[pos + 2];
+        f8b[4] = buf[pos + 3];
+        f8b[3] = buf[pos + 4];
+        f8b[2] = buf[pos + 5];
+        f8b[1] = buf[pos + 6];
+        f8b[0] = buf[pos + 7];
+        return f64[0];
+      }
+
+      /* istanbul ignore next */
+      exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
+      /* istanbul ignore next */
+      exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;
+
+      // double: ieee754
+    })();else (function () {
+      function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {
+        var sign = val < 0 ? 1 : 0;
+        if (sign) val = -val;
+        if (val === 0) {
+          writeUint(0, buf, pos + off0);
+          writeUint(1 / val > 0 ? /* positive */0 : /* negative 0 */2147483648, buf, pos + off1);
+        } else if (isNaN(val)) {
+          writeUint(0, buf, pos + off0);
+          writeUint(2146959360, buf, pos + off1);
+        } else if (val > 1.7976931348623157e+308) {
+          // +-Infinity
+          writeUint(0, buf, pos + off0);
+          writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);
+        } else {
+          var mantissa;
+          if (val < 2.2250738585072014e-308) {
+            // denormal
+            mantissa = val / 5e-324;
+            writeUint(mantissa >>> 0, buf, pos + off0);
+            writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);
+          } else {
+            var exponent = Math.floor(Math.log(val) / Math.LN2);
+            if (exponent === 1024) exponent = 1023;
+            mantissa = val * Math.pow(2, -exponent);
+            writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);
+            writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);
+          }
+        }
+      }
+      exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
+      exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
+      function readDouble_ieee754(readUint, off0, off1, buf, pos) {
+        var lo = readUint(buf, pos + off0),
+          hi = readUint(buf, pos + off1);
+        var sign = (hi >> 31) * 2 + 1,
+          exponent = hi >>> 20 & 2047,
+          mantissa = 4294967296 * (hi & 1048575) + lo;
+        return exponent === 2047 ? mantissa ? NaN : sign * Infinity : exponent === 0 // denormal
+        ? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
+      }
+      exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);
+      exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);
+    })();
+    return exports;
+  }
+
+  // uint helpers
+
+  function writeUintLE(val, buf, pos) {
+    buf[pos] = val & 255;
+    buf[pos + 1] = val >>> 8 & 255;
+    buf[pos + 2] = val >>> 16 & 255;
+    buf[pos + 3] = val >>> 24;
+  }
+  function writeUintBE(val, buf, pos) {
+    buf[pos] = val >>> 24;
+    buf[pos + 1] = val >>> 16 & 255;
+    buf[pos + 2] = val >>> 8 & 255;
+    buf[pos + 3] = val & 255;
+  }
+  function readUintLE(buf, pos) {
+    return (buf[pos] | buf[pos + 1] << 8 | buf[pos + 2] << 16 | buf[pos + 3] << 24) >>> 0;
+  }
+  function readUintBE(buf, pos) {
+    return (buf[pos] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3]) >>> 0;
+  }
+  return float;
+}
+
+exports.__require = requireFloat;

package/dist/cjs/node_modules/@protobufjs/inquire/index.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var inquire_1;
+var hasRequiredInquire;
+function requireInquire() {
+  if (hasRequiredInquire) return inquire_1;
+  hasRequiredInquire = 1;
+  inquire_1 = inquire;
+
+  /**
+   * Requires a module only if available.
+   * @memberof util
+   * @param {string} moduleName Module to require
+   * @returns {?Object} Required module if available and not empty, otherwise `null`
+   */
+  function inquire(moduleName) {
+    try {
+      var mod = eval("quire".replace(/^/, "re"))(moduleName); // eslint-disable-line no-eval
+      if (mod && (mod.length || Object.keys(mod).length)) return mod;
+    } catch (e) {} // eslint-disable-line no-empty
+    return null;
+  }
+  return inquire_1;
+}
+
+exports.__require = requireInquire;

package/dist/cjs/node_modules/@protobufjs/pool/index.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var pool_1;
+var hasRequiredPool;
+function requirePool() {
+  if (hasRequiredPool) return pool_1;
+  hasRequiredPool = 1;
+  pool_1 = pool;
+
+  /**
+   * An allocator as used by {@link util.pool}.
+   * @typedef PoolAllocator
+   * @type {function}
+   * @param {number} size Buffer size
+   * @returns {Uint8Array} Buffer
+   */
+
+  /**
+   * A slicer as used by {@link util.pool}.
+   * @typedef PoolSlicer
+   * @type {function}
+   * @param {number} start Start offset
+   * @param {number} end End offset
+   * @returns {Uint8Array} Buffer slice
+   * @this {Uint8Array}
+   */
+
+  /**
+   * A general purpose buffer pool.
+   * @memberof util
+   * @function
+   * @param {PoolAllocator} alloc Allocator
+   * @param {PoolSlicer} slice Slicer
+   * @param {number} [size=8192] Slab size
+   * @returns {PoolAllocator} Pooled allocator
+   */
+  function pool(alloc, slice, size) {
+    var SIZE = size || 8192;
+    var MAX = SIZE >>> 1;
+    var slab = null;
+    var offset = SIZE;
+    return function pool_alloc(size) {
+      if (size < 1 || size > MAX) return alloc(size);
+      if (offset + size > SIZE) {
+        slab = alloc(SIZE);
+        offset = 0;
+      }
+      var buf = slice.call(slab, offset, offset += size);
+      if (offset & 7)
+        // align to 32 bit
+        offset = (offset | 7) + 1;
+      return buf;
+    };
+  }
+  return pool_1;
+}
+
+exports.__require = requirePool;