@dappworks/kit 0.5.20 → 0.5.22

package/dist/{PromiseState-GU5X863c.d.ts → PromiseState-DVdsif1j.d.ts}

@@ -17,7 +17,6 @@ declare class PromiseState<T extends (...args: any[]) => Promise<any>, U = Retur
     defaultValue: any;
     function: T;
     transform?: (value: any) => Promise<Awaited<U>> | Awaited<U>;
-    signOut?: () => void | null;
     onError?: (error: any) => void | null;
     autoAlert: boolean;
     autoUpdate: boolean;
@@ -26,6 +25,7 @@ declare class PromiseState<T extends (...args: any[]) => Promise<any>, U = Retur
     context: any;
     successMsg: string;
     errMsg: string;
+    showUnauthorizedAlert: boolean;
     loadingLock: boolean;
     event: EventEmitter<[never]>;
     on<E extends keyof Events>(event: E, listener: Events[E]): this;

package/dist/{chunk-I3PECBV3.mjs → chunk-43PPHYFY.mjs}

@@ -6934,10 +6934,10 @@ __export(ethers_exports, {
   constants: () => lib_exports2,
   errors: () => ErrorCode,
   getDefaultProvider: () => getDefaultProvider,
-  logger: () => logger46,
+  logger: () => logger47,
   providers: () => lib_exports4,
   utils: () => utils_exports,
-  version: () => version26,
+  version: () => version27,
   wordlists: () => wordlists
 });
 
