astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es1261.js

@@ -0,0 +1,57 @@
+import { SCWSigner as g } from "./astra-sdk.es1351.js";
+import { WalletLinkSigner as o } from "./astra-sdk.es1352.js";
+import { ScopedLocalStorage as p } from "./astra-sdk.es1138.js";
+const i = "SignerType", r = new p("CBWSDK", "SignerConfigurator");
+function k() {
+  return r.getItem(i);
+}
+function w(e) {
+  r.setItem(i, e);
+}
+async function m(e) {
+  const { communicator: t, metadata: n, handshakeRequest: a, callback: s } = e;
+  S(t, n, s).catch(() => {
+  });
+  const c = {
+    id: crypto.randomUUID(),
+    event: "selectSignerType",
+    data: Object.assign(Object.assign({}, e.preference), { handshakeRequest: a })
+  }, { data: l } = await t.postRequestAndWaitForResponse(c);
+  return l;
+}
+function y(e) {
+  const { signerType: t, metadata: n, communicator: a, callback: s } = e;
+  switch (t) {
+    case "scw":
+      return new g({
+        metadata: n,
+        callback: s,
+        communicator: a
+      });
+    case "walletlink":
+      return new o({
+        metadata: n,
+        callback: s
+      });
+  }
+}
+async function S(e, t, n) {
+  await e.onMessage(({ event: s }) => s === "WalletLinkSessionRequest");
+  const a = new o({
+    metadata: t,
+    callback: n
+  });
+  e.postMessage({
+    event: "WalletLinkUpdate",
+    data: { session: a.getSession() }
+  }), await a.handshake(), e.postMessage({
+    event: "WalletLinkUpdate",
+    data: { connected: !0 }
+  });
+}
+export {
+  y as createSigner,
+  m as fetchSignerType,
+  k as loadSignerType,
+  w as storeSignerType
+};

package/dist/astra-sdk.es1262.js

@@ -0,0 +1,44 @@
+import { VERSION as u } from "./astra-sdk.es1137.js";
+import { CB_KEYS_URL as c } from "./astra-sdk.es1353.js";
+import { standardErrors as p } from "./astra-sdk.es1264.js";
+import { closePopup as d, openPopup as l } from "./astra-sdk.es1354.js";
+class L {
+  constructor({ url: n = c, metadata: a, preference: h }) {
+    this.popup = null, this.listeners = /* @__PURE__ */ new Map(), this.postMessage = async (e) => {
+      (await this.waitForPopupLoaded()).postMessage(e, this.url.origin);
+    }, this.postRequestAndWaitForResponse = async (e) => {
+      const s = this.onMessage(({ requestId: i }) => i === e.id);
+      return this.postMessage(e), await s;
+    }, this.onMessage = async (e) => new Promise((s, i) => {
+      const t = (o) => {
+        if (o.origin !== this.url.origin)
+          return;
+        const r = o.data;
+        e(r) && (s(r), window.removeEventListener("message", t), this.listeners.delete(t));
+      };
+      window.addEventListener("message", t), this.listeners.set(t, { reject: i });
+    }), this.disconnect = () => {
+      d(this.popup), this.popup = null, this.listeners.forEach(({ reject: e }, s) => {
+        e(p.provider.userRejectedRequest("Request rejected")), window.removeEventListener("message", s);
+      }), this.listeners.clear();
+    }, this.waitForPopupLoaded = async () => this.popup && !this.popup.closed ? (this.popup.focus(), this.popup) : (this.popup = l(this.url), this.onMessage(({ event: e }) => e === "PopupUnload").then(this.disconnect).catch(() => {
+    }), this.onMessage(({ event: e }) => e === "PopupLoaded").then((e) => {
+      this.postMessage({
+        requestId: e.id,
+        data: {
+          version: u,
+          metadata: this.metadata,
+          preference: this.preference,
+          location: window.location.toString()
+        }
+      });
+    }).then(() => {
+      if (!this.popup)
+        throw p.rpc.internal();
+      return this.popup;
+    })), this.url = new URL(n), this.metadata = a, this.preference = h;
+  }
+}
+export {
+  L as Communicator
+};

package/dist/astra-sdk.es1263.js

