@0xsquid/react-hooks 8.10.1-beta-bitcoin-coralv2.0 → 8.11.0

package/dist/core/canton/cantonConnector.d.ts

@@ -1,3 +1,4 @@
+import { type CantonClient } from "@sigilry/dapp";
 import type { CantonAccount, CantonConnectResult, CantonConnector, CantonConnectorEvent, CantonConnectorEventHandler, CantonLedgerApiParams, CantonPrepareExecuteAndWaitResult, CantonPrepareExecuteParams } from "../types/canton";
 import { AnnouncedCantonProvider } from "./cip103Client";
 /**
@@ -11,7 +12,7 @@ export declare class CantonBrowserConnector implements CantonConnector {
     private readonly client;
     private readonly listeners;
     private _accounts;
-    constructor(provider: AnnouncedCantonProvider, win?: Window);
+    constructor(provider: AnnouncedCantonProvider, win?: Window, client?: CantonClient);
     get accounts(): CantonAccount[];
     get address(): string | undefined;
     connect(): Promise<CantonConnectResult>;

package/dist/core/canton/injectedCantonProvider.d.ts

@@ -0,0 +1,31 @@
+import type { CantonClient, SpliceProvider } from "@sigilry/dapp";
+import type { ConnectorID } from "../types/wallet";
+export interface InjectedCantonWalletConfig {
+    connectorId: ConnectorID;
+    name: string;
+    icon?: string;
+    /** Dot-path to the injected CIP-103 provider on `window` (e.g. `nightly.canton`). */
+    windowPath: string;
+}
+/**
+ * CIP-103 wallets that expose their provider as an injected `window` global
+ * instead of participating in the `canton:announceProvider` discovery protocol.
+ * Add an entry to support a new one.
+ */
+export declare const INJECTED_CANTON_WALLETS: InjectedCantonWalletConfig[];
+export interface DiscoveredInjectedCantonWallet {
+    config: InjectedCantonWalletConfig;
+    provider: SpliceProvider;
+}
+/**
+ * Adapts an injected CIP-103 `SpliceProvider` (the normative `request` API) to
+ * the {@link CantonClient} surface consumed by `CantonBrowserConnector`, so
+ * injected wallets reuse the same connector as announce-discovered ones.
+ */
+export declare function cantonClientFromSpliceProvider(provider: SpliceProvider): CantonClient;
+/**
+ * Detect installed injected Canton wallets by walking each registered
+ * `windowPath`, mirroring the `definedInWindow` install check used for other
+ * non-autodiscovered wallets.
+ */
+export declare function discoverInjectedCantonWallets(win?: Window): DiscoveredInjectedCantonWallet[];

package/dist/core/index.d.ts

@@ -1,4 +1,4 @@
-export { CHAIN_IDS, chainTypeToNativeTokenAddressMap, chainTypeToZeroAddressMap, DEFAULT_LOCALE, DEFAULT_ROUTE_REFETCH_INTERVAL, destinationAddressResetValue, fallbackAddressResetValue, nativeBitcoinTokenAddress, nativeCosmosTokenAddress, nativeEvmTokenAddress, nativeSolanaTokenAddress, nativeStellarTokenAddress, nativeSuiTokenAddress, nativeXrplTokenAddress, } from "./constants";
+export { CHAIN_IDS, DEFAULT_LOCALE, DEFAULT_ROUTE_REFETCH_INTERVAL, chainTypeToNativeTokenAddressMap, chainTypeToZeroAddressMap, destinationAddressResetValue, fallbackAddressResetValue, nativeBitcoinTokenAddress, nativeCantonTokenAddress, nativeCosmosTokenAddress, nativeEvmTokenAddress, nativeSolanaTokenAddress, nativeStellarTokenAddress, nativeSuiTokenAddress, nativeXrplTokenAddress, } from "./constants";
 export { CosmosProvider, useCosmosContext } from "./providers/CosmosProvider";
 export { QueryKeys } from "./queries/queries-keys";
 export * from "./types";

package/dist/hooks/canton/useCantonWallets.d.ts

