web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/protobufjs/src/index-minimal.js

@@ -0,0 +1,55 @@
+import { __exports as indexMinimal } from '../../../_virtual/index-minimal.js';
+import { __require as requireWriter } from './writer.js';
+import { __require as requireWriter_buffer } from './writer_buffer.js';
+import { __require as requireReader } from './reader.js';
+import { __require as requireReader_buffer } from './reader_buffer.js';
+import { __require as requireMinimal } from './util/minimal.js';
+import { __require as requireRpc } from './rpc.js';
+import { __require as requireRoots } from './roots.js';
+
+var hasRequiredIndexMinimal;
+function requireIndexMinimal() {
+  if (hasRequiredIndexMinimal) return indexMinimal;
+  hasRequiredIndexMinimal = 1;
+  (function (exports) {
+
+    var protobuf = exports;
+
+    /**
+     * Build type, one of `"full"`, `"light"` or `"minimal"`.
+     * @name build
+     * @type {string}
+     * @const
+     */
+    protobuf.build = "minimal";
+
+    // Serialization
+    protobuf.Writer = requireWriter();
+    protobuf.BufferWriter = requireWriter_buffer();
+    protobuf.Reader = requireReader();
+    protobuf.BufferReader = requireReader_buffer();
+
+    // Utility
+    protobuf.util = requireMinimal();
+    protobuf.rpc = requireRpc();
+    protobuf.roots = requireRoots();
+    protobuf.configure = configure;
+
+    /* istanbul ignore next */
+    /**
+     * Reconfigures the library according to the environment.
+     * @returns {undefined}
+     */
+    function configure() {
+      protobuf.util._configure();
+      protobuf.Writer._configure(protobuf.BufferWriter);
+      protobuf.Reader._configure(protobuf.BufferReader);
+    }
+
+    // Set up buffer utility according to the environment
+    configure();
+  })(indexMinimal);
+  return indexMinimal;
+}
+
+export { requireIndexMinimal as __require };

package/dist/esm/node_modules/protobufjs/src/reader.js