@@ -0,0 +1,96 @@
+const e = {
+  rpc: {
+    invalidInput: -32e3,
+    resourceNotFound: -32001,
+    resourceUnavailable: -32002,
+    transactionRejected: -32003,
+    methodNotSupported: -32004,
+    limitExceeded: -32005,
+    parse: -32700,
+    invalidRequest: -32600,
+    methodNotFound: -32601,
+    invalidParams: -32602,
+    internal: -32603
+  },
+  provider: {
+    userRejectedRequest: 4001,
+    unauthorized: 4100,
+    unsupportedMethod: 4200,
+    disconnected: 4900,
+    chainDisconnected: 4901,
+    unsupportedChain: 4902
+  }
+}, s = {
+  "-32700": {
+    standard: "JSON RPC 2.0",
+    message: "Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text."
+  },
+  "-32600": {
+    standard: "JSON RPC 2.0",
+    message: "The JSON sent is not a valid Request object."
+  },
+  "-32601": {
+    standard: "JSON RPC 2.0",
+    message: "The method does not exist / is not available."
+  },
+  "-32602": {
+    standard: "JSON RPC 2.0",
+    message: "Invalid method parameter(s)."
+  },
+  "-32603": {
+    standard: "JSON RPC 2.0",
+    message: "Internal JSON-RPC error."
+  },
+  "-32000": {
+    standard: "EIP-1474",
+    message: "Invalid input."
+  },
+  "-32001": {
+    standard: "EIP-1474",
+    message: "Resource not found."
+  },
+  "-32002": {
+    standard: "EIP-1474",
+    message: "Resource unavailable."
+  },
+  "-32003": {
+    standard: "EIP-1474",
+    message: "Transaction rejected."
+  },
+  "-32004": {
+    standard: "EIP-1474",
+    message: "Method not supported."
+  },
+  "-32005": {
+    standard: "EIP-1474",
+    message: "Request limit exceeded."
+  },
+  4001: {
+    standard: "EIP-1193",
+    message: "User rejected the request."
+  },
+  4100: {
+    standard: "EIP-1193",
+    message: "The requested account and/or method has not been authorized by the user."
+  },
+  4200: {
+    standard: "EIP-1193",
+    message: "The requested method is not supported by this Ethereum provider."
+  },
+  4900: {
+    standard: "EIP-1193",
+    message: "The provider is disconnected from all chains."
+  },
+  4901: {
+    standard: "EIP-1193",
+    message: "The provider is disconnected from the specified chain."
+  },
+  4902: {
+    standard: "EIP-3085",
+    message: "Unrecognized chain ID."
+  }
+};
+export {
+  s as errorValues,
+  e as standardErrorCodes
+};

package/dist/astra-sdk.es1264.js

@@ -0,0 +1,88 @@
+import { standardErrorCodes as t } from "./astra-sdk.es1263.js";
+import { getMessageFromCode as u } from "./astra-sdk.es1355.js";
+const f = {
+  rpc: {
+    parse: (r) => o(t.rpc.parse, r),
+    invalidRequest: (r) => o(t.rpc.invalidRequest, r),
+    invalidParams: (r) => o(t.rpc.invalidParams, r),
+    methodNotFound: (r) => o(t.rpc.methodNotFound, r),
+    internal: (r) => o(t.rpc.internal, r),
+    server: (r) => {
+      if (!r || typeof r != "object" || Array.isArray(r))
+        throw new Error("Ethereum RPC Server errors must provide single object argument.");
+      const { code: e } = r;
+      if (!Number.isInteger(e) || e > -32005 || e < -32099)
+        throw new Error('"code" must be an integer such that: -32099 <= code <= -32005');
+      return o(e, r);
+    },
+    invalidInput: (r) => o(t.rpc.invalidInput, r),
+    resourceNotFound: (r) => o(t.rpc.resourceNotFound, r),
+    resourceUnavailable: (r) => o(t.rpc.resourceUnavailable, r),
+    transactionRejected: (r) => o(t.rpc.transactionRejected, r),
+    methodNotSupported: (r) => o(t.rpc.methodNotSupported, r),
+    limitExceeded: (r) => o(t.rpc.limitExceeded, r)
+  },
+  provider: {
+    userRejectedRequest: (r) => s(t.provider.userRejectedRequest, r),
+    unauthorized: (r) => s(t.provider.unauthorized, r),
+    unsupportedMethod: (r) => s(t.provider.unsupportedMethod, r),
+    disconnected: (r) => s(t.provider.disconnected, r),
+    chainDisconnected: (r) => s(t.provider.chainDisconnected, r),
+    unsupportedChain: (r) => s(t.provider.unsupportedChain, r),
+    custom: (r) => {
+      if (!r || typeof r != "object" || Array.isArray(r))
+        throw new Error("Ethereum Provider custom errors must provide single object argument.");
+      const { code: e, message: n, data: i } = r;
+      if (!n || typeof n != "string")
+        throw new Error('"message" must be a nonempty string');
+      return new a(e, n, i);
+    }
+  }
+};
+function o(r, e) {
+  const [n, i] = d(e);
+  return new c(r, n || u(r), i);
+}
+function s(r, e) {
+  const [n, i] = d(e);
+  return new a(r, n || u(r), i);
+}
+function d(r) {
+  if (r) {
+    if (typeof r == "string")
+      return [r];
+    if (typeof r == "object" && !Array.isArray(r)) {
+      const { message: e, data: n } = r;
+      if (e && typeof e != "string")
+        throw new Error("Must specify string message.");
+      return [e || void 0, n];
+    }
+  }
+  return [];
+}
+class c extends Error {
+  constructor(e, n, i) {
+    if (!Number.isInteger(e))
+      throw new Error('"code" must be an integer.');
+    if (!n || typeof n != "string")
+      throw new Error('"message" must be a nonempty string.');
+    super(n), this.code = e, i !== void 0 && (this.data = i);
+  }
+}
+class a extends c {
+  /**
+   * Create an Ethereum Provider JSON-RPC error.
+   * `code` must be an integer in the 1000 <= 4999 range.
+   */
+  constructor(e, n, i) {
+    if (!p(e))
+      throw new Error('"code" must be an integer such that: 1000 <= code <= 4999');
+    super(e, n, i);
+  }
+}
+function p(r) {
+  return Number.isInteger(r) && r >= 1e3 && r <= 4999;
+}
+export {
+  f as standardErrors
+};

