module-develop-kit 0.5.10 → 0.5.12

package/dist/vendor/crypto-js/x64-core.js

@@ -0,0 +1,235 @@
+import { __module as n } from "../../commonjs-virtual-dir/x64-core.js";
+import { __require as x } from "./core.js";
+var g = n.exports, v;
+function w() {
+  return v ? n.exports : (v = 1, function(f, p) {
+    (function(s, i) {
+      f.exports = i(x());
+    })(g, function(s) {
+      return function(i) {
+        var u = s, h = u.lib, a = h.Base, d = h.WordArray, c = u.x64 = {};
+        c.Word = a.extend({
+          /**
+           * Initializes a newly created 64-bit word.
+           *
+           * @param {number} high The high 32 bits.
+           * @param {number} low The low 32 bits.
+           *
+           * @example
+           *
+           *     var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607);
+           */
+          init: function(r, e) {
+            this.high = r, this.low = e;
+          }
+          /**
+           * Bitwise NOTs this word.
+           *
+           * @return {X64Word} A new x64-Word object after negating.
+           *
+           * @example
+           *
+           *     var negated = x64Word.not();
+           */
+          // not: function () {
+          // var high = ~this.high;
+          // var low = ~this.low;
+          // return X64Word.create(high, low);
+          // },
+          /**
+           * Bitwise ANDs this word with the passed word.
+           *
+           * @param {X64Word} word The x64-Word to AND with this word.
+           *
+           * @return {X64Word} A new x64-Word object after ANDing.
+           *
+           * @example
+           *
+           *     var anded = x64Word.and(anotherX64Word);
+           */
+          // and: function (word) {
+          // var high = this.high & word.high;
+          // var low = this.low & word.low;
+          // return X64Word.create(high, low);
+          // },
+          /**
+           * Bitwise ORs this word with the passed word.
+           *
+           * @param {X64Word} word The x64-Word to OR with this word.
+           *
+           * @return {X64Word} A new x64-Word object after ORing.
+           *
+           * @example
+           *
+           *     var ored = x64Word.or(anotherX64Word);
+           */
+          // or: function (word) {
+          // var high = this.high | word.high;
+          // var low = this.low | word.low;
+          // return X64Word.create(high, low);
+          // },
+          /**
+           * Bitwise XORs this word with the passed word.
+           *
+           * @param {X64Word} word The x64-Word to XOR with this word.
+           *
+           * @return {X64Word} A new x64-Word object after XORing.
+           *
+           * @example
+           *
+           *     var xored = x64Word.xor(anotherX64Word);
+           */
+          // xor: function (word) {
+          // var high = this.high ^ word.high;
+          // var low = this.low ^ word.low;
+          // return X64Word.create(high, low);
+          // },
+          /**
+           * Shifts this word n bits to the left.
+           *
+           * @param {number} n The number of bits to shift.
+           *
+           * @return {X64Word} A new x64-Word object after shifting.
+           *
+           * @example
+           *
+           *     var shifted = x64Word.shiftL(25);
+           */
+          // shiftL: function (n) {
+          // if (n < 32) {
+          // var high = (this.high << n) | (this.low >>> (32 - n));
+          // var low = this.low << n;
+          // } else {
+          // var high = this.low << (n - 32);
+          // var low = 0;
+          // }
+          // return X64Word.create(high, low);
+          // },
+          /**
+           * Shifts this word n bits to the right.
+           *
+           * @param {number} n The number of bits to shift.
+           *
+           * @return {X64Word} A new x64-Word object after shifting.
+           *
+           * @example
+           *
+           *     var shifted = x64Word.shiftR(7);
+           */
+          // shiftR: function (n) {
+          // if (n < 32) {
+          // var low = (this.low >>> n) | (this.high << (32 - n));
+          // var high = this.high >>> n;
+          // } else {
+          // var low = this.high >>> (n - 32);
+          // var high = 0;
+          // }
+          // return X64Word.create(high, low);
+          // },
+          /**
+           * Rotates this word n bits to the left.
+           *
+           * @param {number} n The number of bits to rotate.
+           *
+           * @return {X64Word} A new x64-Word object after rotating.
+           *
+           * @example
+           *
+           *     var rotated = x64Word.rotL(25);
+           */
+          // rotL: function (n) {
+          // return this.shiftL(n).or(this.shiftR(64 - n));
+          // },
+          /**
+           * Rotates this word n bits to the right.
+           *
+           * @param {number} n The number of bits to rotate.
+           *
+           * @return {X64Word} A new x64-Word object after rotating.
+           *
+           * @example
+           *
+           *     var rotated = x64Word.rotR(7);
+           */
+          // rotR: function (n) {
+          // return this.shiftR(n).or(this.shiftL(64 - n));
+          // },
+          /**
+           * Adds this word with the passed word.
+           *
+           * @param {X64Word} word The x64-Word to add with this word.
+           *
+           * @return {X64Word} A new x64-Word object after adding.
+           *
+           * @example
+           *
+           *     var added = x64Word.add(anotherX64Word);
+           */
+          // add: function (word) {
+          // var low = (this.low + word.low) | 0;
+          // var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0;
+          // var high = (this.high + word.high + carry) | 0;
+          // return X64Word.create(high, low);
+          // }
+        }), c.WordArray = a.extend({
+          /**
+           * Initializes a newly created word array.
+           *
+           * @param {Array} words (Optional) An array of CryptoJS.x64.Word objects.
+           * @param {number} sigBytes (Optional) The number of significant bytes in the words.
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.x64.WordArray.create();
+           *
+           *     var wordArray = CryptoJS.x64.WordArray.create([
+           *         CryptoJS.x64.Word.create(0x00010203, 0x04050607),
+           *         CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
+           *     ]);
+           *
+           *     var wordArray = CryptoJS.x64.WordArray.create([
+           *         CryptoJS.x64.Word.create(0x00010203, 0x04050607),
+           *         CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
+           *     ], 10);
+           */
+          init: function(r, e) {
+            r = this.words = r || [], e != i ? this.sigBytes = e : this.sigBytes = r.length * 8;
+          },
+          /**
+           * Converts this 64-bit word array to a 32-bit word array.
+           *
+           * @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array.
+           *
+           * @example
+           *
+           *     var x32WordArray = x64WordArray.toX32();
+           */
+          toX32: function() {
+            for (var r = this.words, e = r.length, t = [], o = 0; o < e; o++) {
+              var l = r[o];
+              t.push(l.high), t.push(l.low);
+            }
+            return d.create(t, this.sigBytes);
+          },
+          /**
+           * Creates a copy of this word array.
+           *
+           * @return {X64WordArray} The clone.
+           *
+           * @example
+           *
+           *     var clone = x64WordArray.clone();
+           */
+          clone: function() {
+            for (var r = a.clone.call(this), e = r.words = this.words.slice(0), t = e.length, o = 0; o < t; o++)
+              e[o] = e[o].clone();
+            return r;
+          }
+        });
+      }(), s;
+    });
+  }(n), n.exports);
+}
+export {
+  w as __require
+};

