astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es1570.js

@@ -0,0 +1,603 @@
+class N extends TypeError {
+  constructor(n, t) {
+    let r;
+    const { message: i, explanation: o, ...c } = n, { path: f } = n, u = f.length === 0 ? i : `At path: ${f.join(".")} -- ${i}`;
+    super(o ?? u), o != null && (this.cause = u), Object.assign(this, c), this.name = this.constructor.name, this.failures = () => r ?? (r = [n, ...t()]);
+  }
+}
+function M(e) {
+  return l(e) && typeof e[Symbol.iterator] == "function";
+}
+function l(e) {
+  return typeof e == "object" && e != null;
+}
+function k(e) {
+  if (Object.prototype.toString.call(e) !== "[object Object]")
+    return !1;
+  const n = Object.getPrototypeOf(e);
+  return n === null || n === Object.prototype;
+}
+function a(e) {
+  return typeof e == "symbol" ? e.toString() : typeof e == "string" ? JSON.stringify(e) : `${e}`;
+}
+function _(e) {
+  const { done: n, value: t } = e.next();
+  return n ? void 0 : t;
+}
+function T(e, n, t, r) {
+  if (e === !0)
+    return;
+  e === !1 ? e = {} : typeof e == "string" && (e = { message: e });
+  const { path: i, branch: o } = n, { type: c } = t, { refinement: f, message: u = `Expected a value of type \`${c}\`${f ? ` with refinement \`${f}\`` : ""}, but received: \`${a(r)}\`` } = e;
+  return {
+    value: r,
+    type: c,
+    refinement: f,
+    key: i[i.length - 1],
+    path: i,
+    branch: o,
+    ...e,
+    message: u
+  };
+}
+function* w(e, n, t, r) {
+  M(e) || (e = [e]);
+  for (const i of e) {
+    const o = T(i, n, t, r);
+    o && (yield o);
+  }
+}
+function* j(e, n, t = {}) {
+  const { path: r = [], branch: i = [e], coerce: o = !1, mask: c = !1 } = t, f = { path: r, branch: i };
+  if (o && (e = n.coercer(e, f), c && n.type !== "type" && l(n.schema) && l(e) && !Array.isArray(e)))
+    for (const s in e)
+      n.schema[s] === void 0 && delete e[s];
+  let u = "valid";
+  for (const s of n.validator(e, f))
+    s.explanation = t.message, u = "not_valid", yield [s, void 0];
+  for (let [s, y, A] of n.entries(e, f)) {
+    const O = j(y, A, {
+      path: s === void 0 ? r : [...r, s],
+      branch: s === void 0 ? i : [...i, y],
+      coerce: o,
+      mask: c,
+      message: t.message
+    });
+    for (const m of O)
+      m[0] ? (u = m[0].refinement != null ? "not_refined" : "not_valid", yield [m[0], void 0]) : o && (y = m[1], s === void 0 ? e = y : e instanceof Map ? e.set(s, y) : e instanceof Set ? e.add(y) : l(e) && (y !== void 0 || s in e) && (e[s] = y));
+  }
+  if (u !== "not_valid")
+    for (const s of n.refiner(e, f))
+      s.explanation = t.message, u = "not_refined", yield [s, void 0];
+  u === "valid" && (yield [void 0, e]);
+}
+class d {
+  constructor(n) {
+    const { type: t, schema: r, validator: i, refiner: o, coercer: c = (u) => u, entries: f = function* () {
+    } } = n;
+    this.type = t, this.schema = r, this.entries = f, this.coercer = c, i ? this.validator = (u, s) => {
+      const y = i(u, s);
+      return w(y, s, this, u);
+    } : this.validator = () => [], o ? this.refiner = (u, s) => {
+      const y = o(u, s);
+      return w(y, s, this, u);
+    } : this.refiner = () => [];
+  }
+  /**
+   * Assert that a value passes the struct's validation, throwing if it doesn't.
+   */
+  assert(n, t) {
+    return D(n, this, t);
+  }
+  /**
+   * Create a value with the struct's coercion logic, then validate it.
+   */
+  create(n, t) {
+    return I(n, this, t);
+  }
+  /**
+   * Check if a value passes the struct's validation.
+   */
+  is(n) {
+    return E(n, this);
+  }
+  /**
+   * Mask a value, coercing and validating it, but returning only the subset of
+   * properties defined by the struct's schema.
+   */
+  mask(n, t) {
+    return q(n, this, t);
+  }
+  /**
+   * Validate a value with the struct's validation logic, returning a tuple
+   * representing the result.
+   *
+   * You may optionally pass `true` for the `withCoercion` argument to coerce
+   * the value before attempting to validate it. If you do, the result will
+   * contain the coerced result when successful.
+   */
+  validate(n, t = {}) {
+    return b(n, this, t);
+  }
+}
+function D(e, n, t) {
+  const r = b(e, n, { message: t });
+  if (r[0])
+    throw r[0];
+}
+function I(e, n, t) {
+  const r = b(e, n, { coerce: !0, message: t });
+  if (r[0])
+    throw r[0];
+  return r[1];
+}
+function q(e, n, t) {
+  const r = b(e, n, { coerce: !0, mask: !0, message: t });
+  if (r[0])
+    throw r[0];
+  return r[1];
+}
+function E(e, n) {
+  return !b(e, n)[0];
+}
+function b(e, n, t = {}) {
+  const r = j(e, n, t), i = _(r);
+  return i[0] ? [new N(i[0], function* () {
+    for (const c of r)
+      c[0] && (yield c[0]);
+  }), void 0] : [void 0, i[1]];
+}
+function R(...e) {
+  const n = e[0].type === "type", t = e.map((i) => i.schema), r = Object.assign({}, ...t);
+  return n ? g(r) : $(r);
+}
+function p(e, n) {
+  return new d({ type: e, schema: null, validator: n });
+}
+function B(e, n) {
+  return new d({
+    ...e,
+    refiner: (t, r) => t === void 0 || e.refiner(t, r),
+    validator(t, r) {
+      return t === void 0 ? !0 : (n(t, r), e.validator(t, r));
+    }
+  });
+}
+function G(e) {
+  return new d({
+    type: "dynamic",
+    schema: null,
+    *entries(n, t) {
+      yield* e(n, t).entries(n, t);
+    },
+    validator(n, t) {
+      return e(n, t).validator(n, t);
+    },
+    coercer(n, t) {
+      return e(n, t).coercer(n, t);
+    },
+    refiner(n, t) {
+      return e(n, t).refiner(n, t);
+    }
+  });
+}
+function H(e) {
+  let n;
+  return new d({
+    type: "lazy",
+    schema: null,
+    *entries(t, r) {
+      n ?? (n = e()), yield* n.entries(t, r);
+    },
+    validator(t, r) {
+      return n ?? (n = e()), n.validator(t, r);
+    },
+    coercer(t, r) {
+      return n ?? (n = e()), n.coercer(t, r);
+    },
+    refiner(t, r) {
+      return n ?? (n = e()), n.refiner(t, r);
+    }
+  });
+}
+function L(e, n) {
+  const { schema: t } = e, r = { ...t };
+  for (const i of n)
+    delete r[i];
+  switch (e.type) {
+    case "type":
+      return g(r);
+    default:
+      return $(r);
+  }
+}
+function Q(e) {
+  const n = e instanceof d, t = n ? { ...e.schema } : { ...e };
+  for (const r in t)
+    t[r] = F(t[r]);
+  return n && e.type === "type" ? g(t) : $(t);
+}
+function U(e, n) {
+  const { schema: t } = e, r = {};
+  for (const i of n)
+    r[i] = t[i];
+  switch (e.type) {
+    case "type":
+      return g(r);
+    default:
+      return $(r);
+  }
+}
+function W(e, n) {
+  return console.warn("superstruct@0.11 - The `struct` helper has been renamed to `define`."), p(e, n);
+}
+function X() {
+  return p("any", () => !0);
+}
+function Y(e) {
+  return new d({
+    type: "array",
+    schema: e,
+    *entries(n) {
+      if (e && Array.isArray(n))
+        for (const [t, r] of n.entries())
+          yield [t, r, e];
+    },
+    coercer(n) {
+      return Array.isArray(n) ? n.slice() : n;
+    },
+    validator(n) {
+      return Array.isArray(n) || `Expected an array value, but received: ${a(n)}`;
+    }
+  });
+}
+function Z() {
+  return p("bigint", (e) => typeof e == "bigint");
+}
+function C() {
+  return p("boolean", (e) => typeof e == "boolean");
+}
+function K() {
+  return p("date", (e) => e instanceof Date && !isNaN(e.getTime()) || `Expected a valid \`Date\` object, but received: ${a(e)}`);
+}
+function V(e) {
+  const n = {}, t = e.map((r) => a(r)).join();
+  for (const r of e)
+    n[r] = r;
+  return new d({
+    type: "enums",
+    schema: n,
+    validator(r) {
+      return e.includes(r) || `Expected one of \`${t}\`, but received: ${a(r)}`;
+    }
+  });
+}
+function v() {
+  return p("func", (e) => typeof e == "function" || `Expected a function, but received: ${a(e)}`);
+}
+function ee(e) {
+  return p("instance", (n) => n instanceof e || `Expected a \`${e.name}\` instance, but received: ${a(n)}`);
+}
+function ne() {
+  return p("integer", (e) => typeof e == "number" && !isNaN(e) && Number.isInteger(e) || `Expected an integer, but received: ${a(e)}`);
+}
+function te(e) {
+  return new d({
+    type: "intersection",
+    schema: null,
+    *entries(n, t) {
+      for (const r of e)
+        yield* r.entries(n, t);
+    },
+    *validator(n, t) {
+      for (const r of e)
+        yield* r.validator(n, t);
+    },
+    *refiner(n, t) {
+      for (const r of e)
+        yield* r.refiner(n, t);
+    }
+  });
+}
+function re(e) {
+  const n = a(e), t = typeof e;
+  return new d({
+    type: "literal",
+    schema: t === "string" || t === "number" || t === "boolean" ? e : null,
+    validator(r) {
+      return r === e || `Expected the literal \`${n}\`, but received: ${a(r)}`;
+    }
+  });
+}
+function ie(e, n) {
+  return new d({
+    type: "map",
+    schema: null,
+    *entries(t) {
+      if (e && n && t instanceof Map)
+        for (const [r, i] of t.entries())
+          yield [r, r, e], yield [r, i, n];
+    },
+    coercer(t) {
+      return t instanceof Map ? new Map(t) : t;
+    },
+    validator(t) {
+      return t instanceof Map || `Expected a \`Map\` object, but received: ${a(t)}`;
+    }
+  });
+}
+function x() {
+  return p("never", () => !1);
+}
+function oe(e) {
+  return new d({
+    ...e,
+    validator: (n, t) => n === null || e.validator(n, t),
+    refiner: (n, t) => n === null || e.refiner(n, t)
+  });
+}
+function ce() {
+  return p("number", (e) => typeof e == "number" && !isNaN(e) || `Expected a number, but received: ${a(e)}`);
+}
+function $(e) {
+  const n = e ? Object.keys(e) : [], t = x();
+  return new d({
+    type: "object",
+    schema: e || null,
+    *entries(r) {
+      if (e && l(r)) {
+        const i = new Set(Object.keys(r));
+        for (const o of n)
+          i.delete(o), yield [o, r[o], e[o]];
+        for (const o of i)
+          yield [o, r[o], t];
+      }
+    },
+    validator(r) {
+      return l(r) || `Expected an object, but received: ${a(r)}`;
+    },
+    coercer(r) {
+      return l(r) ? { ...r } : r;
+    }
+  });
+}
+function F(e) {
+  return new d({
+    ...e,
+    validator: (n, t) => n === void 0 || e.validator(n, t),
+    refiner: (n, t) => n === void 0 || e.refiner(n, t)
+  });
+}
+function se(e, n) {
+  return new d({
+    type: "record",
+    schema: null,
+    *entries(t) {
+      if (l(t))
+        for (const r in t) {
+          const i = t[r];
+          yield [r, r, e], yield [r, i, n];
+        }
+    },
+    validator(t) {
+      return l(t) || `Expected an object, but received: ${a(t)}`;
+    }
+  });
+}
+function fe() {
+  return p("regexp", (e) => e instanceof RegExp);
+}
+function ue(e) {
+  return new d({
+    type: "set",
+    schema: null,
+    *entries(n) {
+      if (e && n instanceof Set)
+        for (const t of n)
+          yield [t, t, e];
+    },
+    coercer(n) {
+      return n instanceof Set ? new Set(n) : n;
+    },
+    validator(n) {
+      return n instanceof Set || `Expected a \`Set\` object, but received: ${a(n)}`;
+    }
+  });
+}
+function P() {
+  return p("string", (e) => typeof e == "string" || `Expected a string, but received: ${a(e)}`);
+}
+function de(e) {
+  const n = x();
+  return new d({
+    type: "tuple",
+    schema: null,
+    *entries(t) {
+      if (Array.isArray(t)) {
+        const r = Math.max(e.length, t.length);
+        for (let i = 0; i < r; i++)
+          yield [i, t[i], e[i] || n];
+      }
+    },
+    validator(t) {
+      return Array.isArray(t) || `Expected an array, but received: ${a(t)}`;
+    }
+  });
+}
+function g(e) {
+  const n = Object.keys(e);
+  return new d({
+    type: "type",
+    schema: e,
+    *entries(t) {
+      if (l(t))
+        for (const r of n)
+          yield [r, t[r], e[r]];
+    },
+    validator(t) {
+      return l(t) || `Expected an object, but received: ${a(t)}`;
+    },
+    coercer(t) {
+      return l(t) ? { ...t } : t;
+    }
+  });
+}
+function ae(e) {
+  const n = e.map((t) => t.type).join(" | ");
+  return new d({
+    type: "union",
+    schema: null,
+    coercer(t) {
+      for (const r of e) {
+        const [i, o] = r.validate(t, { coerce: !0 });
+        if (!i)
+          return o;
+      }
+      return t;
+    },
+    validator(t, r) {
+      const i = [];
+      for (const o of e) {
+        const [...c] = j(t, o, r), [f] = c;
+        if (f[0])
+          for (const [u] of c)
+            u && i.push(u);
+        else
+          return [];
+      }
+      return [
+        `Expected the value to satisfy a union of \`${n}\`, but received: ${a(t)}`,
+        ...i
+      ];
+    }
+  });
+}
+function J() {
+  return p("unknown", () => !0);
+}
+function S(e, n, t) {
+  return new d({
+    ...e,
+    coercer: (r, i) => E(r, n) ? e.coercer(t(r, i), i) : e.coercer(r, i)
+  });
+}
+function pe(e, n, t = {}) {
+  return S(e, J(), (r) => {
+    const i = typeof n == "function" ? n() : n;
+    if (r === void 0)
+      return i;
+    if (!t.strict && k(r) && k(i)) {
+      const o = { ...r };
+      let c = !1;
+      for (const f in i)
+        o[f] === void 0 && (o[f] = i[f], c = !0);
+      if (c)
+        return o;
+    }
+    return r;
+  });
+}
+function ye(e) {
+  return S(e, P(), (n) => n.trim());
+}
+function le(e) {
+  return h(e, "empty", (n) => {
+    const t = z(n);
+    return t === 0 || `Expected an empty ${e.type} but received one with a size of \`${t}\``;
+  });
+}
+function z(e) {
+  return e instanceof Map || e instanceof Set ? e.size : e.length;
+}
+function he(e, n, t = {}) {
+  const { exclusive: r } = t;
+  return h(e, "max", (i) => r ? i < n : i <= n || `Expected a ${e.type} less than ${r ? "" : "or equal to "}${n} but received \`${i}\``);
+}
+function be(e, n, t = {}) {
+  const { exclusive: r } = t;
+  return h(e, "min", (i) => r ? i > n : i >= n || `Expected a ${e.type} greater than ${r ? "" : "or equal to "}${n} but received \`${i}\``);
+}
+function me(e) {
+  return h(e, "nonempty", (n) => z(n) > 0 || `Expected a nonempty ${e.type} but received an empty one`);
+}
+function $e(e, n) {
+  return h(e, "pattern", (t) => n.test(t) || `Expected a ${e.type} matching \`/${n.source}/\` but received "${t}"`);
+}
+function ge(e, n, t = n) {
+  const r = `Expected a ${e.type}`, i = n === t ? `of \`${n}\`` : `between \`${n}\` and \`${t}\``;
+  return h(e, "size", (o) => {
+    if (typeof o == "number" || o instanceof Date)
+      return n <= o && o <= t || `${r} ${i} but received \`${o}\``;
+    if (o instanceof Map || o instanceof Set) {
+      const { size: c } = o;
+      return n <= c && c <= t || `${r} with a size ${i} but received one with a size of \`${c}\``;
+    } else {
+      const { length: c } = o;
+      return n <= c && c <= t || `${r} with a length ${i} but received one with a length of \`${c}\``;
+    }
+  });
+}
+function h(e, n, t) {
+  return new d({
+    ...e,
+    *refiner(r, i) {
+      yield* e.refiner(r, i);
+      const o = t(r, i), c = w(o, i, e, r);
+      for (const f of c)
+        yield { ...f, refinement: n };
+    }
+  });
+}
+export {
+  d as Struct,
+  N as StructError,
+  X as any,
+  Y as array,
+  D as assert,
+  R as assign,
+  Z as bigint,
+  C as boolean,
+  S as coerce,
+  I as create,
+  K as date,
+  pe as defaulted,
+  p as define,
+  B as deprecated,
+  G as dynamic,
+  le as empty,
+  V as enums,
+  v as func,
+  ee as instance,
+  ne as integer,
+  te as intersection,
+  E as is,
+  H as lazy,
+  re as literal,
+  ie as map,
+  q as mask,
+  he as max,
+  be as min,
+  x as never,
+  me as nonempty,
+  oe as nullable,
+  ce as number,
+  $ as object,
+  L as omit,
+  F as optional,
+  Q as partial,
+  $e as pattern,
+  U as pick,
+  se as record,
+  h as refine,
+  fe as regexp,
+  ue as set,
+  ge as size,
+  P as string,
+  W as struct,
+  ye as trimmed,
+  de as tuple,
+  g as type,
+  ae as union,
+  J as unknown,
+  b as validate
+};