package/dist/astra-sdk.es1265.js

@@ -0,0 +1,30 @@
+import { VERSION as a } from "./astra-sdk.es1137.js";
+import { isErrorResponse as n } from "./astra-sdk.es1356.js";
+import { standardErrorCodes as r } from "./astra-sdk.es1263.js";
+import { serialize as c } from "./astra-sdk.es1355.js";
+function f(e) {
+  const s = c(d(e), {
+    shouldIncludeStack: !0
+  }), t = new URL("https://docs.cloud.coinbase.com/wallet-sdk/docs/errors");
+  return t.searchParams.set("version", a), t.searchParams.set("code", s.code.toString()), t.searchParams.set("message", s.message), Object.assign(Object.assign({}, s), { docUrl: t.href });
+}
+function d(e) {
+  var s;
+  if (typeof e == "string")
+    return {
+      message: e,
+      code: r.rpc.internal
+    };
+  if (n(e)) {
+    const t = e.errorMessage, o = (s = e.errorCode) !== null && s !== void 0 ? s : t.match(/(denied|rejected)/i) ? r.provider.userRejectedRequest : void 0;
+    return Object.assign(Object.assign({}, e), {
+      message: t,
+      code: o,
+      data: { method: e.method }
+    });
+  }
+  return e;
+}
+export {
+  f as serializeError
+};

package/dist/astra-sdk.es1266.js

@@ -0,0 +1,6 @@
+import t from "./astra-sdk.es562.js";
+class i extends t {
+}
+export {
+  i as ProviderEventEmitter
+};

package/dist/astra-sdk.es1267.js

