astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es1523.js

@@ -0,0 +1,240 @@
+import s from "./astra-sdk.es52.js";
+import { commonjsGlobal as D } from "./astra-sdk.es474.js";
+import { __require as fe } from "./astra-sdk.es1569.js";
+import { __require as ue } from "./astra-sdk.es1560.js";
+import { __require as oe } from "./astra-sdk.es1221.js";
+import { __require as le } from "./astra-sdk.es1563.js";
+import { __require as se } from "./astra-sdk.es1564.js";
+import { __require as ae } from "./astra-sdk.es1565.js";
+import { __require as de } from "./astra-sdk.es1284.js";
+import { __require as A } from "./astra-sdk.es1524.js";
+var g, B;
+function ve() {
+  if (B) return g;
+  B = 1, g = f;
+  function v(r) {
+    var e = this;
+    this.next = null, this.entry = null, this.finish = function() {
+      ie(e, r);
+    };
+  }
+  var a;
+  f.WritableState = c;
+  var m = {
+    deprecate: fe()
+  }, S = ue(), y = oe().Buffer, N = (typeof D < "u" ? D : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
+  };
+  function O(r) {
+    return y.from(r);
+  }
+  function C(r) {
+    return y.isBuffer(r) || r instanceof N;
+  }
+  var R = le(), x = se(), I = x.getHighWaterMark, o = ae().codes, P = o.ERR_INVALID_ARG_TYPE, L = o.ERR_METHOD_NOT_IMPLEMENTED, k = o.ERR_MULTIPLE_CALLBACK, W = o.ERR_STREAM_CANNOT_PIPE, j = o.ERR_STREAM_DESTROYED, U = o.ERR_STREAM_NULL_VALUES, F = o.ERR_STREAM_WRITE_AFTER_END, H = o.ERR_UNKNOWN_ENCODING, d = R.errorOrDestroy;
+  de()(f, S);
+  function G() {
+  }
+  function c(r, e, i) {
+    a = a || A(), r = r || {}, typeof i != "boolean" && (i = e instanceof a), this.objectMode = !!r.objectMode, i && (this.objectMode = this.objectMode || !!r.writableObjectMode), this.highWaterMark = I(this, r, "writableHighWaterMark", i), this.finalCalled = !1, this.needDrain = !1, this.ending = !1, this.ended = !1, this.finished = !1, this.destroyed = !1;
+    var t = r.decodeStrings === !1;
+    this.decodeStrings = !t, this.defaultEncoding = r.defaultEncoding || "utf8", this.length = 0, this.writing = !1, this.corked = 0, this.sync = !0, this.bufferProcessing = !1, this.onwrite = function(n) {
+      Q(e, n);
+    }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = !1, this.errorEmitted = !1, this.emitClose = r.emitClose !== !1, this.autoDestroy = !!r.autoDestroy, this.bufferedRequestCount = 0, this.corkedRequestsFree = new v(this);
+  }
+  c.prototype.getBuffer = function() {
+    for (var e = this.bufferedRequest, i = []; e; )
+      i.push(e), e = e.next;
+    return i;
+  }, function() {
+    try {
+      Object.defineProperty(c.prototype, "buffer", {
+        get: m.deprecate(function() {
+          return this.getBuffer();
+        }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
+      });
+    } catch {
+    }
+  }();
+  var b;
+  typeof Symbol == "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] == "function" ? (b = Function.prototype[Symbol.hasInstance], Object.defineProperty(f, Symbol.hasInstance, {
+    value: function(e) {
+      return b.call(this, e) ? !0 : this !== f ? !1 : e && e._writableState instanceof c;
+    }
+  })) : b = function(e) {
+    return e instanceof this;
+  };
+  function f(r) {
+    a = a || A();
+    var e = this instanceof a;
+    if (!e && !b.call(f, this)) return new f(r);
+    this._writableState = new c(r, this, e), this.writable = !0, r && (typeof r.write == "function" && (this._write = r.write), typeof r.writev == "function" && (this._writev = r.writev), typeof r.destroy == "function" && (this._destroy = r.destroy), typeof r.final == "function" && (this._final = r.final)), S.call(this);
+  }
+  f.prototype.pipe = function() {
+    d(this, new W());
+  };
+  function K(r, e) {
+    var i = new F();
+    d(r, i), s.nextTick(e, i);
+  }
+  function V(r, e, i, t) {
+    var n;
+    return i === null ? n = new U() : typeof i != "string" && !e.objectMode && (n = new P("chunk", ["string", "Buffer"], i)), n ? (d(r, n), s.nextTick(t, n), !1) : !0;
+  }
+  f.prototype.write = function(r, e, i) {
+    var t = this._writableState, n = !1, u = !t.objectMode && C(r);
+    return u && !y.isBuffer(r) && (r = O(r)), typeof e == "function" && (i = e, e = null), u ? e = "buffer" : e || (e = t.defaultEncoding), typeof i != "function" && (i = G), t.ending ? K(this, i) : (u || V(this, t, r, i)) && (t.pendingcb++, n = $(this, t, u, r, e, i)), n;
+  }, f.prototype.cork = function() {
+    this._writableState.corked++;
+  }, f.prototype.uncork = function() {
+    var r = this._writableState;
+    r.corked && (r.corked--, !r.writing && !r.corked && !r.bufferProcessing && r.bufferedRequest && M(this, r));
+  }, f.prototype.setDefaultEncoding = function(e) {
+    if (typeof e == "string" && (e = e.toLowerCase()), !(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((e + "").toLowerCase()) > -1)) throw new H(e);
+    return this._writableState.defaultEncoding = e, this;
+  }, Object.defineProperty(f.prototype, "writableBuffer", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState && this._writableState.getBuffer();
+    }
+  });
+  function Y(r, e, i) {
+    return !r.objectMode && r.decodeStrings !== !1 && typeof e == "string" && (e = y.from(e, i)), e;
+  }
+  Object.defineProperty(f.prototype, "writableHighWaterMark", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState.highWaterMark;
+    }
+  });
+  function $(r, e, i, t, n, u) {
+    if (!i) {
+      var l = Y(e, t, n);
+      t !== l && (i = !0, n = "buffer", t = l);
+    }
+    var h = e.objectMode ? 1 : t.length;
+    e.length += h;
+    var w = e.length < e.highWaterMark;
+    if (w || (e.needDrain = !0), e.writing || e.corked) {
+      var p = e.lastBufferedRequest;
+      e.lastBufferedRequest = {
+        chunk: t,
+        encoding: n,
+        isBuf: i,
+        callback: u,
+        next: null
+      }, p ? p.next = e.lastBufferedRequest : e.bufferedRequest = e.lastBufferedRequest, e.bufferedRequestCount += 1;
+    } else
+      E(r, e, !1, h, t, n, u);
+    return w;
+  }
+  function E(r, e, i, t, n, u, l) {
+    e.writelen = t, e.writecb = l, e.writing = !0, e.sync = !0, e.destroyed ? e.onwrite(new j("write")) : i ? r._writev(n, e.onwrite) : r._write(n, u, e.onwrite), e.sync = !1;
+  }
+  function z(r, e, i, t, n) {
+    --e.pendingcb, i ? (s.nextTick(n, t), s.nextTick(_, r, e), r._writableState.errorEmitted = !0, d(r, t)) : (n(t), r._writableState.errorEmitted = !0, d(r, t), _(r, e));
+  }
+  function J(r) {
+    r.writing = !1, r.writecb = null, r.length -= r.writelen, r.writelen = 0;
+  }
+  function Q(r, e) {
+    var i = r._writableState, t = i.sync, n = i.writecb;
+    if (typeof n != "function") throw new k();
+    if (J(i), e) z(r, i, t, e, n);
+    else {
+      var u = T(i) || r.destroyed;
+      !u && !i.corked && !i.bufferProcessing && i.bufferedRequest && M(r, i), t ? s.nextTick(q, r, i, u, n) : q(r, i, u, n);
+    }
+  }
+  function q(r, e, i, t) {
+    i || X(r, e), e.pendingcb--, t(), _(r, e);
+  }
+  function X(r, e) {
+    e.length === 0 && e.needDrain && (e.needDrain = !1, r.emit("drain"));
+  }
+  function M(r, e) {
+    e.bufferProcessing = !0;
+    var i = e.bufferedRequest;
+    if (r._writev && i && i.next) {
+      var t = e.bufferedRequestCount, n = new Array(t), u = e.corkedRequestsFree;
+      u.entry = i;
+      for (var l = 0, h = !0; i; )
+        n[l] = i, i.isBuf || (h = !1), i = i.next, l += 1;
+      n.allBuffers = h, E(r, e, !0, e.length, n, "", u.finish), e.pendingcb++, e.lastBufferedRequest = null, u.next ? (e.corkedRequestsFree = u.next, u.next = null) : e.corkedRequestsFree = new v(e), e.bufferedRequestCount = 0;
+    } else {
+      for (; i; ) {
+        var w = i.chunk, p = i.encoding, te = i.callback, ne = e.objectMode ? 1 : w.length;
+        if (E(r, e, !1, ne, w, p, te), i = i.next, e.bufferedRequestCount--, e.writing)
+          break;
+      }
+      i === null && (e.lastBufferedRequest = null);
+    }
+    e.bufferedRequest = i, e.bufferProcessing = !1;
+  }
+  f.prototype._write = function(r, e, i) {
+    i(new L("_write()"));
+  }, f.prototype._writev = null, f.prototype.end = function(r, e, i) {
+    var t = this._writableState;
+    return typeof r == "function" ? (i = r, r = null, e = null) : typeof e == "function" && (i = e, e = null), r != null && this.write(r, e), t.corked && (t.corked = 1, this.uncork()), t.ending || re(this, t, i), this;
+  }, Object.defineProperty(f.prototype, "writableLength", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState.length;
+    }
+  });
+  function T(r) {
+    return r.ending && r.length === 0 && r.bufferedRequest === null && !r.finished && !r.writing;
+  }
+  function Z(r, e) {
+    r._final(function(i) {
+      e.pendingcb--, i && d(r, i), e.prefinished = !0, r.emit("prefinish"), _(r, e);
+    });
+  }
+  function ee(r, e) {
+    !e.prefinished && !e.finalCalled && (typeof r._final == "function" && !e.destroyed ? (e.pendingcb++, e.finalCalled = !0, s.nextTick(Z, r, e)) : (e.prefinished = !0, r.emit("prefinish")));
+  }
+  function _(r, e) {
+    var i = T(e);
+    if (i && (ee(r, e), e.pendingcb === 0 && (e.finished = !0, r.emit("finish"), e.autoDestroy))) {
+      var t = r._readableState;
+      (!t || t.autoDestroy && t.endEmitted) && r.destroy();
+    }
+    return i;
+  }
+  function re(r, e, i) {
+    e.ending = !0, _(r, e), i && (e.finished ? s.nextTick(i) : r.once("finish", i)), e.ended = !0, r.writable = !1;
+  }
+  function ie(r, e, i) {
+    var t = r.entry;
+    for (r.entry = null; t; ) {
+      var n = t.callback;
+      e.pendingcb--, n(i), t = t.next;
+    }
+    e.corkedRequestsFree.next = r;
+  }
+  return Object.defineProperty(f.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._writableState === void 0 ? !1 : this._writableState.destroyed;
+    },
+    set: function(e) {
+      this._writableState && (this._writableState.destroyed = e);
+    }
+  }), f.prototype.destroy = R.destroy, f.prototype._undestroy = R.undestroy, f.prototype._destroy = function(r, e) {
+    e(r);
+  }, g;
+}
+export {
+  ve as __require
+};