@@ -0,0 +1,382 @@
+import { __require as requireMinimal } from './util/minimal.js';
+
+var reader;
+var hasRequiredReader;
+function requireReader() {
+  if (hasRequiredReader) return reader;
+  hasRequiredReader = 1;
+  reader = Reader;
+  var util = requireMinimal();
+  var BufferReader; // cyclic
+
+  var LongBits = util.LongBits,
+    utf8 = util.utf8;
+
+  /* istanbul ignore next */
+  function indexOutOfRange(reader, writeLength) {
+    return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
+  }
+
+  /**
+   * Constructs a new reader instance using the specified buffer.
+   * @classdesc Wire format reader using `Uint8Array` if available, otherwise `Array`.
+   * @constructor
+   * @param {Uint8Array} buffer Buffer to read from
+   */
+  function Reader(buffer) {
+    /**
+     * Read buffer.
+     * @type {Uint8Array}
+     */
+    this.buf = buffer;
+
+    /**
+     * Read buffer position.
+     * @type {number}
+     */
+    this.pos = 0;
+
+    /**
+     * Read buffer length.
+     * @type {number}
+     */
+    this.len = buffer.length;
+  }
+  var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer) {
+    if (buffer instanceof Uint8Array || Array.isArray(buffer)) return new Reader(buffer);
+    throw Error("illegal buffer");
+  }
+  /* istanbul ignore next */ : function create_array(buffer) {
+    if (Array.isArray(buffer)) return new Reader(buffer);
+    throw Error("illegal buffer");
+  };
+  var create = function create() {
+    return util.Buffer ? function create_buffer_setup(buffer) {
+      return (Reader.create = function create_buffer(buffer) {
+        return util.Buffer.isBuffer(buffer) ? new BufferReader(buffer)
+        /* istanbul ignore next */ : create_array(buffer);
+      })(buffer);
+    }
+    /* istanbul ignore next */ : create_array;
+  };
+
+  /**
+   * Creates a new reader using the specified buffer.
+   * @function
+   * @param {Uint8Array|Buffer} buffer Buffer to read from
+   * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}
+   * @throws {Error} If `buffer` is not a valid buffer
+   */
+  Reader.create = create();
+  Reader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */util.Array.prototype.slice;
+
+  /**
+   * Reads a varint as an unsigned 32 bit value.
+   * @function
+   * @returns {number} Value read
+   */
+  Reader.prototype.uint32 = function read_uint32_setup() {
+    var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)
+    return function read_uint32() {
+      value = (this.buf[this.pos] & 127) >>> 0;
+      if (this.buf[this.pos++] < 128) return value;
+      value = (value | (this.buf[this.pos] & 127) << 7) >>> 0;
+      if (this.buf[this.pos++] < 128) return value;
+      value = (value | (this.buf[this.pos] & 127) << 14) >>> 0;
+      if (this.buf[this.pos++] < 128) return value;
+      value = (value | (this.buf[this.pos] & 127) << 21) >>> 0;
+      if (this.buf[this.pos++] < 128) return value;
+      value = (value | (this.buf[this.pos] & 15) << 28) >>> 0;
+      if (this.buf[this.pos++] < 128) return value;
+
+      /* istanbul ignore if */
+      if ((this.pos += 5) > this.len) {
+        this.pos = this.len;
+        throw indexOutOfRange(this, 10);
+      }
+      return value;
+    };
+  }();
+
+  /**
+   * Reads a varint as a signed 32 bit value.
+   * @returns {number} Value read
+   */
+  Reader.prototype.int32 = function read_int32() {
+    return this.uint32() | 0;
+  };
+
+  /**
+   * Reads a zig-zag encoded varint as a signed 32 bit value.
+   * @returns {number} Value read
+   */
+  Reader.prototype.sint32 = function read_sint32() {
+    var value = this.uint32();
+    return value >>> 1 ^ -(value & 1) | 0;
+  };
+
+  /* eslint-disable no-invalid-this */
+
+  function readLongVarint() {
+    // tends to deopt with local vars for octet etc.
+    var bits = new LongBits(0, 0);
+    var i = 0;
+    if (this.len - this.pos > 4) {
+      // fast route (lo)
+      for (; i < 4; ++i) {
+        // 1st..4th
+        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+        if (this.buf[this.pos++] < 128) return bits;
+      }
+      // 5th
+      bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;
+      bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;
+      if (this.buf[this.pos++] < 128) return bits;
+      i = 0;
+    } else {
+      for (; i < 3; ++i) {
+        /* istanbul ignore if */
+        if (this.pos >= this.len) throw indexOutOfRange(this);
+        // 1st..3th
+        bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;
+        if (this.buf[this.pos++] < 128) return bits;
+      }
+      // 4th
+      bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;
+      return bits;
+    }
+    if (this.len - this.pos > 4) {
+      // fast route (hi)
+      for (; i < 5; ++i) {
+        // 6th..10th
+        bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+        if (this.buf[this.pos++] < 128) return bits;
+      }
+    } else {
+      for (; i < 5; ++i) {
+        /* istanbul ignore if */
+        if (this.pos >= this.len) throw indexOutOfRange(this);
+        // 6th..10th
+        bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;
+        if (this.buf[this.pos++] < 128) return bits;
+      }
+    }
+    /* istanbul ignore next */
+    throw Error("invalid varint encoding");
+  }
+
+  /* eslint-enable no-invalid-this */
+
+  /**
+   * Reads a varint as a signed 64 bit value.
+   * @name Reader#int64
+   * @function
+   * @returns {Long} Value read
+   */
+
+  /**
+   * Reads a varint as an unsigned 64 bit value.
+   * @name Reader#uint64
+   * @function
+   * @returns {Long} Value read
+   */
+
+  /**
+   * Reads a zig-zag encoded varint as a signed 64 bit value.
+   * @name Reader#sint64
+   * @function
+   * @returns {Long} Value read
+   */
+
+  /**
+   * Reads a varint as a boolean.
+   * @returns {boolean} Value read
+   */
+  Reader.prototype.bool = function read_bool() {
+    return this.uint32() !== 0;
+  };
+  function readFixed32_end(buf, end) {
+    // note that this uses `end`, not `pos`
+    return (buf[end - 4] | buf[end - 3] << 8 | buf[end - 2] << 16 | buf[end - 1] << 24) >>> 0;
+  }
+
+  /**
+   * Reads fixed 32 bits as an unsigned 32 bit integer.
+   * @returns {number} Value read
+   */
+  Reader.prototype.fixed32 = function read_fixed32() {
+    /* istanbul ignore if */
+    if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+    return readFixed32_end(this.buf, this.pos += 4);
+  };
+
+  /**
+   * Reads fixed 32 bits as a signed 32 bit integer.
+   * @returns {number} Value read
+   */
+  Reader.prototype.sfixed32 = function read_sfixed32() {
+    /* istanbul ignore if */
+    if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+    return readFixed32_end(this.buf, this.pos += 4) | 0;
+  };
+
+  /* eslint-disable no-invalid-this */
+
+  function readFixed64(/* this: Reader */
+  ) {
+    /* istanbul ignore if */
+    if (this.pos + 8 > this.len) throw indexOutOfRange(this, 8);
+    return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));
+  }
+
+  /* eslint-enable no-invalid-this */
+
+  /**
+   * Reads fixed 64 bits.
+   * @name Reader#fixed64
+   * @function
+   * @returns {Long} Value read
+   */
+
+  /**
+   * Reads zig-zag encoded fixed 64 bits.
+   * @name Reader#sfixed64
+   * @function
+   * @returns {Long} Value read
+   */
+
+  /**
+   * Reads a float (32 bit) as a number.
+   * @function
+   * @returns {number} Value read
+   */
+  Reader.prototype.float = function read_float() {
+    /* istanbul ignore if */
+    if (this.pos + 4 > this.len) throw indexOutOfRange(this, 4);
+    var value = util.float.readFloatLE(this.buf, this.pos);
+    this.pos += 4;
+    return value;
+  };
+
+  /**
+   * Reads a double (64 bit float) as a number.
+   * @function
+   * @returns {number} Value read
+   */
+  Reader.prototype.double = function read_double() {
+    /* istanbul ignore if */
+    if (this.pos + 8 > this.len) throw indexOutOfRange(this, 4);
+    var value = util.float.readDoubleLE(this.buf, this.pos);
+    this.pos += 8;
+    return value;
+  };
+
+  /**
+   * Reads a sequence of bytes preceeded by its length as a varint.
+   * @returns {Uint8Array} Value read
+   */
+  Reader.prototype.bytes = function read_bytes() {
+    var length = this.uint32(),
+      start = this.pos,
+      end = this.pos + length;
+
+    /* istanbul ignore if */
+    if (end > this.len) throw indexOutOfRange(this, length);
+    this.pos += length;
+    if (Array.isArray(this.buf))
+      // plain array
+      return this.buf.slice(start, end);
+    if (start === end) {
+      // fix for IE 10/Win8 and others' subarray returning array of size 1
+      var nativeBuffer = util.Buffer;
+      return nativeBuffer ? nativeBuffer.alloc(0) : new this.buf.constructor(0);
+    }
+    return this._slice.call(this.buf, start, end);
+  };
+
+  /**
+   * Reads a string preceeded by its byte length as a varint.
+   * @returns {string} Value read
+   */
+  Reader.prototype.string = function read_string() {
+    var bytes = this.bytes();
+    return utf8.read(bytes, 0, bytes.length);
+  };
+
+  /**
+   * Skips the specified number of bytes if specified, otherwise skips a varint.
+   * @param {number} [length] Length if known, otherwise a varint is assumed
+   * @returns {Reader} `this`
+   */
+  Reader.prototype.skip = function skip(length) {
+    if (typeof length === "number") {
+      /* istanbul ignore if */
+      if (this.pos + length > this.len) throw indexOutOfRange(this, length);
+      this.pos += length;
+    } else {
+      do {
+        /* istanbul ignore if */
+        if (this.pos >= this.len) throw indexOutOfRange(this);
+      } while (this.buf[this.pos++] & 128);
+    }
+    return this;
+  };
+
+  /**
+   * Skips the next element of the specified wire type.
+   * @param {number} wireType Wire type received
+   * @returns {Reader} `this`
+   */
+  Reader.prototype.skipType = function (wireType) {
+    switch (wireType) {
+      case 0:
+        this.skip();
+        break;
+      case 1:
+        this.skip(8);
+        break;
+      case 2:
+        this.skip(this.uint32());
+        break;
+      case 3:
+        while ((wireType = this.uint32() & 7) !== 4) {
+          this.skipType(wireType);
+        }
+        break;
+      case 5:
+        this.skip(4);
+        break;
+
+      /* istanbul ignore next */
+      default:
+        throw Error("invalid wire type " + wireType + " at offset " + this.pos);
+    }
+    return this;
+  };
+  Reader._configure = function (BufferReader_) {
+    BufferReader = BufferReader_;
+    Reader.create = create();
+    BufferReader._configure();
+    var fn = util.Long ? "toLong" : /* istanbul ignore next */"toNumber";
+    util.merge(Reader.prototype, {
+      int64: function read_int64() {
+        return readLongVarint.call(this)[fn](false);
+      },
+      uint64: function read_uint64() {
+        return readLongVarint.call(this)[fn](true);
+      },
+      sint64: function read_sint64() {
+        return readLongVarint.call(this).zzDecode()[fn](false);
+      },
+      fixed64: function read_fixed64() {
+        return readFixed64.call(this)[fn](true);
+      },
+      sfixed64: function read_sfixed64() {
+        return readFixed64.call(this)[fn](false);
+      }
+    });
+  };
+  return reader;
+}
+
+export { requireReader as __require };

