astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es1519.js

@@ -0,0 +1,130 @@
+import { __exports as y } from "./astra-sdk.es1558.js";
+import { __require as D } from "./astra-sdk.es1559.js";
+import { __require as I } from "./astra-sdk.es1517.js";
+var g;
+function P() {
+  return g ? y : (g = 1, function(n) {
+    /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+    Object.defineProperty(n, "__esModule", { value: !0 }), n.Hash = n.nextTick = n.byteSwapIfBE = n.byteSwap = n.isLE = n.rotl = n.rotr = n.createView = n.u32 = n.u8 = void 0, n.isBytes = p, n.byteSwap32 = O, n.bytesToHex = k, n.hexToBytes = E, n.asyncLoop = U, n.utf8ToBytes = w, n.toBytes = a, n.concatBytes = V, n.checkOpts = j, n.wrapConstructor = C, n.wrapConstructorWithOpts = H, n.wrapXOFConstructorWithOpts = F, n.randomBytes = R;
+    const f = /* @__PURE__ */ D(), s = /* @__PURE__ */ I();
+    function p(t) {
+      return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+    }
+    const h = (t) => new Uint8Array(t.buffer, t.byteOffset, t.byteLength);
+    n.u8 = h;
+    const m = (t) => new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
+    n.u32 = m;
+    const _ = (t) => new DataView(t.buffer, t.byteOffset, t.byteLength);
+    n.createView = _;
+    const B = (t, e) => t << 32 - e | t >>> e;
+    n.rotr = B;
+    const L = (t, e) => t << e | t >>> 32 - e >>> 0;
+    n.rotl = L, n.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+    const A = (t) => t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255;
+    n.byteSwap = A, n.byteSwapIfBE = n.isLE ? (t) => t : (t) => (0, n.byteSwap)(t);
+    function O(t) {
+      for (let e = 0; e < t.length; e++)
+        t[e] = (0, n.byteSwap)(t[e]);
+    }
+    const T = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+    function k(t) {
+      (0, s.abytes)(t);
+      let e = "";
+      for (let o = 0; o < t.length; o++)
+        e += T[t[o]];
+      return e;
+    }
+    const u = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+    function l(t) {
+      if (t >= u._0 && t <= u._9)
+        return t - u._0;
+      if (t >= u.A && t <= u.F)
+        return t - (u.A - 10);
+      if (t >= u.a && t <= u.f)
+        return t - (u.a - 10);
+    }
+    function E(t) {
+      if (typeof t != "string")
+        throw new Error("hex string expected, got " + typeof t);
+      const e = t.length, o = e / 2;
+      if (e % 2)
+        throw new Error("hex string expected, got unpadded hex of length " + e);
+      const r = new Uint8Array(o);
+      for (let i = 0, c = 0; i < o; i++, c += 2) {
+        const d = l(t.charCodeAt(c)), b = l(t.charCodeAt(c + 1));
+        if (d === void 0 || b === void 0) {
+          const W = t[c] + t[c + 1];
+          throw new Error('hex string expected, got non-hex character "' + W + '" at index ' + c);
+        }
+        r[i] = d * 16 + b;
+      }
+      return r;
+    }
+    const S = async () => {
+    };
+    n.nextTick = S;
+    async function U(t, e, o) {
+      let r = Date.now();
+      for (let i = 0; i < t; i++) {
+        o(i);
+        const c = Date.now() - r;
+        c >= 0 && c < e || (await (0, n.nextTick)(), r += c);
+      }
+    }
+    function w(t) {
+      if (typeof t != "string")
+        throw new Error("utf8ToBytes expected string, got " + typeof t);
+      return new Uint8Array(new TextEncoder().encode(t));
+    }
+    function a(t) {
+      return typeof t == "string" && (t = w(t)), (0, s.abytes)(t), t;
+    }
+    function V(...t) {
+      let e = 0;
+      for (let r = 0; r < t.length; r++) {
+        const i = t[r];
+        (0, s.abytes)(i), e += i.length;
+      }
+      const o = new Uint8Array(e);
+      for (let r = 0, i = 0; r < t.length; r++) {
+        const c = t[r];
+        o.set(c, i), i += c.length;
+      }
+      return o;
+    }
+    class q {
+      // Safe version that clones internal state
+      clone() {
+        return this._cloneInto();
+      }
+    }
+    n.Hash = q;
+    function j(t, e) {
+      if (e !== void 0 && {}.toString.call(e) !== "[object Object]")
+        throw new Error("Options should be object or undefined");
+      return Object.assign(t, e);
+    }
+    function C(t) {
+      const e = (r) => t().update(a(r)).digest(), o = t();
+      return e.outputLen = o.outputLen, e.blockLen = o.blockLen, e.create = () => t(), e;
+    }
+    function H(t) {
+      const e = (r, i) => t(i).update(a(r)).digest(), o = t({});
+      return e.outputLen = o.outputLen, e.blockLen = o.blockLen, e.create = (r) => t(r), e;
+    }
+    function F(t) {
+      const e = (r, i) => t(i).update(a(r)).digest(), o = t({});
+      return e.outputLen = o.outputLen, e.blockLen = o.blockLen, e.create = (r) => t(r), e;
+    }
+    function R(t = 32) {
+      if (f.crypto && typeof f.crypto.getRandomValues == "function")
+        return f.crypto.getRandomValues(new Uint8Array(t));
+      if (f.crypto && typeof f.crypto.randomBytes == "function")
+        return f.crypto.randomBytes(t);
+      throw new Error("crypto.getRandomValues must be defined");
+    }
+  }(y), y);
+}
+export {
+  P as __require
+};