package/dist/astra-sdk.es1524.js

@@ -0,0 +1,71 @@
+import h from "./astra-sdk.es52.js";
+import { __require as p } from "./astra-sdk.es1522.js";
+import { __require as c } from "./astra-sdk.es1523.js";
+import { __require as w } from "./astra-sdk.es1284.js";
+var l, u;
+function q() {
+  if (u) return l;
+  u = 1;
+  var o = Object.keys || function(e) {
+    var r = [];
+    for (var _ in e) r.push(_);
+    return r;
+  };
+  l = t;
+  var f = p(), a = c();
+  w()(t, f);
+  for (var s = o(a.prototype), i = 0; i < s.length; i++) {
+    var n = s[i];
+    t.prototype[n] || (t.prototype[n] = a.prototype[n]);
+  }
+  function t(e) {
+    if (!(this instanceof t)) return new t(e);
+    f.call(this, e), a.call(this, e), this.allowHalfOpen = !0, e && (e.readable === !1 && (this.readable = !1), e.writable === !1 && (this.writable = !1), e.allowHalfOpen === !1 && (this.allowHalfOpen = !1, this.once("end", d)));
+  }
+  Object.defineProperty(t.prototype, "writableHighWaterMark", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState.highWaterMark;
+    }
+  }), Object.defineProperty(t.prototype, "writableBuffer", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState && this._writableState.getBuffer();
+    }
+  }), Object.defineProperty(t.prototype, "writableLength", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState.length;
+    }
+  });
+  function d() {
+    this._writableState.ended || h.nextTick(b, this);
+  }
+  function b(e) {
+    e.end();
+  }
+  return Object.defineProperty(t.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 || this._writableState === void 0 ? !1 : this._readableState.destroyed && this._writableState.destroyed;
+    },
+    set: function(r) {
+      this._readableState === void 0 || this._writableState === void 0 || (this._readableState.destroyed = r, this._writableState.destroyed = r);
+    }
+  }), l;
+}
+export {
+  q as __require
+};

