astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es1124.js

@@ -0,0 +1,614 @@
+import { __exports as R } from "./astra-sdk.es1216.js";
+import { __require as P } from "./astra-sdk.es1128.js";
+import { __require as q } from "./astra-sdk.es1206.js";
+import { __require as M } from "./astra-sdk.es1118.js";
+import { __require as U } from "./astra-sdk.es1133.js";
+import { __require as N } from "./astra-sdk.es1129.js";
+import { __require as B } from "./astra-sdk.es1130.js";
+import { __require as w } from "./astra-sdk.es1217.js";
+import { __require as L } from "./astra-sdk.es1131.js";
+import { __require as T } from "./astra-sdk.es1123.js";
+var W;
+function z() {
+  if (W) return R;
+  W = 1, Object.defineProperty(R, "__esModule", { value: !0 }), R.WalletLinkRelay = void 0;
+  const b = /* @__PURE__ */ P(), v = /* @__PURE__ */ q(), h = /* @__PURE__ */ M(), g = /* @__PURE__ */ U(), I = /* @__PURE__ */ N(), E = /* @__PURE__ */ B(), A = /* @__PURE__ */ w(), p = /* @__PURE__ */ L(), y = /* @__PURE__ */ T();
+  let k = class S extends I.RelayAbstract {
+    constructor(e) {
+      var s;
+      super(), this.accountsCallback = null, this.chainCallbackParams = { chainId: "", jsonRpcUrl: "" }, this.chainCallback = null, this.dappDefaultChain = 1, this.appName = "", this.appLogoUrl = null, this.linkedUpdated = (r) => {
+        var n;
+        this.isLinked = r;
+        const o = this.storage.getItem(I.LOCAL_STORAGE_ADDRESSES_KEY);
+        if (r && (this.session.linked = r), this.isUnlinkedErrorState = !1, o) {
+          const d = o.split(" "), c = this.storage.getItem("IsStandaloneSigning") === "true";
+          if (d[0] !== "" && !r && this.session.linked && !c) {
+            this.isUnlinkedErrorState = !0;
+            const l = this.getSessionIdHash();
+            (n = this.diagnostic) === null || n === void 0 || n.log(g.EVENTS.UNLINKED_ERROR_STATE, {
+              sessionIdHash: l
+            });
+          }
+        }
+      }, this.metadataUpdated = (r, n) => {
+        this.storage.setItem(r, n);
+      }, this.chainUpdated = (r, n) => {
+        this.chainCallbackParams.chainId === r && this.chainCallbackParams.jsonRpcUrl === n || (this.chainCallbackParams = {
+          chainId: r,
+          jsonRpcUrl: n
+        }, this.chainCallback && this.chainCallback(r, n));
+      }, this.accountUpdated = (r) => {
+        this.accountsCallback && this.accountsCallback([r]), S.accountRequestCallbackIds.size > 0 && (Array.from(S.accountRequestCallbackIds.values()).forEach((n) => {
+          const o = {
+            type: "WEB3_RESPONSE",
+            id: n,
+            response: {
+              method: "requestEthereumAccounts",
+              result: [r]
+            }
+          };
+          this.invokeCallback(Object.assign(Object.assign({}, o), { id: n }));
+        }), S.accountRequestCallbackIds.clear());
+      }, this.connectedUpdated = (r) => {
+        this.ui.setConnected(r);
+      }, this.resetAndReload = this.resetAndReload.bind(this), this.linkAPIUrl = e.linkAPIUrl, this.storage = e.storage, this.options = e;
+      const { session: t, ui: i, connection: a } = this.subscribe();
+      this._session = t, this.connection = a, this.relayEventManager = e.relayEventManager, this.diagnostic = e.diagnosticLogger, this._reloadOnDisconnect = (s = e.reloadOnDisconnect) !== null && s !== void 0 ? s : !0, this.ui = i;
+    }
+    subscribe() {
+      const e = E.Session.load(this.storage) || new E.Session(this.storage).save(), { linkAPIUrl: s, diagnostic: t } = this, i = new A.WalletLinkConnection({
+        session: e,
+        linkAPIUrl: s,
+        diagnostic: t,
+        listener: this
+      }), { version: a, darkMode: r } = this.options, n = this.options.uiConstructor({
+        linkAPIUrl: s,
+        version: a,
+        darkMode: r,
+        session: e
+      });
+      return i.connect(), { session: e, ui: n, connection: i };
+    }
+    attachUI() {
+      this.ui.attach();
+    }
+    resetAndReload() {
+      Promise.race([
+        this.connection.setSessionMetadata("__destroyed", "1"),
+        new Promise((e) => setTimeout(() => e(null), 1e3))
+      ]).then(() => {
+        var e, s;
+        const t = this.ui.isStandalone();
+        (e = this.diagnostic) === null || e === void 0 || e.log(g.EVENTS.SESSION_STATE_CHANGE, {
+          method: "relay::resetAndReload",
+          sessionMetadataChange: "__destroyed, 1",
+          sessionIdHash: this.getSessionIdHash()
+        }), this.connection.destroy();
+        const i = E.Session.load(this.storage);
+        if ((i == null ? void 0 : i.id) === this._session.id ? this.storage.clear() : i && ((s = this.diagnostic) === null || s === void 0 || s.log(g.EVENTS.SKIPPED_CLEARING_SESSION, {
+          sessionIdHash: this.getSessionIdHash(),
+          storedSessionIdHash: E.Session.hash(i.id)
+        })), this._reloadOnDisconnect) {
+          this.ui.reloadUI();
+          return;
+        }
+        this.accountsCallback && this.accountsCallback([], !0);
+        const { session: a, ui: r, connection: n } = this.subscribe();
+        this._session = a, this.connection = n, this.ui = r, t && this.ui.setStandalone && this.ui.setStandalone(!0), this.options.headlessMode || this.attachUI();
+      }).catch((e) => {
+        var s;
+        (s = this.diagnostic) === null || s === void 0 || s.log(g.EVENTS.FAILURE, {
+          method: "relay::resetAndReload",
+          message: `failed to reset and reload with ${e}`,
+          sessionIdHash: this.getSessionIdHash()
+        });
+      });
+    }
+    setAppInfo(e, s) {
+      this.appName = e, this.appLogoUrl = s;
+    }
+    getStorageItem(e) {
+      return this.storage.getItem(e);
+    }
+    get session() {
+      return this._session;
+    }
+    setStorageItem(e, s) {
+      this.storage.setItem(e, s);
+    }
+    signEthereumMessage(e, s, t, i) {
+      return this.sendRequest({
+        method: "signEthereumMessage",
+        params: {
+          message: (0, h.hexStringFromBuffer)(e, !0),
+          address: s,
+          addPrefix: t,
+          typedDataJson: i || null
+        }
+      });
+    }
+    ethereumAddressFromSignedMessage(e, s, t) {
+      return this.sendRequest({
+        method: "ethereumAddressFromSignedMessage",
+        params: {
+          message: (0, h.hexStringFromBuffer)(e, !0),
+          signature: (0, h.hexStringFromBuffer)(s, !0),
+          addPrefix: t
+        }
+      });
+    }
+    signEthereumTransaction(e) {
+      return this.sendRequest({
+        method: "signEthereumTransaction",
+        params: {
+          fromAddress: e.fromAddress,
+          toAddress: e.toAddress,
+          weiValue: (0, h.bigIntStringFromBN)(e.weiValue),
+          data: (0, h.hexStringFromBuffer)(e.data, !0),
+          nonce: e.nonce,
+          gasPriceInWei: e.gasPriceInWei ? (0, h.bigIntStringFromBN)(e.gasPriceInWei) : null,
+          maxFeePerGas: e.gasPriceInWei ? (0, h.bigIntStringFromBN)(e.gasPriceInWei) : null,
+          maxPriorityFeePerGas: e.gasPriceInWei ? (0, h.bigIntStringFromBN)(e.gasPriceInWei) : null,
+          gasLimit: e.gasLimit ? (0, h.bigIntStringFromBN)(e.gasLimit) : null,
+          chainId: e.chainId,
+          shouldSubmit: !1
+        }
+      });
+    }
+    signAndSubmitEthereumTransaction(e) {
+      return this.sendRequest({
+        method: "signEthereumTransaction",
+        params: {
+          fromAddress: e.fromAddress,
+          toAddress: e.toAddress,
+          weiValue: (0, h.bigIntStringFromBN)(e.weiValue),
+          data: (0, h.hexStringFromBuffer)(e.data, !0),
+          nonce: e.nonce,
+          gasPriceInWei: e.gasPriceInWei ? (0, h.bigIntStringFromBN)(e.gasPriceInWei) : null,
+          maxFeePerGas: e.maxFeePerGas ? (0, h.bigIntStringFromBN)(e.maxFeePerGas) : null,
+          maxPriorityFeePerGas: e.maxPriorityFeePerGas ? (0, h.bigIntStringFromBN)(e.maxPriorityFeePerGas) : null,
+          gasLimit: e.gasLimit ? (0, h.bigIntStringFromBN)(e.gasLimit) : null,
+          chainId: e.chainId,
+          shouldSubmit: !0
+        }
+      });
+    }
+    submitEthereumTransaction(e, s) {
+      return this.sendRequest({
+        method: "submitEthereumTransaction",
+        params: {
+          signedTransaction: (0, h.hexStringFromBuffer)(e, !0),
+          chainId: s
+        }
+      });
+    }
+    scanQRCode(e) {
+      return this.sendRequest({
+        method: "scanQRCode",
+        params: {
+          regExp: e
+        }
+      });
+    }
+    getQRCodeUrl() {
+      return (0, h.createQrUrl)(this._session.id, this._session.secret, this.linkAPIUrl, !1, this.options.version, this.dappDefaultChain);
+    }
+    genericRequest(e, s) {
+      return this.sendRequest({
+        method: "generic",
+        params: {
+          action: s,
+          data: e
+        }
+      });
+    }
+    sendGenericMessage(e) {
+      return this.sendRequest(e);
+    }
+    sendRequest(e) {
+      let s = null;
+      const t = (0, h.randomBytesHex)(8), i = (r) => {
+        this.publishWeb3RequestCanceledEvent(t), this.handleErrorResponse(t, e.method, r), s == null || s();
+      };
+      return { promise: new Promise((r, n) => {
+        this.ui.isStandalone() || (s = this.ui.showConnecting({
+          isUnlinkedErrorState: this.isUnlinkedErrorState,
+          onCancel: i,
+          onResetConnection: this.resetAndReload
+          // eslint-disable-line @typescript-eslint/unbound-method
+        })), this.relayEventManager.callbacks.set(t, (o) => {
+          if (s == null || s(), (0, p.isErrorResponse)(o))
+            return n(new Error(o.errorMessage));
+          r(o);
+        }), this.ui.isStandalone() ? this.sendRequestStandalone(t, e) : this.publishWeb3RequestEvent(t, e);
+      }), cancel: i };
+    }
+    setConnectDisabled(e) {
+      this.ui.setConnectDisabled(e);
+    }
+    setAccountsCallback(e) {
+      this.accountsCallback = e;
+    }
+    setChainCallback(e) {
+      this.chainCallback = e;
+    }
+    setDappDefaultChainCallback(e) {
+      this.dappDefaultChain = e, this.ui instanceof y.WalletLinkRelayUI && this.ui.setChainId(e);
+    }
+    publishWeb3RequestEvent(e, s) {
+      var t;
+      const i = { type: "WEB3_REQUEST", id: e, request: s }, a = E.Session.load(this.storage);
+      (t = this.diagnostic) === null || t === void 0 || t.log(g.EVENTS.WEB3_REQUEST, {
+        eventId: i.id,
+        method: `relay::${s.method}`,
+        sessionIdHash: this.getSessionIdHash(),
+        storedSessionIdHash: a ? E.Session.hash(a.id) : "",
+        isSessionMismatched: ((a == null ? void 0 : a.id) !== this._session.id).toString()
+      }), this.publishEvent("Web3Request", i, !0).then((r) => {
+        var n;
+        (n = this.diagnostic) === null || n === void 0 || n.log(g.EVENTS.WEB3_REQUEST_PUBLISHED, {
+          eventId: i.id,
+          method: `relay::${s.method}`,
+          sessionIdHash: this.getSessionIdHash(),
+          storedSessionIdHash: a ? E.Session.hash(a.id) : "",
+          isSessionMismatched: ((a == null ? void 0 : a.id) !== this._session.id).toString()
+        });
+      }).catch((r) => {
+        this.handleWeb3ResponseMessage({
+          type: "WEB3_RESPONSE",
+          id: i.id,
+          response: {
+            method: s.method,
+            errorMessage: r.message
+          }
+        });
+      });
+    }
+    publishWeb3RequestCanceledEvent(e) {
+      const s = {
+        type: "WEB3_REQUEST_CANCELED",
+        id: e
+      };
+      this.publishEvent("Web3RequestCanceled", s, !1).then();
+    }
+    publishEvent(e, s, t) {
+      return this.connection.publishEvent(e, s, t);
+    }
+    handleWeb3ResponseMessage(e) {
+      var s;
+      const { response: t } = e;
+      if ((s = this.diagnostic) === null || s === void 0 || s.log(g.EVENTS.WEB3_RESPONSE, {
+        eventId: e.id,
+        method: `relay::${t.method}`,
+        sessionIdHash: this.getSessionIdHash()
+      }), t.method === "requestEthereumAccounts") {
+        S.accountRequestCallbackIds.forEach((i) => this.invokeCallback(Object.assign(Object.assign({}, e), { id: i }))), S.accountRequestCallbackIds.clear();
+        return;
+      }
+      this.invokeCallback(e);
+    }
+    handleErrorResponse(e, s, t, i) {
+      var a;
+      const r = (a = t == null ? void 0 : t.message) !== null && a !== void 0 ? a : (0, b.getMessageFromCode)(i);
+      this.handleWeb3ResponseMessage({
+        type: "WEB3_RESPONSE",
+        id: e,
+        response: {
+          method: s,
+          errorMessage: r,
+          errorCode: i
+        }
+      });
+    }
+    invokeCallback(e) {
+      const s = this.relayEventManager.callbacks.get(e.id);
+      s && (s(e.response), this.relayEventManager.callbacks.delete(e.id));
+    }
+    requestEthereumAccounts() {
+      const e = {
+        method: "requestEthereumAccounts",
+        params: {
+          appName: this.appName,
+          appLogoUrl: this.appLogoUrl || null
+        }
+      }, s = (0, h.randomBytesHex)(8), t = (a) => {
+        this.publishWeb3RequestCanceledEvent(s), this.handleErrorResponse(s, e.method, a);
+      };
+      return { promise: new Promise((a, r) => {
+        if (this.relayEventManager.callbacks.set(s, (n) => {
+          if (this.ui.hideRequestEthereumAccounts(), (0, p.isErrorResponse)(n))
+            return r(new Error(n.errorMessage));
+          a(n);
+        }), this.ui.inlineAccountsResponse()) {
+          const n = (o) => {
+            this.handleWeb3ResponseMessage({
+              type: "WEB3_RESPONSE",
+              id: s,
+              response: { method: "requestEthereumAccounts", result: o }
+            });
+          };
+          this.ui.requestEthereumAccounts({
+            onCancel: t,
+            onAccounts: n
+          });
+        } else {
+          const n = b.standardErrors.provider.userRejectedRequest("User denied account authorization");
+          this.ui.requestEthereumAccounts({
+            onCancel: () => t(n)
+          });
+        }
+        S.accountRequestCallbackIds.add(s), !this.ui.inlineAccountsResponse() && !this.ui.isStandalone() && this.publishWeb3RequestEvent(s, e);
+      }), cancel: t };
+    }
+    selectProvider(e) {
+      const s = {
+        method: "selectProvider",
+        params: {
+          providerOptions: e
+        }
+      }, t = (0, h.randomBytesHex)(8), i = (r) => {
+        this.publishWeb3RequestCanceledEvent(t), this.handleErrorResponse(t, s.method, r);
+      }, a = new Promise((r, n) => {
+        this.relayEventManager.callbacks.set(t, (c) => {
+          if ((0, p.isErrorResponse)(c))
+            return n(new Error(c.errorMessage));
+          r(c);
+        });
+        const o = (c) => {
+          this.handleWeb3ResponseMessage({
+            type: "WEB3_RESPONSE",
+            id: t,
+            response: { method: "selectProvider", result: v.ProviderType.Unselected }
+          });
+        }, d = (c) => {
+          this.handleWeb3ResponseMessage({
+            type: "WEB3_RESPONSE",
+            id: t,
+            response: { method: "selectProvider", result: c }
+          });
+        };
+        this.ui.selectProvider && this.ui.selectProvider({
+          onApprove: d,
+          onCancel: o,
+          providerOptions: e
+        });
+      });
+      return { cancel: i, promise: a };
+    }
+    watchAsset(e, s, t, i, a, r) {
+      const n = {
+        method: "watchAsset",
+        params: {
+          type: e,
+          options: {
+            address: s,
+            symbol: t,
+            decimals: i,
+            image: a
+          },
+          chainId: r
+        }
+      };
+      let o = null;
+      const d = (0, h.randomBytesHex)(8), c = (u) => {
+        this.publishWeb3RequestCanceledEvent(d), this.handleErrorResponse(d, n.method, u), o == null || o();
+      };
+      this.ui.inlineWatchAsset() || (o = this.ui.showConnecting({
+        isUnlinkedErrorState: this.isUnlinkedErrorState,
+        onCancel: c,
+        onResetConnection: this.resetAndReload
+        // eslint-disable-line @typescript-eslint/unbound-method
+      }));
+      const l = new Promise((u, f) => {
+        this.relayEventManager.callbacks.set(d, (m) => {
+          if (o == null || o(), (0, p.isErrorResponse)(m))
+            return f(new Error(m.errorMessage));
+          u(m);
+        });
+        const C = (m) => {
+          this.handleWeb3ResponseMessage({
+            type: "WEB3_RESPONSE",
+            id: d,
+            response: {
+              method: "watchAsset",
+              result: !1
+            }
+          });
+        }, _ = () => {
+          this.handleWeb3ResponseMessage({
+            type: "WEB3_RESPONSE",
+            id: d,
+            response: {
+              method: "watchAsset",
+              result: !0
+            }
+          });
+        };
+        this.ui.inlineWatchAsset() && this.ui.watchAsset({
+          onApprove: _,
+          onCancel: C,
+          type: e,
+          address: s,
+          symbol: t,
+          decimals: i,
+          image: a,
+          chainId: r
+        }), !this.ui.inlineWatchAsset() && !this.ui.isStandalone() && this.publishWeb3RequestEvent(d, n);
+      });
+      return { cancel: c, promise: l };
+    }
+    addEthereumChain(e, s, t, i, a, r) {
+      const n = {
+        method: "addEthereumChain",
+        params: {
+          chainId: e,
+          rpcUrls: s,
+          blockExplorerUrls: i,
+          chainName: a,
+          iconUrls: t,
+          nativeCurrency: r
+        }
+      };
+      let o = null;
+      const d = (0, h.randomBytesHex)(8), c = (u) => {
+        this.publishWeb3RequestCanceledEvent(d), this.handleErrorResponse(d, n.method, u), o == null || o();
+      };
+      return this.ui.inlineAddEthereumChain(e) || (o = this.ui.showConnecting({
+        isUnlinkedErrorState: this.isUnlinkedErrorState,
+        onCancel: c,
+        onResetConnection: this.resetAndReload
+        // eslint-disable-line @typescript-eslint/unbound-method
+      })), { promise: new Promise((u, f) => {
+        this.relayEventManager.callbacks.set(d, (m) => {
+          if (o == null || o(), (0, p.isErrorResponse)(m))
+            return f(new Error(m.errorMessage));
+          u(m);
+        });
+        const C = (m) => {
+          this.handleWeb3ResponseMessage({
+            type: "WEB3_RESPONSE",
+            id: d,
+            response: {
+              method: "addEthereumChain",
+              result: {
+                isApproved: !1,
+                rpcUrl: ""
+              }
+            }
+          });
+        }, _ = (m) => {
+          this.handleWeb3ResponseMessage({
+            type: "WEB3_RESPONSE",
+            id: d,
+            response: {
+              method: "addEthereumChain",
+              result: {
+                isApproved: !0,
+                rpcUrl: m
+              }
+            }
+          });
+        };
+        this.ui.inlineAddEthereumChain(e) && this.ui.addEthereumChain({
+          onCancel: C,
+          onApprove: _,
+          chainId: n.params.chainId,
+          rpcUrls: n.params.rpcUrls,
+          blockExplorerUrls: n.params.blockExplorerUrls,
+          chainName: n.params.chainName,
+          iconUrls: n.params.iconUrls,
+          nativeCurrency: n.params.nativeCurrency
+        }), !this.ui.inlineAddEthereumChain(e) && !this.ui.isStandalone() && this.publishWeb3RequestEvent(d, n);
+      }), cancel: c };
+    }
+    switchEthereumChain(e, s) {
+      const t = {
+        method: "switchEthereumChain",
+        params: Object.assign({ chainId: e }, { address: s })
+      }, i = (0, h.randomBytesHex)(8), a = (n) => {
+        this.publishWeb3RequestCanceledEvent(i), this.handleErrorResponse(i, t.method, n);
+      };
+      return { promise: new Promise((n, o) => {
+        this.relayEventManager.callbacks.set(i, (l) => {
+          if ((0, p.isErrorResponse)(l) && l.errorCode)
+            return o(b.standardErrors.provider.custom({
+              code: l.errorCode,
+              message: "Unrecognized chain ID. Try adding the chain using addEthereumChain first."
+            }));
+          if ((0, p.isErrorResponse)(l))
+            return o(new Error(l.errorMessage));
+          n(l);
+        });
+        const d = (l) => {
+          var u;
+          if (l) {
+            const f = (u = (0, b.getErrorCode)(l)) !== null && u !== void 0 ? u : b.standardErrorCodes.provider.unsupportedChain;
+            this.handleErrorResponse(i, "switchEthereumChain", l instanceof Error ? l : b.standardErrors.provider.unsupportedChain(e), f);
+          } else
+            this.handleWeb3ResponseMessage({
+              type: "WEB3_RESPONSE",
+              id: i,
+              response: {
+                method: "switchEthereumChain",
+                result: {
+                  isApproved: !1,
+                  rpcUrl: ""
+                }
+              }
+            });
+        }, c = (l) => {
+          this.handleWeb3ResponseMessage({
+            type: "WEB3_RESPONSE",
+            id: i,
+            response: {
+              method: "switchEthereumChain",
+              result: {
+                isApproved: !0,
+                rpcUrl: l
+              }
+            }
+          });
+        };
+        this.ui.switchEthereumChain({
+          onCancel: d,
+          onApprove: c,
+          chainId: t.params.chainId,
+          address: t.params.address
+        }), !this.ui.inlineSwitchEthereumChain() && !this.ui.isStandalone() && this.publishWeb3RequestEvent(i, t);
+      }), cancel: a };
+    }
+    inlineAddEthereumChain(e) {
+      return this.ui.inlineAddEthereumChain(e);
+    }
+    getSessionIdHash() {
+      return E.Session.hash(this._session.id);
+    }
+    sendRequestStandalone(e, s) {
+      const t = (a) => {
+        this.handleErrorResponse(e, s.method, a);
+      }, i = (a) => {
+        this.handleWeb3ResponseMessage({
+          type: "WEB3_RESPONSE",
+          id: e,
+          response: a
+        });
+      };
+      switch (s.method) {
+        case "signEthereumMessage":
+          this.ui.signEthereumMessage({
+            request: s,
+            onSuccess: i,
+            onCancel: t
+          });
+          break;
+        case "signEthereumTransaction":
+          this.ui.signEthereumTransaction({
+            request: s,
+            onSuccess: i,
+            onCancel: t
+          });
+          break;
+        case "submitEthereumTransaction":
+          this.ui.submitEthereumTransaction({
+            request: s,
+            onSuccess: i,
+            onCancel: t
+          });
+          break;
+        case "ethereumAddressFromSignedMessage":
+          this.ui.ethereumAddressFromSignedMessage({
+            request: s,
+            onSuccess: i
+          });
+          break;
+        default:
+          t();
+          break;
+      }
+    }
+  };
+  return R.WalletLinkRelay = k, k.accountRequestCallbackIds = /* @__PURE__ */ new Set(), R;
+}
+export {
+  z as __require
+};

package/dist/astra-sdk.es1125.js

@@ -0,0 +1,8 @@
+import { __exports as e } from "./astra-sdk.es1218.js";
+var r;
+function n() {
+  return r ? e : (r = 1, Object.defineProperty(e, "__esModule", { value: !0 }), e.LIB_VERSION = void 0, e.LIB_VERSION = "3.9.3", e);
+}
+export {
+  n as __require
+};

package/dist/astra-sdk.es1126.js

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