package/dist/astra-sdk.es152.js

@@ -0,0 +1,169 @@
+import "./astra-sdk.es18.js";
+import { RouterController as s } from "./astra-sdk.es19.js";
+import "./astra-sdk.es20.js";
+import "./astra-sdk.es21.js";
+import "./astra-sdk.es22.js";
+import "./astra-sdk.es23.js";
+import { ConnectorController as a } from "./astra-sdk.es24.js";
+import "./astra-sdk.es25.js";
+import { ApiController as f } from "./astra-sdk.es26.js";
+import "./astra-sdk.es27.js";
+import "./astra-sdk.es28.js";
+import "./astra-sdk.es29.js";
+import "./astra-sdk.es30.js";
+import "./astra-sdk.es31.js";
+import "./astra-sdk.es32.js";
+import "./astra-sdk.es33.js";
+import "./astra-sdk.es34.js";
+import "./astra-sdk.es35.js";
+import "./astra-sdk.es36.js";
+import "./astra-sdk.es37.js";
+import "./astra-sdk.es38.js";
+import { AssetUtil as h } from "./astra-sdk.es348.js";
+import { CoreHelperUtil as b } from "./astra-sdk.es58.js";
+import "./astra-sdk.es14.js";
+import "./astra-sdk.es15.js";
+import "./astra-sdk.es39.js";
+import "./astra-sdk.es10.js";
+import "./astra-sdk.es12.js";
+import "./astra-sdk.es13.js";
+import "./astra-sdk.es16.js";
+import "./astra-sdk.es229.js";
+import { html as c } from "./astra-sdk.es230.js";
+import { LitElement as x } from "./astra-sdk.es231.js";
+import "./astra-sdk.es232.js";
+import "./astra-sdk.es233.js";
+import "./astra-sdk.es234.js";
+import "./astra-sdk.es235.js";
+import "./astra-sdk.es236.js";
+import "./astra-sdk.es237.js";
+import "./astra-sdk.es238.js";
+import "./astra-sdk.es239.js";
+import "./astra-sdk.es240.js";
+import "./astra-sdk.es241.js";
+import "./astra-sdk.es242.js";
+import "./astra-sdk.es243.js";
+import "./astra-sdk.es244.js";
+import "./astra-sdk.es245.js";
+import "./astra-sdk.es246.js";
+import "./astra-sdk.es247.js";
+import "./astra-sdk.es248.js";
+import "./astra-sdk.es249.js";
+import "./astra-sdk.es250.js";
+import "./astra-sdk.es251.js";
+import "./astra-sdk.es252.js";
+import "./astra-sdk.es253.js";
+import "./astra-sdk.es254.js";
+import "./astra-sdk.es255.js";
+import "./astra-sdk.es256.js";
+import "./astra-sdk.es257.js";
+import "./astra-sdk.es258.js";
+import "./astra-sdk.es259.js";
+import "./astra-sdk.es260.js";
+import "./astra-sdk.es261.js";
+import "./astra-sdk.es262.js";
+import "./astra-sdk.es263.js";
+import "./astra-sdk.es264.js";
+import "./astra-sdk.es265.js";
+import "./astra-sdk.es266.js";
+import "./astra-sdk.es267.js";
+import "./astra-sdk.es268.js";
+import "./astra-sdk.es269.js";
+import "./astra-sdk.es270.js";
+import "./astra-sdk.es271.js";
+import "./astra-sdk.es272.js";
+import "./astra-sdk.es273.js";
+import "./astra-sdk.es274.js";
+import "./astra-sdk.es275.js";
+import "./astra-sdk.es276.js";
+import "./astra-sdk.es277.js";
+import "./astra-sdk.es278.js";
+import "./astra-sdk.es279.js";
+import "./astra-sdk.es280.js";
+import "./astra-sdk.es281.js";
+import "./astra-sdk.es282.js";
+import "./astra-sdk.es283.js";
+import "./astra-sdk.es284.js";
+import "./astra-sdk.es285.js";
+import "./astra-sdk.es286.js";
+import "./astra-sdk.es287.js";
+import "./astra-sdk.es288.js";
+import "./astra-sdk.es289.js";
+import "./astra-sdk.es290.js";
+import "./astra-sdk.es291.js";
+import "./astra-sdk.es292.js";
+import "./astra-sdk.es293.js";
+import "./astra-sdk.es294.js";
+import "./astra-sdk.es295.js";
+import "./astra-sdk.es296.js";
+import "./astra-sdk.es297.js";
+import "./astra-sdk.es298.js";
+import "./astra-sdk.es299.js";
+import "./astra-sdk.es300.js";
+import "./astra-sdk.es301.js";
+import "./astra-sdk.es302.js";
+import "./astra-sdk.es303.js";
+import "./astra-sdk.es304.js";
+import "./astra-sdk.es305.js";
+import "./astra-sdk.es306.js";
+import "./astra-sdk.es307.js";
+import "./astra-sdk.es308.js";
+import "./astra-sdk.es309.js";
+import "./astra-sdk.es310.js";
+import "./astra-sdk.es311.js";
+import { customElement as C } from "./astra-sdk.es456.js";
+import { property as w } from "./astra-sdk.es475.js";
+import { state as g } from "./astra-sdk.es476.js";
+import { ifDefined as d } from "./astra-sdk.es477.js";
+var u = function(p, t, i, o) {
+  var m = arguments.length, r = m < 3 ? t : o === null ? o = Object.getOwnPropertyDescriptor(t, i) : o, e;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") r = Reflect.decorate(p, t, i, o);
+  else for (var l = p.length - 1; l >= 0; l--) (e = p[l]) && (r = (m < 3 ? e(r) : m > 3 ? e(t, i, r) : e(t, i)) || r);
+  return m > 3 && r && Object.defineProperty(t, i, r), r;
+};
+let n = class extends x {
+  constructor() {
+    super(), this.unsubscribe = [], this.tabIdx = void 0, this.connectors = a.state.connectors, this.unsubscribe.push(a.subscribeKey("connectors", (t) => this.connectors = t));
+  }
+  disconnectedCallback() {
+    this.unsubscribe.forEach((t) => t());
+  }
+  render() {
+    const t = this.connectors.filter((i) => i.type === "ANNOUNCED");
+    return t != null && t.length ? c`
+      <wui-flex flexDirection="column" gap="xs">
+        ${t.map((i) => {
+      var o, m;
+      return (o = i.info) != null && o.rdns && f.state.excludedRDNS && f.state.excludedRDNS.includes((m = i == null ? void 0 : i.info) == null ? void 0 : m.rdns) ? null : c`
+            <wui-list-wallet
+              imageSrc=${d(h.getConnectorImage(i))}
+              name=${i.name ?? "Unknown"}
+              @click=${() => this.onConnector(i)}
+              tagVariant="success"
+              tagLabel="installed"
+              data-testid=${`wallet-selector-${i.id}`}
+              .installed=${!0}
+              tabIdx=${d(this.tabIdx)}
+            >
+            </wui-list-wallet>
+          `;
+    })}
+      </wui-flex>
+    ` : (this.style.cssText = "display: none", null);
+  }
+  onConnector(t) {
+    t.id === "walletConnect" ? b.isMobile() ? s.push("AllWallets") : s.push("ConnectingWalletConnect") : s.push("ConnectingExternal", { connector: t });
+  }
+};
+u([
+  w()
+], n.prototype, "tabIdx", void 0);
+u([
+  g()
+], n.prototype, "connectors", void 0);
+n = u([
+  C("w3m-connect-announced-widget")
+], n);
+export {
+  n as W3mConnectAnnouncedWidget
+};