package/dist/esm/node_modules/protobufjs/src/reader_buffer.js

@@ -0,0 +1,56 @@
+import { __require as requireReader } from './reader.js';
+import { __require as requireMinimal } from './util/minimal.js';
+
+var reader_buffer;
+var hasRequiredReader_buffer;
+function requireReader_buffer() {
+  if (hasRequiredReader_buffer) return reader_buffer;
+  hasRequiredReader_buffer = 1;
+  reader_buffer = BufferReader;
+
+  // extends Reader
+  var Reader = requireReader();
+  (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
+  var util = requireMinimal();
+
+  /**
+   * Constructs a new buffer reader instance.
+   * @classdesc Wire format reader using node buffers.
+   * @extends Reader
+   * @constructor
+   * @param {Buffer} buffer Buffer to read from
+   */
+  function BufferReader(buffer) {
+    Reader.call(this, buffer);
+
+    /**
+     * Read buffer.
+     * @name BufferReader#buf
+     * @type {Buffer}
+     */
+  }
+  BufferReader._configure = function () {
+    /* istanbul ignore else */
+    if (util.Buffer) BufferReader.prototype._slice = util.Buffer.prototype.slice;
+  };
+
+  /**
+   * @override
+   */
+  BufferReader.prototype.string = function read_string_buffer() {
+    var len = this.uint32(); // modifies pos
+    return this.buf.utf8Slice ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len)) : this.buf.toString("utf-8", this.pos, this.pos = Math.min(this.pos + len, this.len));
+  };
+
+  /**
+   * Reads a sequence of bytes preceeded by its length as a varint.
+   * @name BufferReader#bytes
+   * @function
+   * @returns {Buffer} Value read
+   */
+
+  BufferReader._configure();
+  return reader_buffer;
+}
+
+export { requireReader_buffer as __require };

