@luckystack/core 0.1.9 → 0.2.0

package/dist/chunk-OZTB2RL2.js

@@ -0,0 +1,699 @@
+import {
+  getProjectConfig
+} from "./chunk-W62GGT2P.js";
+import {
+  captureException,
+  getLogger
+} from "./chunk-V2WKGTZH.js";
+import {
+  createRegistry
+} from "./chunk-USQA6QTX.js";
+
+// src/apiMethodMapRegistry.ts
+var registry = createRegistry(null);
+var registerApiMethodMap = (map) => {
+  registry.register(map);
+};
+var getRegisteredApiMethod = (pagePath, apiName, version) => {
+  const activeMap = registry.get();
+  if (!activeMap) return void 0;
+  return activeMap[pagePath]?.[apiName]?.[version];
+};
+var isApiMethodMapRegistered = () => registry.isRegistered();
+
+// src/httpApiUtils.ts
+var isGetMethodName = (methodNameLower) => methodNameLower.startsWith("get") || methodNameLower.startsWith("fetch") || methodNameLower.startsWith("list");
+var inferHttpMethod = (apiName) => {
+  const nameParts = apiName.split("/");
+  const lastPart = nameParts.at(-1)?.toLowerCase() ?? "";
+  const methodName = /^v\d+$/.test(lastPart) ? (nameParts.at(-2) ?? "").toLowerCase() : lastPart;
+  if (isGetMethodName(methodName)) {
+    return "GET";
+  }
+  if (methodName.startsWith("delete") || methodName.startsWith("remove")) {
+    return "DELETE";
+  }
+  if (methodName.startsWith("update") || methodName.startsWith("edit") || methodName.startsWith("patch")) {
+    return "PUT";
+  }
+  return "POST";
+};
+var getEffectiveHttpMethod = (apiConfig, apiName) => {
+  return apiConfig.httpMethod ?? inferHttpMethod(apiName);
+};
+var isMethodAllowed = (requestMethod, allowedMethod) => {
+  return requestMethod === allowedMethod;
+};
+
+// src/socketState.ts
+var socket = null;
+var waiters = [];
+var WAIT_FOR_SOCKET_TIMEOUT_MS = 5e3;
+var setSocket = (next) => {
+  socket = next;
+  if (next) {
+    const pending = waiters;
+    waiters = [];
+    for (const resolve of pending) {
+      resolve(next);
+    }
+  }
+};
+var responseIndex = 0;
+var incrementResponseIndex = () => {
+  responseIndex = responseIndex + 1;
+  return responseIndex;
+};
+var waitForSocket = () => {
+  if (socket) return Promise.resolve(socket);
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      waiters = waiters.filter((w) => w !== onSocket);
+      resolve(null);
+    }, WAIT_FOR_SOCKET_TIMEOUT_MS);
+    const onSocket = (s) => {
+      clearTimeout(timer);
+      resolve(s);
+    };
+    waiters.push(onSocket);
+  });
+};
+
+// src/notifier.ts
+var noopNotifier = {
+  success: () => {
+  },
+  error: () => {
+  },
+  info: () => {
+  },
+  warning: () => {
+  }
+};
+var registry2 = createRegistry(noopNotifier);
+var registerNotifier = (notifier) => {
+  registry2.register(notifier);
+};
+var getNotifier = () => registry2.get();
+var notify = {
+  success: (input) => {
+    registry2.get().success(input);
+  },
+  error: (input) => {
+    registry2.get().error(input);
+  },
+  info: (input) => {
+    registry2.get().info(input);
+  },
+  warning: (input) => {
+    registry2.get().warning(input);
+  }
+};
+
+// src/tryCatchSync.ts
+function tryCatchSync(func, params) {
+  try {
+    const response = func(params);
+    return [null, response];
+  } catch (error) {
+    return [error, null];
+  }
+}
+
+// src/clientHookBus.ts
+var handlerSets = {};
+function registerClientHook(name, handler) {
+  const existing = handlerSets[name];
+  const set = existing ?? /* @__PURE__ */ new Set();
+  if (!existing) handlerSets[name] = set;
+  const wrapped = handler;
+  set.add(wrapped);
+  return () => {
+    set.delete(wrapped);
+  };
+}
+function dispatchClientHook(name, payload) {
+  const set = handlerSets[name];
+  if (!set || set.size === 0) return;
+  const handlers = [...set];
+  for (const handler of handlers) {
+    try {
+      const result = handler(payload);
+      if (result && typeof result.catch === "function") {
+        result.catch((error) => {
+          getLogger().error(`[clientHook:${name}] async handler rejected`, error);
+        });
+      }
+    } catch (error) {
+      getLogger().error(`[clientHook:${name}] handler threw`, error);
+    }
+  }
+}
+async function dispatchVetoableClientHook(name, payload) {
+  const set = handlerSets[name];
+  if (!set || set.size === 0) return { stopped: false };
+  const handlers = [...set];
+  for (const handler of handlers) {
+    let result;
+    try {
+      result = await handler(payload);
+    } catch (error) {
+      getLogger().error(`[clientHook:${name}] vetoable handler threw`, error);
+      continue;
+    }
+    if (result?.stop) {
+      return { stopped: true, signal: result };
+    }
+  }
+  return { stopped: false };
+}
+
+// src/offlineQueue.ts
+var apiQueue = [];
+var syncQueue = [];
+var isFlushingApi = false;
+var isFlushingSync = false;
+var isOnline = () => {
+  if (typeof navigator === "undefined") return true;
+  return navigator.onLine;
+};
+var notifyDropped = (item, reason) => {
+  if (!item.onDrop) return;
+  tryCatchSync(() => {
+    item.onDrop?.(reason);
+  });
+};
+var safeDispatchDropHook = (queue, key, reason, dropPolicy) => {
+  tryCatchSync(() => {
+    dispatchClientHook("queueItemDropped", { queue, key, reason, dropPolicy });
+  });
+};
+var evictExpired = (queue, label) => {
+  const { maxAgeMs, dropPolicy: globalPolicy } = getProjectConfig().offlineQueue;
+  if (maxAgeMs <= 0) return;
+  const cutoff = Date.now() - maxAgeMs;
+  for (let i = queue.length - 1; i >= 0; i -= 1) {
+    const item = queue[i];
+    if (item && item.createdAt < cutoff) {
+      queue.splice(i, 1);
+      notifyDropped(item, "expired");
+      safeDispatchDropHook(label, item.key, "expired", item.dropPolicy ?? globalPolicy);
+    }
+  }
+};
+var enqueueWithPolicy = (queue, item, label) => {
+  evictExpired(queue, label);
+  const { maxSize, dropPolicy: globalPolicy } = getProjectConfig().offlineQueue;
+  const effectivePolicy = item.dropPolicy ?? globalPolicy;
+  if (queue.length < maxSize) {
+    queue.push(item);
+    return true;
+  }
+  if (effectivePolicy === "drop-oldest") {
+    const dropped = queue.shift();
+    queue.push(item);
+    getLogger().debug(`offlineQueue:${label} full \u2014 dropped oldest item (policy=${effectivePolicy})`);
+    if (dropped) {
+      notifyDropped(dropped, "queue-full");
+      safeDispatchDropHook(label, dropped.key, "queue-full", effectivePolicy);
+    }
+    return true;
+  }
+  if (effectivePolicy === "drop-newest") {
+    getLogger().debug(`offlineQueue:${label} full \u2014 dropped newest item (policy=${effectivePolicy})`);
+    notifyDropped(item, "queue-full");
+    safeDispatchDropHook(label, item.key, "queue-full", effectivePolicy);
+    return false;
+  }
+  getLogger().warn(`offlineQueue:${label} full \u2014 rejecting enqueue (policy=${effectivePolicy})`);
+  notifyDropped(item, "queue-full");
+  safeDispatchDropHook(label, item.key, "queue-full", effectivePolicy);
+  return false;
+};
+var enqueueApiRequest = (item) => enqueueWithPolicy(apiQueue, item, "api");
+var enqueueSyncRequest = (item) => enqueueWithPolicy(syncQueue, item, "sync");
+var removeApiQueueItem = (id) => {
+  const index = apiQueue.findIndex((item) => item.id === id);
+  if (index !== -1) {
+    apiQueue.splice(index, 1);
+  }
+};
+var removeSyncQueueItem = (id) => {
+  const index = syncQueue.findIndex((item) => item.id === id);
+  if (index !== -1) {
+    syncQueue.splice(index, 1);
+  }
+};
+var removeApiQueueItemsByKey = (key) => {
+  for (let i = apiQueue.length - 1; i >= 0; i -= 1) {
+    if (apiQueue[i]?.key === key) {
+      apiQueue.splice(i, 1);
+    }
+  }
+};
+var runQueueItem = (queue, item, socketInstance, label) => {
+  const [error] = tryCatchSync(() => {
+    item.run(socketInstance);
+  });
+  if (error) {
+    queue.unshift(item);
+    getLogger().warn(`offlineQueue:${label} run threw \u2014 requeued item, pausing flush`, { error });
+    return false;
+  }
+  return true;
+};
+var flushApiQueue = (canRun, socketInstance) => {
+  if (isFlushingApi) return;
+  evictExpired(apiQueue, "api");
+  if (apiQueue.length === 0) return;
+  if (!canRun()) return;
+  isFlushingApi = true;
+  while (apiQueue.length > 0) {
+    if (!canRun()) break;
+    const item = apiQueue.shift();
+    if (item && !runQueueItem(apiQueue, item, socketInstance, "api")) break;
+  }
+  isFlushingApi = false;
+};
+var flushSyncQueue = (canRun, socketInstance) => {
+  if (isFlushingSync) return;
+  evictExpired(syncQueue, "sync");
+  if (syncQueue.length === 0) return;
+  if (!canRun()) return;
+  isFlushingSync = true;
+  while (syncQueue.length > 0) {
+    if (!canRun()) break;
+    const item = syncQueue.shift();
+    if (item && !runQueueItem(syncQueue, item, socketInstance, "sync")) break;
+  }
+  isFlushingSync = false;
+};
+var getApiQueueSize = () => apiQueue.length;
+var getSyncQueueSize = () => syncQueue.length;
+
+// src/responseNormalizer.ts
+var INVALID_ERROR_RESPONSE_CODE = "error.invalidResponse";
+var isErrorParamArray = (value) => {
+  return Array.isArray(value) && value.every((item) => {
+    return !!item && typeof item === "object" && typeof item.key === "string" && ["string", "number", "boolean"].includes(typeof item.value);
+  });
+};
+var normalizeErrorResponseCore = ({
+  response,
+  fallbackHttpStatus,
+  fallbackErrorCode,
+  resolveMessage
+}) => {
+  const normalizedParams = isErrorParamArray(response.errorParams) ? response.errorParams : void 0;
+  const errorCodeValue = typeof response.errorCode === "string" ? response.errorCode.trim() : "";
+  const hasErrorCode = errorCodeValue.length > 0;
+  const finalErrorCode = hasErrorCode ? errorCodeValue : fallbackErrorCode ?? INVALID_ERROR_RESPONSE_CODE;
+  const providedHttpStatus = typeof response.httpStatus === "number" ? response.httpStatus : void 0;
+  const message = resolveMessage ? resolveMessage({ errorCode: finalErrorCode, errorParams: normalizedParams }) : finalErrorCode;
+  return {
+    status: "error",
+    message,
+    errorCode: finalErrorCode,
+    errorParams: normalizedParams,
+    httpStatus: providedHttpStatus ?? fallbackHttpStatus
+  };
+};
+var defaultHttpStatusForResponse = ({
+  status,
+  explicitHttpStatus,
+  fallbackErrorStatus = 400
+}) => {
+  if (typeof explicitHttpStatus === "number") return explicitHttpStatus;
+  return status === "success" ? 200 : fallbackErrorStatus;
+};
+
+// src/serviceRoute.ts
+var VERSION_SEGMENT_REGEX = /^v\d+$/;
+var normalizeRawRoute = (value) => {
+  return value.trim().replaceAll("\\", "/").replaceAll(/^\/+/g, "").replaceAll(/\/+$/g, "");
+};
+var hasEmptySegments = (value) => {
+  return value.split("/").some((segment) => segment.length === 0);
+};
+var parseServiceRouteName = (value) => {
+  const normalized = normalizeRawRoute(value);
+  if (!normalized) {
+    return { status: "error", reason: "Route name cannot be empty." };
+  }
+  if (hasEmptySegments(normalized)) {
+    return { status: "error", reason: "Route name cannot contain empty segments." };
+  }
+  const segments = normalized.split("/");
+  if (segments.length < 2) {
+    return { status: "error", reason: "Route name must include service and route segments." };
+  }
+  const [service, ...routeSegments] = segments;
+  const routeName = routeSegments.join("/");
+  if (!service || !routeName) {
+    return { status: "error", reason: "Route name must include service and route segments." };
+  }
+  return {
+    status: "success",
+    normalizedRouteName: `${service}/${routeName}`,
+    service,
+    routeName
+  };
+};
+var parseTransportRouteName = ({
+  value,
+  prefix
+}) => {
+  const normalized = normalizeRawRoute(value);
+  if (!normalized) {
+    return { status: "error", reason: "Transport route cannot be empty." };
+  }
+  if (hasEmptySegments(normalized)) {
+    return { status: "error", reason: "Transport route cannot contain empty segments." };
+  }
+  const segments = normalized.split("/");
+  const routeSegments = segments[0] === prefix ? segments.slice(1) : segments;
+  if (routeSegments.length < 3) {
+    return {
+      status: "error",
+      reason: `Transport route must use ${prefix}/{service}/{name}/{version} format.`
+    };
+  }
+  const version = routeSegments.at(-1);
+  if (!version || !VERSION_SEGMENT_REGEX.test(version)) {
+    return { status: "error", reason: "Route version segment must match v{number}." };
+  }
+  const serviceRouteToken = routeSegments.slice(0, -1).join("/");
+  const serviceRoute = parseServiceRouteName(serviceRouteToken);
+  if (serviceRoute.status === "error") {
+    return {
+      status: "error",
+      reason: serviceRoute.reason
+    };
+  }
+  return {
+    status: "success",
+    normalizedFullName: `${prefix}/${serviceRoute.normalizedRouteName}/${version}`,
+    version,
+    serviceRoute
+  };
+};
+
+// src/socketEvents.ts
+var withIndex = (prefix, responseIndex2) => {
+  return `${prefix}${String(responseIndex2)}`;
+};
+var socketEventNames = {
+  apiRequest: "apiRequest",
+  apiCancel: "apiCancel",
+  sync: "sync",
+  syncCancel: "syncCancel",
+  joinRoom: "joinRoom",
+  leaveRoom: "leaveRoom",
+  getJoinedRooms: "getJoinedRooms",
+  updateLocation: "updateLocation",
+  updateSession: "updateSession",
+  sessionReplaced: "sessionReplaced",
+  logout: "logout",
+  intentionalDisconnect: "intentionalDisconnect",
+  intentionalReconnect: "intentionalReconnect",
+  //? Client -> server activity heartbeat (mouse/keyboard/touch), throttled.
+  //? Drives the server-side activity sampler that fires registered activity
+  //? events (e.g. the built-in AFK detector).
+  activity: "activity",
+  userAfk: "userAfk",
+  userBack: "userBack",
+  //? Emitted to a room's remaining members when a peer leaves — hard disconnect
+  //? (socket close) or grace-expiry (presence MIS-003). Lets clients prune a
+  //? departed peer from their roster without polling. The presence package owns
+  //? the dispatch; core owns the wire-event name so client + server can't drift.
+  userLeft: "userLeft",
+  connect: "connect",
+  disconnect: "disconnect",
+  reconnectAttempt: "reconnect_attempt",
+  connectError: "connect_error",
+  apiResponsePrefix: "apiResponse-",
+  apiStreamPrefix: "apiStream-",
+  syncResponsePrefix: "sync-",
+  syncProgressPrefix: "sync-progress-",
+  joinRoomResponsePrefix: "joinRoom-",
+  leaveRoomResponsePrefix: "leaveRoom-",
+  getJoinedRoomsResponsePrefix: "getJoinedRooms-"
+};
+var buildApiResponseEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.apiResponsePrefix, responseIndex2);
+};
+var buildApiStreamEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.apiStreamPrefix, responseIndex2);
+};
+var buildSyncResponseEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.syncResponsePrefix, responseIndex2);
+};
+var buildSyncProgressEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.syncProgressPrefix, responseIndex2);
+};
+var buildJoinRoomResponseEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.joinRoomResponsePrefix, responseIndex2);
+};
+var buildLeaveRoomResponseEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.leaveRoomResponsePrefix, responseIndex2);
+};
+var buildGetJoinedRoomsResponseEventName = (responseIndex2) => {
+  return withIndex(socketEventNames.getJoinedRoomsResponsePrefix, responseIndex2);
+};
+
+// src/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/csrfConfig.ts
+var DEFAULT_CSRF_CONFIG = {
+  cookieName: "csrf-token",
+  headerName: "x-csrf-token",
+  tokenLength: 32,
+  cookieOptions: {
+    sameSite: "lax",
+    secure: true,
+    httpOnly: false,
+    path: "/",
+    maxAgeMs: 24 * 60 * 60 * 1e3
+  }
+};
+var registry3 = createRegistry(DEFAULT_CSRF_CONFIG, {
+  //? Merge shallowly with the CURRENT config; `cookieOptions` is deep-merged
+  //? so a partial override of (say) `sameSite` does not clobber `path` /
+  //? `maxAgeMs`. Last-write-wins, and successive calls accumulate.
+  transform: (input, current) => ({
+    ...current,
+    ...input,
+    cookieOptions: { ...current.cookieOptions, ...input.cookieOptions }
+  })
+});
+var registerCsrfConfig = (input) => {
+  registry3.register(input);
+};
+var getCsrfConfig = () => registry3.get();
+var resetCsrfConfigForTests = () => {
+  registry3.reset();
+};
+
+// src/tryCatch.ts
+async function tryCatch(func, params, context) {
+  try {
+    const response = await func(params);
+    return [null, response];
+  } catch (error) {
+    captureException(error, context);
+    return [error, null];
+  }
+}
+
+// src/csrf.ts
+var cachedToken = null;
+var inflightFetch = null;
+var resolveBackendUrl = () => {
+  const socketUri = socket?.io.opts.hostname ? `${socket.io.opts.secure ? "https" : "http"}://${socket.io.opts.hostname}${socket.io.opts.port ? `:${socket.io.opts.port}` : ""}` : "";
+  if (socketUri) return socketUri;
+  if (globalThis.window !== void 0 && globalThis.location?.origin) {
+    return globalThis.location.origin;
+  }
+  return "";
+};
+var fetchCsrfToken = async () => {
+  const base = resolveBackendUrl();
+  const [error, token] = await tryCatch(async () => {
+    const response = await fetch(`${base}/auth/csrf`, {
+      method: "GET",
+      credentials: "include"
+    });
+    if (!response.ok) return null;
+    const body = await response.json();
+    return body.csrfToken ?? null;
+  });
+  if (error) return null;
+  return token ?? null;
+};
+var getCsrfToken = async () => {
+  if (getProjectConfig().session.basedToken) {
+    return null;
+  }
+  if (cachedToken) return cachedToken;
+  if (inflightFetch) return inflightFetch;
+  inflightFetch = fetchCsrfToken().then((token) => {
+    cachedToken = token;
+    inflightFetch = null;
+    return token;
+  });
+  return inflightFetch;
+};
+var clearCsrfToken = () => {
+  cachedToken = null;
+  inflightFetch = null;
+};
+var STATE_CHANGING = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var isCsrfMismatchResponse = async (response) => {
+  if (response.status !== 403) return false;
+  const [error, isMismatch] = await tryCatch(async () => {
+    const cloned = response.clone();
+    const body = await cloned.json();
+    return body.errorCode === "auth.csrfMismatch";
+  });
+  if (error) return false;
+  return isMismatch ?? false;
+};
+var httpFetch = async (input, init = {}) => {
+  const method = (init.method ?? "GET").toUpperCase();
+  const headers = new Headers(init.headers);
+  if (!headers.has("Content-Type") && init.body && typeof init.body === "string") {
+    headers.set("Content-Type", "application/json");
+  }
+  const csrfHeaderName = getCsrfConfig().headerName;
+  const send = async (csrfToken) => {
+    const finalHeaders = new Headers(headers);
+    if (csrfToken && STATE_CHANGING.has(method) && !finalHeaders.has(csrfHeaderName)) {
+      finalHeaders.set(csrfHeaderName, csrfToken);
+    }
+    return fetch(input, {
+      ...init,
+      method,
+      headers: finalHeaders,
+      credentials: init.credentials ?? "include"
+    });
+  };
+  if (!STATE_CHANGING.has(method) || getProjectConfig().session.basedToken) {
+    return send(null);
+  }
+  const token = await getCsrfToken();
+  let response = await send(token);
+  if (await isCsrfMismatchResponse(response)) {
+    clearCsrfToken();
+    const refreshed = await getCsrfToken();
+    if (refreshed) {
+      response = await send(refreshed);
+    }
+  }
+  return response;
+};
+
+// src/pageRouteValidation.ts
+var DEFAULT_PAGE_ROUTE_RULES = {
+  privateFolderPrefix: "_",
+  scaffoldIgnoredFolders: [
+    "_api",
+    "_sync",
+    "_function",
+    "_functions",
+    "_component",
+    "_components",
+    "_provider",
+    "_providers",
+    "_locale",
+    "_locales",
+    "_socket",
+    "_sockets",
+    "_shared",
+    "_server"
+  ]
+};
+var validatePagePath = (srcRelativePath, rules = DEFAULT_PAGE_ROUTE_RULES) => {
+  const normalized = srcRelativePath.replaceAll("\\", "/").replace(/^\.\//, "").replace(/^\/+/, "");
+  const segments = normalized.split("/").filter((segment) => segment.length > 0);
+  if (segments.length === 0) {
+    return { valid: false, reason: "empty path" };
+  }
+  const filename = segments.at(-1);
+  if (filename !== "page.tsx" && filename !== "page.jsx") {
+    return { valid: false, reason: "not a page file (expected page.tsx)" };
+  }
+  const folderSegments = segments.slice(0, -1);
+  const prefix = rules.privateFolderPrefix;
+  const reserved = rules.scaffoldIgnoredFolders;
+  for (const reservedName of reserved) {
+    if (folderSegments.includes(reservedName)) {
+      return { valid: false, reason: `page.tsx cannot live inside reserved folder ${reservedName}` };
+    }
+  }
+  const visibleSegments = folderSegments.filter((segment) => !segment.startsWith(prefix));
+  if (folderSegments.length > 0 && visibleSegments.length === 0) {
+    return { valid: false, reason: "no URL segment left after stripping underscore folders" };
+  }
+  const route = visibleSegments.length === 0 ? "/" : `/${visibleSegments.join("/")}`;
+  return { valid: true, route };
+};
+
+export {
+  registerApiMethodMap,
+  getRegisteredApiMethod,
+  isApiMethodMapRegistered,
+  isGetMethodName,
+  inferHttpMethod,
+  getEffectiveHttpMethod,
+  isMethodAllowed,
+  socket,
+  setSocket,
+  incrementResponseIndex,
+  waitForSocket,
+  registerNotifier,
+  getNotifier,
+  notify,
+  tryCatchSync,
+  registerClientHook,
+  dispatchClientHook,
+  dispatchVetoableClientHook,
+  isOnline,
+  enqueueApiRequest,
+  enqueueSyncRequest,
+  removeApiQueueItem,
+  removeSyncQueueItem,
+  removeApiQueueItemsByKey,
+  flushApiQueue,
+  flushSyncQueue,
+  getApiQueueSize,
+  getSyncQueueSize,
+  INVALID_ERROR_RESPONSE_CODE,
+  isErrorParamArray,
+  normalizeErrorResponseCore,
+  defaultHttpStatusForResponse,
+  parseServiceRouteName,
+  parseTransportRouteName,
+  socketEventNames,
+  buildApiResponseEventName,
+  buildApiStreamEventName,
+  buildSyncResponseEventName,
+  buildSyncProgressEventName,
+  buildJoinRoomResponseEventName,
+  buildLeaveRoomResponseEventName,
+  buildGetJoinedRoomsResponseEventName,
+  sleep,
+  DEFAULT_CSRF_CONFIG,
+  registerCsrfConfig,
+  getCsrfConfig,
+  resetCsrfConfigForTests,
+  tryCatch,
+  getCsrfToken,
+  clearCsrfToken,
+  httpFetch,
+  DEFAULT_PAGE_ROUTE_RULES,
+  validatePagePath
+};
+//# sourceMappingURL=chunk-OZTB2RL2.js.map