@@ -1,7 +1,9 @@
 import { CantonWallet } from "../../core/types/wallet";
 /**
- * Discovers Canton browser-extension wallets via the CIP-103 announce protocol
- * (on mount and on window focus) and maps each to a {@link CantonWallet}.
+ * Discovers Canton browser-extension wallets and maps each to a
+ * {@link CantonWallet}: CIP-103 announce-protocol wallets (on mount and on
+ * window focus), plus injected wallets that ship the CIP-103 RPC surface as a
+ * `window` global instead of announcing (see `INJECTED_CANTON_WALLETS`).
  */
 export declare function useCantonWallets(): {
     wallets: CantonWallet[];

package/dist/{index-Cw1rn5LQ.js → index-BzTFES6t.js}

@@ -3463,7 +3463,7 @@ function get$1(object, path, defaultValue) {
 
 var get_1 = get$1;
 
-var get$2 = /*@__PURE__*/getDefaultExportFromCjs(get_1);
+var getProperty = /*@__PURE__*/getDefaultExportFromCjs(get_1);
 
 /**
  * The base implementation of `_.hasIn` without support for deep paths.
@@ -4739,52 +4739,6 @@ class BitcoinConnectorInvalidAccountError extends BitcoinConnectorError {
     }
 }
 
-class KeplrConnector {
-    get getProvider() {
-        const provider = window?.bitcoin_keplr;
-        if (!provider) {
-            throw new BitcoinConnectorProviderNotFoundError("Keplr");
-        }
-        return provider;
-    }
-    async sendBTC(to, amount) {
-        const txHash = await this.getProvider.sendBitcoin(to, amount);
-        if (!txHash) {
-            throw new BitcoinConnectorTransactionFailedError();
-        }
-        return { txHash };
-    }
-    async requestAccount() {
-        const accounts = await this.getProvider.requestAccounts();
-        const account = accounts[0];
-        if (typeof account !== "string") {
-            throw new BitcoinConnectorInvalidAccountError();
-        }
-        return {
-            address: account,
-        };
-    }
-    async signPsbt(psbtHex) {
-        // Keplr follows the UniSat-style Bitcoin provider API: `signPsbt` signs and,
-        // with `autoFinalized` (the default), finalizes every input, returning the
-        // signed PSBT as a hex string.
-        // https://docs.keplr.app/api/bitcoin
-        const signedPsbtHex = await this.getProvider.signPsbt(psbtHex, {
-            autoFinalized: true,
-        });
-        // Keplr only exposes `pushTx`, so extract the finalized raw transaction from
-        // the signed PSBT before broadcasting it.
-        const rawTxHex = bitcoin__namespace.Psbt.fromHex(signedPsbtHex)
-            .extractTransaction()
-            .toHex();
-        const txHash = await this.getProvider.pushTx(rawTxHex);
-        if (!txHash) {
-            throw new BitcoinConnectorTransactionFailedError();
-        }
-        return { txHash };
-    }
-}
-
 bitcoin__namespace.initEccLib(ecc__namespace);
 const network = bitcoin__namespace.networks.bitcoin;
 const fromHexString = (hexString) => {
@@ -4873,6 +4827,53 @@ async function getTransactionStatus$1(txHash) {
         .then((response) => response.data);
 }
 
+class KeplrConnector {
+    get getProvider() {
+        const provider = window?.bitcoin_keplr;
+        if (!provider) {
+            throw new BitcoinConnectorProviderNotFoundError("Keplr");
+        }
+        return provider;
+    }
+    async sendBTC(to, amount) {
+        const txHash = await this.getProvider.sendBitcoin(to, amount);
+        if (!txHash) {
+            throw new BitcoinConnectorTransactionFailedError();
+        }
+        return { txHash };
+    }
+    async requestAccount() {
+        const accounts = await this.getProvider.requestAccounts();
+        const account = accounts[0];
+        if (typeof account !== "string") {
+            throw new BitcoinConnectorInvalidAccountError();
+        }
+        return {
+            address: account,
+        };
+    }
+    async signPsbt(psbtHex) {
+        // Keplr follows the UniSat-style Bitcoin provider API: `signPsbt` signs and,
+        // with `autoFinalized` (the default), finalizes every input, returning the
+        // signed PSBT as a hex string.
+        // https://docs.keplr.app/api/bitcoin
+        const signedPsbtHex = await this.getProvider.signPsbt(psbtHex, {
+            autoFinalized: true,
+        });
+        // Broadcast the finalized raw transaction directly rather than through
+        // Keplr's `pushTx`, which proxies via Keplr's own Bitcoin indexer
+        // (api-indexer-bitcoin.keplr.app) and fails when that service is down.
+        const rawTxHex = bitcoin__namespace.Psbt.fromHex(signedPsbtHex)
+            .extractTransaction()
+            .toHex();
+        const txHash = await broadcastTx(rawTxHex);
+        if (!txHash) {
+            throw new BitcoinConnectorTransactionFailedError();
+        }
+        return { txHash };
+    }
+}
+
 const MAINNET = bitcoin__namespace.networks.bitcoin;
 class PhantomConnector {
     get getProvider() {
@@ -20604,7 +20605,7 @@ const walletIconBaseUrl = "https://raw.githubusercontent.com/0xsquid/assets/main
  * Returns the value of the property if found, otherwise undefined.
  */
 const accessProperty = (object, path) => {
-    const value = get$2(object, path);
+    const value = getProperty(object, path);
     if (value === undefined) {
         console.error(`Property "${path}" not found while reading object`, object);
     }
@@ -20932,6 +20933,16 @@ const fallbackWallets = [
             chrome: "https://chromewebstore.google.com/detail/console-wallet/lpnfhpbpmlobjlgkdmnjieeihjmihhjd",
         },
     },
+    {
+        chainType: squidTypes.ChainType.CANTON,
+        id: "nightly",
+        name: "Nightly",
+        connectorName: "Nightly",
+        icon: `${walletIconBaseUrl}/nightly.webp`,
+        links: {
+            chrome: "https://chromewebstore.google.com/detail/nightly/fiikommddbeccaoicoejoniammnalkfa",
+        },
+    },
 ];
 
 // Validation taken from Squid API repo
@@ -20953,6 +20964,32 @@ const isBitcoinAddressValid = (address) => {
     }
 };
 