package/dist/esm/node_modules/protobufjs/src/roots.js

@@ -0,0 +1,26 @@
+var roots;
+var hasRequiredRoots;
+function requireRoots() {
+  if (hasRequiredRoots) return roots;
+  hasRequiredRoots = 1;
+  roots = {};
+
+  /**
+   * Named roots.
+   * This is where pbjs stores generated structures (the option `-r, --root` specifies a name).
+   * Can also be used manually to make roots available across modules.
+   * @name roots
+   * @type {Object.<string,Root>}
+   * @example
+   * // pbjs -r myroot -o compiled.js ...
+   *
+   * // in another module:
+   * require("./compiled.js");
+   *
+   * // in any subsequent module:
+   * var root = protobuf.roots["myroot"];
+   */
+  return roots;
+}
+
+export { requireRoots as __require };

package/dist/esm/node_modules/protobufjs/src/rpc/service.js

@@ -0,0 +1,139 @@
+import { __require as requireMinimal } from '../util/minimal.js';
+
+var service;
+var hasRequiredService;
+function requireService() {
+  if (hasRequiredService) return service;
+  hasRequiredService = 1;
+  service = Service;
+  var util = requireMinimal();
+
+  // Extends EventEmitter
+  (Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
+
+  /**
+   * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
+   *
+   * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.
+   * @typedef rpc.ServiceMethodCallback
+   * @template TRes extends Message<TRes>
+   * @type {function}
+   * @param {Error|null} error Error, if any
+   * @param {TRes} [response] Response message
+   * @returns {undefined}
+   */
+
+  /**
+   * A service method part of a {@link rpc.Service} as created by {@link Service.create}.
+   * @typedef rpc.ServiceMethod
+   * @template TReq extends Message<TReq>
+   * @template TRes extends Message<TRes>
+   * @type {function}
+   * @param {TReq|Properties<TReq>} request Request message or plain object
+   * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message
+   * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`
+   */
+
+  /**
+   * Constructs a new RPC service instance.
+   * @classdesc An RPC service as returned by {@link Service#create}.
+   * @exports rpc.Service
+   * @extends util.EventEmitter
+   * @constructor
+   * @param {RPCImpl} rpcImpl RPC implementation
+   * @param {boolean} [requestDelimited=false] Whether requests are length-delimited
+   * @param {boolean} [responseDelimited=false] Whether responses are length-delimited
+   */
+  function Service(rpcImpl, requestDelimited, responseDelimited) {
+    if (typeof rpcImpl !== "function") throw TypeError("rpcImpl must be a function");
+    util.EventEmitter.call(this);
+
+    /**
+     * RPC implementation. Becomes `null` once the service is ended.
+     * @type {RPCImpl|null}
+     */
+    this.rpcImpl = rpcImpl;
+
+    /**
+     * Whether requests are length-delimited.
+     * @type {boolean}
+     */
+    this.requestDelimited = Boolean(requestDelimited);
+
+    /**
+     * Whether responses are length-delimited.
+     * @type {boolean}
+     */
+    this.responseDelimited = Boolean(responseDelimited);
+  }
+
+  /**
+   * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.
+   * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method
+   * @param {Constructor<TReq>} requestCtor Request constructor
+   * @param {Constructor<TRes>} responseCtor Response constructor
+   * @param {TReq|Properties<TReq>} request Request message or plain object
+   * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback
+   * @returns {undefined}
+   * @template TReq extends Message<TReq>
+   * @template TRes extends Message<TRes>
+   */
+  Service.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {
+    if (!request) throw TypeError("request must be specified");
+    var self = this;
+    if (!callback) return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);
+    if (!self.rpcImpl) {
+      setTimeout(function () {
+        callback(Error("already ended"));
+      }, 0);
+      return undefined;
+    }
+    try {
+      return self.rpcImpl(method, requestCtor[self.requestDelimited ? "encodeDelimited" : "encode"](request).finish(), function rpcCallback(err, response) {
+        if (err) {
+          self.emit("error", err, method);
+          return callback(err);
+        }
+        if (response === null) {
+          self.end(/* endedByRPC */true);
+          return undefined;
+        }
+        if (!(response instanceof responseCtor)) {
+          try {
+            response = responseCtor[self.responseDelimited ? "decodeDelimited" : "decode"](response);
+          } catch (err) {
+            self.emit("error", err, method);
+            return callback(err);
+          }
+        }
+        self.emit("data", response, method);
+        return callback(null, response);
+      });
+    } catch (err) {
+      self.emit("error", err, method);
+      setTimeout(function () {
+        callback(err);
+      }, 0);
+      return undefined;
+    }
+  };
+
+  /**
+   * Ends this service and emits the `end` event.
+   * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.
+   * @returns {rpc.Service} `this`
+   */
+  Service.prototype.end = function end(endedByRPC) {
+    if (this.rpcImpl) {
+      if (!endedByRPC)
+        // signal end to rpcImpl
+        this.rpcImpl(null, null, null);
+      this.rpcImpl = null;
+      this.emit("end").off();
+    }
+    return this;
+  };
+  return service;
+}
+
+export { requireService as __require };