package/dist/astra-sdk.es1525.js

@@ -0,0 +1,65 @@
+import { __require as T } from "./astra-sdk.es1565.js";
+import { __require as p } from "./astra-sdk.es1524.js";
+import { __require as w } from "./astra-sdk.es1284.js";
+var o, u;
+function S() {
+  if (u) return o;
+  u = 1, o = i;
+  var s = T().codes, h = s.ERR_METHOD_NOT_IMPLEMENTED, l = s.ERR_MULTIPLE_CALLBACK, c = s.ERR_TRANSFORM_ALREADY_TRANSFORMING, m = s.ERR_TRANSFORM_WITH_LENGTH_0, f = p();
+  w()(i, f);
+  function R(r, e) {
+    var t = this._transformState;
+    t.transforming = !1;
+    var a = t.writecb;
+    if (a === null)
+      return this.emit("error", new l());
+    t.writechunk = null, t.writecb = null, e != null && this.push(e), a(r);
+    var n = this._readableState;
+    n.reading = !1, (n.needReadable || n.length < n.highWaterMark) && this._read(n.highWaterMark);
+  }
+  function i(r) {
+    if (!(this instanceof i)) return new i(r);
+    f.call(this, r), this._transformState = {
+      afterTransform: R.bind(this),
+      needTransform: !1,
+      transforming: !1,
+      writecb: null,
+      writechunk: null,
+      writeencoding: null
+    }, this._readableState.needReadable = !0, this._readableState.sync = !1, r && (typeof r.transform == "function" && (this._transform = r.transform), typeof r.flush == "function" && (this._flush = r.flush)), this.on("prefinish", d);
+  }
+  function d() {
+    var r = this;
+    typeof this._flush == "function" && !this._readableState.destroyed ? this._flush(function(e, t) {
+      _(r, e, t);
+    }) : _(this, null, null);
+  }
+  i.prototype.push = function(r, e) {
+    return this._transformState.needTransform = !1, f.prototype.push.call(this, r, e);
+  }, i.prototype._transform = function(r, e, t) {
+    t(new h("_transform()"));
+  }, i.prototype._write = function(r, e, t) {
+    var a = this._transformState;
+    if (a.writecb = t, a.writechunk = r, a.writeencoding = e, !a.transforming) {
+      var n = this._readableState;
+      (a.needTransform || n.needReadable || n.length < n.highWaterMark) && this._read(n.highWaterMark);
+    }
+  }, i.prototype._read = function(r) {
+    var e = this._transformState;
+    e.writechunk !== null && !e.transforming ? (e.transforming = !0, this._transform(e.writechunk, e.writeencoding, e.afterTransform)) : e.needTransform = !0;
+  }, i.prototype._destroy = function(r, e) {
+    f.prototype._destroy.call(this, r, function(t) {
+      e(t);
+    });
+  };
+  function _(r, e, t) {
+    if (e) return r.emit("error", e);
+    if (t != null && r.push(t), r._writableState.length) throw new m();
+    if (r._transformState.transforming) throw new c();
+    return r.push(null);
+  }
+  return o;
+}
+export {
+  S as __require
+};