@@ -7010,10 +7010,10 @@ var ErrorCode;
 })(ErrorCode || (ErrorCode = {}));
 var HEX = "0123456789abcdef";
 var Logger = class _Logger {
-  constructor(version27) {
+  constructor(version28) {
     Object.defineProperty(this, "version", {
       enumerable: true,
-      value: version27,
+      value: version28,
       writable: false
     });
   }
@@ -7225,8 +7225,8 @@ var Logger = class _Logger {
     }
     _logLevel = level;
   }
-  static from(version27) {
-    return new _Logger(version27);
+  static from(version28) {
+    return new _Logger(version28);
   }
 };
 Logger.errors = ErrorCode;
@@ -16701,7 +16701,7 @@ __export(lib_exports4, {
 });
 
 // ../../node_modules/@ethersproject/networks/lib.esm/_version.js
-var version21 = "networks/5.7.0";
+var version21 = "networks/5.7.1";
 
 // ../../node_modules/@ethersproject/networks/lib.esm/index.js
 var logger27 = new Logger(version21);
@@ -16733,7 +16733,7 @@ function ethDefaultProvider(network) {
       }
     }
     if (providers.PocketProvider && options.pocket !== "-") {
-      const skip = ["goerli", "ropsten", "rinkeby"];
+      const skip = ["goerli", "ropsten", "rinkeby", "sepolia"];
       try {
         const provider = new providers.PocketProvider(network, options.pocket);
         if (provider.network && skip.indexOf(provider.network.name) === -1) {
@@ -16831,6 +16831,11 @@ var networks = {
     _defaultProvider: ethDefaultProvider("goerli")
   },
   kintsugi: { chainId: 1337702, name: "kintsugi" },
+  sepolia: {
+    chainId: 11155111,
+    name: "sepolia",
+    _defaultProvider: ethDefaultProvider("sepolia")
+  },
   // ETC (See: #351)
   classic: {
     chainId: 61,
@@ -16925,7 +16930,7 @@ function getNetwork(network) {
 }
 
 // ../../node_modules/@ethersproject/web/lib.esm/_version.js
-var version22 = "web/5.7.0";
+var version22 = "web/5.7.1";
 
 // ../../node_modules/@ethersproject/web/lib.esm/geturl.js
 var __awaiter8 = function(thisArg, _arguments, P, generator) {
@@ -17063,6 +17068,11 @@ function bodyify(value, type) {
   }
   return value;
 }
+function unpercent(value) {
+  return toUtf8Bytes(value.replace(/%([0-9a-f][0-9a-f])/gi, (all, code) => {
+    return String.fromCharCode(parseInt(code, 16));
+  }));
+}
 function _fetchData(connection, body, processFunc) {
   const attemptLimit = typeof connection === "object" && connection.throttleLimit != null ? connection.throttleLimit : 12;
   logger28.assertArgument(attemptLimit > 0 && attemptLimit % 1 === 0, "invalid connection throttle limit", "connection.throttleLimit", attemptLimit);
@@ -17113,15 +17123,15 @@ function _fetchData(connection, body, processFunc) {
       options.fetchOptions = shallowCopy(connection.fetchOptions);
     }
   }
-  const reData = new RegExp("^data:([a-z0-9-]+/[a-z0-9-]+);base64,(.*)$", "i");
+  const reData = new RegExp("^data:([^;:]*)?(;base64)?,(.*)$", "i");
   const dataMatch = url ? url.match(reData) : null;
   if (dataMatch) {
     try {
       const response = {
         statusCode: 200,
         statusMessage: "OK",
-        headers: { "content-type": dataMatch[1] },
-        body: decode2(dataMatch[2])
+        headers: { "content-type": dataMatch[1] || "text/plain" },
+        body: dataMatch[2] ? decode2(dataMatch[3]) : unpercent(dataMatch[3])
       };
       let result = response.body;
       if (processFunc) {
@@ -18139,17 +18149,17 @@ var Resolver = class {
     }
     if (coinInfo.prefix != null) {
       const length = bytes[1];
-      let version27 = bytes[0];
-      if (version27 === 0) {
+      let version28 = bytes[0];
+      if (version28 === 0) {
         if (length !== 20 && length !== 32) {
-          version27 = -1;
+          version28 = -1;
         }
       } else {
-        version27 = -1;
+        version28 = -1;
       }
-      if (version27 >= 0 && bytes.length === 2 + length && length >= 1 && length <= 75) {
+      if (version28 >= 0 && bytes.length === 2 + length && length >= 1 && length <= 75) {
         const words2 = import_bech32.default.toWords(bytes.slice(2));
-        words2.unshift(version27);
+        words2.unshift(version28);
         return import_bech32.default.encode(coinInfo.prefix, words2);
       }
     }
@@ -20204,7 +20214,7 @@ var JsonRpcProvider = class extends BaseProvider {
     const pendingFilter = this.send("eth_newPendingTransactionFilter", []);
     this._pendingFilter = pendingFilter;
     pendingFilter.then(function(filterId) {
-      function poll2() {
+      function poll3() {
         self2.send("eth_getFilterChanges", [filterId]).then(function(hashes) {
           if (self2._pendingFilter != pendingFilter) {
             return null;
@@ -20228,13 +20238,13 @@ var JsonRpcProvider = class extends BaseProvider {
             return;
           }
           setTimeout(function() {
-            poll2();
+            poll3();
           }, 0);
           return null;
         }).catch((error) => {
         });
       }
-      poll2();
+      poll3();
       return filterId;
     }).catch((error) => {
     });
@@ -20296,9 +20306,9 @@ try {
     throw new Error("inject please");
   }
 } catch (error) {
-  const logger47 = new Logger(version23);
+  const logger48 = new Logger(version23);
   WS = function() {
-    logger47.throwError("WebSockets not supported in this environment", Logger.errors.UNSUPPORTED_OPERATION, {
+    logger48.throwError("WebSockets not supported in this environment", Logger.errors.UNSUPPORTED_OPERATION, {
       operation: "new WebSocket()"
     });
   };
@@ -22281,7 +22291,7 @@ __export(utils_exports, {
   Utf8ErrorFuncs: () => Utf8ErrorFuncs,
   Utf8ErrorReason: () => Utf8ErrorReason,
   _TypedDataEncoder: () => TypedDataEncoder,
-  _fetchData: () => _fetchData,
+  _fetchData: () => _fetchData2,
   _toEscapedUtf8String: () => _toEscapedUtf8String,
   accessListify: () => accessListify,
   arrayify: () => arrayify,
@@ -22300,7 +22310,7 @@ __export(utils_exports, {
   defineReadOnly: () => defineReadOnly,
   dnsEncode: () => dnsEncode,
   entropyToMnemonic: () => entropyToMnemonic,
-  fetchJson: () => fetchJson,
+  fetchJson: () => fetchJson2,
   formatBytes32String: () => formatBytes32String,
   formatEther: () => formatEther,
   formatUnits: () => formatUnits,
@@ -22336,7 +22346,7 @@ __export(utils_exports, {
   parseEther: () => parseEther,
   parseTransaction: () => parse,
   parseUnits: () => parseUnits,
-  poll: () => poll,
+  poll: () => poll2,
   randomBytes: () => randomBytes,
   recoverAddress: () => recoverAddress,
   recoverPublicKey: () => recoverPublicKey,
@@ -22524,11 +22534,473 @@ function parseEther(ether) {
   return parseUnits(ether, 18);
 }
 
+// ../../node_modules/ethers/node_modules/@ethersproject/web/lib.esm/_version.js
+var version26 = "web/5.7.0";
+
+// ../../node_modules/ethers/node_modules/@ethersproject/web/lib.esm/geturl.js
+var __awaiter17 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+};
+function getUrl2(href, options) {
+  return __awaiter17(this, void 0, void 0, function* () {
+    if (options == null) {
+      options = {};
+    }
+    const request = {
+      method: options.method || "GET",
+      headers: options.headers || {},
+      body: options.body || void 0
+    };
+    if (options.skipFetchSetup !== true) {
+      request.mode = "cors";
+      request.cache = "no-cache";
+      request.credentials = "same-origin";
+      request.redirect = "follow";
+      request.referrer = "client";
+    }
+    if (options.fetchOptions != null) {
+      const opts = options.fetchOptions;
+      if (opts.mode) {
+        request.mode = opts.mode;
+      }
+      if (opts.cache) {
+        request.cache = opts.cache;
+      }
+      if (opts.credentials) {
+        request.credentials = opts.credentials;
+      }
+      if (opts.redirect) {
+        request.redirect = opts.redirect;
+      }
+      if (opts.referrer) {
+        request.referrer = opts.referrer;
+      }
+    }
+    const response = yield fetch(href, request);
+    const body = yield response.arrayBuffer();
+    const headers = {};
+    if (response.headers.forEach) {
+      response.headers.forEach((value, key2) => {
+        headers[key2.toLowerCase()] = value;
+      });
+    } else {
+      response.headers.keys().forEach((key2) => {
+        headers[key2.toLowerCase()] = response.headers.get(key2);
+      });
+    }
+    return {
+      headers,
+      statusCode: response.status,
+      statusMessage: response.statusText,
+      body: arrayify(new Uint8Array(body))
+    };
+  });
+}
+
+// ../../node_modules/ethers/node_modules/@ethersproject/web/lib.esm/index.js
+var __awaiter18 = function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+};
+var logger46 = new Logger(version26);
+function staller2(duration) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, duration);
+  });
+}
+function bodyify2(value, type) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (isBytesLike(value)) {
+    if (type && (type.split("/")[0] === "text" || type.split(";")[0].trim() === "application/json")) {
+      try {
+        return toUtf8String(value);
+      } catch (error) {
+      }
+    }
+    return hexlify(value);
+  }
+  return value;
+}
+function _fetchData2(connection, body, processFunc) {
+  const attemptLimit = typeof connection === "object" && connection.throttleLimit != null ? connection.throttleLimit : 12;
+  logger46.assertArgument(attemptLimit > 0 && attemptLimit % 1 === 0, "invalid connection throttle limit", "connection.throttleLimit", attemptLimit);
+  const throttleCallback = typeof connection === "object" ? connection.throttleCallback : null;
+  const throttleSlotInterval = typeof connection === "object" && typeof connection.throttleSlotInterval === "number" ? connection.throttleSlotInterval : 100;
+  logger46.assertArgument(throttleSlotInterval > 0 && throttleSlotInterval % 1 === 0, "invalid connection throttle slot interval", "connection.throttleSlotInterval", throttleSlotInterval);
+  const errorPassThrough = typeof connection === "object" ? !!connection.errorPassThrough : false;
+  const headers = {};
+  let url = null;
+  const options = {
+    method: "GET"
+  };
+  let allow304 = false;
+  let timeout = 2 * 60 * 1e3;
+  if (typeof connection === "string") {
+    url = connection;
+  } else if (typeof connection === "object") {
+    if (connection == null || connection.url == null) {
+      logger46.throwArgumentError("missing URL", "connection.url", connection);
+    }
+    url = connection.url;
+    if (typeof connection.timeout === "number" && connection.timeout > 0) {
+      timeout = connection.timeout;
+    }
+    if (connection.headers) {
+      for (const key2 in connection.headers) {
+        headers[key2.toLowerCase()] = { key: key2, value: String(connection.headers[key2]) };
+        if (["if-none-match", "if-modified-since"].indexOf(key2.toLowerCase()) >= 0) {
+          allow304 = true;
+        }
+      }
+    }
+    options.allowGzip = !!connection.allowGzip;
+    if (connection.user != null && connection.password != null) {
+      if (url.substring(0, 6) !== "https:" && connection.allowInsecureAuthentication !== true) {
+        logger46.throwError("basic authentication requires a secure https url", Logger.errors.INVALID_ARGUMENT, { argument: "url", url, user: connection.user, password: "[REDACTED]" });
+      }
+      const authorization = connection.user + ":" + connection.password;
+      headers["authorization"] = {
+        key: "Authorization",
+        value: "Basic " + encode2(toUtf8Bytes(authorization))
+      };
+    }
+    if (connection.skipFetchSetup != null) {
+      options.skipFetchSetup = !!connection.skipFetchSetup;
+    }
+    if (connection.fetchOptions != null) {
+      options.fetchOptions = shallowCopy(connection.fetchOptions);
+    }
+  }
+  const reData = new RegExp("^data:([a-z0-9-]+/[a-z0-9-]+);base64,(.*)$", "i");
+  const dataMatch = url ? url.match(reData) : null;
+  if (dataMatch) {
+    try {
+      const response = {
+        statusCode: 200,
+        statusMessage: "OK",
+        headers: { "content-type": dataMatch[1] },
+        body: decode2(dataMatch[2])
+      };
+      let result = response.body;
+      if (processFunc) {
+        result = processFunc(response.body, response);
+      }
+      return Promise.resolve(result);
+    } catch (error) {
+      logger46.throwError("processing response error", Logger.errors.SERVER_ERROR, {
+        body: bodyify2(dataMatch[1], dataMatch[2]),
+        error,
+        requestBody: null,
+        requestMethod: "GET",
+        url
+      });
+    }
+  }
+  if (body) {
+    options.method = "POST";
+    options.body = body;
+    if (headers["content-type"] == null) {
+      headers["content-type"] = { key: "Content-Type", value: "application/octet-stream" };
+    }
+    if (headers["content-length"] == null) {
+      headers["content-length"] = { key: "Content-Length", value: String(body.length) };
+    }
+  }
+  const flatHeaders = {};
+  Object.keys(headers).forEach((key2) => {
+    const header = headers[key2];
+    flatHeaders[header.key] = header.value;
+  });
+  options.headers = flatHeaders;
+  const runningTimeout = function() {
+    let timer2 = null;
+    const promise = new Promise(function(resolve, reject) {
+      if (timeout) {
+        timer2 = setTimeout(() => {
+          if (timer2 == null) {
+            return;
+          }
+          timer2 = null;
+          reject(logger46.makeError("timeout", Logger.errors.TIMEOUT, {
+            requestBody: bodyify2(options.body, flatHeaders["content-type"]),
+            requestMethod: options.method,
+            timeout,
+            url
+          }));
+        }, timeout);
+      }
+    });
+    const cancel = function() {
+      if (timer2 == null) {
+        return;
+      }
+      clearTimeout(timer2);
+      timer2 = null;
+    };
+    return { promise, cancel };
+  }();
+  const runningFetch = function() {
+    return __awaiter18(this, void 0, void 0, function* () {
+      for (let attempt = 0; attempt < attemptLimit; attempt++) {
+        let response = null;
+        try {
+          response = yield getUrl2(url, options);
+          if (attempt < attemptLimit) {
+            if (response.statusCode === 301 || response.statusCode === 302) {
+              const location = response.headers.location || "";
+              if (options.method === "GET" && location.match(/^https:/)) {
+                url = response.headers.location;
+                continue;
+              }
+            } else if (response.statusCode === 429) {
+              let tryAgain = true;
+              if (throttleCallback) {
+                tryAgain = yield throttleCallback(attempt, url);
+              }
+              if (tryAgain) {
+                let stall3 = 0;
+                const retryAfter = response.headers["retry-after"];
+                if (typeof retryAfter === "string" && retryAfter.match(/^[1-9][0-9]*$/)) {
+                  stall3 = parseInt(retryAfter) * 1e3;
+                } else {
+                  stall3 = throttleSlotInterval * parseInt(String(Math.random() * Math.pow(2, attempt)));
+                }
+                yield staller2(stall3);
+                continue;
+              }
+            }
+          }
+        } catch (error) {
+          response = error.response;
+          if (response == null) {
+            runningTimeout.cancel();
+            logger46.throwError("missing response", Logger.errors.SERVER_ERROR, {
+              requestBody: bodyify2(options.body, flatHeaders["content-type"]),
+              requestMethod: options.method,
+              serverError: error,
+              url
+            });
+          }
+        }
+        let body2 = response.body;
+        if (allow304 && response.statusCode === 304) {
+          body2 = null;
+        } else if (!errorPassThrough && (response.statusCode < 200 || response.statusCode >= 300)) {
+          runningTimeout.cancel();
+          logger46.throwError("bad response", Logger.errors.SERVER_ERROR, {
+            status: response.statusCode,
+            headers: response.headers,
+            body: bodyify2(body2, response.headers ? response.headers["content-type"] : null),
+            requestBody: bodyify2(options.body, flatHeaders["content-type"]),
+            requestMethod: options.method,
+            url
+          });
+        }
+        if (processFunc) {
+          try {
+            const result = yield processFunc(body2, response);
+            runningTimeout.cancel();
+            return result;
+          } catch (error) {
+            if (error.throttleRetry && attempt < attemptLimit) {
+              let tryAgain = true;
+              if (throttleCallback) {
+                tryAgain = yield throttleCallback(attempt, url);
+              }
+              if (tryAgain) {
+                const timeout2 = throttleSlotInterval * parseInt(String(Math.random() * Math.pow(2, attempt)));
+                yield staller2(timeout2);
+                continue;
+              }
+            }
+            runningTimeout.cancel();
+            logger46.throwError("processing response error", Logger.errors.SERVER_ERROR, {
+              body: bodyify2(body2, response.headers ? response.headers["content-type"] : null),
+              error,
+              requestBody: bodyify2(options.body, flatHeaders["content-type"]),
+              requestMethod: options.method,
+              url
+            });
+          }
+        }
+        runningTimeout.cancel();
+        return body2;
+      }
+      return logger46.throwError("failed response", Logger.errors.SERVER_ERROR, {
+        requestBody: bodyify2(options.body, flatHeaders["content-type"]),
+        requestMethod: options.method,
+        url
+      });
+    });
+  }();
+  return Promise.race([runningTimeout.promise, runningFetch]);
+}
+function fetchJson2(connection, json, processFunc) {
+  let processJsonFunc = (value, response) => {
+    let result = null;
+    if (value != null) {
+      try {
+        result = JSON.parse(toUtf8String(value));
+      } catch (error) {
+        logger46.throwError("invalid JSON", Logger.errors.SERVER_ERROR, {
+          body: value,
+          error
+        });
+      }
+    }
+    if (processFunc) {
+      result = processFunc(result, response);
+    }
+    return result;
+  };
+  let body = null;
+  if (json != null) {
+    body = toUtf8Bytes(json);
+    const updated = typeof connection === "string" ? { url: connection } : shallowCopy(connection);
+    if (updated.headers) {
+      const hasContentType = Object.keys(updated.headers).filter((k) => k.toLowerCase() === "content-type").length !== 0;
+      if (!hasContentType) {
+        updated.headers = shallowCopy(updated.headers);
+        updated.headers["content-type"] = "application/json";
+      }
+    } else {
+      updated.headers = { "content-type": "application/json" };
+    }
+    connection = updated;
+  }
+  return _fetchData2(connection, body, processJsonFunc);
+}
+function poll2(func, options) {
+  if (!options) {
+    options = {};
+  }
+  options = shallowCopy(options);
+  if (options.floor == null) {
+    options.floor = 0;
+  }
+  if (options.ceiling == null) {
+    options.ceiling = 1e4;
+  }
+  if (options.interval == null) {
+    options.interval = 250;
+  }
+  return new Promise(function(resolve, reject) {
+    let timer2 = null;
+    let done = false;
+    const cancel = () => {
+      if (done) {
+        return false;
+      }
+      done = true;
+      if (timer2) {
+        clearTimeout(timer2);
+      }
+      return true;
+    };
+    if (options.timeout) {
+      timer2 = setTimeout(() => {
+        if (cancel()) {
+          reject(new Error("timeout"));
+        }
+      }, options.timeout);
+    }
+    const retryLimit = options.retryLimit;
+    let attempt = 0;
+    function check() {
+      return func().then(function(result) {
+        if (result !== void 0) {
+          if (cancel()) {
+            resolve(result);
+          }
+        } else if (options.oncePoll) {
+          options.oncePoll.once("poll", check);
+        } else if (options.onceBlock) {
+          options.onceBlock.once("block", check);
+        } else if (!done) {
+          attempt++;
+          if (attempt > retryLimit) {
+            if (cancel()) {
+              reject(new Error("retry limit reached"));
+            }
+            return;
+          }
+          let timeout = options.interval * parseInt(String(Math.random() * Math.pow(2, attempt)));
+          if (timeout < options.floor) {
+            timeout = options.floor;
+          }
+          if (timeout > options.ceiling) {
+            timeout = options.ceiling;
+          }
+          setTimeout(check, timeout);
+        }
+        return null;
+      }, function(error) {
+        if (cancel()) {
+          reject(error);
+        }
+      });
+    }
+    check();
+  });
+}
+
 // ../../node_modules/ethers/lib.esm/_version.js
-var version26 = "ethers/5.7.0";
+var version27 = "ethers/5.7.0";
 
 // ../../node_modules/ethers/lib.esm/ethers.js
-var logger46 = new Logger(version26);
+var logger47 = new Logger(version27);
 
 // ../../node_modules/ethers/lib.esm/index.js
 try {
@@ -23037,12 +23509,14 @@ var WalletStore = class _WalletStore {
       if (this.isLedger) {
         const ledger = await GlobalLedgerSigner();
         console.log(ledger, "ledger signer");
-        hash3 = await ledger.sendTransaction({
+        const tx = await ledger.sendTransaction({
           to: address,
           data,
           value: value ? BigInt(value) : void 0,
-          from: this.account
+          from: this.account,
+          type: 0
         });
+        hash3 = tx == null ? void 0 : tx.hash;
       } else {
         hash3 = await this.walletClient.sendTransaction({
           account: this.account,
@@ -23203,4 +23677,4 @@ js-sha3/src/sha3.js:
 
 export { AppProvider, AutoMan, BigNumberInputState, BigNumberState, ConnectLedger, DisconnectLedger, ObjectPool, PromiseHook, StorageListState, StorageState, WalletConfigStore, WalletHistoryStore, WalletRpcStore, WalletStore };
 //# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-I3PECBV3.mjs.map
+//# sourceMappingURL=chunk-43PPHYFY.mjs.map