package/dist/astra-sdk.es1520.js

@@ -0,0 +1,4 @@
+var r = {};
+export {
+  r as __exports
+};

package/dist/astra-sdk.es1521.js

@@ -0,0 +1,4 @@
+var e = { exports: {} };
+export {
+  e as __module
+};

package/dist/astra-sdk.es1522.js

@@ -0,0 +1,356 @@
+import l from "./astra-sdk.es52.js";
+import { commonjsGlobal as Y } from "./astra-sdk.es474.js";
+import { __require as _e } from "./astra-sdk.es961.js";
+import { __require as me } from "./astra-sdk.es1560.js";
+import { __require as ye } from "./astra-sdk.es1221.js";
+import { __require as ve } from "./astra-sdk.es1561.js";
+import { __require as we } from "./astra-sdk.es1562.js";
+import { __require as Re } from "./astra-sdk.es1563.js";
+import { __require as Se } from "./astra-sdk.es1564.js";
+import { __require as Ee } from "./astra-sdk.es1565.js";
+import { __require as Me } from "./astra-sdk.es1284.js";
+import { __require as $ } from "./astra-sdk.es1524.js";
+import { __require as X } from "./astra-sdk.es1566.js";
+import { __require as Le } from "./astra-sdk.es1567.js";
+import { __require as De } from "./astra-sdk.es1568.js";
+var W, z;
+function ke() {
+  if (z) return W;
+  z = 1, W = o;
+  var u;
+  o.ReadableState = x, _e().EventEmitter;
+  var N = function(e, i) {
+    return e.listeners(i).length;
+  }, g = me(), m = ye().Buffer, J = (typeof Y < "u" ? Y : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
+  };
+  function K(r) {
+    return m.from(r);
+  }
+  function Q(r) {
+    return m.isBuffer(r) || r instanceof J;
+  }
+  var R = ve(), n;
+  R && R.debuglog ? n = R.debuglog("stream") : n = function() {
+  };
+  var Z = we(), S = Re(), ee = Se(), re = ee.getHighWaterMark, y = Ee().codes, ie = y.ERR_INVALID_ARG_TYPE, te = y.ERR_STREAM_PUSH_AFTER_EOF, ne = y.ERR_METHOD_NOT_IMPLEMENTED, ae = y.ERR_STREAM_UNSHIFT_AFTER_END_EVENT, s, E, M;
+  Me()(o, g);
+  var c = S.errorOrDestroy, L = ["error", "close", "destroy", "pause", "resume"];
+  function oe(r, e, i) {
+    if (typeof r.prependListener == "function") return r.prependListener(e, i);
+    !r._events || !r._events[e] ? r.on(e, i) : Array.isArray(r._events[e]) ? r._events[e].unshift(i) : r._events[e] = [i, r._events[e]];
+  }
+  function x(r, e, i) {
+    u = u || $(), r = r || {}, typeof i != "boolean" && (i = e instanceof u), this.objectMode = !!r.objectMode, i && (this.objectMode = this.objectMode || !!r.readableObjectMode), this.highWaterMark = re(this, r, "readableHighWaterMark", i), this.buffer = new Z(), this.length = 0, this.pipes = null, this.pipesCount = 0, this.flowing = null, this.ended = !1, this.endEmitted = !1, this.reading = !1, this.sync = !0, this.needReadable = !1, this.emittedReadable = !1, this.readableListening = !1, this.resumeScheduled = !1, this.paused = !0, this.emitClose = r.emitClose !== !1, this.autoDestroy = !!r.autoDestroy, this.destroyed = !1, this.defaultEncoding = r.defaultEncoding || "utf8", this.awaitDrain = 0, this.readingMore = !1, this.decoder = null, this.encoding = null, r.encoding && (s || (s = X().StringDecoder), this.decoder = new s(r.encoding), this.encoding = r.encoding);
+  }
+  function o(r) {
+    if (u = u || $(), !(this instanceof o)) return new o(r);
+    var e = this instanceof u;
+    this._readableState = new x(r, this, e), this.readable = !0, r && (typeof r.read == "function" && (this._read = r.read), typeof r.destroy == "function" && (this._destroy = r.destroy)), g.call(this);
+  }
+  Object.defineProperty(o.prototype, "destroyed", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState === void 0 ? !1 : this._readableState.destroyed;
+    },
+    set: function(e) {
+      this._readableState && (this._readableState.destroyed = e);
+    }
+  }), o.prototype.destroy = S.destroy, o.prototype._undestroy = S.undestroy, o.prototype._destroy = function(r, e) {
+    e(r);
+  }, o.prototype.push = function(r, e) {
+    var i = this._readableState, t;
+    return i.objectMode ? t = !0 : typeof r == "string" && (e = e || i.defaultEncoding, e !== i.encoding && (r = m.from(r, e), e = ""), t = !0), U(this, r, e, !1, t);
+  }, o.prototype.unshift = function(r) {
+    return U(this, r, null, !0, !1);
+  };
+  function U(r, e, i, t, f) {
+    n("readableAddChunk", e);
+    var a = r._readableState;
+    if (e === null)
+      a.reading = !1, le(r, a);
+    else {
+      var d;
+      if (f || (d = de(a, e)), d)
+        c(r, d);
+      else if (a.objectMode || e && e.length > 0)
+        if (typeof e != "string" && !a.objectMode && Object.getPrototypeOf(e) !== m.prototype && (e = K(e)), t)
+          a.endEmitted ? c(r, new ae()) : D(r, a, e, !0);
+        else if (a.ended)
+          c(r, new te());
+        else {
+          if (a.destroyed)
+            return !1;
+          a.reading = !1, a.decoder && !i ? (e = a.decoder.write(e), a.objectMode || e.length !== 0 ? D(r, a, e, !1) : T(r, a)) : D(r, a, e, !1);
+        }
+      else t || (a.reading = !1, T(r, a));
+    }
+    return !a.ended && (a.length < a.highWaterMark || a.length === 0);
+  }
+  function D(r, e, i, t) {
+    e.flowing && e.length === 0 && !e.sync ? (e.awaitDrain = 0, r.emit("data", i)) : (e.length += e.objectMode ? 1 : i.length, t ? e.buffer.unshift(i) : e.buffer.push(i), e.needReadable && v(r)), T(r, e);
+  }
+  function de(r, e) {
+    var i;
+    return !Q(e) && typeof e != "string" && e !== void 0 && !r.objectMode && (i = new ie("chunk", ["string", "Buffer", "Uint8Array"], e)), i;
+  }
+  o.prototype.isPaused = function() {
+    return this._readableState.flowing === !1;
+  }, o.prototype.setEncoding = function(r) {
+    s || (s = X().StringDecoder);
+    var e = new s(r);
+    this._readableState.decoder = e, this._readableState.encoding = this._readableState.decoder.encoding;
+    for (var i = this._readableState.buffer.head, t = ""; i !== null; )
+      t += e.write(i.data), i = i.next;
+    return this._readableState.buffer.clear(), t !== "" && this._readableState.buffer.push(t), this._readableState.length = t.length, this;
+  };
+  var P = 1073741824;
+  function fe(r) {
+    return r >= P ? r = P : (r--, r |= r >>> 1, r |= r >>> 2, r |= r >>> 4, r |= r >>> 8, r |= r >>> 16, r++), r;
+  }
+  function I(r, e) {
+    return r <= 0 || e.length === 0 && e.ended ? 0 : e.objectMode ? 1 : r !== r ? e.flowing && e.length ? e.buffer.head.data.length : e.length : (r > e.highWaterMark && (e.highWaterMark = fe(r)), r <= e.length ? r : e.ended ? e.length : (e.needReadable = !0, 0));
+  }
+  o.prototype.read = function(r) {
+    n("read", r), r = parseInt(r, 10);
+    var e = this._readableState, i = r;
+    if (r !== 0 && (e.emittedReadable = !1), r === 0 && e.needReadable && ((e.highWaterMark !== 0 ? e.length >= e.highWaterMark : e.length > 0) || e.ended))
+      return n("read: emitReadable", e.length, e.ended), e.length === 0 && e.ended ? C(this) : v(this), null;
+    if (r = I(r, e), r === 0 && e.ended)
+      return e.length === 0 && C(this), null;
+    var t = e.needReadable;
+    n("need readable", t), (e.length === 0 || e.length - r < e.highWaterMark) && (t = !0, n("length less than watermark", t)), e.ended || e.reading ? (t = !1, n("reading or ended", t)) : t && (n("do read"), e.reading = !0, e.sync = !0, e.length === 0 && (e.needReadable = !0), this._read(e.highWaterMark), e.sync = !1, e.reading || (r = I(i, e)));
+    var f;
+    return r > 0 ? f = B(r, e) : f = null, f === null ? (e.needReadable = e.length <= e.highWaterMark, r = 0) : (e.length -= r, e.awaitDrain = 0), e.length === 0 && (e.ended || (e.needReadable = !0), i !== r && e.ended && C(this)), f !== null && this.emit("data", f), f;
+  };
+  function le(r, e) {
+    if (n("onEofChunk"), !e.ended) {
+      if (e.decoder) {
+        var i = e.decoder.end();
+        i && i.length && (e.buffer.push(i), e.length += e.objectMode ? 1 : i.length);
+      }
+      e.ended = !0, e.sync ? v(r) : (e.needReadable = !1, e.emittedReadable || (e.emittedReadable = !0, F(r)));
+    }
+  }
+  function v(r) {
+    var e = r._readableState;
+    n("emitReadable", e.needReadable, e.emittedReadable), e.needReadable = !1, e.emittedReadable || (n("emitReadable", e.flowing), e.emittedReadable = !0, l.nextTick(F, r));
+  }
+  function F(r) {
+    var e = r._readableState;
+    n("emitReadable_", e.destroyed, e.length, e.ended), !e.destroyed && (e.length || e.ended) && (r.emit("readable"), e.emittedReadable = !1), e.needReadable = !e.flowing && !e.ended && e.length <= e.highWaterMark, q(r);
+  }
+  function T(r, e) {
+    e.readingMore || (e.readingMore = !0, l.nextTick(ue, r, e));
+  }
+  function ue(r, e) {
+    for (; !e.reading && !e.ended && (e.length < e.highWaterMark || e.flowing && e.length === 0); ) {
+      var i = e.length;
+      if (n("maybeReadMore read 0"), r.read(0), i === e.length)
+        break;
+    }
+    e.readingMore = !1;
+  }
+  o.prototype._read = function(r) {
+    c(this, new ne("_read()"));
+  }, o.prototype.pipe = function(r, e) {
+    var i = this, t = this._readableState;
+    switch (t.pipesCount) {
+      case 0:
+        t.pipes = r;
+        break;
+      case 1:
+        t.pipes = [t.pipes, r];
+        break;
+      default:
+        t.pipes.push(r);
+        break;
+    }
+    t.pipesCount += 1, n("pipe count=%d opts=%j", t.pipesCount, e);
+    var f = (!e || e.end !== !1) && r !== l.stdout && r !== l.stderr, a = f ? p : _;
+    t.endEmitted ? l.nextTick(a) : i.once("end", a), r.on("unpipe", d);
+    function d(h, b) {
+      n("onunpipe"), h === i && b && b.hasUnpiped === !1 && (b.hasUnpiped = !0, ce());
+    }
+    function p() {
+      n("onend"), r.end();
+    }
+    var w = se(i);
+    r.on("drain", w);
+    var V = !1;
+    function ce() {
+      n("cleanup"), r.removeListener("close", j), r.removeListener("finish", O), r.removeListener("drain", w), r.removeListener("error", A), r.removeListener("unpipe", d), i.removeListener("end", p), i.removeListener("end", _), i.removeListener("data", G), V = !0, t.awaitDrain && (!r._writableState || r._writableState.needDrain) && w();
+    }
+    i.on("data", G);
+    function G(h) {
+      n("ondata");
+      var b = r.write(h);
+      n("dest.write", b), b === !1 && ((t.pipesCount === 1 && t.pipes === r || t.pipesCount > 1 && k(t.pipes, r) !== -1) && !V && (n("false write response, pause", t.awaitDrain), t.awaitDrain++), i.pause());
+    }
+    function A(h) {
+      n("onerror", h), _(), r.removeListener("error", A), N(r, "error") === 0 && c(r, h);
+    }
+    oe(r, "error", A);
+    function j() {
+      r.removeListener("finish", O), _();
+    }
+    r.once("close", j);
+    function O() {
+      n("onfinish"), r.removeListener("close", j), _();
+    }
+    r.once("finish", O);
+    function _() {
+      n("unpipe"), i.unpipe(r);
+    }
+    return r.emit("pipe", i), t.flowing || (n("pipe resume"), i.resume()), r;
+  };
+  function se(r) {
+    return function() {
+      var i = r._readableState;
+      n("pipeOnDrain", i.awaitDrain), i.awaitDrain && i.awaitDrain--, i.awaitDrain === 0 && N(r, "data") && (i.flowing = !0, q(r));
+    };
+  }
+  o.prototype.unpipe = function(r) {
+    var e = this._readableState, i = {
+      hasUnpiped: !1
+    };
+    if (e.pipesCount === 0) return this;
+    if (e.pipesCount === 1)
+      return r && r !== e.pipes ? this : (r || (r = e.pipes), e.pipes = null, e.pipesCount = 0, e.flowing = !1, r && r.emit("unpipe", this, i), this);
+    if (!r) {
+      var t = e.pipes, f = e.pipesCount;
+      e.pipes = null, e.pipesCount = 0, e.flowing = !1;
+      for (var a = 0; a < f; a++) t[a].emit("unpipe", this, {
+        hasUnpiped: !1
+      });
+      return this;
+    }
+    var d = k(e.pipes, r);
+    return d === -1 ? this : (e.pipes.splice(d, 1), e.pipesCount -= 1, e.pipesCount === 1 && (e.pipes = e.pipes[0]), r.emit("unpipe", this, i), this);
+  }, o.prototype.on = function(r, e) {
+    var i = g.prototype.on.call(this, r, e), t = this._readableState;
+    return r === "data" ? (t.readableListening = this.listenerCount("readable") > 0, t.flowing !== !1 && this.resume()) : r === "readable" && !t.endEmitted && !t.readableListening && (t.readableListening = t.needReadable = !0, t.flowing = !1, t.emittedReadable = !1, n("on readable", t.length, t.reading), t.length ? v(this) : t.reading || l.nextTick(pe, this)), i;
+  }, o.prototype.addListener = o.prototype.on, o.prototype.removeListener = function(r, e) {
+    var i = g.prototype.removeListener.call(this, r, e);
+    return r === "readable" && l.nextTick(H, this), i;
+  }, o.prototype.removeAllListeners = function(r) {
+    var e = g.prototype.removeAllListeners.apply(this, arguments);
+    return (r === "readable" || r === void 0) && l.nextTick(H, this), e;
+  };
+  function H(r) {
+    var e = r._readableState;
+    e.readableListening = r.listenerCount("readable") > 0, e.resumeScheduled && !e.paused ? e.flowing = !0 : r.listenerCount("data") > 0 && r.resume();
+  }
+  function pe(r) {
+    n("readable nexttick read 0"), r.read(0);
+  }
+  o.prototype.resume = function() {
+    var r = this._readableState;
+    return r.flowing || (n("resume"), r.flowing = !r.readableListening, he(this, r)), r.paused = !1, this;
+  };
+  function he(r, e) {
+    e.resumeScheduled || (e.resumeScheduled = !0, l.nextTick(be, r, e));
+  }
+  function be(r, e) {
+    n("resume", e.reading), e.reading || r.read(0), e.resumeScheduled = !1, r.emit("resume"), q(r), e.flowing && !e.reading && r.read(0);
+  }
+  o.prototype.pause = function() {
+    return n("call pause flowing=%j", this._readableState.flowing), this._readableState.flowing !== !1 && (n("pause"), this._readableState.flowing = !1, this.emit("pause")), this._readableState.paused = !0, this;
+  };
+  function q(r) {
+    var e = r._readableState;
+    for (n("flow", e.flowing); e.flowing && r.read() !== null; ) ;
+  }
+  o.prototype.wrap = function(r) {
+    var e = this, i = this._readableState, t = !1;
+    r.on("end", function() {
+      if (n("wrapped end"), i.decoder && !i.ended) {
+        var d = i.decoder.end();
+        d && d.length && e.push(d);
+      }
+      e.push(null);
+    }), r.on("data", function(d) {
+      if (n("wrapped data"), i.decoder && (d = i.decoder.write(d)), !(i.objectMode && d == null) && !(!i.objectMode && (!d || !d.length))) {
+        var p = e.push(d);
+        p || (t = !0, r.pause());
+      }
+    });
+    for (var f in r)
+      this[f] === void 0 && typeof r[f] == "function" && (this[f] = /* @__PURE__ */ function(p) {
+        return function() {
+          return r[p].apply(r, arguments);
+        };
+      }(f));
+    for (var a = 0; a < L.length; a++)
+      r.on(L[a], this.emit.bind(this, L[a]));
+    return this._read = function(d) {
+      n("wrapped _read", d), t && (t = !1, r.resume());
+    }, this;
+  }, typeof Symbol == "function" && (o.prototype[Symbol.asyncIterator] = function() {
+    return E === void 0 && (E = Le()), E(this);
+  }), Object.defineProperty(o.prototype, "readableHighWaterMark", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState.highWaterMark;
+    }
+  }), Object.defineProperty(o.prototype, "readableBuffer", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState && this._readableState.buffer;
+    }
+  }), Object.defineProperty(o.prototype, "readableFlowing", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState.flowing;
+    },
+    set: function(e) {
+      this._readableState && (this._readableState.flowing = e);
+    }
+  }), o._fromList = B, Object.defineProperty(o.prototype, "readableLength", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState.length;
+    }
+  });
+  function B(r, e) {
+    if (e.length === 0) return null;
+    var i;
+    return e.objectMode ? i = e.buffer.shift() : !r || r >= e.length ? (e.decoder ? i = e.buffer.join("") : e.buffer.length === 1 ? i = e.buffer.first() : i = e.buffer.concat(e.length), e.buffer.clear()) : i = e.buffer.consume(r, e.decoder), i;
+  }
+  function C(r) {
+    var e = r._readableState;
+    n("endReadable", e.endEmitted), e.endEmitted || (e.ended = !0, l.nextTick(ge, e, r));
+  }
+  function ge(r, e) {
+    if (n("endReadableNT", r.endEmitted, r.length), !r.endEmitted && r.length === 0 && (r.endEmitted = !0, e.readable = !1, e.emit("end"), r.autoDestroy)) {
+      var i = e._writableState;
+      (!i || i.autoDestroy && i.finished) && e.destroy();
+    }
+  }
+  typeof Symbol == "function" && (o.from = function(r, e) {
+    return M === void 0 && (M = De()), M(o, r, e);
+  });
+  function k(r, e) {
+    for (var i = 0, t = r.length; i < t; i++)
+      if (r[i] === e) return i;
+    return -1;
+  }
+  return W;
+}
+export {
+  ke as __require
+};