database-devtools 0.1.0

package/dist/chunk-ZS5MZR75.js

@@ -0,0 +1,655 @@
+import { generateDeviceId, generateTransactionId, generateWriteId } from './chunk-AZECU6D7.js';
+import { DevToolsRole, buildDevToolsWsUrl, DEFAULT_DEVTOOLS_PORT, PROJECT_DEVICE_EXPORTS_API_PATH, PROJECT_DATABASE_API_PATH, PROJECT_DATABASE_META_API_PATH, PROJECT_DATABASES_API_PATH, wsUrlToHttpUrl, buildDeviceSnapshotUrl, MessageType, isPingMessage, isDeviceStatusMessage, isSnapshotUploadRequestedMessage, isExportSnapshotErrorMessage, isRefreshStatusMessage, isSnapshotReadyMessage, isRefreshErrorMessage, isBeginTransactionMessage, isCommitTransactionMessage, isRollbackTransactionMessage, isExecuteWriteMessage, isTransactionStatusMessage, isWriteResultMessage, isWriteErrorMessage } from './chunk-CPVVIH5G.js';
+import { SNAPSHOT_MIME_HEADER, SNAPSHOT_KIND_HEADER, SNAPSHOT_NAME_HEADER } from './chunk-HIDZTOJ3.js';
+
+// src/utils/reconnect.ts
+var DEFAULT_BASE_MS = 1e3;
+var DEFAULT_MAX_MS = 3e4;
+var DEFAULT_JITTER_MS = 500;
+function calculateBackoffDelay(attempt, options = {}) {
+  const baseMs = options.baseMs ?? DEFAULT_BASE_MS;
+  const maxMs = options.maxMs ?? DEFAULT_MAX_MS;
+  const jitterMs = options.jitterMs ?? DEFAULT_JITTER_MS;
+  const exponential = baseMs * 2 ** attempt;
+  const capped = Math.min(exponential, maxMs);
+  const jitter = Math.floor(Math.random() * jitterMs);
+  return capped + jitter;
+}
+var ReconnectScheduler = class {
+  attempt = 0;
+  timer = null;
+  onReconnect;
+  options;
+  constructor({ onReconnect, ...options }) {
+    this.onReconnect = onReconnect;
+    this.options = options;
+  }
+  schedule() {
+    if (this.timer !== null) {
+      return;
+    }
+    const delay = calculateBackoffDelay(this.attempt, this.options);
+    this.attempt += 1;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.onReconnect();
+    }, delay);
+  }
+  reset() {
+    this.attempt = 0;
+    this.cancel();
+  }
+  cancel() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+
+// src/client/createDevToolsClient.ts
+var WRITE_TIMEOUT_MS = 3e4;
+function createDevToolsClient(options = {}) {
+  const role = options.role ?? DevToolsRole.MOBILE;
+  const WebSocketImpl = options.WebSocketImpl ?? globalThis.WebSocket;
+  if (!WebSocketImpl) {
+    throw new Error("WebSocket is not available in this environment.");
+  }
+  let socket = null;
+  let deviceStatus = null;
+  let connectionState = "disconnected";
+  let lastConnectionError = null;
+  let intentionalDisconnect = false;
+  let transactionState = "idle";
+  let activeTransactionId = null;
+  let activeDeviceId = null;
+  const pendingTransaction = /* @__PURE__ */ new Map();
+  const pendingWrites = /* @__PURE__ */ new Map();
+  const deviceId = role === DevToolsRole.MOBILE ? options.deviceId ?? generateDeviceId() : void 0;
+  let wsUrl = options.serverUrl ?? buildDevToolsWsUrl("localhost", DEFAULT_DEVTOOLS_PORT);
+  const setConnectionState = (state) => {
+    if (connectionState === state) {
+      return;
+    }
+    connectionState = state;
+    options.onConnectionStateChange?.(state);
+  };
+  const setTransactionState = (state) => {
+    if (transactionState === state) {
+      return;
+    }
+    transactionState = state;
+    options.onTransactionStateChange?.(state);
+  };
+  const resetTransaction = () => {
+    setTransactionState("idle");
+    activeTransactionId = null;
+    activeDeviceId = null;
+  };
+  const rejectPendingTransaction = (transactionId, error) => {
+    const pending = pendingTransaction.get(transactionId);
+    if (pending) {
+      pending.reject(error);
+      pendingTransaction.delete(transactionId);
+    }
+  };
+  const rejectAllPending = (error) => {
+    for (const [id, pending] of pendingTransaction) {
+      pending.reject(error);
+      pendingTransaction.delete(id);
+    }
+    for (const [id, pending] of pendingWrites) {
+      pending.reject(error);
+      pendingWrites.delete(id);
+    }
+    resetTransaction();
+  };
+  const reconnectScheduler = new ReconnectScheduler({
+    onReconnect: () => {
+      openSocket();
+    }
+  });
+  const send = (message) => {
+    if (!socket || socket.readyState !== WebSocketImpl.OPEN) {
+      return;
+    }
+    socket.send(JSON.stringify({ ...message, timestamp: Date.now() }));
+  };
+  const sendRegister = () => {
+    send({
+      type: MessageType.REGISTER,
+      role,
+      ...deviceId ? { deviceId } : {},
+      ...options.metadata ? { metadata: options.metadata } : {}
+    });
+  };
+  const handleServerMessage = (parsed) => {
+    if (isPingMessage(parsed)) {
+      send({
+        type: MessageType.PONG,
+        pingId: parsed.pingId
+      });
+      return;
+    }
+    if (isDeviceStatusMessage(parsed)) {
+      deviceStatus = parsed.payload;
+      options.onDeviceStatus?.(parsed.payload);
+      return;
+    }
+    if (isSnapshotUploadRequestedMessage(parsed)) {
+      options.onSnapshotUploadRequested?.(parsed);
+      return;
+    }
+    if (isExportSnapshotErrorMessage(parsed)) {
+      options.onExportSnapshotError?.(parsed);
+      return;
+    }
+    if (isRefreshStatusMessage(parsed)) {
+      options.onRefreshStatus?.(parsed);
+      return;
+    }
+    if (isSnapshotReadyMessage(parsed)) {
+      options.onSnapshotReady?.(parsed);
+      return;
+    }
+    if (isRefreshErrorMessage(parsed)) {
+      options.onRefreshError?.(parsed);
+      return;
+    }
+    if (isBeginTransactionMessage(parsed)) {
+      options.onBeginTransaction?.(parsed);
+      return;
+    }
+    if (isCommitTransactionMessage(parsed)) {
+      options.onCommitTransaction?.(parsed);
+      return;
+    }
+    if (isRollbackTransactionMessage(parsed)) {
+      options.onRollbackTransaction?.(parsed);
+      return;
+    }
+    if (isExecuteWriteMessage(parsed)) {
+      options.onExecuteWrite?.(parsed);
+      return;
+    }
+    if (isTransactionStatusMessage(parsed)) {
+      options.onTransactionStatus?.(parsed);
+      if (role !== DevToolsRole.BROWSER) {
+        return;
+      }
+      const pending = pendingTransaction.get(parsed.transactionId);
+      if (parsed.state === "open" && pending?.action === "begin") {
+        setTransactionState("open");
+        activeTransactionId = parsed.transactionId;
+        activeDeviceId = parsed.deviceId;
+        pending.resolve();
+        pendingTransaction.delete(parsed.transactionId);
+        return;
+      }
+      if (parsed.state === "idle" && pending && (pending.action === "commit" || pending.action === "rollback")) {
+        resetTransaction();
+        pending.resolve();
+        pendingTransaction.delete(parsed.transactionId);
+        return;
+      }
+      if (parsed.state === "failed") {
+        rejectPendingTransaction(
+          parsed.transactionId,
+          new Error(parsed.message ?? "Transaction failed")
+        );
+        resetTransaction();
+      }
+      return;
+    }
+    if (isWriteResultMessage(parsed)) {
+      options.onWriteResult?.(parsed);
+      const pending = pendingWrites.get(parsed.writeId);
+      if (pending) {
+        pending.resolve({ rowsAffected: parsed.rowsAffected });
+        pendingWrites.delete(parsed.writeId);
+      }
+      return;
+    }
+    if (isWriteErrorMessage(parsed)) {
+      options.onWriteError?.(parsed);
+      const error = new Error(parsed.message);
+      if (parsed.writeId) {
+        const pendingWrite = pendingWrites.get(parsed.writeId);
+        if (pendingWrite) {
+          pendingWrite.reject(error);
+          pendingWrites.delete(parsed.writeId);
+        }
+      } else {
+        rejectPendingTransaction(parsed.transactionId, error);
+        resetTransaction();
+      }
+    }
+  };
+  const openSocket = () => {
+    if (socket && (socket.readyState === WebSocketImpl.OPEN || socket.readyState === WebSocketImpl.CONNECTING)) {
+      return;
+    }
+    setConnectionState(intentionalDisconnect ? "disconnected" : connectionState === "disconnected" ? "connecting" : "reconnecting");
+    socket = new WebSocketImpl(wsUrl);
+    socket.addEventListener("open", () => {
+      reconnectScheduler.reset();
+      lastConnectionError = null;
+      setConnectionState("connected");
+      options.onConnect?.();
+      sendRegister();
+    });
+    socket.addEventListener("message", (event) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      handleServerMessage(parsed);
+    });
+    socket.addEventListener("close", () => {
+      socket = null;
+      options.onDisconnect?.();
+      rejectAllPending(new Error("Disconnected from DevTools hub"));
+      if (intentionalDisconnect) {
+        setConnectionState("disconnected");
+        return;
+      }
+      setConnectionState("reconnecting");
+      reconnectScheduler.schedule();
+    });
+    socket.addEventListener("error", () => {
+      const error = new Error(`WebSocket connection failed: ${wsUrl}`);
+      lastConnectionError = error.message;
+      options.onError?.(error);
+    });
+  };
+  const connect = () => {
+    intentionalDisconnect = false;
+    openSocket();
+  };
+  const disconnect = () => {
+    intentionalDisconnect = true;
+    reconnectScheduler.cancel();
+    socket?.close();
+    socket = null;
+    rejectAllPending(new Error("Disconnected"));
+    setConnectionState("disconnected");
+  };
+  const setServerUrl = (url) => {
+    wsUrl = url;
+    const wasConnected = connectionState === "connected" || connectionState === "connecting" || connectionState === "reconnecting";
+    disconnect();
+    intentionalDisconnect = false;
+    if (wasConnected) {
+      connect();
+    }
+  };
+  const requestRefresh = (targetDeviceId) => {
+    send({
+      type: MessageType.REFRESH_REQUEST,
+      deviceId: targetDeviceId,
+      refreshType: "snapshot"
+    });
+  };
+  const requestExportSnapshot = () => {
+    send({
+      type: MessageType.EXPORT_SNAPSHOT_REQUEST,
+      refreshType: "snapshot"
+    });
+  };
+  const sendTransactionAck = (message) => {
+    send({
+      type: MessageType.TRANSACTION_ACK,
+      ...message
+    });
+  };
+  const sendWriteAck = (message) => {
+    send({
+      type: MessageType.WRITE_ACK,
+      ...message
+    });
+  };
+  const waitForTransaction = (transactionId, action) => {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pendingTransaction.delete(transactionId);
+        reject(new Error(`Transaction ${action} timed out`));
+      }, WRITE_TIMEOUT_MS);
+      pendingTransaction.set(transactionId, {
+        action,
+        resolve: () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+    });
+  };
+  const beginTransaction = async (targetDeviceId) => {
+    if (role !== DevToolsRole.BROWSER) {
+      throw new Error("beginTransaction is only available for browser clients");
+    }
+    if (transactionState !== "idle") {
+      throw new Error("A transaction is already active");
+    }
+    const transactionId = generateTransactionId();
+    setTransactionState("opening");
+    activeTransactionId = transactionId;
+    activeDeviceId = targetDeviceId;
+    const promise = waitForTransaction(transactionId, "begin");
+    send({
+      type: MessageType.BEGIN_TRANSACTION_REQUEST,
+      transactionId,
+      deviceId: targetDeviceId
+    });
+    await promise;
+  };
+  const commitTransaction = async () => {
+    if (role !== DevToolsRole.BROWSER) {
+      throw new Error("commitTransaction is only available for browser clients");
+    }
+    if (!activeTransactionId || !activeDeviceId || transactionState !== "open") {
+      throw new Error("No open transaction");
+    }
+    const transactionId = activeTransactionId;
+    const deviceIdForCommit = activeDeviceId;
+    setTransactionState("committing");
+    const promise = waitForTransaction(transactionId, "commit");
+    send({
+      type: MessageType.COMMIT_TRANSACTION_REQUEST,
+      transactionId,
+      deviceId: deviceIdForCommit
+    });
+    await promise;
+  };
+  const rollbackTransaction = async () => {
+    if (role !== DevToolsRole.BROWSER) {
+      throw new Error("rollbackTransaction is only available for browser clients");
+    }
+    if (!activeTransactionId || !activeDeviceId) {
+      throw new Error("No active transaction");
+    }
+    const transactionId = activeTransactionId;
+    const deviceIdForRollback = activeDeviceId;
+    setTransactionState("rolling_back");
+    const promise = waitForTransaction(transactionId, "rollback");
+    send({
+      type: MessageType.ROLLBACK_TRANSACTION_REQUEST,
+      transactionId,
+      deviceId: deviceIdForRollback
+    });
+    await promise;
+  };
+  const executeWrite = async (operation) => {
+    if (role !== DevToolsRole.BROWSER) {
+      throw new Error("executeWrite is only available for browser clients");
+    }
+    if (!activeTransactionId || !activeDeviceId || transactionState !== "open") {
+      throw new Error("No open transaction");
+    }
+    const writeId = generateWriteId();
+    const promise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pendingWrites.delete(writeId);
+        reject(new Error("Write operation timed out"));
+      }, WRITE_TIMEOUT_MS);
+      pendingWrites.set(writeId, {
+        resolve: (result) => {
+          clearTimeout(timer);
+          resolve(result);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+    });
+    send({
+      type: MessageType.WRITE_REQUEST,
+      writeId,
+      transactionId: activeTransactionId,
+      deviceId: activeDeviceId,
+      operation
+    });
+    return promise;
+  };
+  return {
+    connect,
+    disconnect,
+    getConnectionState: () => connectionState,
+    getLastConnectionError: () => lastConnectionError,
+    getDeviceStatus: () => deviceStatus,
+    getDeviceId: () => deviceId,
+    getServerUrl: () => wsUrl,
+    setServerUrl,
+    send,
+    requestRefresh,
+    requestExportSnapshot,
+    sendTransactionAck,
+    sendWriteAck,
+    beginTransaction,
+    commitTransaction,
+    rollbackTransaction,
+    executeWrite,
+    getTransactionState: () => transactionState,
+    getActiveTransactionId: () => activeTransactionId
+  };
+}
+
+// src/client/fetchSnapshot.ts
+async function fetchSnapshot(downloadUrl) {
+  let response;
+  try {
+    response = await fetch(downloadUrl);
+  } catch (error) {
+    const networkMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Network error fetching snapshot from ${downloadUrl}. ${networkMessage} If the web UI runs on a different port than the hub, ensure CORS is enabled on the hub HTTP API.`
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch snapshot from ${downloadUrl}: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.arrayBuffer();
+}
+
+// src/client/resolveDeviceDatabaseUrl.ts
+function resolveApiBase(serverUrl, options) {
+  if (options?.useSameOriginApi && typeof window !== "undefined") {
+    return window.location.origin;
+  }
+  if (serverUrl.startsWith("ws://") || serverUrl.startsWith("wss://")) {
+    return wsUrlToHttpUrl(serverUrl);
+  }
+  return serverUrl.replace(/\/$/, "");
+}
+function resolveDeviceExportDatabaseUrl(serverUrl, deviceId, options) {
+  const base = resolveApiBase(serverUrl, options);
+  return `${base}${PROJECT_DEVICE_EXPORTS_API_PATH}/${encodeURIComponent(deviceId)}/database`;
+}
+function resolveDeviceExportDatabaseMetaUrl(serverUrl, deviceId, options) {
+  const base = resolveApiBase(serverUrl, options);
+  return `${base}${PROJECT_DEVICE_EXPORTS_API_PATH}/${encodeURIComponent(deviceId)}/database/meta`;
+}
+function resolveDeviceExportsUrl(serverUrl, options) {
+  const base = resolveApiBase(serverUrl, options);
+  return `${base}${PROJECT_DEVICE_EXPORTS_API_PATH}`;
+}
+
+// src/client/deviceDatabase.ts
+async function fetchJson(url, errorLabel) {
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    const networkMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Network error fetching ${errorLabel} from ${url}. ${networkMessage}`);
+  }
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${errorLabel} from ${url}: ${response.status} ${response.statusText}`);
+  }
+  return await response.json();
+}
+async function fetchDeviceExportMeta(serverUrl, deviceId, options) {
+  const url = resolveDeviceExportDatabaseMetaUrl(serverUrl, deviceId, options);
+  return fetchJson(url, "device export metadata");
+}
+async function fetchDeviceExportDatabase(serverUrl, deviceId, options) {
+  const url = resolveDeviceExportDatabaseUrl(serverUrl, deviceId, options);
+  return fetchSnapshot(url);
+}
+async function fetchDeviceExports(serverUrl, options) {
+  const url = resolveDeviceExportsUrl(serverUrl, options);
+  const payload = await fetchJson(url, "device exports");
+  return payload.devices ?? [];
+}
+
+// src/client/resolveProjectDatabaseUrl.ts
+function resolveApiBase2(serverUrl, options) {
+  if (options?.useSameOriginApi && typeof window !== "undefined") {
+    return window.location.origin;
+  }
+  if (serverUrl.startsWith("ws://") || serverUrl.startsWith("wss://")) {
+    return wsUrlToHttpUrl(serverUrl);
+  }
+  return serverUrl.replace(/\/$/, "");
+}
+function resolveProjectDatabaseUrl(serverUrl, options) {
+  return `${resolveApiBase2(serverUrl, options)}${PROJECT_DATABASE_API_PATH}`;
+}
+function resolveProjectDatabaseMetaUrl(serverUrl, options) {
+  return `${resolveApiBase2(serverUrl, options)}${PROJECT_DATABASE_META_API_PATH}`;
+}
+function resolveProjectDatabasesUrl(serverUrl, options) {
+  return `${resolveApiBase2(serverUrl, options)}${PROJECT_DATABASES_API_PATH}`;
+}
+
+// src/client/projectDatabase.ts
+async function fetchProjectDatabaseMeta(serverUrl, options) {
+  const url = resolveProjectDatabaseMetaUrl(serverUrl, options);
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    const networkMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Network error fetching project database metadata from ${url}. ${networkMessage}`);
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch project database metadata from ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  return await response.json();
+}
+async function fetchProjectDatabase(serverUrl, options) {
+  const url = resolveProjectDatabaseUrl(serverUrl, options);
+  return fetchSnapshot(url);
+}
+async function fetchProjectDatabases(serverUrl, options) {
+  const url = resolveProjectDatabasesUrl(serverUrl, options);
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    const networkMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Network error fetching project databases from ${url}. ${networkMessage}`);
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch project databases from ${url}: ${response.status} ${response.statusText}`
+    );
+  }
+  const payload = await response.json();
+  return payload.databases ?? [];
+}
+
+// src/client/snapshotUpload.ts
+function createSnapshotUploadBody(bytes) {
+  return bytes;
+}
+function resolveSnapshotUploadUrl(uploadUrl, hubWsUrl) {
+  const hubHttpBase = wsUrlToHttpUrl(hubWsUrl);
+  const target = new URL(uploadUrl);
+  const hub = new URL(hubHttpBase.endsWith("/") ? hubHttpBase : `${hubHttpBase}/`);
+  target.protocol = hub.protocol;
+  target.hostname = hub.hostname;
+  target.port = hub.port;
+  return target.toString();
+}
+async function uploadSnapshot(uploadUrl, bytes, options) {
+  const headers = {
+    "Content-Type": "application/octet-stream",
+    [options.kindHeader]: options.kind,
+    [options.mimeHeader]: options.mimeType
+  };
+  if (options.databaseName && options.nameHeader) {
+    headers[options.nameHeader] = options.databaseName;
+  }
+  const response = await fetch(uploadUrl, {
+    method: "POST",
+    headers,
+    body: createSnapshotUploadBody(bytes)
+  });
+  if (!response.ok) {
+    throw new Error(`Upload failed with status ${response.status}`);
+  }
+}
+
+// src/client/handleDeviceSnapshot.ts
+async function handleDeviceSnapshotUpload(database, message, options = {}) {
+  if (options.deviceId && message.deviceId !== options.deviceId) {
+    return;
+  }
+  if (!database) {
+    throw new Error("No database adapter configured");
+  }
+  if (!options.hubServerUrl) {
+    throw new Error("hubServerUrl is required to upload a device snapshot");
+  }
+  const snapshot = await database.exportSnapshot();
+  const hubHttp = wsUrlToHttpUrl(options.hubServerUrl);
+  const uploadUrl = buildDeviceSnapshotUrl(hubHttp, message.deviceId);
+  await uploadSnapshot(uploadUrl, snapshot.bytes, {
+    kind: snapshot.kind,
+    mimeType: snapshot.mimeType,
+    kindHeader: SNAPSHOT_KIND_HEADER,
+    mimeHeader: SNAPSHOT_MIME_HEADER,
+    databaseName: database.name,
+    nameHeader: SNAPSHOT_NAME_HEADER
+  });
+}
+
+// src/client/formatSyncError.ts
+function formatSyncErrorMessage(code, message) {
+  return formatRefreshErrorMessage(code, message);
+}
+function formatRefreshErrorMessage(code, message) {
+  switch (code) {
+    case "DEVICE_OFFLINE":
+      return "Selected device disconnected. Reconnect the mobile app and try again.";
+    case "REFRESH_IN_PROGRESS":
+      return "A refresh is already in progress for this device.";
+    case "EXPORT_FAILED":
+      return `Device failed to export or upload snapshot: ${message}`;
+    case "UPLOAD_FAILED":
+      return `Snapshot upload failed on the hub: ${message}`;
+    case "TIMEOUT":
+      return "Timed out waiting for the device to upload a snapshot.";
+    case "SNAPSHOT_NOT_FOUND":
+      return "Snapshot expired or was not found. Click Refresh again.";
+    case "INVALID_REQUEST":
+      return `Invalid refresh request: ${message}`;
+    default:
+      return message;
+  }
+}
+
+export { createDevToolsClient, createSnapshotUploadBody, fetchDeviceExportDatabase, fetchDeviceExportMeta, fetchDeviceExports, fetchProjectDatabase, fetchProjectDatabaseMeta, fetchProjectDatabases, fetchSnapshot, formatRefreshErrorMessage, formatSyncErrorMessage, handleDeviceSnapshotUpload, resolveDeviceExportDatabaseMetaUrl, resolveDeviceExportDatabaseUrl, resolveDeviceExportsUrl, resolveProjectDatabaseMetaUrl, resolveProjectDatabaseUrl, resolveProjectDatabasesUrl, resolveSnapshotUploadUrl, uploadSnapshot };
+//# sourceMappingURL=chunk-ZS5MZR75.js.map
+//# sourceMappingURL=chunk-ZS5MZR75.js.map