package/dist/astra-sdk.es1571.js

@@ -0,0 +1,32 @@
+import { __module as T } from "./astra-sdk.es1618.js";
+import { __require as o } from "./astra-sdk.es1572.js";
+import { __require as X } from "./astra-sdk.es1619.js";
+var s;
+function a() {
+  return s ? T.exports : (s = 1, function(D, L) {
+    const {
+      MAX_SAFE_COMPONENT_LENGTH: e,
+      MAX_SAFE_BUILD_LENGTH: C,
+      MAX_LENGTH: P
+    } = o(), r = X();
+    L = D.exports = {};
+    const F = L.re = [], t = L.safeRe = [], E = L.src = [], I = L.t = {};
+    let G = 0;
+    const S = "[a-zA-Z0-9-]", n = [
+      ["\\s", 1],
+      ["\\d", P],
+      [S, C]
+    ], U = (O) => {
+      for (const [N, $] of n)
+        O = O.split(`${N}*`).join(`${N}{0,${$}}`).split(`${N}+`).join(`${N}{1,${$}}`);
+      return O;
+    }, R = (O, N, $) => {
+      const M = U(N), A = G++;
+      r(O, A, N), I[O] = A, E[A] = N, F[A] = new RegExp(N, $ ? "g" : void 0), t[A] = new RegExp(M, $ ? "g" : void 0);
+    };
+    R("NUMERICIDENTIFIER", "0|[1-9]\\d*"), R("NUMERICIDENTIFIERLOOSE", "\\d+"), R("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${S}*`), R("MAINVERSION", `(${E[I.NUMERICIDENTIFIER]})\\.(${E[I.NUMERICIDENTIFIER]})\\.(${E[I.NUMERICIDENTIFIER]})`), R("MAINVERSIONLOOSE", `(${E[I.NUMERICIDENTIFIERLOOSE]})\\.(${E[I.NUMERICIDENTIFIERLOOSE]})\\.(${E[I.NUMERICIDENTIFIERLOOSE]})`), R("PRERELEASEIDENTIFIER", `(?:${E[I.NUMERICIDENTIFIER]}|${E[I.NONNUMERICIDENTIFIER]})`), R("PRERELEASEIDENTIFIERLOOSE", `(?:${E[I.NUMERICIDENTIFIERLOOSE]}|${E[I.NONNUMERICIDENTIFIER]})`), R("PRERELEASE", `(?:-(${E[I.PRERELEASEIDENTIFIER]}(?:\\.${E[I.PRERELEASEIDENTIFIER]})*))`), R("PRERELEASELOOSE", `(?:-?(${E[I.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${E[I.PRERELEASEIDENTIFIERLOOSE]})*))`), R("BUILDIDENTIFIER", `${S}+`), R("BUILD", `(?:\\+(${E[I.BUILDIDENTIFIER]}(?:\\.${E[I.BUILDIDENTIFIER]})*))`), R("FULLPLAIN", `v?${E[I.MAINVERSION]}${E[I.PRERELEASE]}?${E[I.BUILD]}?`), R("FULL", `^${E[I.FULLPLAIN]}$`), R("LOOSEPLAIN", `[v=\\s]*${E[I.MAINVERSIONLOOSE]}${E[I.PRERELEASELOOSE]}?${E[I.BUILD]}?`), R("LOOSE", `^${E[I.LOOSEPLAIN]}$`), R("GTLT", "((?:<|>)?=?)"), R("XRANGEIDENTIFIERLOOSE", `${E[I.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), R("XRANGEIDENTIFIER", `${E[I.NUMERICIDENTIFIER]}|x|X|\\*`), R("XRANGEPLAIN", `[v=\\s]*(${E[I.XRANGEIDENTIFIER]})(?:\\.(${E[I.XRANGEIDENTIFIER]})(?:\\.(${E[I.XRANGEIDENTIFIER]})(?:${E[I.PRERELEASE]})?${E[I.BUILD]}?)?)?`), R("XRANGEPLAINLOOSE", `[v=\\s]*(${E[I.XRANGEIDENTIFIERLOOSE]})(?:\\.(${E[I.XRANGEIDENTIFIERLOOSE]})(?:\\.(${E[I.XRANGEIDENTIFIERLOOSE]})(?:${E[I.PRERELEASELOOSE]})?${E[I.BUILD]}?)?)?`), R("XRANGE", `^${E[I.GTLT]}\\s*${E[I.XRANGEPLAIN]}$`), R("XRANGELOOSE", `^${E[I.GTLT]}\\s*${E[I.XRANGEPLAINLOOSE]}$`), R("COERCEPLAIN", `(^|[^\\d])(\\d{1,${e}})(?:\\.(\\d{1,${e}}))?(?:\\.(\\d{1,${e}}))?`), R("COERCE", `${E[I.COERCEPLAIN]}(?:$|[^\\d])`), R("COERCEFULL", E[I.COERCEPLAIN] + `(?:${E[I.PRERELEASE]})?(?:${E[I.BUILD]})?(?:$|[^\\d])`), R("COERCERTL", E[I.COERCE], !0), R("COERCERTLFULL", E[I.COERCEFULL], !0), R("LONETILDE", "(?:~>?)"), R("TILDETRIM", `(\\s*)${E[I.LONETILDE]}\\s+`, !0), L.tildeTrimReplace = "$1~", R("TILDE", `^${E[I.LONETILDE]}${E[I.XRANGEPLAIN]}$`), R("TILDELOOSE", `^${E[I.LONETILDE]}${E[I.XRANGEPLAINLOOSE]}$`), R("LONECARET", "(?:\\^)"), R("CARETTRIM", `(\\s*)${E[I.LONECARET]}\\s+`, !0), L.caretTrimReplace = "$1^", R("CARET", `^${E[I.LONECARET]}${E[I.XRANGEPLAIN]}$`), R("CARETLOOSE", `^${E[I.LONECARET]}${E[I.XRANGEPLAINLOOSE]}$`), R("COMPARATORLOOSE", `^${E[I.GTLT]}\\s*(${E[I.LOOSEPLAIN]})$|^$`), R("COMPARATOR", `^${E[I.GTLT]}\\s*(${E[I.FULLPLAIN]})$|^$`), R("COMPARATORTRIM", `(\\s*)${E[I.GTLT]}\\s*(${E[I.LOOSEPLAIN]}|${E[I.XRANGEPLAIN]})`, !0), L.comparatorTrimReplace = "$1$2$3", R("HYPHENRANGE", `^\\s*(${E[I.XRANGEPLAIN]})\\s+-\\s+(${E[I.XRANGEPLAIN]})\\s*$`), R("HYPHENRANGELOOSE", `^\\s*(${E[I.XRANGEPLAINLOOSE]})\\s+-\\s+(${E[I.XRANGEPLAINLOOSE]})\\s*$`), R("STAR", "(<|>)?=?\\s*\\*"), R("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), R("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }(T, T.exports), T.exports);
+}
+export {
+  a as __require
+};

package/dist/astra-sdk.es1572.js

@@ -0,0 +1,28 @@
+var E, _;
+function A() {
+  if (_) return E;
+  _ = 1;
+  const n = "2.0.0", r = 256, t = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991, e = 16, o = r - 6;
+  return E = {
+    MAX_LENGTH: r,
+    MAX_SAFE_COMPONENT_LENGTH: e,
+    MAX_SAFE_BUILD_LENGTH: o,
+    MAX_SAFE_INTEGER: t,
+    RELEASE_TYPES: [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ],
+    SEMVER_SPEC_VERSION: n,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  }, E;
+}
+export {
+  A as __require
+};