package/dist/esm/node_modules/protobufjs/src/rpc.js

@@ -0,0 +1,48 @@
+import { __exports as rpc } from '../../../_virtual/rpc.js';
+import { __require as requireService } from './rpc/service.js';
+
+var hasRequiredRpc;
+function requireRpc() {
+  if (hasRequiredRpc) return rpc;
+  hasRequiredRpc = 1;
+  (function (exports) {
+
+    /**
+     * Streaming RPC helpers.
+     * @namespace
+     */
+    var rpc = exports;
+
+    /**
+     * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.
+     * @typedef RPCImpl
+     * @type {function}
+     * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called
+     * @param {Uint8Array} requestData Request data
+     * @param {RPCImplCallback} callback Callback function
+     * @returns {undefined}
+     * @example
+     * function rpcImpl(method, requestData, callback) {
+     *     if (protobuf.util.lcFirst(method.name) !== "myMethod") // compatible with static code
+     *         throw Error("no such method");
+     *     asynchronouslyObtainAResponse(requestData, function(err, responseData) {
+     *         callback(err, responseData);
+     *     });
+     * }
+     */
+
+    /**
+     * Node-style callback as used by {@link RPCImpl}.
+     * @typedef RPCImplCallback
+     * @type {function}
+     * @param {Error|null} error Error, if any, otherwise `null`
+     * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error
+     * @returns {undefined}
+     */
+
+    rpc.Service = requireService();
+  })(rpc);
+  return rpc;
+}
+
+export { requireRpc as __require };