@harbour-enterprises/superdoc 0.14.16 → 0.14.17

package/dist/chunks/index-CXnGrIkh.es.js

@@ -0,0 +1,2956 @@
+import { c as commonjsGlobal, B as Buffer, a as getAugmentedNamespace } from "./jszip-BwJb6_S5.es.js";
+import { p as process$1 } from "./vue-B_OPNNfX.es.js";
+import { c as requireEvents, d as requireDist, e as requireUtil, f as requireInherits_browser, g as requireBrowser$1, h as requireString_decoder } from "./xml-js-BC-eqb4d.es.js";
+import { u as url } from "./url-BGS7DYX5.es.js";
+var streamHttp = {};
+var request = { exports: {} };
+var capability = {};
+var hasRequiredCapability;
+function requireCapability() {
+  if (hasRequiredCapability) return capability;
+  hasRequiredCapability = 1;
+  (function(exports) {
+    exports.fetch = isFunction(commonjsGlobal.fetch) && isFunction(commonjsGlobal.ReadableStream);
+    exports.writableStream = isFunction(commonjsGlobal.WritableStream);
+    exports.abortController = isFunction(commonjsGlobal.AbortController);
+    var xhr;
+    function getXHR() {
+      if (xhr !== void 0) return xhr;
+      if (commonjsGlobal.XMLHttpRequest) {
+        xhr = new commonjsGlobal.XMLHttpRequest();
+        try {
+          xhr.open("GET", commonjsGlobal.XDomainRequest ? "/" : "https://example.com");
+        } catch (e) {
+          xhr = null;
+        }
+      } else {
+        xhr = null;
+      }
+      return xhr;
+    }
+    function checkTypeSupport(type) {
+      var xhr2 = getXHR();
+      if (!xhr2) return false;
+      try {
+        xhr2.responseType = type;
+        return xhr2.responseType === type;
+      } catch (e) {
+      }
+      return false;
+    }
+    exports.arraybuffer = exports.fetch || checkTypeSupport("arraybuffer");
+    exports.msstream = !exports.fetch && checkTypeSupport("ms-stream");
+    exports.mozchunkedarraybuffer = !exports.fetch && checkTypeSupport("moz-chunked-arraybuffer");
+    exports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false);
+    function isFunction(value) {
+      return typeof value === "function";
+    }
+    xhr = null;
+  })(capability);
+  return capability;
+}
+var response = {};
+var readableBrowser = { exports: {} };
+var streamBrowser;
+var hasRequiredStreamBrowser;
+function requireStreamBrowser() {
+  if (hasRequiredStreamBrowser) return streamBrowser;
+  hasRequiredStreamBrowser = 1;
+  streamBrowser = requireEvents().EventEmitter;
+  return streamBrowser;
+}
+var buffer_list;
+var hasRequiredBuffer_list;
+function requireBuffer_list() {
+  if (hasRequiredBuffer_list) return buffer_list;
+  hasRequiredBuffer_list = 1;
+  function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(object);
+      enumerableOnly && (symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })), keys.push.apply(keys, symbols);
+    }
+    return keys;
+  }
+  function _objectSpread(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = null != arguments[i] ? arguments[i] : {};
+      i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+        _defineProperty(target, key, source[key]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+    return target;
+  }
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    Object.defineProperty(Constructor, "prototype", { writable: false });
+    return Constructor;
+  }
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return typeof key === "symbol" ? key : String(key);
+  }
+  function _toPrimitive(input, hint) {
+    if (typeof input !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint);
+      if (typeof res !== "object") return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return String(input);
+  }
+  var _require = requireDist(), Buffer2 = _require.Buffer;
+  var _require2 = requireUtil(), inspect = _require2.inspect;
+  var custom = inspect && inspect.custom || "inspect";
+  function copyBuffer(src, target, offset) {
+    Buffer2.prototype.copy.call(src, target, offset);
+  }
+  buffer_list = /* @__PURE__ */ function() {
+    function BufferList() {
+      _classCallCheck(this, BufferList);
+      this.head = null;
+      this.tail = null;
+      this.length = 0;
+    }
+    _createClass(BufferList, [{
+      key: "push",
+      value: function push(v) {
+        var entry = {
+          data: v,
+          next: null
+        };
+        if (this.length > 0) this.tail.next = entry;
+        else this.head = entry;
+        this.tail = entry;
+        ++this.length;
+      }
+    }, {
+      key: "unshift",
+      value: function unshift(v) {
+        var entry = {
+          data: v,
+          next: this.head
+        };
+        if (this.length === 0) this.tail = entry;
+        this.head = entry;
+        ++this.length;
+      }
+    }, {
+      key: "shift",
+      value: function shift() {
+        if (this.length === 0) return;
+        var ret = this.head.data;
+        if (this.length === 1) this.head = this.tail = null;
+        else this.head = this.head.next;
+        --this.length;
+        return ret;
+      }
+    }, {
+      key: "clear",
+      value: function clear() {
+        this.head = this.tail = null;
+        this.length = 0;
+      }
+    }, {
+      key: "join",
+      value: function join(s) {
+        if (this.length === 0) return "";
+        var p = this.head;
+        var ret = "" + p.data;
+        while (p = p.next) ret += s + p.data;
+        return ret;
+      }
+    }, {
+      key: "concat",
+      value: function concat(n) {
+        if (this.length === 0) return Buffer2.alloc(0);
+        var ret = Buffer2.allocUnsafe(n >>> 0);
+        var p = this.head;
+        var i = 0;
+        while (p) {
+          copyBuffer(p.data, ret, i);
+          i += p.data.length;
+          p = p.next;
+        }
+        return ret;
+      }
+      // Consumes a specified amount of bytes or characters from the buffered data.
+    }, {
+      key: "consume",
+      value: function consume(n, hasStrings) {
+        var ret;
+        if (n < this.head.data.length) {
+          ret = this.head.data.slice(0, n);
+          this.head.data = this.head.data.slice(n);
+        } else if (n === this.head.data.length) {
+          ret = this.shift();
+        } else {
+          ret = hasStrings ? this._getString(n) : this._getBuffer(n);
+        }
+        return ret;
+      }
+    }, {
+      key: "first",
+      value: function first() {
+        return this.head.data;
+      }
+      // Consumes a specified amount of characters from the buffered data.
+    }, {
+      key: "_getString",
+      value: function _getString(n) {
+        var p = this.head;
+        var c = 1;
+        var ret = p.data;
+        n -= ret.length;
+        while (p = p.next) {
+          var str = p.data;
+          var nb = n > str.length ? str.length : n;
+          if (nb === str.length) ret += str;
+          else ret += str.slice(0, n);
+          n -= nb;
+          if (n === 0) {
+            if (nb === str.length) {
+              ++c;
+              if (p.next) this.head = p.next;
+              else this.head = this.tail = null;
+            } else {
+              this.head = p;
+              p.data = str.slice(nb);
+            }
+            break;
+          }
+          ++c;
+        }
+        this.length -= c;
+        return ret;
+      }
+      // Consumes a specified amount of bytes from the buffered data.
+    }, {
+      key: "_getBuffer",
+      value: function _getBuffer(n) {
+        var ret = Buffer2.allocUnsafe(n);
+        var p = this.head;
+        var c = 1;
+        p.data.copy(ret);
+        n -= p.data.length;
+        while (p = p.next) {
+          var buf = p.data;
+          var nb = n > buf.length ? buf.length : n;
+          buf.copy(ret, ret.length - n, 0, nb);
+          n -= nb;
+          if (n === 0) {
+            if (nb === buf.length) {
+              ++c;
+              if (p.next) this.head = p.next;
+              else this.head = this.tail = null;
+            } else {
+              this.head = p;
+              p.data = buf.slice(nb);
+            }
+            break;
+          }
+          ++c;
+        }
+        this.length -= c;
+        return ret;
+      }
+      // Make sure the linked list only shows the minimal necessary information.
+    }, {
+      key: custom,
+      value: function value(_, options) {
+        return inspect(this, _objectSpread(_objectSpread({}, options), {}, {
+          // Only inspect one level.
+          depth: 0,
+          // It should not recurse.
+          customInspect: false
+        }));
+      }
+    }]);
+    return BufferList;
+  }();
+  return buffer_list;
+}
+var destroy_1;
+var hasRequiredDestroy;
+function requireDestroy() {
+  if (hasRequiredDestroy) return destroy_1;
+  hasRequiredDestroy = 1;
+  function destroy(err, cb) {
+    var _this = this;
+    var readableDestroyed = this._readableState && this._readableState.destroyed;
+    var writableDestroyed = this._writableState && this._writableState.destroyed;
+    if (readableDestroyed || writableDestroyed) {
+      if (cb) {
+        cb(err);
+      } else if (err) {
+        if (!this._writableState) {
+          process$1.nextTick(emitErrorNT, this, err);
+        } else if (!this._writableState.errorEmitted) {
+          this._writableState.errorEmitted = true;
+          process$1.nextTick(emitErrorNT, this, err);
+        }
+      }
+      return this;
+    }
+    if (this._readableState) {
+      this._readableState.destroyed = true;
+    }
+    if (this._writableState) {
+      this._writableState.destroyed = true;
+    }
+    this._destroy(err || null, function(err2) {
+      if (!cb && err2) {
+        if (!_this._writableState) {
+          process$1.nextTick(emitErrorAndCloseNT, _this, err2);
+        } else if (!_this._writableState.errorEmitted) {
+          _this._writableState.errorEmitted = true;
+          process$1.nextTick(emitErrorAndCloseNT, _this, err2);
+        } else {
+          process$1.nextTick(emitCloseNT, _this);
+        }
+      } else if (cb) {
+        process$1.nextTick(emitCloseNT, _this);
+        cb(err2);
+      } else {
+        process$1.nextTick(emitCloseNT, _this);
+      }
+    });
+    return this;
+  }
+  function emitErrorAndCloseNT(self2, err) {
+    emitErrorNT(self2, err);
+    emitCloseNT(self2);
+  }
+  function emitCloseNT(self2) {
+    if (self2._writableState && !self2._writableState.emitClose) return;
+    if (self2._readableState && !self2._readableState.emitClose) return;
+    self2.emit("close");
+  }
+  function undestroy() {
+    if (this._readableState) {
+      this._readableState.destroyed = false;
+      this._readableState.reading = false;
+      this._readableState.ended = false;
+      this._readableState.endEmitted = false;
+    }
+    if (this._writableState) {
+      this._writableState.destroyed = false;
+      this._writableState.ended = false;
+      this._writableState.ending = false;
+      this._writableState.finalCalled = false;
+      this._writableState.prefinished = false;
+      this._writableState.finished = false;
+      this._writableState.errorEmitted = false;
+    }
+  }
+  function emitErrorNT(self2, err) {
+    self2.emit("error", err);
+  }
+  function errorOrDestroy(stream, err) {
+    var rState = stream._readableState;
+    var wState = stream._writableState;
+    if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);
+    else stream.emit("error", err);
+  }
+  destroy_1 = {
+    destroy,
+    undestroy,
+    errorOrDestroy
+  };
+  return destroy_1;
+}
+var errorsBrowser = {};
+var hasRequiredErrorsBrowser;
+function requireErrorsBrowser() {
+  if (hasRequiredErrorsBrowser) return errorsBrowser;
+  hasRequiredErrorsBrowser = 1;
+  function _inheritsLoose(subClass, superClass) {
+    subClass.prototype = Object.create(superClass.prototype);
+    subClass.prototype.constructor = subClass;
+    subClass.__proto__ = superClass;
+  }
+  var codes = {};
+  function createErrorType(code, message, Base) {
+    if (!Base) {
+      Base = Error;
+    }
+    function getMessage(arg1, arg2, arg3) {
+      if (typeof message === "string") {
+        return message;
+      } else {
+        return message(arg1, arg2, arg3);
+      }
+    }
+    var NodeError = /* @__PURE__ */ function(_Base) {
+      _inheritsLoose(NodeError2, _Base);
+      function NodeError2(arg1, arg2, arg3) {
+        return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
+      }
+      return NodeError2;
+    }(Base);
+    NodeError.prototype.name = Base.name;
+    NodeError.prototype.code = code;
+    codes[code] = NodeError;
+  }
+  function oneOf(expected, thing) {
+    if (Array.isArray(expected)) {
+      var len = expected.length;
+      expected = expected.map(function(i) {
+        return String(i);
+      });
+      if (len > 2) {
+        return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(", "), ", or ") + expected[len - 1];
+      } else if (len === 2) {
+        return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+      } else {
+        return "of ".concat(thing, " ").concat(expected[0]);
+      }
+    } else {
+      return "of ".concat(thing, " ").concat(String(expected));
+    }
+  }
+  function startsWith(str, search, pos) {
+    return str.substr(0, search.length) === search;
+  }
+  function endsWith(str, search, this_len) {
+    if (this_len === void 0 || this_len > str.length) {
+      this_len = str.length;
+    }
+    return str.substring(this_len - search.length, this_len) === search;
+  }
+  function includes(str, search, start) {
+    if (typeof start !== "number") {
+      start = 0;
+    }
+    if (start + search.length > str.length) {
+      return false;
+    } else {
+      return str.indexOf(search, start) !== -1;
+    }
+  }
+  createErrorType("ERR_INVALID_OPT_VALUE", function(name, value) {
+    return 'The value "' + value + '" is invalid for option "' + name + '"';
+  }, TypeError);
+  createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {
+    var determiner;
+    if (typeof expected === "string" && startsWith(expected, "not ")) {
+      determiner = "must not be";
+      expected = expected.replace(/^not /, "");
+    } else {
+      determiner = "must be";
+    }
+    var msg;
+    if (endsWith(name, " argument")) {
+      msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
+    } else {
+      var type = includes(name, ".") ? "property" : "argument";
+      msg = 'The "'.concat(name, '" ').concat(type, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
+    }
+    msg += ". Received type ".concat(typeof actual);
+    return msg;
+  }, TypeError);
+  createErrorType("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
+  createErrorType("ERR_METHOD_NOT_IMPLEMENTED", function(name) {
+    return "The " + name + " method is not implemented";
+  });
+  createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
+  createErrorType("ERR_STREAM_DESTROYED", function(name) {
+    return "Cannot call " + name + " after a stream was destroyed";
+  });
+  createErrorType("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
+  createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
+  createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
+  createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
+  createErrorType("ERR_UNKNOWN_ENCODING", function(arg) {
+    return "Unknown encoding: " + arg;
+  }, TypeError);
+  createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
+  errorsBrowser.codes = codes;
+  return errorsBrowser;
+}
+var state;
+var hasRequiredState;
+function requireState() {
+  if (hasRequiredState) return state;
+  hasRequiredState = 1;
+  var ERR_INVALID_OPT_VALUE = requireErrorsBrowser().codes.ERR_INVALID_OPT_VALUE;
+  function highWaterMarkFrom(options, isDuplex, duplexKey) {
+    return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
+  }
+  function getHighWaterMark(state2, options, duplexKey, isDuplex) {
+    var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+    if (hwm != null) {
+      if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+        var name = isDuplex ? duplexKey : "highWaterMark";
+        throw new ERR_INVALID_OPT_VALUE(name, hwm);
+      }
+      return Math.floor(hwm);
+    }
+    return state2.objectMode ? 16 : 16 * 1024;
+  }
+  state = {
+    getHighWaterMark
+  };
+  return state;
+}
+var _stream_writable;
+var hasRequired_stream_writable;
+function require_stream_writable() {
+  if (hasRequired_stream_writable) return _stream_writable;
+  hasRequired_stream_writable = 1;
+  _stream_writable = Writable;
+  function CorkedRequest(state2) {
+    var _this = this;
+    this.next = null;
+    this.entry = null;
+    this.finish = function() {
+      onCorkedFinish(_this, state2);
+    };
+  }
+  var Duplex;
+  Writable.WritableState = WritableState;
+  var internalUtil = {
+    deprecate: requireBrowser$1()
+  };
+  var Stream = requireStreamBrowser();
+  var Buffer2 = requireDist().Buffer;
+  var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
+  };
+  function _uint8ArrayToBuffer(chunk) {
+    return Buffer2.from(chunk);
+  }
+  function _isUint8Array(obj) {
+    return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
+  }
+  var destroyImpl = requireDestroy();
+  var _require = requireState(), getHighWaterMark = _require.getHighWaterMark;
+  var _require$codes = requireErrorsBrowser().codes, ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED, ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES, ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END, ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
+  var errorOrDestroy = destroyImpl.errorOrDestroy;
+  requireInherits_browser()(Writable, Stream);
+  function nop() {
+  }
+  function WritableState(options, stream, isDuplex) {
+    Duplex = Duplex || require_stream_duplex();
+    options = options || {};
+    if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex;
+    this.objectMode = !!options.objectMode;
+    if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+    this.highWaterMark = getHighWaterMark(this, options, "writableHighWaterMark", isDuplex);
+    this.finalCalled = false;
+    this.needDrain = false;
+    this.ending = false;
+    this.ended = false;
+    this.finished = false;
+    this.destroyed = false;
+    var noDecode = options.decodeStrings === false;
+    this.decodeStrings = !noDecode;
+    this.defaultEncoding = options.defaultEncoding || "utf8";
+    this.length = 0;
+    this.writing = false;
+    this.corked = 0;
+    this.sync = true;
+    this.bufferProcessing = false;
+    this.onwrite = function(er) {
+      onwrite(stream, er);
+    };
+    this.writecb = null;
+    this.writelen = 0;
+    this.bufferedRequest = null;
+    this.lastBufferedRequest = null;
+    this.pendingcb = 0;
+    this.prefinished = false;
+    this.errorEmitted = false;
+    this.emitClose = options.emitClose !== false;
+    this.autoDestroy = !!options.autoDestroy;
+    this.bufferedRequestCount = 0;
+    this.corkedRequestsFree = new CorkedRequest(this);
+  }
+  WritableState.prototype.getBuffer = function getBuffer() {
+    var current = this.bufferedRequest;
+    var out = [];
+    while (current) {
+      out.push(current);
+      current = current.next;
+    }
+    return out;
+  };
+  (function() {
+    try {
+      Object.defineProperty(WritableState.prototype, "buffer", {
+        get: internalUtil.deprecate(function writableStateBufferGetter() {
+          return this.getBuffer();
+        }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
+      });
+    } catch (_) {
+    }
+  })();
+  var realHasInstance;
+  if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
+    realHasInstance = Function.prototype[Symbol.hasInstance];
+    Object.defineProperty(Writable, Symbol.hasInstance, {
+      value: function value(object) {
+        if (realHasInstance.call(this, object)) return true;
+        if (this !== Writable) return false;
+        return object && object._writableState instanceof WritableState;
+      }
+    });
+  } else {
+    realHasInstance = function realHasInstance2(object) {
+      return object instanceof this;
+    };
+  }
+  function Writable(options) {
+    Duplex = Duplex || require_stream_duplex();
+    var isDuplex = this instanceof Duplex;
+    if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
+    this._writableState = new WritableState(options, this, isDuplex);
+    this.writable = true;
+    if (options) {
+      if (typeof options.write === "function") this._write = options.write;
+      if (typeof options.writev === "function") this._writev = options.writev;
+      if (typeof options.destroy === "function") this._destroy = options.destroy;
+      if (typeof options.final === "function") this._final = options.final;
+    }
+    Stream.call(this);
+  }
+  Writable.prototype.pipe = function() {
+    errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
+  };
+  function writeAfterEnd(stream, cb) {
+    var er = new ERR_STREAM_WRITE_AFTER_END();
+    errorOrDestroy(stream, er);
+    process$1.nextTick(cb, er);
+  }
+  function validChunk(stream, state2, chunk, cb) {
+    var er;
+    if (chunk === null) {
+      er = new ERR_STREAM_NULL_VALUES();
+    } else if (typeof chunk !== "string" && !state2.objectMode) {
+      er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk);
+    }
+    if (er) {
+      errorOrDestroy(stream, er);
+      process$1.nextTick(cb, er);
+      return false;
+    }
+    return true;
+  }
+  Writable.prototype.write = function(chunk, encoding, cb) {
+    var state2 = this._writableState;
+    var ret = false;
+    var isBuf = !state2.objectMode && _isUint8Array(chunk);
+    if (isBuf && !Buffer2.isBuffer(chunk)) {
+      chunk = _uint8ArrayToBuffer(chunk);
+    }
+    if (typeof encoding === "function") {
+      cb = encoding;
+      encoding = null;
+    }
+    if (isBuf) encoding = "buffer";
+    else if (!encoding) encoding = state2.defaultEncoding;
+    if (typeof cb !== "function") cb = nop;
+    if (state2.ending) writeAfterEnd(this, cb);
+    else if (isBuf || validChunk(this, state2, chunk, cb)) {
+      state2.pendingcb++;
+      ret = writeOrBuffer(this, state2, isBuf, chunk, encoding, cb);
+    }
+    return ret;
+  };
+  Writable.prototype.cork = function() {
+    this._writableState.corked++;
+  };
+  Writable.prototype.uncork = function() {
+    var state2 = this._writableState;
+    if (state2.corked) {
+      state2.corked--;
+      if (!state2.writing && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) clearBuffer(this, state2);
+    }
+  };
+  Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+    if (typeof encoding === "string") encoding = encoding.toLowerCase();
+    if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
+    this._writableState.defaultEncoding = encoding;
+    return this;
+  };
+  Object.defineProperty(Writable.prototype, "writableBuffer", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      return this._writableState && this._writableState.getBuffer();
+    }
+  });
+  function decodeChunk(state2, chunk, encoding) {
+    if (!state2.objectMode && state2.decodeStrings !== false && typeof chunk === "string") {
+      chunk = Buffer2.from(chunk, encoding);
+    }
+    return chunk;
+  }
+  Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      return this._writableState.highWaterMark;
+    }
+  });
+  function writeOrBuffer(stream, state2, isBuf, chunk, encoding, cb) {
+    if (!isBuf) {
+      var newChunk = decodeChunk(state2, chunk, encoding);
+      if (chunk !== newChunk) {
+        isBuf = true;
+        encoding = "buffer";
+        chunk = newChunk;
+      }
+    }
+    var len = state2.objectMode ? 1 : chunk.length;
+    state2.length += len;
+    var ret = state2.length < state2.highWaterMark;
+    if (!ret) state2.needDrain = true;
+    if (state2.writing || state2.corked) {
+      var last = state2.lastBufferedRequest;
+      state2.lastBufferedRequest = {
+        chunk,
+        encoding,
+        isBuf,
+        callback: cb,
+        next: null
+      };
+      if (last) {
+        last.next = state2.lastBufferedRequest;
+      } else {
+        state2.bufferedRequest = state2.lastBufferedRequest;
+      }
+      state2.bufferedRequestCount += 1;
+    } else {
+      doWrite(stream, state2, false, len, chunk, encoding, cb);
+    }
+    return ret;
+  }
+  function doWrite(stream, state2, writev, len, chunk, encoding, cb) {
+    state2.writelen = len;
+    state2.writecb = cb;
+    state2.writing = true;
+    state2.sync = true;
+    if (state2.destroyed) state2.onwrite(new ERR_STREAM_DESTROYED("write"));
+    else if (writev) stream._writev(chunk, state2.onwrite);
+    else stream._write(chunk, encoding, state2.onwrite);
+    state2.sync = false;
+  }
+  function onwriteError(stream, state2, sync, er, cb) {
+    --state2.pendingcb;
+    if (sync) {
+      process$1.nextTick(cb, er);
+      process$1.nextTick(finishMaybe, stream, state2);
+      stream._writableState.errorEmitted = true;
+      errorOrDestroy(stream, er);
+    } else {
+      cb(er);
+      stream._writableState.errorEmitted = true;
+      errorOrDestroy(stream, er);
+      finishMaybe(stream, state2);
+    }
+  }
+  function onwriteStateUpdate(state2) {
+    state2.writing = false;
+    state2.writecb = null;
+    state2.length -= state2.writelen;
+    state2.writelen = 0;
+  }
+  function onwrite(stream, er) {
+    var state2 = stream._writableState;
+    var sync = state2.sync;
+    var cb = state2.writecb;
+    if (typeof cb !== "function") throw new ERR_MULTIPLE_CALLBACK();
+    onwriteStateUpdate(state2);
+    if (er) onwriteError(stream, state2, sync, er, cb);
+    else {
+      var finished = needFinish(state2) || stream.destroyed;
+      if (!finished && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) {
+        clearBuffer(stream, state2);
+      }
+      if (sync) {
+        process$1.nextTick(afterWrite, stream, state2, finished, cb);
+      } else {
+        afterWrite(stream, state2, finished, cb);
+      }
+    }
+  }
+  function afterWrite(stream, state2, finished, cb) {
+    if (!finished) onwriteDrain(stream, state2);
+    state2.pendingcb--;
+    cb();
+    finishMaybe(stream, state2);
+  }
+  function onwriteDrain(stream, state2) {
+    if (state2.length === 0 && state2.needDrain) {
+      state2.needDrain = false;
+      stream.emit("drain");
+    }
+  }
+  function clearBuffer(stream, state2) {
+    state2.bufferProcessing = true;
+    var entry = state2.bufferedRequest;
+    if (stream._writev && entry && entry.next) {
+      var l = state2.bufferedRequestCount;
+      var buffer = new Array(l);
+      var holder = state2.corkedRequestsFree;
+      holder.entry = entry;
+      var count = 0;
+      var allBuffers = true;
+      while (entry) {
+        buffer[count] = entry;
+        if (!entry.isBuf) allBuffers = false;
+        entry = entry.next;
+        count += 1;
+      }
+      buffer.allBuffers = allBuffers;
+      doWrite(stream, state2, true, state2.length, buffer, "", holder.finish);
+      state2.pendingcb++;
+      state2.lastBufferedRequest = null;
+      if (holder.next) {
+        state2.corkedRequestsFree = holder.next;
+        holder.next = null;
+      } else {
+        state2.corkedRequestsFree = new CorkedRequest(state2);
+      }
+      state2.bufferedRequestCount = 0;
+    } else {
+      while (entry) {
+        var chunk = entry.chunk;
+        var encoding = entry.encoding;
+        var cb = entry.callback;
+        var len = state2.objectMode ? 1 : chunk.length;
+        doWrite(stream, state2, false, len, chunk, encoding, cb);
+        entry = entry.next;
+        state2.bufferedRequestCount--;
+        if (state2.writing) {
+          break;
+        }
+      }
+      if (entry === null) state2.lastBufferedRequest = null;
+    }
+    state2.bufferedRequest = entry;
+    state2.bufferProcessing = false;
+  }
+  Writable.prototype._write = function(chunk, encoding, cb) {
+    cb(new ERR_METHOD_NOT_IMPLEMENTED("_write()"));
+  };
+  Writable.prototype._writev = null;
+  Writable.prototype.end = function(chunk, encoding, cb) {
+    var state2 = this._writableState;
+    if (typeof chunk === "function") {
+      cb = chunk;
+      chunk = null;
+      encoding = null;
+    } else if (typeof encoding === "function") {
+      cb = encoding;
+      encoding = null;
+    }
+    if (chunk !== null && chunk !== void 0) this.write(chunk, encoding);
+    if (state2.corked) {
+      state2.corked = 1;
+      this.uncork();
+    }
+    if (!state2.ending) endWritable(this, state2, cb);
+    return this;
+  };
+  Object.defineProperty(Writable.prototype, "writableLength", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      return this._writableState.length;
+    }
+  });
+  function needFinish(state2) {
+    return state2.ending && state2.length === 0 && state2.bufferedRequest === null && !state2.finished && !state2.writing;
+  }
+  function callFinal(stream, state2) {
+    stream._final(function(err) {
+      state2.pendingcb--;
+      if (err) {
+        errorOrDestroy(stream, err);
+      }
+      state2.prefinished = true;
+      stream.emit("prefinish");
+      finishMaybe(stream, state2);
+    });
+  }
+  function prefinish(stream, state2) {
+    if (!state2.prefinished && !state2.finalCalled) {
+      if (typeof stream._final === "function" && !state2.destroyed) {
+        state2.pendingcb++;
+        state2.finalCalled = true;
+        process$1.nextTick(callFinal, stream, state2);
+      } else {
+        state2.prefinished = true;
+        stream.emit("prefinish");
+      }
+    }
+  }
+  function finishMaybe(stream, state2) {
+    var need = needFinish(state2);
+    if (need) {
+      prefinish(stream, state2);
+      if (state2.pendingcb === 0) {
+        state2.finished = true;
+        stream.emit("finish");
+        if (state2.autoDestroy) {
+          var rState = stream._readableState;
+          if (!rState || rState.autoDestroy && rState.endEmitted) {
+            stream.destroy();
+          }
+        }
+      }
+    }
+    return need;
+  }
+  function endWritable(stream, state2, cb) {
+    state2.ending = true;
+    finishMaybe(stream, state2);
+    if (cb) {
+      if (state2.finished) process$1.nextTick(cb);
+      else stream.once("finish", cb);
+    }
+    state2.ended = true;
+    stream.writable = false;
+  }
+  function onCorkedFinish(corkReq, state2, err) {
+    var entry = corkReq.entry;
+    corkReq.entry = null;
+    while (entry) {
+      var cb = entry.callback;
+      state2.pendingcb--;
+      cb(err);
+      entry = entry.next;
+    }
+    state2.corkedRequestsFree.next = corkReq;
+  }
+  Object.defineProperty(Writable.prototype, "destroyed", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      if (this._writableState === void 0) {
+        return false;
+      }
+      return this._writableState.destroyed;
+    },
+    set: function set(value) {
+      if (!this._writableState) {
+        return;
+      }
+      this._writableState.destroyed = value;
+    }
+  });
+  Writable.prototype.destroy = destroyImpl.destroy;
+  Writable.prototype._undestroy = destroyImpl.undestroy;
+  Writable.prototype._destroy = function(err, cb) {
+    cb(err);
+  };
+  return _stream_writable;
+}
+var _stream_duplex;
+var hasRequired_stream_duplex;
+function require_stream_duplex() {
+  if (hasRequired_stream_duplex) return _stream_duplex;
+  hasRequired_stream_duplex = 1;
+  var objectKeys = Object.keys || function(obj) {
+    var keys2 = [];
+    for (var key in obj) keys2.push(key);
+    return keys2;
+  };
+  _stream_duplex = Duplex;
+  var Readable = require_stream_readable();
+  var Writable = require_stream_writable();
+  requireInherits_browser()(Duplex, Readable);
+  {
+    var keys = objectKeys(Writable.prototype);
+    for (var v = 0; v < keys.length; v++) {
+      var method = keys[v];
+      if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+    }
+  }
+  function Duplex(options) {
+    if (!(this instanceof Duplex)) return new Duplex(options);
+    Readable.call(this, options);
+    Writable.call(this, options);
+    this.allowHalfOpen = true;
+    if (options) {
+      if (options.readable === false) this.readable = false;
+      if (options.writable === false) this.writable = false;
+      if (options.allowHalfOpen === false) {
+        this.allowHalfOpen = false;
+        this.once("end", onend);
+      }
+    }
+  }
+  Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      return this._writableState.highWaterMark;
+    }
+  });
+  Object.defineProperty(Duplex.prototype, "writableBuffer", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      return this._writableState && this._writableState.getBuffer();
+    }
+  });
+  Object.defineProperty(Duplex.prototype, "writableLength", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      return this._writableState.length;
+    }
+  });
+  function onend() {
+    if (this._writableState.ended) return;
+    process$1.nextTick(onEndNT, this);
+  }
+  function onEndNT(self2) {
+    self2.end();
+  }
+  Object.defineProperty(Duplex.prototype, "destroyed", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      if (this._readableState === void 0 || this._writableState === void 0) {
+        return false;
+      }
+      return this._readableState.destroyed && this._writableState.destroyed;
+    },
+    set: function set(value) {
+      if (this._readableState === void 0 || this._writableState === void 0) {
+        return;
+      }
+      this._readableState.destroyed = value;
+      this._writableState.destroyed = value;
+    }
+  });
+  return _stream_duplex;
+}
+var endOfStream;
+var hasRequiredEndOfStream;
+function requireEndOfStream() {
+  if (hasRequiredEndOfStream) return endOfStream;
+  hasRequiredEndOfStream = 1;
+  var ERR_STREAM_PREMATURE_CLOSE = requireErrorsBrowser().codes.ERR_STREAM_PREMATURE_CLOSE;
+  function once(callback) {
+    var called = false;
+    return function() {
+      if (called) return;
+      called = true;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      callback.apply(this, args);
+    };
+  }
+  function noop() {
+  }
+  function isRequest(stream) {
+    return stream.setHeader && typeof stream.abort === "function";
+  }
+  function eos(stream, opts, callback) {
+    if (typeof opts === "function") return eos(stream, null, opts);
+    if (!opts) opts = {};
+    callback = once(callback || noop);
+    var readable = opts.readable || opts.readable !== false && stream.readable;
+    var writable = opts.writable || opts.writable !== false && stream.writable;
+    var onlegacyfinish = function onlegacyfinish2() {
+      if (!stream.writable) onfinish();
+    };
+    var writableEnded = stream._writableState && stream._writableState.finished;
+    var onfinish = function onfinish2() {
+      writable = false;
+      writableEnded = true;
+      if (!readable) callback.call(stream);
+    };
+    var readableEnded = stream._readableState && stream._readableState.endEmitted;
+    var onend = function onend2() {
+      readable = false;
+      readableEnded = true;
+      if (!writable) callback.call(stream);
+    };
+    var onerror = function onerror2(err) {
+      callback.call(stream, err);
+    };
+    var onclose = function onclose2() {
+      var err;
+      if (readable && !readableEnded) {
+        if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
+        return callback.call(stream, err);
+      }
+      if (writable && !writableEnded) {
+        if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
+        return callback.call(stream, err);
+      }
+    };
+    var onrequest = function onrequest2() {
+      stream.req.on("finish", onfinish);
+    };
+    if (isRequest(stream)) {
+      stream.on("complete", onfinish);
+      stream.on("abort", onclose);
+      if (stream.req) onrequest();
+      else stream.on("request", onrequest);
+    } else if (writable && !stream._writableState) {
+      stream.on("end", onlegacyfinish);
+      stream.on("close", onlegacyfinish);
+    }
+    stream.on("end", onend);
+    stream.on("finish", onfinish);
+    if (opts.error !== false) stream.on("error", onerror);
+    stream.on("close", onclose);
+    return function() {
+      stream.removeListener("complete", onfinish);
+      stream.removeListener("abort", onclose);
+      stream.removeListener("request", onrequest);
+      if (stream.req) stream.req.removeListener("finish", onfinish);
+      stream.removeListener("end", onlegacyfinish);
+      stream.removeListener("close", onlegacyfinish);
+      stream.removeListener("finish", onfinish);
+      stream.removeListener("end", onend);
+      stream.removeListener("error", onerror);
+      stream.removeListener("close", onclose);
+    };
+  }
+  endOfStream = eos;
+  return endOfStream;
+}
+var async_iterator;
+var hasRequiredAsync_iterator;
+function requireAsync_iterator() {
+  if (hasRequiredAsync_iterator) return async_iterator;
+  hasRequiredAsync_iterator = 1;
+  var _Object$setPrototypeO;
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return typeof key === "symbol" ? key : String(key);
+  }
+  function _toPrimitive(input, hint) {
+    if (typeof input !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint);
+      if (typeof res !== "object") return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  var finished = requireEndOfStream();
+  var kLastResolve = Symbol("lastResolve");
+  var kLastReject = Symbol("lastReject");
+  var kError = Symbol("error");
+  var kEnded = Symbol("ended");
+  var kLastPromise = Symbol("lastPromise");
+  var kHandlePromise = Symbol("handlePromise");
+  var kStream = Symbol("stream");
+  function createIterResult(value, done) {
+    return {
+      value,
+      done
+    };
+  }
+  function readAndResolve(iter) {
+    var resolve = iter[kLastResolve];
+    if (resolve !== null) {
+      var data = iter[kStream].read();
+      if (data !== null) {
+        iter[kLastPromise] = null;
+        iter[kLastResolve] = null;
+        iter[kLastReject] = null;
+        resolve(createIterResult(data, false));
+      }
+    }
+  }
+  function onReadable(iter) {
+    process$1.nextTick(readAndResolve, iter);
+  }
+  function wrapForNext(lastPromise, iter) {
+    return function(resolve, reject) {
+      lastPromise.then(function() {
+        if (iter[kEnded]) {
+          resolve(createIterResult(void 0, true));
+          return;
+        }
+        iter[kHandlePromise](resolve, reject);
+      }, reject);
+    };
+  }
+  var AsyncIteratorPrototype = Object.getPrototypeOf(function() {
+  });
+  var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
+    get stream() {
+      return this[kStream];
+    },
+    next: function next() {
+      var _this = this;
+      var error = this[kError];
+      if (error !== null) {
+        return Promise.reject(error);
+      }
+      if (this[kEnded]) {
+        return Promise.resolve(createIterResult(void 0, true));
+      }
+      if (this[kStream].destroyed) {
+        return new Promise(function(resolve, reject) {
+          process$1.nextTick(function() {
+            if (_this[kError]) {
+              reject(_this[kError]);
+            } else {
+              resolve(createIterResult(void 0, true));
+            }
+          });
+        });
+      }
+      var lastPromise = this[kLastPromise];
+      var promise;
+      if (lastPromise) {
+        promise = new Promise(wrapForNext(lastPromise, this));
+      } else {
+        var data = this[kStream].read();
+        if (data !== null) {
+          return Promise.resolve(createIterResult(data, false));
+        }
+        promise = new Promise(this[kHandlePromise]);
+      }
+      this[kLastPromise] = promise;
+      return promise;
+    }
+  }, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function() {
+    return this;
+  }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
+    var _this2 = this;
+    return new Promise(function(resolve, reject) {
+      _this2[kStream].destroy(null, function(err) {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(createIterResult(void 0, true));
+      });
+    });
+  }), _Object$setPrototypeO), AsyncIteratorPrototype);
+  var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator2(stream) {
+    var _Object$create;
+    var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
+      value: stream,
+      writable: true
+    }), _defineProperty(_Object$create, kLastResolve, {
+      value: null,
+      writable: true
+    }), _defineProperty(_Object$create, kLastReject, {
+      value: null,
+      writable: true
+    }), _defineProperty(_Object$create, kError, {
+      value: null,
+      writable: true
+    }), _defineProperty(_Object$create, kEnded, {
+      value: stream._readableState.endEmitted,
+      writable: true
+    }), _defineProperty(_Object$create, kHandlePromise, {
+      value: function value(resolve, reject) {
+        var data = iterator[kStream].read();
+        if (data) {
+          iterator[kLastPromise] = null;
+          iterator[kLastResolve] = null;
+          iterator[kLastReject] = null;
+          resolve(createIterResult(data, false));
+        } else {
+          iterator[kLastResolve] = resolve;
+          iterator[kLastReject] = reject;
+        }
+      },
+      writable: true
+    }), _Object$create));
+    iterator[kLastPromise] = null;
+    finished(stream, function(err) {
+      if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+        var reject = iterator[kLastReject];
+        if (reject !== null) {
+          iterator[kLastPromise] = null;
+          iterator[kLastResolve] = null;
+          iterator[kLastReject] = null;
+          reject(err);
+        }
+        iterator[kError] = err;
+        return;
+      }
+      var resolve = iterator[kLastResolve];
+      if (resolve !== null) {
+        iterator[kLastPromise] = null;
+        iterator[kLastResolve] = null;
+        iterator[kLastReject] = null;
+        resolve(createIterResult(void 0, true));
+      }
+      iterator[kEnded] = true;
+    });
+    stream.on("readable", onReadable.bind(null, iterator));
+    return iterator;
+  };
+  async_iterator = createReadableStreamAsyncIterator;
+  return async_iterator;
+}
+var fromBrowser;
+var hasRequiredFromBrowser;
+function requireFromBrowser() {
+  if (hasRequiredFromBrowser) return fromBrowser;
+  hasRequiredFromBrowser = 1;
+  fromBrowser = function() {
+    throw new Error("Readable.from is not available in the browser");
+  };
+  return fromBrowser;
+}
+var _stream_readable;
+var hasRequired_stream_readable;
+function require_stream_readable() {
+  if (hasRequired_stream_readable) return _stream_readable;
+  hasRequired_stream_readable = 1;
+  _stream_readable = Readable;
+  var Duplex;
+  Readable.ReadableState = ReadableState;
+  requireEvents().EventEmitter;
+  var EElistenerCount = function EElistenerCount2(emitter, type) {
+    return emitter.listeners(type).length;
+  };
+  var Stream = requireStreamBrowser();
+  var Buffer2 = requireDist().Buffer;
+  var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
+  };
+  function _uint8ArrayToBuffer(chunk) {
+    return Buffer2.from(chunk);
+  }
+  function _isUint8Array(obj) {
+    return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
+  }
+  var debugUtil = requireUtil();
+  var debug;
+  if (debugUtil && debugUtil.debuglog) {
+    debug = debugUtil.debuglog("stream");
+  } else {
+    debug = function debug2() {
+    };
+  }
+  var BufferList = requireBuffer_list();
+  var destroyImpl = requireDestroy();
+  var _require = requireState(), getHighWaterMark = _require.getHighWaterMark;
+  var _require$codes = requireErrorsBrowser().codes, ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
+  var StringDecoder;
+  var createReadableStreamAsyncIterator;
+  var from;
+  requireInherits_browser()(Readable, Stream);
+  var errorOrDestroy = destroyImpl.errorOrDestroy;
+  var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
+  function prependListener(emitter, event, fn) {
+    if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
+    if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
+    else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);
+    else emitter._events[event] = [fn, emitter._events[event]];
+  }
+  function ReadableState(options, stream, isDuplex) {
+    Duplex = Duplex || require_stream_duplex();
+    options = options || {};
+    if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex;
+    this.objectMode = !!options.objectMode;
+    if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
+    this.highWaterMark = getHighWaterMark(this, options, "readableHighWaterMark", isDuplex);
+    this.buffer = new BufferList();
+    this.length = 0;
+    this.pipes = null;
+    this.pipesCount = 0;
+    this.flowing = null;
+    this.ended = false;
+    this.endEmitted = false;
+    this.reading = false;
+    this.sync = true;
+    this.needReadable = false;
+    this.emittedReadable = false;
+    this.readableListening = false;
+    this.resumeScheduled = false;
+    this.paused = true;
+    this.emitClose = options.emitClose !== false;
+    this.autoDestroy = !!options.autoDestroy;
+    this.destroyed = false;
+    this.defaultEncoding = options.defaultEncoding || "utf8";
+    this.awaitDrain = 0;
+    this.readingMore = false;
+    this.decoder = null;
+    this.encoding = null;
+    if (options.encoding) {
+      if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder;
+      this.decoder = new StringDecoder(options.encoding);
+      this.encoding = options.encoding;
+    }
+  }
+  function Readable(options) {
+    Duplex = Duplex || require_stream_duplex();
+    if (!(this instanceof Readable)) return new Readable(options);
+    var isDuplex = this instanceof Duplex;
+    this._readableState = new ReadableState(options, this, isDuplex);
+    this.readable = true;
+    if (options) {
+      if (typeof options.read === "function") this._read = options.read;
+      if (typeof options.destroy === "function") this._destroy = options.destroy;
+    }
+    Stream.call(this);
+  }
+  Object.defineProperty(Readable.prototype, "destroyed", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      if (this._readableState === void 0) {
+        return false;
+      }
+      return this._readableState.destroyed;
+    },
+    set: function set(value) {
+      if (!this._readableState) {
+        return;
+      }
+      this._readableState.destroyed = value;
+    }
+  });
+  Readable.prototype.destroy = destroyImpl.destroy;
+  Readable.prototype._undestroy = destroyImpl.undestroy;
+  Readable.prototype._destroy = function(err, cb) {
+    cb(err);
+  };
+  Readable.prototype.push = function(chunk, encoding) {
+    var state2 = this._readableState;
+    var skipChunkCheck;
+    if (!state2.objectMode) {
+      if (typeof chunk === "string") {
+        encoding = encoding || state2.defaultEncoding;
+        if (encoding !== state2.encoding) {
+          chunk = Buffer2.from(chunk, encoding);
+          encoding = "";
+        }
+        skipChunkCheck = true;
+      }
+    } else {
+      skipChunkCheck = true;
+    }
+    return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+  };
+  Readable.prototype.unshift = function(chunk) {
+    return readableAddChunk(this, chunk, null, true, false);
+  };
+  function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+    debug("readableAddChunk", chunk);
+    var state2 = stream._readableState;
+    if (chunk === null) {
+      state2.reading = false;
+      onEofChunk(stream, state2);
+    } else {
+      var er;
+      if (!skipChunkCheck) er = chunkInvalid(state2, chunk);
+      if (er) {
+        errorOrDestroy(stream, er);
+      } else if (state2.objectMode || chunk && chunk.length > 0) {
+        if (typeof chunk !== "string" && !state2.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
+          chunk = _uint8ArrayToBuffer(chunk);
+        }
+        if (addToFront) {
+          if (state2.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
+          else addChunk(stream, state2, chunk, true);
+        } else if (state2.ended) {
+          errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
+        } else if (state2.destroyed) {
+          return false;
+        } else {
+          state2.reading = false;
+          if (state2.decoder && !encoding) {
+            chunk = state2.decoder.write(chunk);
+            if (state2.objectMode || chunk.length !== 0) addChunk(stream, state2, chunk, false);
+            else maybeReadMore(stream, state2);
+          } else {
+            addChunk(stream, state2, chunk, false);
+          }
+        }
+      } else if (!addToFront) {
+        state2.reading = false;
+        maybeReadMore(stream, state2);
+      }
+    }
+    return !state2.ended && (state2.length < state2.highWaterMark || state2.length === 0);
+  }
+  function addChunk(stream, state2, chunk, addToFront) {
+    if (state2.flowing && state2.length === 0 && !state2.sync) {
+      state2.awaitDrain = 0;
+      stream.emit("data", chunk);
+    } else {
+      state2.length += state2.objectMode ? 1 : chunk.length;
+      if (addToFront) state2.buffer.unshift(chunk);
+      else state2.buffer.push(chunk);
+      if (state2.needReadable) emitReadable(stream);
+    }
+    maybeReadMore(stream, state2);
+  }
+  function chunkInvalid(state2, chunk) {
+    var er;
+    if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state2.objectMode) {
+      er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
+    }
+    return er;
+  }
+  Readable.prototype.isPaused = function() {
+    return this._readableState.flowing === false;
+  };
+  Readable.prototype.setEncoding = function(enc) {
+    if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder;
+    var decoder = new StringDecoder(enc);
+    this._readableState.decoder = decoder;
+    this._readableState.encoding = this._readableState.decoder.encoding;
+    var p = this._readableState.buffer.head;
+    var content = "";
+    while (p !== null) {
+      content += decoder.write(p.data);
+      p = p.next;
+    }
+    this._readableState.buffer.clear();
+    if (content !== "") this._readableState.buffer.push(content);
+    this._readableState.length = content.length;
+    return this;
+  };
+  var MAX_HWM = 1073741824;
+  function computeNewHighWaterMark(n) {
+    if (n >= MAX_HWM) {
+      n = MAX_HWM;
+    } else {
+      n--;
+      n |= n >>> 1;
+      n |= n >>> 2;
+      n |= n >>> 4;
+      n |= n >>> 8;
+      n |= n >>> 16;
+      n++;
+    }
+    return n;
+  }
+  function howMuchToRead(n, state2) {
+    if (n <= 0 || state2.length === 0 && state2.ended) return 0;
+    if (state2.objectMode) return 1;
+    if (n !== n) {
+      if (state2.flowing && state2.length) return state2.buffer.head.data.length;
+      else return state2.length;
+    }
+    if (n > state2.highWaterMark) state2.highWaterMark = computeNewHighWaterMark(n);
+    if (n <= state2.length) return n;
+    if (!state2.ended) {
+      state2.needReadable = true;
+      return 0;
+    }
+    return state2.length;
+  }
+  Readable.prototype.read = function(n) {
+    debug("read", n);
+    n = parseInt(n, 10);
+    var state2 = this._readableState;
+    var nOrig = n;
+    if (n !== 0) state2.emittedReadable = false;
+    if (n === 0 && state2.needReadable && ((state2.highWaterMark !== 0 ? state2.length >= state2.highWaterMark : state2.length > 0) || state2.ended)) {
+      debug("read: emitReadable", state2.length, state2.ended);
+      if (state2.length === 0 && state2.ended) endReadable(this);
+      else emitReadable(this);
+      return null;
+    }
+    n = howMuchToRead(n, state2);
+    if (n === 0 && state2.ended) {
+      if (state2.length === 0) endReadable(this);
+      return null;
+    }
+    var doRead = state2.needReadable;
+    debug("need readable", doRead);
+    if (state2.length === 0 || state2.length - n < state2.highWaterMark) {
+      doRead = true;
+      debug("length less than watermark", doRead);
+    }
+    if (state2.ended || state2.reading) {
+      doRead = false;
+      debug("reading or ended", doRead);
+    } else if (doRead) {
+      debug("do read");
+      state2.reading = true;
+      state2.sync = true;
+      if (state2.length === 0) state2.needReadable = true;
+      this._read(state2.highWaterMark);
+      state2.sync = false;
+      if (!state2.reading) n = howMuchToRead(nOrig, state2);
+    }
+    var ret;
+    if (n > 0) ret = fromList(n, state2);
+    else ret = null;
+    if (ret === null) {
+      state2.needReadable = state2.length <= state2.highWaterMark;
+      n = 0;
+    } else {
+      state2.length -= n;
+      state2.awaitDrain = 0;
+    }
+    if (state2.length === 0) {
+      if (!state2.ended) state2.needReadable = true;
+      if (nOrig !== n && state2.ended) endReadable(this);
+    }
+    if (ret !== null) this.emit("data", ret);
+    return ret;
+  };
+  function onEofChunk(stream, state2) {
+    debug("onEofChunk");
+    if (state2.ended) return;
+    if (state2.decoder) {
+      var chunk = state2.decoder.end();
+      if (chunk && chunk.length) {
+        state2.buffer.push(chunk);
+        state2.length += state2.objectMode ? 1 : chunk.length;
+      }
+    }
+    state2.ended = true;
+    if (state2.sync) {
+      emitReadable(stream);
+    } else {
+      state2.needReadable = false;
+      if (!state2.emittedReadable) {
+        state2.emittedReadable = true;
+        emitReadable_(stream);
+      }
+    }
+  }
+  function emitReadable(stream) {
+    var state2 = stream._readableState;
+    debug("emitReadable", state2.needReadable, state2.emittedReadable);
+    state2.needReadable = false;
+    if (!state2.emittedReadable) {
+      debug("emitReadable", state2.flowing);
+      state2.emittedReadable = true;
+      process$1.nextTick(emitReadable_, stream);
+    }
+  }
+  function emitReadable_(stream) {
+    var state2 = stream._readableState;
+    debug("emitReadable_", state2.destroyed, state2.length, state2.ended);
+    if (!state2.destroyed && (state2.length || state2.ended)) {
+      stream.emit("readable");
+      state2.emittedReadable = false;
+    }
+    state2.needReadable = !state2.flowing && !state2.ended && state2.length <= state2.highWaterMark;
+    flow(stream);
+  }
+  function maybeReadMore(stream, state2) {
+    if (!state2.readingMore) {
+      state2.readingMore = true;
+      process$1.nextTick(maybeReadMore_, stream, state2);
+    }
+  }
+  function maybeReadMore_(stream, state2) {
+    while (!state2.reading && !state2.ended && (state2.length < state2.highWaterMark || state2.flowing && state2.length === 0)) {
+      var len = state2.length;
+      debug("maybeReadMore read 0");
+      stream.read(0);
+      if (len === state2.length)
+        break;
+    }
+    state2.readingMore = false;
+  }
+  Readable.prototype._read = function(n) {
+    errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED("_read()"));
+  };
+  Readable.prototype.pipe = function(dest, pipeOpts) {
+    var src = this;
+    var state2 = this._readableState;
+    switch (state2.pipesCount) {
+      case 0:
+        state2.pipes = dest;
+        break;
+      case 1:
+        state2.pipes = [state2.pipes, dest];
+        break;
+      default:
+        state2.pipes.push(dest);
+        break;
+    }
+    state2.pipesCount += 1;
+    debug("pipe count=%d opts=%j", state2.pipesCount, pipeOpts);
+    var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process$1.stdout && dest !== process$1.stderr;
+    var endFn = doEnd ? onend : unpipe;
+    if (state2.endEmitted) process$1.nextTick(endFn);
+    else src.once("end", endFn);
+    dest.on("unpipe", onunpipe);
+    function onunpipe(readable, unpipeInfo) {
+      debug("onunpipe");
+      if (readable === src) {
+        if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+          unpipeInfo.hasUnpiped = true;
+          cleanup();
+        }
+      }
+    }
+    function onend() {
+      debug("onend");
+      dest.end();
+    }
+    var ondrain = pipeOnDrain(src);
+    dest.on("drain", ondrain);
+    var cleanedUp = false;
+    function cleanup() {
+      debug("cleanup");
+      dest.removeListener("close", onclose);
+      dest.removeListener("finish", onfinish);
+      dest.removeListener("drain", ondrain);
+      dest.removeListener("error", onerror);
+      dest.removeListener("unpipe", onunpipe);
+      src.removeListener("end", onend);
+      src.removeListener("end", unpipe);
+      src.removeListener("data", ondata);
+      cleanedUp = true;
+      if (state2.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+    }
+    src.on("data", ondata);
+    function ondata(chunk) {
+      debug("ondata");
+      var ret = dest.write(chunk);
+      debug("dest.write", ret);
+      if (ret === false) {
+        if ((state2.pipesCount === 1 && state2.pipes === dest || state2.pipesCount > 1 && indexOf(state2.pipes, dest) !== -1) && !cleanedUp) {
+          debug("false write response, pause", state2.awaitDrain);
+          state2.awaitDrain++;
+        }
+        src.pause();
+      }
+    }
+    function onerror(er) {
+      debug("onerror", er);
+      unpipe();
+      dest.removeListener("error", onerror);
+      if (EElistenerCount(dest, "error") === 0) errorOrDestroy(dest, er);
+    }
+    prependListener(dest, "error", onerror);
+    function onclose() {
+      dest.removeListener("finish", onfinish);
+      unpipe();
+    }
+    dest.once("close", onclose);
+    function onfinish() {
+      debug("onfinish");
+      dest.removeListener("close", onclose);
+      unpipe();
+    }
+    dest.once("finish", onfinish);
+    function unpipe() {
+      debug("unpipe");
+      src.unpipe(dest);
+    }
+    dest.emit("pipe", src);
+    if (!state2.flowing) {
+      debug("pipe resume");
+      src.resume();
+    }
+    return dest;
+  };
+  function pipeOnDrain(src) {
+    return function pipeOnDrainFunctionResult() {
+      var state2 = src._readableState;
+      debug("pipeOnDrain", state2.awaitDrain);
+      if (state2.awaitDrain) state2.awaitDrain--;
+      if (state2.awaitDrain === 0 && EElistenerCount(src, "data")) {
+        state2.flowing = true;
+        flow(src);
+      }
+    };
+  }
+  Readable.prototype.unpipe = function(dest) {
+    var state2 = this._readableState;
+    var unpipeInfo = {
+      hasUnpiped: false
+    };
+    if (state2.pipesCount === 0) return this;
+    if (state2.pipesCount === 1) {
+      if (dest && dest !== state2.pipes) return this;
+      if (!dest) dest = state2.pipes;
+      state2.pipes = null;
+      state2.pipesCount = 0;
+      state2.flowing = false;
+      if (dest) dest.emit("unpipe", this, unpipeInfo);
+      return this;
+    }
+    if (!dest) {
+      var dests = state2.pipes;
+      var len = state2.pipesCount;
+      state2.pipes = null;
+      state2.pipesCount = 0;
+      state2.flowing = false;
+      for (var i = 0; i < len; i++) dests[i].emit("unpipe", this, {
+        hasUnpiped: false
+      });
+      return this;
+    }
+    var index = indexOf(state2.pipes, dest);
+    if (index === -1) return this;
+    state2.pipes.splice(index, 1);
+    state2.pipesCount -= 1;
+    if (state2.pipesCount === 1) state2.pipes = state2.pipes[0];
+    dest.emit("unpipe", this, unpipeInfo);
+    return this;
+  };
+  Readable.prototype.on = function(ev, fn) {
+    var res = Stream.prototype.on.call(this, ev, fn);
+    var state2 = this._readableState;
+    if (ev === "data") {
+      state2.readableListening = this.listenerCount("readable") > 0;
+      if (state2.flowing !== false) this.resume();
+    } else if (ev === "readable") {
+      if (!state2.endEmitted && !state2.readableListening) {
+        state2.readableListening = state2.needReadable = true;
+        state2.flowing = false;
+        state2.emittedReadable = false;
+        debug("on readable", state2.length, state2.reading);
+        if (state2.length) {
+          emitReadable(this);
+        } else if (!state2.reading) {
+          process$1.nextTick(nReadingNextTick, this);
+        }
+      }
+    }
+    return res;
+  };
+  Readable.prototype.addListener = Readable.prototype.on;
+  Readable.prototype.removeListener = function(ev, fn) {
+    var res = Stream.prototype.removeListener.call(this, ev, fn);
+    if (ev === "readable") {
+      process$1.nextTick(updateReadableListening, this);
+    }
+    return res;
+  };
+  Readable.prototype.removeAllListeners = function(ev) {
+    var res = Stream.prototype.removeAllListeners.apply(this, arguments);
+    if (ev === "readable" || ev === void 0) {
+      process$1.nextTick(updateReadableListening, this);
+    }
+    return res;
+  };
+  function updateReadableListening(self2) {
+    var state2 = self2._readableState;
+    state2.readableListening = self2.listenerCount("readable") > 0;
+    if (state2.resumeScheduled && !state2.paused) {
+      state2.flowing = true;
+    } else if (self2.listenerCount("data") > 0) {
+      self2.resume();
+    }
+  }
+  function nReadingNextTick(self2) {
+    debug("readable nexttick read 0");
+    self2.read(0);
+  }
+  Readable.prototype.resume = function() {
+    var state2 = this._readableState;
+    if (!state2.flowing) {
+      debug("resume");
+      state2.flowing = !state2.readableListening;
+      resume(this, state2);
+    }
+    state2.paused = false;
+    return this;
+  };
+  function resume(stream, state2) {
+    if (!state2.resumeScheduled) {
+      state2.resumeScheduled = true;
+      process$1.nextTick(resume_, stream, state2);
+    }
+  }
+  function resume_(stream, state2) {
+    debug("resume", state2.reading);
+    if (!state2.reading) {
+      stream.read(0);
+    }
+    state2.resumeScheduled = false;
+    stream.emit("resume");
+    flow(stream);
+    if (state2.flowing && !state2.reading) stream.read(0);
+  }
+  Readable.prototype.pause = function() {
+    debug("call pause flowing=%j", this._readableState.flowing);
+    if (this._readableState.flowing !== false) {
+      debug("pause");
+      this._readableState.flowing = false;
+      this.emit("pause");
+    }
+    this._readableState.paused = true;
+    return this;
+  };
+  function flow(stream) {
+    var state2 = stream._readableState;
+    debug("flow", state2.flowing);
+    while (state2.flowing && stream.read() !== null) ;
+  }
+  Readable.prototype.wrap = function(stream) {
+    var _this = this;
+    var state2 = this._readableState;
+    var paused = false;
+    stream.on("end", function() {
+      debug("wrapped end");
+      if (state2.decoder && !state2.ended) {
+        var chunk = state2.decoder.end();
+        if (chunk && chunk.length) _this.push(chunk);
+      }
+      _this.push(null);
+    });
+    stream.on("data", function(chunk) {
+      debug("wrapped data");
+      if (state2.decoder) chunk = state2.decoder.write(chunk);
+      if (state2.objectMode && (chunk === null || chunk === void 0)) return;
+      else if (!state2.objectMode && (!chunk || !chunk.length)) return;
+      var ret = _this.push(chunk);
+      if (!ret) {
+        paused = true;
+        stream.pause();
+      }
+    });
+    for (var i in stream) {
+      if (this[i] === void 0 && typeof stream[i] === "function") {
+        this[i] = /* @__PURE__ */ function methodWrap(method) {
+          return function methodWrapReturnFunction() {
+            return stream[method].apply(stream, arguments);
+          };
+        }(i);
+      }
+    }
+    for (var n = 0; n < kProxyEvents.length; n++) {
+      stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
+    }
+    this._read = function(n2) {
+      debug("wrapped _read", n2);
+      if (paused) {
+        paused = false;
+        stream.resume();
+      }
+    };
+    return this;
+  };
+  if (typeof Symbol === "function") {
+    Readable.prototype[Symbol.asyncIterator] = function() {
+      if (createReadableStreamAsyncIterator === void 0) {
+        createReadableStreamAsyncIterator = requireAsync_iterator();
+      }
+      return createReadableStreamAsyncIterator(this);
+    };
+  }
+  Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      return this._readableState.highWaterMark;
+    }
+  });
+  Object.defineProperty(Readable.prototype, "readableBuffer", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      return this._readableState && this._readableState.buffer;
+    }
+  });
+  Object.defineProperty(Readable.prototype, "readableFlowing", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      return this._readableState.flowing;
+    },
+    set: function set(state2) {
+      if (this._readableState) {
+        this._readableState.flowing = state2;
+      }
+    }
+  });
+  Readable._fromList = fromList;
+  Object.defineProperty(Readable.prototype, "readableLength", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: false,
+    get: function get() {
+      return this._readableState.length;
+    }
+  });
+  function fromList(n, state2) {
+    if (state2.length === 0) return null;
+    var ret;
+    if (state2.objectMode) ret = state2.buffer.shift();
+    else if (!n || n >= state2.length) {
+      if (state2.decoder) ret = state2.buffer.join("");
+      else if (state2.buffer.length === 1) ret = state2.buffer.first();
+      else ret = state2.buffer.concat(state2.length);
+      state2.buffer.clear();
+    } else {
+      ret = state2.buffer.consume(n, state2.decoder);
+    }
+    return ret;
+  }
+  function endReadable(stream) {
+    var state2 = stream._readableState;
+    debug("endReadable", state2.endEmitted);
+    if (!state2.endEmitted) {
+      state2.ended = true;
+      process$1.nextTick(endReadableNT, state2, stream);
+    }
+  }
+  function endReadableNT(state2, stream) {
+    debug("endReadableNT", state2.endEmitted, state2.length);
+    if (!state2.endEmitted && state2.length === 0) {
+      state2.endEmitted = true;
+      stream.readable = false;
+      stream.emit("end");
+      if (state2.autoDestroy) {
+        var wState = stream._writableState;
+        if (!wState || wState.autoDestroy && wState.finished) {
+          stream.destroy();
+        }
+      }
+    }
+  }
+  if (typeof Symbol === "function") {
+    Readable.from = function(iterable, opts) {
+      if (from === void 0) {
+        from = requireFromBrowser();
+      }
+      return from(Readable, iterable, opts);
+    };
+  }
+  function indexOf(xs, x) {
+    for (var i = 0, l = xs.length; i < l; i++) {
+      if (xs[i] === x) return i;
+    }
+    return -1;
+  }
+  return _stream_readable;
+}
+var _stream_transform;
+var hasRequired_stream_transform;
+function require_stream_transform() {
+  if (hasRequired_stream_transform) return _stream_transform;
+  hasRequired_stream_transform = 1;
+  _stream_transform = Transform;
+  var _require$codes = requireErrorsBrowser().codes, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING, ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
+  var Duplex = require_stream_duplex();
+  requireInherits_browser()(Transform, Duplex);
+  function afterTransform(er, data) {
+    var ts = this._transformState;
+    ts.transforming = false;
+    var cb = ts.writecb;
+    if (cb === null) {
+      return this.emit("error", new ERR_MULTIPLE_CALLBACK());
+    }
+    ts.writechunk = null;
+    ts.writecb = null;
+    if (data != null)
+      this.push(data);
+    cb(er);
+    var rs = this._readableState;
+    rs.reading = false;
+    if (rs.needReadable || rs.length < rs.highWaterMark) {
+      this._read(rs.highWaterMark);
+    }
+  }
+  function Transform(options) {
+    if (!(this instanceof Transform)) return new Transform(options);
+    Duplex.call(this, options);
+    this._transformState = {
+      afterTransform: afterTransform.bind(this),
+      needTransform: false,
+      transforming: false,
+      writecb: null,
+      writechunk: null,
+      writeencoding: null
+    };
+    this._readableState.needReadable = true;
+    this._readableState.sync = false;
+    if (options) {
+      if (typeof options.transform === "function") this._transform = options.transform;
+      if (typeof options.flush === "function") this._flush = options.flush;
+    }
+    this.on("prefinish", prefinish);
+  }
+  function prefinish() {
+    var _this = this;
+    if (typeof this._flush === "function" && !this._readableState.destroyed) {
+      this._flush(function(er, data) {
+        done(_this, er, data);
+      });
+    } else {
+      done(this, null, null);
+    }
+  }
+  Transform.prototype.push = function(chunk, encoding) {
+    this._transformState.needTransform = false;
+    return Duplex.prototype.push.call(this, chunk, encoding);
+  };
+  Transform.prototype._transform = function(chunk, encoding, cb) {
+    cb(new ERR_METHOD_NOT_IMPLEMENTED("_transform()"));
+  };
+  Transform.prototype._write = function(chunk, encoding, cb) {
+    var ts = this._transformState;
+    ts.writecb = cb;
+    ts.writechunk = chunk;
+    ts.writeencoding = encoding;
+    if (!ts.transforming) {
+      var rs = this._readableState;
+      if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+    }
+  };
+  Transform.prototype._read = function(n) {
+    var ts = this._transformState;
+    if (ts.writechunk !== null && !ts.transforming) {
+      ts.transforming = true;
+      this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+    } else {
+      ts.needTransform = true;
+    }
+  };
+  Transform.prototype._destroy = function(err, cb) {
+    Duplex.prototype._destroy.call(this, err, function(err2) {
+      cb(err2);
+    });
+  };
+  function done(stream, er, data) {
+    if (er) return stream.emit("error", er);
+    if (data != null)
+      stream.push(data);
+    if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
+    if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
+    return stream.push(null);
+  }
+  return _stream_transform;
+}
+var _stream_passthrough;
+var hasRequired_stream_passthrough;
+function require_stream_passthrough() {
+  if (hasRequired_stream_passthrough) return _stream_passthrough;
+  hasRequired_stream_passthrough = 1;
+  _stream_passthrough = PassThrough;
+  var Transform = require_stream_transform();
+  requireInherits_browser()(PassThrough, Transform);
+  function PassThrough(options) {
+    if (!(this instanceof PassThrough)) return new PassThrough(options);
+    Transform.call(this, options);
+  }
+  PassThrough.prototype._transform = function(chunk, encoding, cb) {
+    cb(null, chunk);
+  };
+  return _stream_passthrough;
+}
+var pipeline_1;
+var hasRequiredPipeline;
+function requirePipeline() {
+  if (hasRequiredPipeline) return pipeline_1;
+  hasRequiredPipeline = 1;
+  var eos;
+  function once(callback) {
+    var called = false;
+    return function() {
+      if (called) return;
+      called = true;
+      callback.apply(void 0, arguments);
+    };
+  }
+  var _require$codes = requireErrorsBrowser().codes, ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
+  function noop(err) {
+    if (err) throw err;
+  }
+  function isRequest(stream) {
+    return stream.setHeader && typeof stream.abort === "function";
+  }
+  function destroyer(stream, reading, writing, callback) {
+    callback = once(callback);
+    var closed = false;
+    stream.on("close", function() {
+      closed = true;
+    });
+    if (eos === void 0) eos = requireEndOfStream();
+    eos(stream, {
+      readable: reading,
+      writable: writing
+    }, function(err) {
+      if (err) return callback(err);
+      closed = true;
+      callback();
+    });
+    var destroyed = false;
+    return function(err) {
+      if (closed) return;
+      if (destroyed) return;
+      destroyed = true;
+      if (isRequest(stream)) return stream.abort();
+      if (typeof stream.destroy === "function") return stream.destroy();
+      callback(err || new ERR_STREAM_DESTROYED("pipe"));
+    };
+  }
+  function call(fn) {
+    fn();
+  }
+  function pipe(from, to) {
+    return from.pipe(to);
+  }
+  function popCallback(streams) {
+    if (!streams.length) return noop;
+    if (typeof streams[streams.length - 1] !== "function") return noop;
+    return streams.pop();
+  }
+  function pipeline() {
+    for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
+      streams[_key] = arguments[_key];
+    }
+    var callback = popCallback(streams);
+    if (Array.isArray(streams[0])) streams = streams[0];
+    if (streams.length < 2) {
+      throw new ERR_MISSING_ARGS("streams");
+    }
+    var error;
+    var destroys = streams.map(function(stream, i) {
+      var reading = i < streams.length - 1;
+      var writing = i > 0;
+      return destroyer(stream, reading, writing, function(err) {
+        if (!error) error = err;
+        if (err) destroys.forEach(call);
+        if (reading) return;
+        destroys.forEach(call);
+        callback(error);
+      });
+    });
+    return streams.reduce(pipe);
+  }
+  pipeline_1 = pipeline;
+  return pipeline_1;
+}
+var hasRequiredReadableBrowser;
+function requireReadableBrowser() {
+  if (hasRequiredReadableBrowser) return readableBrowser.exports;
+  hasRequiredReadableBrowser = 1;
+  (function(module, exports) {
+    exports = module.exports = require_stream_readable();
+    exports.Stream = exports;
+    exports.Readable = exports;
+    exports.Writable = require_stream_writable();
+    exports.Duplex = require_stream_duplex();
+    exports.Transform = require_stream_transform();
+    exports.PassThrough = require_stream_passthrough();
+    exports.finished = requireEndOfStream();
+    exports.pipeline = requirePipeline();
+  })(readableBrowser, readableBrowser.exports);
+  return readableBrowser.exports;
+}
+var hasRequiredResponse;
+function requireResponse() {
+  if (hasRequiredResponse) return response;
+  hasRequiredResponse = 1;
+  var capability2 = requireCapability();
+  var inherits = requireInherits_browser();
+  var stream = requireReadableBrowser();
+  var rStates = response.readyStates = {
+    UNSENT: 0,
+    OPENED: 1,
+    HEADERS_RECEIVED: 2,
+    LOADING: 3,
+    DONE: 4
+  };
+  var IncomingMessage = response.IncomingMessage = function(xhr, response2, mode, resetTimers) {
+    var self2 = this;
+    stream.Readable.call(self2);
+    self2._mode = mode;
+    self2.headers = {};
+    self2.rawHeaders = [];
+    self2.trailers = {};
+    self2.rawTrailers = [];
+    self2.on("end", function() {
+      process$1.nextTick(function() {
+        self2.emit("close");
+      });
+    });
+    if (mode === "fetch") {
+      let read = function() {
+        reader.read().then(function(result) {
+          if (self2._destroyed)
+            return;
+          resetTimers(result.done);
+          if (result.done) {
+            self2.push(null);
+            return;
+          }
+          self2.push(Buffer.from(result.value));
+          read();
+        }).catch(function(err) {
+          resetTimers(true);
+          if (!self2._destroyed)
+            self2.emit("error", err);
+        });
+      };
+      self2._fetchResponse = response2;
+      self2.url = response2.url;
+      self2.statusCode = response2.status;
+      self2.statusMessage = response2.statusText;
+      response2.headers.forEach(function(header, key) {
+        self2.headers[key.toLowerCase()] = header;
+        self2.rawHeaders.push(key, header);
+      });
+      if (capability2.writableStream) {
+        var writable = new WritableStream({
+          write: function(chunk) {
+            resetTimers(false);
+            return new Promise(function(resolve, reject) {
+              if (self2._destroyed) {
+                reject();
+              } else if (self2.push(Buffer.from(chunk))) {
+                resolve();
+              } else {
+                self2._resumeFetch = resolve;
+              }
+            });
+          },
+          close: function() {
+            resetTimers(true);
+            if (!self2._destroyed)
+              self2.push(null);
+          },
+          abort: function(err) {
+            resetTimers(true);
+            if (!self2._destroyed)
+              self2.emit("error", err);
+          }
+        });
+        try {
+          response2.body.pipeTo(writable).catch(function(err) {
+            resetTimers(true);
+            if (!self2._destroyed)
+              self2.emit("error", err);
+          });
+          return;
+        } catch (e) {
+        }
+      }
+      var reader = response2.body.getReader();
+      read();
+    } else {
+      self2._xhr = xhr;
+      self2._pos = 0;
+      self2.url = xhr.responseURL;
+      self2.statusCode = xhr.status;
+      self2.statusMessage = xhr.statusText;
+      var headers = xhr.getAllResponseHeaders().split(/\r?\n/);
+      headers.forEach(function(header) {
+        var matches = header.match(/^([^:]+):\s*(.*)/);
+        if (matches) {
+          var key = matches[1].toLowerCase();
+          if (key === "set-cookie") {
+            if (self2.headers[key] === void 0) {
+              self2.headers[key] = [];
+            }
+            self2.headers[key].push(matches[2]);
+          } else if (self2.headers[key] !== void 0) {
+            self2.headers[key] += ", " + matches[2];
+          } else {
+            self2.headers[key] = matches[2];
+          }
+          self2.rawHeaders.push(matches[1], matches[2]);
+        }
+      });
+      self2._charset = "x-user-defined";
+      if (!capability2.overrideMimeType) {
+        var mimeType = self2.rawHeaders["mime-type"];
+        if (mimeType) {
+          var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/);
+          if (charsetMatch) {
+            self2._charset = charsetMatch[1].toLowerCase();
+          }
+        }
+        if (!self2._charset)
+          self2._charset = "utf-8";
+      }
+    }
+  };
+  inherits(IncomingMessage, stream.Readable);
+  IncomingMessage.prototype._read = function() {
+    var self2 = this;
+    var resolve = self2._resumeFetch;
+    if (resolve) {
+      self2._resumeFetch = null;
+      resolve();
+    }
+  };
+  IncomingMessage.prototype._onXHRProgress = function(resetTimers) {
+    var self2 = this;
+    var xhr = self2._xhr;
+    var response2 = null;
+    switch (self2._mode) {
+      case "text":
+        response2 = xhr.responseText;
+        if (response2.length > self2._pos) {
+          var newData = response2.substr(self2._pos);
+          if (self2._charset === "x-user-defined") {
+            var buffer = Buffer.alloc(newData.length);
+            for (var i = 0; i < newData.length; i++)
+              buffer[i] = newData.charCodeAt(i) & 255;
+            self2.push(buffer);
+          } else {
+            self2.push(newData, self2._charset);
+          }
+          self2._pos = response2.length;
+        }
+        break;
+      case "arraybuffer":
+        if (xhr.readyState !== rStates.DONE || !xhr.response)
+          break;
+        response2 = xhr.response;
+        self2.push(Buffer.from(new Uint8Array(response2)));
+        break;
+      case "moz-chunked-arraybuffer":
+        response2 = xhr.response;
+        if (xhr.readyState !== rStates.LOADING || !response2)
+          break;
+        self2.push(Buffer.from(new Uint8Array(response2)));
+        break;
+      case "ms-stream":
+        response2 = xhr.response;
+        if (xhr.readyState !== rStates.LOADING)
+          break;
+        var reader = new commonjsGlobal.MSStreamReader();
+        reader.onprogress = function() {
+          if (reader.result.byteLength > self2._pos) {
+            self2.push(Buffer.from(new Uint8Array(reader.result.slice(self2._pos))));
+            self2._pos = reader.result.byteLength;
+          }
+        };
+        reader.onload = function() {
+          resetTimers(true);
+          self2.push(null);
+        };
+        reader.readAsArrayBuffer(response2);
+        break;
+    }
+    if (self2._xhr.readyState === rStates.DONE && self2._mode !== "ms-stream") {
+      resetTimers(true);
+      self2.push(null);
+    }
+  };
+  return response;
+}
+var hasRequiredRequest;
+function requireRequest() {
+  if (hasRequiredRequest) return request.exports;
+  hasRequiredRequest = 1;
+  var capability2 = requireCapability();
+  var inherits = requireInherits_browser();
+  var response2 = requireResponse();
+  var stream = requireReadableBrowser();
+  var IncomingMessage = response2.IncomingMessage;
+  var rStates = response2.readyStates;
+  function decideMode(preferBinary, useFetch) {
+    if (capability2.fetch && useFetch) {
+      return "fetch";
+    } else if (capability2.mozchunkedarraybuffer) {
+      return "moz-chunked-arraybuffer";
+    } else if (capability2.msstream) {
+      return "ms-stream";
+    } else if (capability2.arraybuffer && preferBinary) {
+      return "arraybuffer";
+    } else {
+      return "text";
+    }
+  }
+  var ClientRequest = request.exports = function(opts) {
+    var self2 = this;
+    stream.Writable.call(self2);
+    self2._opts = opts;
+    self2._body = [];
+    self2._headers = {};
+    if (opts.auth)
+      self2.setHeader("Authorization", "Basic " + Buffer.from(opts.auth).toString("base64"));
+    Object.keys(opts.headers).forEach(function(name) {
+      self2.setHeader(name, opts.headers[name]);
+    });
+    var preferBinary;
+    var useFetch = true;
+    if (opts.mode === "disable-fetch" || "requestTimeout" in opts && !capability2.abortController) {
+      useFetch = false;
+      preferBinary = true;
+    } else if (opts.mode === "prefer-streaming") {
+      preferBinary = false;
+    } else if (opts.mode === "allow-wrong-content-type") {
+      preferBinary = !capability2.overrideMimeType;
+    } else if (!opts.mode || opts.mode === "default" || opts.mode === "prefer-fast") {
+      preferBinary = true;
+    } else {
+      throw new Error("Invalid value for opts.mode");
+    }
+    self2._mode = decideMode(preferBinary, useFetch);
+    self2._fetchTimer = null;
+    self2._socketTimeout = null;
+    self2._socketTimer = null;
+    self2.on("finish", function() {
+      self2._onFinish();
+    });
+  };
+  inherits(ClientRequest, stream.Writable);
+  ClientRequest.prototype.setHeader = function(name, value) {
+    var self2 = this;
+    var lowerName = name.toLowerCase();
+    if (unsafeHeaders.indexOf(lowerName) !== -1)
+      return;
+    self2._headers[lowerName] = {
+      name,
+      value
+    };
+  };
+  ClientRequest.prototype.getHeader = function(name) {
+    var header = this._headers[name.toLowerCase()];
+    if (header)
+      return header.value;
+    return null;
+  };
+  ClientRequest.prototype.removeHeader = function(name) {
+    var self2 = this;
+    delete self2._headers[name.toLowerCase()];
+  };
+  ClientRequest.prototype._onFinish = function() {
+    var self2 = this;
+    if (self2._destroyed)
+      return;
+    var opts = self2._opts;
+    if ("timeout" in opts && opts.timeout !== 0) {
+      self2.setTimeout(opts.timeout);
+    }
+    var headersObj = self2._headers;
+    var body = null;
+    if (opts.method !== "GET" && opts.method !== "HEAD") {
+      body = new Blob(self2._body, {
+        type: (headersObj["content-type"] || {}).value || ""
+      });
+    }
+    var headersList = [];
+    Object.keys(headersObj).forEach(function(keyName) {
+      var name = headersObj[keyName].name;
+      var value = headersObj[keyName].value;
+      if (Array.isArray(value)) {
+        value.forEach(function(v) {
+          headersList.push([name, v]);
+        });
+      } else {
+        headersList.push([name, value]);
+      }
+    });
+    if (self2._mode === "fetch") {
+      var signal = null;
+      if (capability2.abortController) {
+        var controller = new AbortController();
+        signal = controller.signal;
+        self2._fetchAbortController = controller;
+        if ("requestTimeout" in opts && opts.requestTimeout !== 0) {
+          self2._fetchTimer = commonjsGlobal.setTimeout(function() {
+            self2.emit("requestTimeout");
+            if (self2._fetchAbortController)
+              self2._fetchAbortController.abort();
+          }, opts.requestTimeout);
+        }
+      }
+      commonjsGlobal.fetch(self2._opts.url, {
+        method: self2._opts.method,
+        headers: headersList,
+        body: body || void 0,
+        mode: "cors",
+        credentials: opts.withCredentials ? "include" : "same-origin",
+        signal
+      }).then(function(response3) {
+        self2._fetchResponse = response3;
+        self2._resetTimers(false);
+        self2._connect();
+      }, function(reason) {
+        self2._resetTimers(true);
+        if (!self2._destroyed)
+          self2.emit("error", reason);
+      });
+    } else {
+      var xhr = self2._xhr = new commonjsGlobal.XMLHttpRequest();
+      try {
+        xhr.open(self2._opts.method, self2._opts.url, true);
+      } catch (err) {
+        process$1.nextTick(function() {
+          self2.emit("error", err);
+        });
+        return;
+      }
+      if ("responseType" in xhr)
+        xhr.responseType = self2._mode;
+      if ("withCredentials" in xhr)
+        xhr.withCredentials = !!opts.withCredentials;
+      if (self2._mode === "text" && "overrideMimeType" in xhr)
+        xhr.overrideMimeType("text/plain; charset=x-user-defined");
+      if ("requestTimeout" in opts) {
+        xhr.timeout = opts.requestTimeout;
+        xhr.ontimeout = function() {
+          self2.emit("requestTimeout");
+        };
+      }
+      headersList.forEach(function(header) {
+        xhr.setRequestHeader(header[0], header[1]);
+      });
+      self2._response = null;
+      xhr.onreadystatechange = function() {
+        switch (xhr.readyState) {
+          case rStates.LOADING:
+          case rStates.DONE:
+            self2._onXHRProgress();
+            break;
+        }
+      };
+      if (self2._mode === "moz-chunked-arraybuffer") {
+        xhr.onprogress = function() {
+          self2._onXHRProgress();
+        };
+      }
+      xhr.onerror = function() {
+        if (self2._destroyed)
+          return;
+        self2._resetTimers(true);
+        self2.emit("error", new Error("XHR error"));
+      };
+      try {
+        xhr.send(body);
+      } catch (err) {
+        process$1.nextTick(function() {
+          self2.emit("error", err);
+        });
+        return;
+      }
+    }
+  };
+  function statusValid(xhr) {
+    try {
+      var status = xhr.status;
+      return status !== null && status !== 0;
+    } catch (e) {
+      return false;
+    }
+  }
+  ClientRequest.prototype._onXHRProgress = function() {
+    var self2 = this;
+    self2._resetTimers(false);
+    if (!statusValid(self2._xhr) || self2._destroyed)
+      return;
+    if (!self2._response)
+      self2._connect();
+    self2._response._onXHRProgress(self2._resetTimers.bind(self2));
+  };
+  ClientRequest.prototype._connect = function() {
+    var self2 = this;
+    if (self2._destroyed)
+      return;
+    self2._response = new IncomingMessage(self2._xhr, self2._fetchResponse, self2._mode, self2._resetTimers.bind(self2));
+    self2._response.on("error", function(err) {
+      self2.emit("error", err);
+    });
+    self2.emit("response", self2._response);
+  };
+  ClientRequest.prototype._write = function(chunk, encoding, cb) {
+    var self2 = this;
+    self2._body.push(chunk);
+    cb();
+  };
+  ClientRequest.prototype._resetTimers = function(done) {
+    var self2 = this;
+    commonjsGlobal.clearTimeout(self2._socketTimer);
+    self2._socketTimer = null;
+    if (done) {
+      commonjsGlobal.clearTimeout(self2._fetchTimer);
+      self2._fetchTimer = null;
+    } else if (self2._socketTimeout) {
+      self2._socketTimer = commonjsGlobal.setTimeout(function() {
+        self2.emit("timeout");
+      }, self2._socketTimeout);
+    }
+  };
+  ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function(err) {
+    var self2 = this;
+    self2._destroyed = true;
+    self2._resetTimers(true);
+    if (self2._response)
+      self2._response._destroyed = true;
+    if (self2._xhr)
+      self2._xhr.abort();
+    else if (self2._fetchAbortController)
+      self2._fetchAbortController.abort();
+    if (err)
+      self2.emit("error", err);
+  };
+  ClientRequest.prototype.end = function(data, encoding, cb) {
+    var self2 = this;
+    if (typeof data === "function") {
+      cb = data;
+      data = void 0;
+    }
+    stream.Writable.prototype.end.call(self2, data, encoding, cb);
+  };
+  ClientRequest.prototype.setTimeout = function(timeout, cb) {
+    var self2 = this;
+    if (cb)
+      self2.once("timeout", cb);
+    self2._socketTimeout = timeout;
+    self2._resetTimers(false);
+  };
+  ClientRequest.prototype.flushHeaders = function() {
+  };
+  ClientRequest.prototype.setNoDelay = function() {
+  };
+  ClientRequest.prototype.setSocketKeepAlive = function() {
+  };
+  var unsafeHeaders = [
+    "accept-charset",
+    "accept-encoding",
+    "access-control-request-headers",
+    "access-control-request-method",
+    "connection",
+    "content-length",
+    "cookie",
+    "cookie2",
+    "date",
+    "dnt",
+    "expect",
+    "host",
+    "keep-alive",
+    "origin",
+    "referer",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    "via"
+  ];
+  return request.exports;
+}
+var immutable;
+var hasRequiredImmutable;
+function requireImmutable() {
+  if (hasRequiredImmutable) return immutable;
+  hasRequiredImmutable = 1;
+  immutable = extend;
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  function extend() {
+    var target = {};
+    for (var i = 0; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  }
+  return immutable;
+}
+var browser;
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser;
+  hasRequiredBrowser = 1;
+  browser = {
+    "100": "Continue",
+    "101": "Switching Protocols",
+    "102": "Processing",
+    "200": "OK",
+    "201": "Created",
+    "202": "Accepted",
+    "203": "Non-Authoritative Information",
+    "204": "No Content",
+    "205": "Reset Content",
+    "206": "Partial Content",
+    "207": "Multi-Status",
+    "208": "Already Reported",
+    "226": "IM Used",
+    "300": "Multiple Choices",
+    "301": "Moved Permanently",
+    "302": "Found",
+    "303": "See Other",
+    "304": "Not Modified",
+    "305": "Use Proxy",
+    "307": "Temporary Redirect",
+    "308": "Permanent Redirect",
+    "400": "Bad Request",
+    "401": "Unauthorized",
+    "402": "Payment Required",
+    "403": "Forbidden",
+    "404": "Not Found",
+    "405": "Method Not Allowed",
+    "406": "Not Acceptable",
+    "407": "Proxy Authentication Required",
+    "408": "Request Timeout",
+    "409": "Conflict",
+    "410": "Gone",
+    "411": "Length Required",
+    "412": "Precondition Failed",
+    "413": "Payload Too Large",
+    "414": "URI Too Long",
+    "415": "Unsupported Media Type",
+    "416": "Range Not Satisfiable",
+    "417": "Expectation Failed",
+    "418": "I'm a teapot",
+    "421": "Misdirected Request",
+    "422": "Unprocessable Entity",
+    "423": "Locked",
+    "424": "Failed Dependency",
+    "425": "Unordered Collection",
+    "426": "Upgrade Required",
+    "428": "Precondition Required",
+    "429": "Too Many Requests",
+    "431": "Request Header Fields Too Large",
+    "451": "Unavailable For Legal Reasons",
+    "500": "Internal Server Error",
+    "501": "Not Implemented",
+    "502": "Bad Gateway",
+    "503": "Service Unavailable",
+    "504": "Gateway Timeout",
+    "505": "HTTP Version Not Supported",
+    "506": "Variant Also Negotiates",
+    "507": "Insufficient Storage",
+    "508": "Loop Detected",
+    "509": "Bandwidth Limit Exceeded",
+    "510": "Not Extended",
+    "511": "Network Authentication Required"
+  };
+  return browser;
+}
+const require$$1 = /* @__PURE__ */ getAugmentedNamespace(url);
+var hasRequiredStreamHttp;
+function requireStreamHttp() {
+  if (hasRequiredStreamHttp) return streamHttp;
+  hasRequiredStreamHttp = 1;
+  (function(exports) {
+    var ClientRequest = requireRequest();
+    var response2 = requireResponse();
+    var extend = requireImmutable();
+    var statusCodes = requireBrowser();
+    var url2 = require$$1;
+    var http = exports;
+    http.request = function(opts, cb) {
+      if (typeof opts === "string")
+        opts = url2.parse(opts);
+      else
+        opts = extend(opts);
+      var defaultProtocol = commonjsGlobal.location.protocol.search(/^https?:$/) === -1 ? "http:" : "";
+      var protocol = opts.protocol || defaultProtocol;
+      var host = opts.hostname || opts.host;
+      var port = opts.port;
+      var path = opts.path || "/";
+      if (host && host.indexOf(":") !== -1)
+        host = "[" + host + "]";
+      opts.url = (host ? protocol + "//" + host : "") + (port ? ":" + port : "") + path;
+      opts.method = (opts.method || "GET").toUpperCase();
+      opts.headers = opts.headers || {};
+      var req = new ClientRequest(opts);
+      if (cb)
+        req.on("response", cb);
+      return req;
+    };
+    http.get = function get(opts, cb) {
+      var req = http.request(opts, cb);
+      req.end();
+      return req;
+    };
+    http.ClientRequest = ClientRequest;
+    http.IncomingMessage = response2.IncomingMessage;
+    http.Agent = function() {
+    };
+    http.Agent.defaultMaxSockets = 4;
+    http.globalAgent = new http.Agent();
+    http.STATUS_CODES = statusCodes;
+    http.METHODS = [
+      "CHECKOUT",
+      "CONNECT",
+      "COPY",
+      "DELETE",
+      "GET",
+      "HEAD",
+      "LOCK",
+      "M-SEARCH",
+      "MERGE",
+      "MKACTIVITY",
+      "MKCOL",
+      "MOVE",
+      "NOTIFY",
+      "OPTIONS",
+      "PATCH",
+      "POST",
+      "PROPFIND",
+      "PROPPATCH",
+      "PURGE",
+      "PUT",
+      "REPORT",
+      "SEARCH",
+      "SUBSCRIBE",
+      "TRACE",
+      "UNLOCK",
+      "UNSUBSCRIBE"
+    ];
+  })(streamHttp);
+  return streamHttp;
+}
+export {
+  require$$1 as a,
+  requireStreamHttp as r
+};