package/dist/vendor/debug/src/browser.js

@@ -0,0 +1,146 @@
+import { __module as C } from "../../../commonjs-virtual-dir/browser.js";
+import { __require as g } from "./common.js";
+var F;
+function p() {
+  return F ? C.exports : (F = 1, function(t, r) {
+    r.formatArgs = u, r.save = c, r.load = d, r.useColors = a, r.storage = l(), r.destroy = /* @__PURE__ */ (() => {
+      let e = !1;
+      return () => {
+        e || (e = !0, console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."));
+      };
+    })(), r.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function a() {
+      if (typeof window < "u" && window.process && (window.process.type === "renderer" || window.process.__nwjs))
+        return !0;
+      if (typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/))
+        return !1;
+      let e;
+      return typeof document < "u" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window < "u" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator < "u" && navigator.userAgent && (e = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(e[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function u(e) {
+      if (e[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + e[0] + (this.useColors ? "%c " : " ") + "+" + t.exports.humanize(this.diff), !this.useColors)
+        return;
+      const o = "color: " + this.color;
+      e.splice(1, 0, o, "color: inherit");
+      let n = 0, s = 0;
+      e[0].replace(/%[a-zA-Z%]/g, (i) => {
+        i !== "%%" && (n++, i === "%c" && (s = n));
+      }), e.splice(s, 0, o);
+    }
+    r.log = console.debug || console.log || (() => {
+    });
+    function c(e) {
+      try {
+        e ? r.storage.setItem("debug", e) : r.storage.removeItem("debug");
+      } catch {
+      }
+    }
+    function d() {
+      let e;
+      try {
+        e = r.storage.getItem("debug") || r.storage.getItem("DEBUG");
+      } catch {
+      }
+      return !e && typeof process < "u" && "env" in process && (e = process.env.DEBUG), e;
+    }
+    function l() {
+      try {
+        return localStorage;
+      } catch {
+      }
+    }
+    t.exports = g()(r);
+    const { formatters: f } = t.exports;
+    f.j = function(e) {
+      try {
+        return JSON.stringify(e);
+      } catch (o) {
+        return "[UnexpectedJSONParseError]: " + o.message;
+      }
+    };
+  }(C, C.exports), C.exports);
+}
+export {
+  p as __require
+};

package/dist/vendor/debug/src/common.js

@@ -0,0 +1,97 @@
+import { __require as _ } from "../../ms/index.js";
+var d, m;
+function z() {
+  if (m) return d;
+  m = 1;
+  function g(b) {
+    e.debug = e, e.default = e, e.coerce = I, e.disable = k, e.enable = x, e.enabled = w, e.humanize = _(), e.destroy = q, Object.keys(b).forEach((n) => {
+      e[n] = b[n];
+    }), e.names = [], e.skips = [], e.formatters = {};
+    function y(n) {
+      let t = 0;
+      for (let r = 0; r < n.length; r++)
+        t = (t << 5) - t + n.charCodeAt(r), t |= 0;
+      return e.colors[Math.abs(t) % e.colors.length];
+    }
+    e.selectColor = y;
+    function e(n) {
+      let t, r = null, o, f;
+      function s(...l) {
+        if (!s.enabled)
+          return;
+        const i = s, u = Number(/* @__PURE__ */ new Date()), v = u - (t || u);
+        i.diff = v, i.prev = t, i.curr = u, t = u, l[0] = e.coerce(l[0]), typeof l[0] != "string" && l.unshift("%O");
+        let c = 0;
+        l[0] = l[0].replace(/%([a-zA-Z%])/g, (a, j) => {
+          if (a === "%%")
+            return "%";
+          c++;
+          const p = e.formatters[j];
+          if (typeof p == "function") {
+            const O = l[c];
+            a = p.call(i, O), l.splice(c, 1), c--;
+          }
+          return a;
+        }), e.formatArgs.call(i, l), (i.log || e.log).apply(i, l);
+      }
+      return s.namespace = n, s.useColors = e.useColors(), s.color = e.selectColor(n), s.extend = C, s.destroy = e.destroy, Object.defineProperty(s, "enabled", {
+        enumerable: !0,
+        configurable: !1,
+        get: () => r !== null ? r : (o !== e.namespaces && (o = e.namespaces, f = e.enabled(n)), f),
+        set: (l) => {
+          r = l;
+        }
+      }), typeof e.init == "function" && e.init(s), s;
+    }
+    function C(n, t) {
+      const r = e(this.namespace + (typeof t > "u" ? ":" : t) + n);
+      return r.log = this.log, r;
+    }
+    function x(n) {
+      e.save(n), e.namespaces = n, e.names = [], e.skips = [];
+      const t = (typeof n == "string" ? n : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+      for (const r of t)
+        r[0] === "-" ? e.skips.push(r.slice(1)) : e.names.push(r);
+    }
+    function h(n, t) {
+      let r = 0, o = 0, f = -1, s = 0;
+      for (; r < n.length; )
+        if (o < t.length && (t[o] === n[r] || t[o] === "*"))
+          t[o] === "*" ? (f = o, s = r, o++) : (r++, o++);
+        else if (f !== -1)
+          o = f + 1, s++, r = s;
+        else
+          return !1;
+      for (; o < t.length && t[o] === "*"; )
+        o++;
+      return o === t.length;
+    }
+    function k() {
+      const n = [
+        ...e.names,
+        ...e.skips.map((t) => "-" + t)
+      ].join(",");
+      return e.enable(""), n;
+    }
+    function w(n) {
+      for (const t of e.skips)
+        if (h(n, t))
+          return !1;
+      for (const t of e.names)
+        if (h(n, t))
+          return !0;
+      return !1;
+    }
+    function I(n) {
+      return n instanceof Error ? n.stack || n.message : n;
+    }
+    function q() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    return e.enable(e.load()), e;
+  }
+  return d = g, d;
+}
+export {
+  z as __require
+};

package/dist/vendor/events/events.js

@@ -0,0 +1,216 @@
+import { __module as p } from "../../commonjs-virtual-dir/events.js";
+var x;
+function F() {
+  if (x) return p.exports;
+  x = 1;
+  var a = typeof Reflect == "object" ? Reflect : null, d = a && typeof a.apply == "function" ? a.apply : function(e, n, r) {
+    return Function.prototype.apply.call(e, n, r);
+  }, l;
+  a && typeof a.ownKeys == "function" ? l = a.ownKeys : Object.getOwnPropertySymbols ? l = function(e) {
+    return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e));
+  } : l = function(e) {
+    return Object.getOwnPropertyNames(e);
+  };
+  function C(t) {
+    console && console.warn && console.warn(t);
+  }
+  var h = Number.isNaN || function(e) {
+    return e !== e;
+  };
+  function o() {
+    o.init.call(this);
+  }
+  p.exports = o, p.exports.once = M, o.EventEmitter = o, o.prototype._events = void 0, o.prototype._eventsCount = 0, o.prototype._maxListeners = void 0;
+  var m = 10;
+  function v(t) {
+    if (typeof t != "function")
+      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof t);
+  }
+  Object.defineProperty(o, "defaultMaxListeners", {
+    enumerable: !0,
+    get: function() {
+      return m;
+    },
+    set: function(t) {
+      if (typeof t != "number" || t < 0 || h(t))
+        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + t + ".");
+      m = t;
+    }
+  }), o.init = function() {
+    (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+  }, o.prototype.setMaxListeners = function(e) {
+    if (typeof e != "number" || e < 0 || h(e))
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + e + ".");
+    return this._maxListeners = e, this;
+  };
+  function L(t) {
+    return t._maxListeners === void 0 ? o.defaultMaxListeners : t._maxListeners;
+  }
+  o.prototype.getMaxListeners = function() {
+    return L(this);
+  }, o.prototype.emit = function(e) {
+    for (var n = [], r = 1; r < arguments.length; r++) n.push(arguments[r]);
+    var i = e === "error", f = this._events;
+    if (f !== void 0)
+      i = i && f.error === void 0;
+    else if (!i)
+      return !1;
+    if (i) {
+      var s;
+      if (n.length > 0 && (s = n[0]), s instanceof Error)
+        throw s;
+      var u = new Error("Unhandled error." + (s ? " (" + s.message + ")" : ""));
+      throw u.context = s, u;
+    }
+    var c = f[e];
+    if (c === void 0)
+      return !1;
+    if (typeof c == "function")
+      d(c, this, n);
+    else
+      for (var O = c.length, P = b(c, O), r = 0; r < O; ++r)
+        d(P[r], this, n);
+    return !0;
+  };
+  function y(t, e, n, r) {
+    var i, f, s;
+    if (v(n), f = t._events, f === void 0 ? (f = t._events = /* @__PURE__ */ Object.create(null), t._eventsCount = 0) : (f.newListener !== void 0 && (t.emit(
+      "newListener",
+      e,
+      n.listener ? n.listener : n
+    ), f = t._events), s = f[e]), s === void 0)
+      s = f[e] = n, ++t._eventsCount;
+    else if (typeof s == "function" ? s = f[e] = r ? [n, s] : [s, n] : r ? s.unshift(n) : s.push(n), i = L(t), i > 0 && s.length > i && !s.warned) {
+      s.warned = !0;
+      var u = new Error("Possible EventEmitter memory leak detected. " + s.length + " " + String(e) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+      u.name = "MaxListenersExceededWarning", u.emitter = t, u.type = e, u.count = s.length, C(u);
+    }
+    return t;
+  }
+  o.prototype.addListener = function(e, n) {
+    return y(this, e, n, !1);
+  }, o.prototype.on = o.prototype.addListener, o.prototype.prependListener = function(e, n) {
+    return y(this, e, n, !0);
+  };
+  function R() {
+    if (!this.fired)
+      return this.target.removeListener(this.type, this.wrapFn), this.fired = !0, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
+  }
+  function g(t, e, n) {
+    var r = { fired: !1, wrapFn: void 0, target: t, type: e, listener: n }, i = R.bind(r);
+    return i.listener = n, r.wrapFn = i, i;
+  }
+  o.prototype.once = function(e, n) {
+    return v(n), this.on(e, g(this, e, n)), this;
+  }, o.prototype.prependOnceListener = function(e, n) {
+    return v(n), this.prependListener(e, g(this, e, n)), this;
+  }, o.prototype.removeListener = function(e, n) {
+    var r, i, f, s, u;
+    if (v(n), i = this._events, i === void 0)
+      return this;
+    if (r = i[e], r === void 0)
+      return this;
+    if (r === n || r.listener === n)
+      --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete i[e], i.removeListener && this.emit("removeListener", e, r.listener || n));
+    else if (typeof r != "function") {
+      for (f = -1, s = r.length - 1; s >= 0; s--)
+        if (r[s] === n || r[s].listener === n) {
+          u = r[s].listener, f = s;
+          break;
+        }
+      if (f < 0)
+        return this;
+      f === 0 ? r.shift() : j(r, f), r.length === 1 && (i[e] = r[0]), i.removeListener !== void 0 && this.emit("removeListener", e, u || n);
+    }
+    return this;
+  }, o.prototype.off = o.prototype.removeListener, o.prototype.removeAllListeners = function(e) {
+    var n, r, i;
+    if (r = this._events, r === void 0)
+      return this;
+    if (r.removeListener === void 0)
+      return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : r[e] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete r[e]), this;
+    if (arguments.length === 0) {
+      var f = Object.keys(r), s;
+      for (i = 0; i < f.length; ++i)
+        s = f[i], s !== "removeListener" && this.removeAllListeners(s);
+      return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
+    }
+    if (n = r[e], typeof n == "function")
+      this.removeListener(e, n);
+    else if (n !== void 0)
+      for (i = n.length - 1; i >= 0; i--)
+        this.removeListener(e, n[i]);
+    return this;
+  };
+  function _(t, e, n) {
+    var r = t._events;
+    if (r === void 0)
+      return [];
+    var i = r[e];
+    return i === void 0 ? [] : typeof i == "function" ? n ? [i.listener || i] : [i] : n ? N(i) : b(i, i.length);
+  }
+  o.prototype.listeners = function(e) {
+    return _(this, e, !0);
+  }, o.prototype.rawListeners = function(e) {
+    return _(this, e, !1);
+  }, o.listenerCount = function(t, e) {
+    return typeof t.listenerCount == "function" ? t.listenerCount(e) : w.call(t, e);
+  }, o.prototype.listenerCount = w;
+  function w(t) {
+    var e = this._events;
+    if (e !== void 0) {
+      var n = e[t];
+      if (typeof n == "function")
+        return 1;
+      if (n !== void 0)
+        return n.length;
+    }
+    return 0;
+  }
+  o.prototype.eventNames = function() {
+    return this._eventsCount > 0 ? l(this._events) : [];
+  };
+  function b(t, e) {
+    for (var n = new Array(e), r = 0; r < e; ++r)
+      n[r] = t[r];
+    return n;
+  }
+  function j(t, e) {
+    for (; e + 1 < t.length; e++)
+      t[e] = t[e + 1];
+    t.pop();
+  }
+  function N(t) {
+    for (var e = new Array(t.length), n = 0; n < e.length; ++n)
+      e[n] = t[n].listener || t[n];
+    return e;
+  }
+  function M(t, e) {
+    return new Promise(function(n, r) {
+      function i(s) {
+        t.removeListener(e, f), r(s);
+      }
+      function f() {
+        typeof t.removeListener == "function" && t.removeListener("error", i), n([].slice.call(arguments));
+      }
+      E(t, e, f, { once: !0 }), e !== "error" && A(t, i, { once: !0 });
+    });
+  }
+  function A(t, e, n) {
+    typeof t.on == "function" && E(t, "error", e, n);
+  }
+  function E(t, e, n, r) {
+    if (typeof t.on == "function")
+      r.once ? t.once(e, n) : t.on(e, n);
+    else if (typeof t.addEventListener == "function")
+      t.addEventListener(e, function i(f) {
+        r.once && t.removeEventListener(e, i), n(f);
+      });
+    else
+      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof t);
+  }
+  return p.exports;
+}
+export {
+  F as __require
+};