@@ -0,0 +1,131 @@
+import f from "./astra-sdk.es222.js";
+import { standardErrors as e } from "./astra-sdk.es1264.js";
+import { HexString as i, AddressString as S, IntNumber as u, BigIntString as m } from "./astra-sdk.es1269.js";
+const c = /^[0-9]*$/, a = /^[a-f0-9]*$/;
+function E(t) {
+  return d(crypto.getRandomValues(new Uint8Array(t)));
+}
+function d(t) {
+  return [...t].map((r) => r.toString(16).padStart(2, "0")).join("");
+}
+function l(t) {
+  return new Uint8Array(t.match(/.{1,2}/g).map((r) => Number.parseInt(r, 16)));
+}
+function y(t, r = !1) {
+  const n = t.toString("hex");
+  return i(r ? `0x${n}` : n);
+}
+function A(t) {
+  return y(N(t), !0);
+}
+function H(t) {
+  return m(t.toString(10));
+}
+function P(t) {
+  return i(`0x${BigInt(t).toString(16)}`);
+}
+function p(t) {
+  return t.startsWith("0x") || t.startsWith("0X");
+}
+function s(t) {
+  return p(t) ? t.slice(2) : t;
+}
+function I(t) {
+  return p(t) ? `0x${t.slice(2)}` : `0x${t}`;
+}
+function o(t) {
+  if (typeof t != "string")
+    return !1;
+  const r = s(t).toLowerCase();
+  return a.test(r);
+}
+function x(t, r = !1) {
+  if (typeof t == "string") {
+    const n = s(t).toLowerCase();
+    if (a.test(n))
+      return i(r ? `0x${n}` : n);
+  }
+  throw e.rpc.invalidParams(`"${String(t)}" is not a hexadecimal string`);
+}
+function g(t, r = !1) {
+  let n = x(t, !1);
+  return n.length % 2 === 1 && (n = i(`0${n}`)), r ? i(`0x${n}`) : n;
+}
+function L(t) {
+  if (typeof t == "string") {
+    const r = s(t).toLowerCase();
+    if (o(r) && r.length === 40)
+      return S(I(r));
+  }
+  throw e.rpc.invalidParams(`Invalid Ethereum address: ${String(t)}`);
+}
+function N(t) {
+  if (f.isBuffer(t))
+    return t;
+  if (typeof t == "string") {
+    if (o(t)) {
+      const r = g(t, !1);
+      return f.from(r, "hex");
+    }
+    return f.from(t, "utf8");
+  }
+  throw e.rpc.invalidParams(`Not binary data: ${String(t)}`);
+}
+function b(t) {
+  if (typeof t == "number" && Number.isInteger(t))
+    return u(t);
+  if (typeof t == "string") {
+    if (c.test(t))
+      return u(Number(t));
+    if (o(t))
+      return u(Number(BigInt(g(t, !0))));
+  }
+  throw e.rpc.invalidParams(`Not an integer: ${String(t)}`);
+}
+function T(t) {
+  if (t !== null && (typeof t == "bigint" || h(t)))
+    return BigInt(t.toString(10));
+  if (typeof t == "number")
+    return BigInt(b(t));
+  if (typeof t == "string") {
+    if (c.test(t))
+      return BigInt(t);
+    if (o(t))
+      return BigInt(g(t, !0));
+  }
+  throw e.rpc.invalidParams(`Not an integer: ${String(t)}`);
+}
+function C(t) {
+  if (typeof t == "string")
+    return JSON.parse(t);
+  if (typeof t == "object")
+    return t;
+  throw e.rpc.invalidParams(`Not a JSON string or an object: ${String(t)}`);
+}
+function h(t) {
+  if (t == null || typeof t.constructor != "function")
+    return !1;
+  const { constructor: r } = t;
+  return typeof r.config == "function" && typeof r.EUCLID == "number";
+}
+export {
+  H as bigIntStringFromBigInt,
+  A as encodeToHexString,
+  L as ensureAddressString,
+  T as ensureBigInt,
+  N as ensureBuffer,
+  g as ensureEvenLengthHexString,
+  x as ensureHexString,
+  b as ensureIntNumber,
+  C as ensureParsedJSONObject,
+  p as has0xPrefix,
+  y as hexStringFromBuffer,
+  P as hexStringFromNumber,
+  l as hexStringToUint8Array,
+  h as isBigNumber,
+  o as isHexString,
+  I as prepend0x,
+  E as randomBytesHex,
+  s as strip0x,
+  d as uint8ArrayToHex
+};

package/dist/astra-sdk.es1268.js