package/dist/astra-sdk.es1526.js

@@ -0,0 +1,19 @@
+import { __require as n } from "./astra-sdk.es1525.js";
+import { __require as o } from "./astra-sdk.es1284.js";
+var s, a;
+function f() {
+  if (a) return s;
+  a = 1, s = r;
+  var t = n();
+  o()(r, t);
+  function r(e) {
+    if (!(this instanceof r)) return new r(e);
+    t.call(this, e);
+  }
+  return r.prototype._transform = function(e, u, i) {
+    i(null, e);
+  }, s;
+}
+export {
+  f as __require
+};

package/dist/astra-sdk.es1527.js

@@ -0,0 +1,51 @@
+import { __require as A } from "./astra-sdk.es1565.js";
+var v, q;
+function g() {
+  if (q) return v;
+  q = 1;
+  var c = A().codes.ERR_STREAM_PREMATURE_CLOSE;
+  function h(e) {
+    var n = !1;
+    return function() {
+      if (!n) {
+        n = !0;
+        for (var r = arguments.length, f = new Array(r), i = 0; i < r; i++)
+          f[i] = arguments[i];
+        e.apply(this, f);
+      }
+    };
+  }
+  function L() {
+  }
+  function R(e) {
+    return e.setHeader && typeof e.abort == "function";
+  }
+  function b(e, n, r) {
+    if (typeof n == "function") return b(e, null, n);
+    n || (n = {}), r = h(r || L);
+    var f = n.readable || n.readable !== !1 && e.readable, i = n.writable || n.writable !== !1 && e.writable, u = function() {
+      e.writable || o();
+    }, E = e._writableState && e._writableState.finished, o = function() {
+      i = !1, E = !0, f || r.call(e);
+    }, S = e._readableState && e._readableState.endEmitted, w = function() {
+      f = !1, S = !0, i || r.call(e);
+    }, _ = function(l) {
+      r.call(e, l);
+    }, d = function() {
+      var l;
+      if (f && !S)
+        return (!e._readableState || !e._readableState.ended) && (l = new c()), r.call(e, l);
+      if (i && !E)
+        return (!e._writableState || !e._writableState.ended) && (l = new c()), r.call(e, l);
+    }, a = function() {
+      e.req.on("finish", o);
+    };
+    return R(e) ? (e.on("complete", o), e.on("abort", d), e.req ? a() : e.on("request", a)) : i && !e._writableState && (e.on("end", u), e.on("close", u)), e.on("end", w), e.on("finish", o), n.error !== !1 && e.on("error", _), e.on("close", d), function() {
+      e.removeListener("complete", o), e.removeListener("abort", d), e.removeListener("request", a), e.req && e.req.removeListener("finish", o), e.removeListener("end", u), e.removeListener("close", u), e.removeListener("finish", o), e.removeListener("end", w), e.removeListener("error", _), e.removeListener("close", d);
+    };
+  }
+  return v = b, v;
+}
+export {
+  g as __require
+};