+/**
+ * Format a Canton connector into a Squid {@link CantonWallet}. Shared by the
+ * announce-discovery and injected-provider paths.
+ */
+function formatCantonWallet({ connectorId, name, icon, connector, }) {
+    return {
+        name,
+        connectorId,
+        connectorName: name,
+        icon,
+        windowFlag: connectorId,
+        skipInstallCheck: true,
+        isInstalled: () => true,
+        isMultiChain: false,
+        type: squidTypes.ChainType.CANTON,
+        connector,
+    };
+}
+/**
+ * Append injected wallets that aren't already covered by an announce-discovered
+ * wallet with the same connectorId (in case a wallet later does both).
+ */
+function mergeInjectedCantonWallets(announced, injected) {
+    const seen = new Set(announced.map((w) => w.connectorId));
+    return [...announced, ...injected.filter((w) => !seen.has(w.connectorId))];
+}
 // Canton PartyID = address
 const CANTON_PARTY_ID_SEPARATOR = "::";
 /** Canton Coin's well-known token-standard instrument id (its address carries no id prefix). */
@@ -22928,21 +22965,21 @@ const resolveChainIdFromAsset = (asset, chains) => {
 };
 const getConfigWithDefaults = (config) => {
     return {
-        integratorId: get$2(config, "integratorId", defaultConfigValues.integratorId),
-        slippage: get$2(config, "slippage", defaultConfigValues.slippage),
-        collectFees: get$2(config, "collectFees", defaultConfigValues.collectFees),
-        apiUrl: get$2(config, "apiUrl", defaultConfigValues.apiUrl),
-        priceImpactWarnings: get$2(config, "priceImpactWarnings", defaultConfigValues.priceImpactWarnings),
-        initialAssets: get$2(config, "initialAssets", defaultConfigValues.initialAssets),
-        defaultTokensPerChain: get$2(config, "defaultTokensPerChain", defaultConfigValues.defaultTokensPerChain),
-        loadPreviousStateFromLocalStorage: get$2(config, "loadPreviousStateFromLocalStorage", defaultConfigValues.loadPreviousStateFromLocalStorage),
-        availableChains: get$2(config, "availableChains", defaultConfigValues.availableChains),
-        availableTokens: get$2(config, "availableTokens", defaultConfigValues.availableTokens),
-        disabledChains: get$2(config, "disabledChains", defaultConfigValues.disabledChains),
-        degenMode: get$2(config, "degenMode", defaultConfigValues.degenMode),
-        preHook: get$2(config, "preHook", defaultConfigValues.preHook),
-        postHook: get$2(config, "postHook", defaultConfigValues.postHook),
-        overrideGasRefundAddress: get$2(config, "overrideGasRefundAddress", defaultConfigValues.overrideGasRefundAddress),
+        integratorId: getProperty(config, "integratorId", defaultConfigValues.integratorId),
+        slippage: getProperty(config, "slippage", defaultConfigValues.slippage),
+        collectFees: getProperty(config, "collectFees", defaultConfigValues.collectFees),
+        apiUrl: getProperty(config, "apiUrl", defaultConfigValues.apiUrl),
+        priceImpactWarnings: getProperty(config, "priceImpactWarnings", defaultConfigValues.priceImpactWarnings),
+        initialAssets: getProperty(config, "initialAssets", defaultConfigValues.initialAssets),
+        defaultTokensPerChain: getProperty(config, "defaultTokensPerChain", defaultConfigValues.defaultTokensPerChain),
+        loadPreviousStateFromLocalStorage: getProperty(config, "loadPreviousStateFromLocalStorage", defaultConfigValues.loadPreviousStateFromLocalStorage),
+        availableChains: getProperty(config, "availableChains", defaultConfigValues.availableChains),
+        availableTokens: getProperty(config, "availableTokens", defaultConfigValues.availableTokens),
+        disabledChains: getProperty(config, "disabledChains", defaultConfigValues.disabledChains),
+        degenMode: getProperty(config, "degenMode", defaultConfigValues.degenMode),
+        preHook: getProperty(config, "preHook", defaultConfigValues.preHook),
+        postHook: getProperty(config, "postHook", defaultConfigValues.postHook),
+        overrideGasRefundAddress: getProperty(config, "overrideGasRefundAddress", defaultConfigValues.overrideGasRefundAddress),
     };
 };
 const randomIntFromInterval = (min, max) => {
@@ -23639,7 +23676,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-6H3XQVCV.js'); });
+    const { fetchAllSecretBalances } = await Promise.resolve().then(function () { return require('./secretService-D70MRo5w.js'); });
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -26870,14 +26907,16 @@ class CantonBrowserConnector {
     client;
     listeners = { connect: new Set(), disconnect: new Set() };
     _accounts = [];
-    constructor(provider, win = window) {
+    constructor(provider, win = window, client) {
         this.providerId = provider.id;
         this.name = provider.name;
         this.target = provider.target ?? provider.id;
-        this.client = dapp.createCantonClient(new dapp.WindowTransport(win, {
-            target: this.target,
-            timeout: REQUEST_TIMEOUT_MS,
-        }));
+        this.client =
+            client ??
+                dapp.createCantonClient(new dapp.WindowTransport(win, {
+                    target: this.target,
+                    timeout: REQUEST_TIMEOUT_MS,
+                }));
     }
     get accounts() {
         return this._accounts;
@@ -26979,44 +27018,116 @@ async function discoverCantonProviders(timeoutMs = DEFAULT_DISCOVERY_TIMEOUT_MS,
 }
 
 /**
- * Discovers Canton browser-extension wallets via the CIP-103 announce protocol
- * (on mount and on window focus) and maps each to a {@link CantonWallet}.
+ * CIP-103 wallets that expose their provider as an injected `window` global
+ * instead of participating in the `canton:announceProvider` discovery protocol.
+ * Add an entry to support a new one.
+ */
+const INJECTED_CANTON_WALLETS = [
+    {
+        connectorId: "nightly",
+        name: "Nightly",
+        icon: `${walletIconBaseUrl}/nightly.webp`,
+        windowPath: "nightly.canton",
+    },
+];
+/**
+ * Adapts an injected CIP-103 `SpliceProvider` (the normative `request` API) to
+ * the {@link CantonClient} surface consumed by `CantonBrowserConnector`, so
+ * injected wallets reuse the same connector as announce-discovered ones.
+ */
+function cantonClientFromSpliceProvider(provider) {
+    return {
+        status: () => provider.request({ method: "status" }),
+        connect: () => provider.request({ method: "connect" }),
+        disconnect: () => provider.request({ method: "disconnect" }),
+        isConnected: () => provider.request({ method: "isConnected" }),
+        getActiveNetwork: () => provider.request({ method: "getActiveNetwork" }),
+        listAccounts: () => provider.request({ method: "listAccounts" }),
+        getPrimaryAccount: () => provider.request({ method: "getPrimaryAccount" }),
+        prepareExecute: (params) => provider.request({ method: "prepareExecute", params }),
+        prepareExecuteAndWait: (params) => provider.request({ method: "prepareExecuteAndWait", params }),
+        signMessage: (params) => provider.request({ method: "signMessage", params }),
+        ledgerApi: (params) => provider.request({ method: "ledgerApi", params }),
+    };
+}
+/**
+ * Detect installed injected Canton wallets by walking each registered
+ * `windowPath`, mirroring the `definedInWindow` install check used for other
+ * non-autodiscovered wallets.
+ */
+function discoverInjectedCantonWallets(win) {
+    const source = (typeof window !== "undefined" ? window : undefined);
+    if (!source)
+        return [];
+    return INJECTED_CANTON_WALLETS.flatMap((config) => {
+        const provider = getProperty(source, config.windowPath);
+        if (!provider || typeof provider.request !== "function")
+            return [];
+        return [{ config, provider }];
+    });
+}
+
+/**
+ * Discovers Canton browser-extension wallets and maps each to a
+ * {@link CantonWallet}: CIP-103 announce-protocol wallets (on mount and on
+ * window focus), plus injected wallets that ship the CIP-103 RPC surface as a
+ * `window` global instead of announcing (see `INJECTED_CANTON_WALLETS`).
  */
 function useCantonWallets() {
     const [wallets, setWallets] = React.useState([]);
-    const connectorCache = React.useRef(new Map());
-    const toWallet = React.useCallback((provider) => {
-        let connector = connectorCache.current.get(provider.id);
+    const announcedCache = React.useRef(new Map());
+    const injectedCache = React.useRef(new Map());
+    const toAnnouncedWallet = React.useCallback((provider) => {
+        let connector = announcedCache.current.get(provider.id);
         if (!connector) {
             connector = new CantonBrowserConnector(provider);
-            connectorCache.current.set(provider.id, connector);
+            announcedCache.current.set(provider.id, connector);
         }
-        return {
-            name: provider.name,
+        return formatCantonWallet({
             connectorId: provider.id,
-            connectorName: provider.name,
+            name: provider.name,
             icon: provider.icon,
-            windowFlag: provider.id,
-            skipInstallCheck: true,
-            isInstalled: () => true,
-            isMultiChain: false,
-            type: squidTypes.ChainType.CANTON,
             connector,
-        };
+        });
+    }, []);
+    const toInjectedWallet = React.useCallback(({ config, provider }) => {
+        // Rebuild if the wallet re-injects a new provider object (e.g. extension
+        // reload): the cached connector closes over the previous provider.
+        let entry = injectedCache.current.get(config.connectorId);
+        if (!entry || entry.provider !== provider) {
+            entry = {
+                connector: new CantonBrowserConnector({ id: config.connectorId, name: config.name, icon: config.icon }, window, cantonClientFromSpliceProvider(provider)),
+                provider,
+            };
+            injectedCache.current.set(config.connectorId, entry);
+        }
+        return formatCantonWallet({
+            connectorId: config.connectorId,
+            name: config.name,
+            icon: config.icon,
+            connector: entry.connector,
+        });
     }, []);
     const refresh = React.useCallback(async () => {
         if (typeof window === "undefined")
             return;
-        const providers = await discoverCantonProviders();
-        setWallets(providers.map(toWallet));
-    }, [toWallet]);
+        const announced = (await discoverCantonProviders()).map(toAnnouncedWallet);
+        const injected = discoverInjectedCantonWallets().map(toInjectedWallet);
+        setWallets(mergeInjectedCantonWallets(announced, injected));
+    }, [toAnnouncedWallet, toInjectedWallet]);
     React.useEffect(() => {
         refresh();
         if (typeof window === "undefined")
-            return;
+            return undefined;
         const onFocus = () => refresh();
         window.addEventListener("focus", onFocus);
-        return () => window.removeEventListener("focus", onFocus);
+        // Extensions may inject their global shortly after mount; re-check a couple
+        // of times so late injection surfaces without a focus change.
+        const retries = [500, 1500].map((ms) => window.setTimeout(refresh, ms));
+        return () => {
+            window.removeEventListener("focus", onFocus);
+            retries.forEach((id) => window.clearTimeout(id));
+        };
     }, [refresh]);
     return { wallets };
 }
@@ -27313,7 +27424,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module.mjs');
-                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-CElL9N4g.js'); });
+                const { formatStellarWallet } = await Promise.resolve().then(function () { return require('./stellarService.client-DhwF4F1c.js'); });
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -30772,7 +30883,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-DQyW9YL5.js'); });
+                const { EthereumProvider } = await Promise.resolve().then(function () { return require('./index.es-DaKI7v5_.js'); });
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -37499,10 +37610,6 @@ const useExecuteTransaction = (squidRoute) => {
         }
     });
     const swapMutationBitcoin = reactQuery.useMutation(async ({ id, route }) => {
-        console.log("Validating route", {
-            bitcoinSigner,
-            route,
-        });
         if (!bitcoinSigner || !route?.transactionRequest) {
             throw new Error("Need all parameters");
         }
@@ -37545,17 +37652,13 @@ const useExecuteTransaction = (squidRoute) => {
                 break;
             }
             case squidTypes.SquidDataType.DepositAddressCalldata: {
-                console.log(`Route type: ${route.transactionRequest?.type}`);
                 if (!isOnChainTxData(route.transactionRequest)) {
-                    console.log("Invalid route data", route.transactionRequest);
                     throw new Error("Invalid route data");
                 }
                 const { data: transactionHex } = route.transactionRequest;
                 await changeNetworkIfNeeded.mutateAsync();
                 dispatchSignatureRequestEvent(route);
-                console.log("Signing psbt", { transactionHex });
                 const { txHash } = await bitcoinSigner.signPsbt(transactionHex);
-                console.log("Signed psbt", { txHash });
                 if (txHash) {
                     resetQueriesAfterTxSigned();
                 }
@@ -38889,6 +38992,7 @@ exports.isXionSmartContractAddress = isXionSmartContractAddress;
 exports.isXrplAddressValid = isXrplAddressValid;
 exports.mergeWallets = mergeWallets;
 exports.nativeBitcoinTokenAddress = nativeBitcoinTokenAddress;
+exports.nativeCantonTokenAddress = nativeCantonTokenAddress;
 exports.nativeCosmosTokenAddress = nativeCosmosTokenAddress;
 exports.nativeEvmTokenAddress = nativeEvmTokenAddress;
 exports.nativeSolanaTokenAddress = nativeSolanaTokenAddress;
@@ -39010,4 +39114,4 @@ exports.useXrplTrustLine = useXrplTrustLine;
 exports.waitForReceiptWithRetry = waitForReceiptWithRetry;
 exports.walletIconBaseUrl = walletIconBaseUrl;
 exports.walletSupportsChainType = walletSupportsChainType;
-//# sourceMappingURL=index-Cw1rn5LQ.js.map
+//# sourceMappingURL=index-BzTFES6t.js.map