@@ -0,0 +1,71 @@
+import { VERSION as u, NAME as l } from "./astra-sdk.es1137.js";
+import { standardErrors as d } from "./astra-sdk.es1264.js";
+async function b(e, t) {
+  const n = Object.assign(Object.assign({}, e), { jsonrpc: "2.0", id: crypto.randomUUID() }), o = await window.fetch(t, {
+    method: "POST",
+    body: JSON.stringify(n),
+    mode: "cors",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Cbw-Sdk-Version": u,
+      "X-Cbw-Sdk-Platform": l
+    }
+  }), { result: i, error: a } = await o.json();
+  if (a)
+    throw a;
+  return i;
+}
+function p() {
+  return globalThis.coinbaseWalletExtension;
+}
+function f() {
+  var e, t;
+  try {
+    const n = globalThis;
+    return (e = n.ethereum) !== null && e !== void 0 ? e : (t = n.top) === null || t === void 0 ? void 0 : t.ethereum;
+  } catch {
+    return;
+  }
+}
+function y({ metadata: e, preference: t }) {
+  var n, o;
+  const { appName: i, appLogoUrl: a, appChainIds: c } = e;
+  if (t.options !== "smartWalletOnly") {
+    const s = p();
+    if (s)
+      return (n = s.setAppInfo) === null || n === void 0 || n.call(s, i, a, c, t), s;
+  }
+  const r = f();
+  if (r != null && r.isCoinbaseBrowser)
+    return (o = r.setAppInfo) === null || o === void 0 || o.call(r, i, a, c, t), r;
+}
+function w(e) {
+  if (!e || typeof e != "object" || Array.isArray(e))
+    throw d.rpc.invalidParams({
+      message: "Expected a single, non-array, object argument.",
+      data: e
+    });
+  const { method: t, params: n } = e;
+  if (typeof t != "string" || t.length === 0)
+    throw d.rpc.invalidParams({
+      message: "'args.method' must be a non-empty string.",
+      data: e
+    });
+  if (n !== void 0 && !Array.isArray(n) && (typeof n != "object" || n === null))
+    throw d.rpc.invalidParams({
+      message: "'args.params' must be an object or array if provided.",
+      data: e
+    });
+  switch (t) {
+    case "eth_sign":
+    case "eth_signTypedData_v2":
+    case "eth_subscribe":
+    case "eth_unsubscribe":
+      throw d.provider.unsupportedMethod();
+  }
+}
+export {
+  w as checkErrorForInvalidRequestArgs,
+  b as fetchRPCRequest,
+  y as getCoinbaseInjectedProvider
+};

package/dist/astra-sdk.es1269.js

@@ -0,0 +1,14 @@
+function t() {
+  return (n) => n;
+}
+const r = t(), e = t(), o = t();
+function i(n) {
+  return Math.floor(n);
+}
+export {
+  e as AddressString,
+  o as BigIntString,
+  r as HexString,
+  i as IntNumber,
+  t as OpaqueType
+};

package/dist/astra-sdk.es127.js

@@ -0,0 +1,126 @@
+import "./astra-sdk.es229.js";
+import { html as l } from "./astra-sdk.es230.js";
+import { LitElement as u } 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 "./astra-sdk.es14.js";
+import "./astra-sdk.es15.js";
+import { customElement as c } from "./astra-sdk.es456.js";
+import { property as x } from "./astra-sdk.es475.js";
+var f = function(o, t, r, p) {
+  var m = arguments.length, i = m < 3 ? t : p === null ? p = Object.getOwnPropertyDescriptor(t, r) : p, e;
+  if (typeof Reflect == "object" && typeof Reflect.decorate == "function") i = Reflect.decorate(o, t, r, p);
+  else for (var n = o.length - 1; n >= 0; n--) (e = o[n]) && (i = (m < 3 ? e(i) : m > 3 ? e(t, r, i) : e(t, r)) || i);
+  return m > 3 && i && Object.defineProperty(t, r, i), i;
+};
+let a = class extends u {
+  constructor() {
+    super(...arguments), this.data = [];
+  }
+  render() {
+    return l`
+      <wui-flex flexDirection="column" alignItems="center" gap="l">
+        ${this.data.map((t) => l`
+            <wui-flex flexDirection="column" alignItems="center" gap="xl">
+              <wui-flex flexDirection="row" justifyContent="center" gap="1xs">
+                ${t.images.map((r) => l`<wui-visual name=${r}></wui-visual>`)}
+              </wui-flex>
+            </wui-flex>
+            <wui-flex flexDirection="column" alignItems="center" gap="xxs">
+              <wui-text variant="paragraph-500" color="fg-100" align="center">
+                ${t.title}
+              </wui-text>
+              <wui-text variant="small-500" color="fg-200" align="center">${t.text}</wui-text>
+            </wui-flex>
+          `)}
+      </wui-flex>
+    `;
+  }
+};
+f([
+  x({ type: Array })
+], a.prototype, "data", void 0);
+a = f([
+  c("w3m-help-widget")
+], a);
+export {
+  a as W3mHelpWidget
+};

package/dist/astra-sdk.es1270.js

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

package/dist/astra-sdk.es1271.js

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

package/dist/astra-sdk.es1272.js

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

package/dist/astra-sdk.es1273.js

@@ -0,0 +1,6 @@
+function r(o) {
+  throw new Error('Could not dynamically require "' + o + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+export {
+  r as commonjsRequire
+};