package/dist/astra-sdk.es1528.js

@@ -0,0 +1,69 @@
+import { __require as G } from "./astra-sdk.es1565.js";
+import { __require as I } from "./astra-sdk.es1527.js";
+var p, v;
+function O() {
+  if (v) return p;
+  v = 1;
+  var f;
+  function _(r) {
+    var n = !1;
+    return function() {
+      n || (n = !0, r.apply(void 0, arguments));
+    };
+  }
+  var c = G().codes, S = c.ERR_MISSING_ARGS, g = c.ERR_STREAM_DESTROYED;
+  function a(r) {
+    if (r) throw r;
+  }
+  function h(r) {
+    return r.setHeader && typeof r.abort == "function";
+  }
+  function q(r, n, u, e) {
+    e = _(e);
+    var i = !1;
+    r.on("close", function() {
+      i = !0;
+    }), f === void 0 && (f = I()), f(r, {
+      readable: n,
+      writable: u
+    }, function(o) {
+      if (o) return e(o);
+      i = !0, e();
+    });
+    var t = !1;
+    return function(o) {
+      if (!i && !t) {
+        if (t = !0, h(r)) return r.abort();
+        if (typeof r.destroy == "function") return r.destroy();
+        e(o || new g("pipe"));
+      }
+    };
+  }
+  function d(r) {
+    r();
+  }
+  function y(r, n) {
+    return r.pipe(n);
+  }
+  function w(r) {
+    return !r.length || typeof r[r.length - 1] != "function" ? a : r.pop();
+  }
+  function A() {
+    for (var r = arguments.length, n = new Array(r), u = 0; u < r; u++)
+      n[u] = arguments[u];
+    var e = w(n);
+    if (Array.isArray(n[0]) && (n = n[0]), n.length < 2)
+      throw new S("streams");
+    var i, t = n.map(function(o, l) {
+      var R = l < n.length - 1, D = l > 0;
+      return q(o, R, D, function(E) {
+        i || (i = E), E && t.forEach(d), !R && (t.forEach(d), e(i));
+      });
+    });
+    return n.reduce(y);
+  }
+  return p = A, p;
+}
+export {
+  O as __require
+};

package/dist/astra-sdk.es1529.js

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