@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-5QIKR7RR.cjs

@@ -0,0 +1,224 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkQNPEUFHQcjs = require('./chunk-QNPEUFHQ.cjs');
+
+
+var _chunkUS2QVW3Ecjs = require('./chunk-US2QVW3E.cjs');
+
+
+
+
+var _chunkNO3WWW3Ncjs = require('./chunk-NO3WWW3N.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/utils.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function parseRoutePath(filePath) {
+  const segments = [];
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const pathParts = normalizedPath.split("/").filter(Boolean);
+  const fileName = pathParts.pop() || "";
+  const fileType = getRouteType(fileName);
+  const routePath = `/${pathParts.join("/")}`;
+  _chunkNO3WWW3Ncjs.assertBrowserStableRoutePath.call(void 0, routePath);
+  _chunkNO3WWW3Ncjs.assertTerminalCatchAll.call(void 0, routePath);
+  _chunkNO3WWW3Ncjs.assertUniqueRouteParameters.call(void 0, routePath);
+  for (const part of pathParts) {
+    if (part.startsWith("(") && part.endsWith(")")) continue;
+    if (part.startsWith("[") && part.endsWith("]")) {
+      let segment = part.slice(1, -1);
+      const isDynamic = true;
+      let isOptional = false;
+      let isCatchAll = false;
+      if (segment.startsWith("[") && segment.endsWith("]")) {
+        isOptional = true;
+        segment = segment.slice(1, -1);
+        if (segment.startsWith("...")) {
+          segment = segment.slice(3);
+          isCatchAll = true;
+        }
+      } else if (segment.startsWith("...")) {
+        segment = segment.slice(3);
+        isCatchAll = true;
+      }
+      segments.push({ segment, isDynamic, isOptional, isCatchAll });
+    } else {
+      segments.push({
+        segment: part,
+        isDynamic: false,
+        isOptional: false,
+        isCatchAll: false
+      });
+    }
+  }
+  return {
+    segments,
+    filePath: normalizedPath,
+    type: fileType
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseRoutePath, "parseRoutePath");
+function getRouteType(fileName) {
+  const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|mdx?|markdown)$/, "");
+  switch (baseName) {
+    case "page":
+      return "page";
+    case "layout":
+      return "layout";
+    case "loading":
+      return "loading";
+    case "error":
+      return "error";
+    case "not-found":
+      return "not-found";
+    default:
+      return "page";
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRouteType, "getRouteType");
+function segmentsToPattern(segments) {
+  if (segments.length === 0) return "/";
+  return "/" + segments.map((segment) => {
+    if (!segment.isDynamic) return segment.segment;
+    if (segment.isCatchAll) {
+      return segment.isOptional ? `*${segment.segment}?` : `*${segment.segment}`;
+    }
+    return `:${segment.segment}`;
+  }).join("/");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, segmentsToPattern, "segmentsToPattern");
+function matchRoute(url, segments) {
+  return matchRouteParts(splitRoutePath(url), segments);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchRoute, "matchRoute");
+function splitRoutePath(url) {
+  return url.split("/").filter(Boolean).map(_chunkUS2QVW3Ecjs.decodeRouteSegment);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, splitRoutePath, "splitRoutePath");
+function matchRouteParts(urlParts, segments) {
+  const params = {};
+  if (segments.length === 0) {
+    return { params, matches: urlParts.length === 0 };
+  }
+  let urlIndex = 0;
+  let segmentIndex = 0;
+  while (segmentIndex < segments.length && urlIndex <= urlParts.length) {
+    const segment = segments[segmentIndex];
+    if (!segment.isDynamic) {
+      if (urlParts[urlIndex] !== segment.segment) {
+        return { params: {}, matches: false };
+      }
+      urlIndex++;
+      segmentIndex++;
+    } else if (segment.isCatchAll) {
+      const remainingParts = urlParts.slice(urlIndex);
+      if (remainingParts.length === 0 && !segment.isOptional) {
+        return { params: {}, matches: false };
+      }
+      params[segment.segment] = remainingParts.join("/");
+      urlIndex = urlParts.length;
+      segmentIndex++;
+    } else {
+      if (urlIndex >= urlParts.length) {
+        return { params: {}, matches: false };
+      }
+      params[segment.segment] = urlParts[urlIndex];
+      urlIndex++;
+      segmentIndex++;
+    }
+  }
+  const matches = segmentIndex === segments.length && urlIndex === urlParts.length;
+  return { params, matches };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchRouteParts, "matchRouteParts");
+function matchRoutePrefix(url, segments) {
+  return matchRoutePrefixParts(splitRoutePath(url), segments);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchRoutePrefix, "matchRoutePrefix");
+function matchRoutePrefixParts(urlParts, segments) {
+  let urlIndex = 0;
+  for (const segment of segments) {
+    if (segment.isCatchAll) {
+      return segment.isOptional || urlIndex < urlParts.length;
+    }
+    const urlPart = urlParts[urlIndex];
+    if (urlPart === void 0) return false;
+    if (!segment.isDynamic && segment.segment !== urlPart) return false;
+    urlIndex++;
+  }
+  return true;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchRoutePrefixParts, "matchRoutePrefixParts");
+function resolveAppPath(root, ...paths) {
+  return _path2.default.resolve(root, ...paths);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveAppPath, "resolveAppPath");
+function toRootRelativeUrlPath(absolutePath, projectRoot) {
+  if (absolutePath === projectRoot) return "";
+  if (absolutePath.startsWith(`${projectRoot}/`) || absolutePath.startsWith(`${projectRoot}\\`)) {
+    return absolutePath.slice(projectRoot.length).replace(/\\/g, "/");
+  }
+  return void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toRootRelativeUrlPath, "toRootRelativeUrlPath");
+function toPosixPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toPosixPath, "toPosixPath");
+function toViteModuleId(filePath, root) {
+  if (!_path2.default.isAbsolute(filePath)) return filePath;
+  const relativePath = _path2.default.relative(root, filePath);
+  if (relativePath && !relativePath.startsWith("..") && !_path2.default.isAbsolute(relativePath)) {
+    return `/${relativePath.split(_path2.default.sep).join("/")}`;
+  }
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  return normalizedPath.startsWith("/") ? `/@fs${normalizedPath}` : `/@fs/${normalizedPath}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toViteModuleId, "toViteModuleId");
+async function fileExists(filePath) {
+  try {
+    const fs = await import("fs/promises");
+    await fs.access(filePath);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, fileExists, "fileExists");
+async function globFiles(pattern, cwd) {
+  const glob = await import("fast-glob");
+  return glob.default(pattern, { cwd, absolute: false });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, globFiles, "globFiles");
+function parseSearchParams(searchParams) {
+  return _chunkQNPEUFHQcjs.searchParamsToObject.call(void 0, searchParams);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseSearchParams, "parseSearchParams");
+var logger = {
+  info: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.log(`[info] ${message}`), "info"),
+  success: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.log(`[success] ${message}`), "success"),
+  warn: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.warn(`\u26A0\uFE0F  ${message}`), "warn"),
+  error: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.error(`\u274C ${message}`), "error"),
+  ready: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.log(`${message}`), "ready"),
+  event: /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (message) => console.log(`  ${message}`), "event")
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.parseRoutePath = parseRoutePath; exports.segmentsToPattern = segmentsToPattern; exports.matchRoute = matchRoute; exports.splitRoutePath = splitRoutePath; exports.matchRouteParts = matchRouteParts; exports.matchRoutePrefix = matchRoutePrefix; exports.matchRoutePrefixParts = matchRoutePrefixParts; exports.resolveAppPath = resolveAppPath; exports.toRootRelativeUrlPath = toRootRelativeUrlPath; exports.toPosixPath = toPosixPath; exports.toViteModuleId = toViteModuleId; exports.fileExists = fileExists; exports.globFiles = globFiles; exports.parseSearchParams = parseSearchParams; exports.logger = logger;

package/dist/{chunk-MOQNHLTS.mjs → chunk-5QOEPUYE.mjs}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-TVGP4BBZ.mjs";
 import {
   farmAcceptQuality
-} from "./chunk-6SCB2MXB.mjs";
+} from "./chunk-SXHV42UQ.mjs";
 import {
   matchesFarmIfNoneMatch
 } from "./chunk-XF7Q24PF.mjs";
@@ -1970,6 +1970,7 @@ function createFarmDocsHandler(docs, options) {
     if (!isFarmDocsRequest(docs, request)) return null;
     const page = loadPage(contentDir, docs, request);
     if (!page) return null;
+    const negotiatesAccept = !requestUrl.pathname.endsWith(".md");
     if (shouldReturnMarkdown(request)) {
       const origin = new URL(request.url).origin;
       return omitFarmDocsHeadBody(
@@ -1984,7 +1985,8 @@ function createFarmDocsHandler(docs, options) {
             status: 200,
             headers: {
               "Content-Type": "text/markdown; charset=utf-8",
-              "Cache-Control": "public, max-age=60"
+              "Cache-Control": "public, max-age=60",
+              ...negotiatesAccept ? { Vary: "Accept" } : {}
             }
           }
         )
@@ -2014,6 +2016,7 @@ function createFarmDocsHandler(docs, options) {
           headers: {
             "Content-Type": "text/html; charset=utf-8",
             "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300",
+            Vary: "Accept",
             ...fontPreloadHeader ? { Link: fontPreloadHeader } : {}
           }
         }

package/dist/{chunk-HKLRP3BN.mjs → chunk-5SPPCN5J.mjs}

@@ -1,6 +1,6 @@
 import {
   createRouteDataCacheKey
-} from "./chunk-IGO2HEV7.mjs";
+} from "./chunk-F6SJAKFJ.mjs";
 import {
   subscribeFarmCacheInvalidation
 } from "./chunk-4SIYUGRY.mjs";

package/dist/chunk-5ZSWG4UX.cjs

@@ -0,0 +1,127 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkU4KT7QP3cjs = require('./chunk-U4KT7QP3.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/server/request.ts
+var _async_hooks = require('async_hooks');
+var _stream = require('stream');
+var REQUEST_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-storage");
+function getRequestStore() {
+  const runtime = globalThis;
+  const existing = runtime[REQUEST_STORAGE_KEY];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new (0, _async_hooks.AsyncLocalStorage)();
+  runtime[REQUEST_STORAGE_KEY] = storage;
+  return storage;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestStore, "getRequestStore");
+var requestStore = getRequestStore();
+_chunkU4KT7QP3cjs._setCurrentRequestResolver.call(void 0, () => requestStore.getStore());
+function resolveFarmRequestURL(req, options = {}) {
+  if (options.origin) {
+    return new URL(req.url || "/", options.origin);
+  }
+  const forwardedHost = options.trustProxy ? firstForwardedHeaderValue(req.headers["x-forwarded-host"]) : void 0;
+  const fallbackHost = firstForwardedHeaderValue(req.headers.host) || "localhost";
+  const forwardedProto = options.trustProxy ? firstForwardedHeaderValue(req.headers["x-forwarded-proto"]) : void 0;
+  const normalizedProto = _optionalChain([forwardedProto, 'optionalAccess', _ => _.toLowerCase, 'call', _2 => _2()]);
+  const proto = normalizedProto === "https" || normalizedProto === "http" ? normalizedProto : isEncryptedFarmRequest(req) ? "https" : "http";
+  return new URL(req.url || "/", resolveRequestOrigin(proto, forwardedHost, fallbackHost));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRequestURL, "resolveFarmRequestURL");
+function resolveFarmWebRequestOrigin(request, options = {}) {
+  const url = new URL(request.url);
+  if (!options.trustProxy) return url.origin;
+  const forwardedHost = firstForwardedHeaderValue(
+    _nullishCoalesce(request.headers.get("x-forwarded-host"), () => ( void 0))
+  );
+  const forwardedProto = _optionalChain([firstForwardedHeaderValue, 'call', _3 => _3(
+    _nullishCoalesce(request.headers.get("x-forwarded-proto"), () => ( void 0))
+  ), 'optionalAccess', _4 => _4.toLowerCase, 'call', _5 => _5()]);
+  const proto = forwardedProto === "https" || forwardedProto === "http" ? forwardedProto : url.protocol === "https:" ? "https" : "http";
+  return resolveRequestOrigin(proto, forwardedHost, url.host);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmWebRequestOrigin, "resolveFarmWebRequestOrigin");
+function createWebRequestFromFarmRequest(req, options = {}) {
+  const fullUrl = resolveFarmRequestURL(req, options).toString();
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+      continue;
+    }
+    headers.set(key, value);
+  }
+  const method = (req.method || "GET").toUpperCase();
+  const init = {
+    method: req.method,
+    headers
+  };
+  if (method !== "GET" && method !== "HEAD") {
+    init.body = _stream.Readable.toWeb(req);
+    init.duplex = "half";
+  }
+  return new Request(fullUrl, init);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createWebRequestFromFarmRequest, "createWebRequestFromFarmRequest");
+function isEncryptedFarmRequest(req) {
+  return Boolean(_optionalChain([req, 'access', _6 => _6.socket, 'optionalAccess', _7 => _7.encrypted]));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isEncryptedFarmRequest, "isEncryptedFarmRequest");
+function firstForwardedHeaderValue(value) {
+  const first = Array.isArray(value) ? value[0] : value;
+  const token = _optionalChain([first, 'optionalAccess', _8 => _8.split, 'call', _9 => _9(",", 1), 'access', _10 => _10[0], 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()]);
+  return token || void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, firstForwardedHeaderValue, "firstForwardedHeaderValue");
+function resolveRequestOrigin(proto, host, fallback) {
+  for (const candidate of [host, fallback, "localhost"]) {
+    if (!candidate) continue;
+    if (/[\s/?#@\\]/u.test(candidate)) continue;
+    try {
+      const url = new URL(`${proto}://${candidate}`);
+      if (url.username || url.password || url.pathname !== "/" || url.search || url.hash) continue;
+      return url.origin;
+    } catch (e) {
+    }
+  }
+  return `${proto}://localhost`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveRequestOrigin, "resolveRequestOrigin");
+async function _runWithCurrentRequest(request, fn) {
+  return requestStore.run(request, fn);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithCurrentRequest, "_runWithCurrentRequest");
+function getCurrentRequest() {
+  const request = requestStore.getStore();
+  if (!request) {
+    throw new Error(
+      "No current request is available. getCurrentRequest() can only be used during server rendering."
+    );
+  }
+  return request;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getCurrentRequest, "getCurrentRequest");
+function getCurrentRequestOrNull() {
+  return _nullishCoalesce(requestStore.getStore(), () => ( null));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getCurrentRequestOrNull, "getCurrentRequestOrNull");
+
+
+
+
+
+
+
+
+exports.resolveFarmRequestURL = resolveFarmRequestURL; exports.resolveFarmWebRequestOrigin = resolveFarmWebRequestOrigin; exports.createWebRequestFromFarmRequest = createWebRequestFromFarmRequest; exports._runWithCurrentRequest = _runWithCurrentRequest; exports.getCurrentRequest = getCurrentRequest; exports.getCurrentRequestOrNull = getCurrentRequestOrNull;

package/dist/chunk-62YJ2IEB.cjs

@@ -0,0 +1,238 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkSU7MH53Pcjs = require('./chunk-SU7MH53P.cjs');
+
+
+
+
+
+
+var _chunkWJ3HK3LJcjs = require('./chunk-WJ3HK3LJ.cjs');
+
+
+var _chunk5OVTOKGHcjs = require('./chunk-5OVTOKGH.cjs');
+
+
+var _chunkU4KT7QP3cjs = require('./chunk-U4KT7QP3.cjs');
+
+
+var _chunkBIDYX3SLcjs = require('./chunk-BIDYX3SL.cjs');
+
+
+
+
+
+var _chunkI57LW5VZcjs = require('./chunk-I57LW5VZ.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client/router.ts
+var _react = require('react');
+function shouldBlockUnload(options) {
+  const path = window.location.pathname + window.location.search;
+  const context = {
+    from: path,
+    to: path,
+    action: "replace"
+  };
+  const when = typeof options.when === "function" ? options.when(context) : options.when;
+  if (!when) return false;
+  if (!options.shouldBlock) return true;
+  try {
+    const result = options.shouldBlock(context);
+    if (typeof result === "boolean") return result;
+    void result.catch(() => void 0);
+    return true;
+  } catch (e) {
+    return true;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, shouldBlockUnload, "shouldBlockUnload");
+function navigateViaRouter(href, basePath, replace) {
+  if (typeof window === "undefined") return;
+  const url = _chunkI57LW5VZcjs.applyFarmBasePath.call(void 0, href, basePath);
+  const spaRouter = _chunkWJ3HK3LJcjs.getInstalledFarmSPARouter.call(void 0, );
+  if (spaRouter) {
+    void spaRouter.navigate(url, { replace });
+    return;
+  }
+  if (replace) {
+    window.history.replaceState(null, "", url);
+  } else {
+    window.history.pushState(null, "", url);
+  }
+  _chunkWJ3HK3LJcjs.notifyHistoryChange.call(void 0, "url-search");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, navigateViaRouter, "navigateViaRouter");
+function useRouter(options = {}) {
+  const basePath = options.basePath === void 0 ? _chunkI57LW5VZcjs.getFarmBasePath.call(void 0, ) : _chunkI57LW5VZcjs.normalizeFarmBasePath.call(void 0, options.basePath);
+  const routes = options.routes;
+  const routeKey = _optionalChain([routes, 'optionalAccess', _ => _.map, 'call', _2 => _2((route) => typeof route === "string" ? route : route.path), 'access', _3 => _3.join, 'call', _4 => _4("\n")]) || "";
+  const routeMatcher = _react.useMemo.call(void 0, 
+    () => routeKey ? _chunkSU7MH53Pcjs.createFarmRouter.call(void 0, routeKey.split("\n")) : null,
+    [routeKey]
+  );
+  const [state, setState] = _react.useState.call(void 0, () => {
+    return readRouterState(basePath, routeMatcher);
+  });
+  _react.useEffect.call(void 0, () => {
+    if (typeof window === "undefined") return;
+    const handlePopState = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+      setState(readRouterState(basePath, routeMatcher));
+    }, "handlePopState");
+    handlePopState();
+    const unsubscribe = _chunkWJ3HK3LJcjs.subscribeHistoryChange.call(void 0, handlePopState);
+    return unsubscribe;
+  }, [basePath, routeMatcher]);
+  const push = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (href) => {
+    navigateViaRouter(href, basePath, false);
+  }, "push");
+  const replace = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (href) => {
+    navigateViaRouter(href, basePath, true);
+  }, "replace");
+  const pushState = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (pageState, href) => {
+    if (typeof window === "undefined") return;
+    _chunkWJ3HK3LJcjs.getRouter.call(void 0, ).pushState(pageState, resolveClientHref(href, basePath));
+  }, "pushState");
+  const replaceState = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (pageState, href) => {
+    if (typeof window === "undefined") return;
+    _chunkWJ3HK3LJcjs.getRouter.call(void 0, ).replaceState(pageState, resolveClientHref(href, basePath));
+  }, "replaceState");
+  const back = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (typeof window !== "undefined") {
+      window.history.back();
+    }
+  }, "back");
+  const forward = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (typeof window !== "undefined") {
+      window.history.forward();
+    }
+  }, "forward");
+  return {
+    ...state,
+    push,
+    replace,
+    pushState,
+    replaceState,
+    back,
+    forward
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, useRouter, "useRouter");
+function usePageState() {
+  const [state, setState] = _react.useState.call(void 0, () => _chunkWJ3HK3LJcjs.readPageState.call(void 0, ));
+  _react.useEffect.call(void 0, () => {
+    if (typeof window === "undefined") return;
+    const handlePopState = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+      setState(_chunkWJ3HK3LJcjs.readPageState.call(void 0, ));
+    }, "handlePopState");
+    handlePopState();
+    return _chunkWJ3HK3LJcjs.subscribeHistoryChange.call(void 0, handlePopState);
+  }, []);
+  return state;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, usePageState, "usePageState");
+function useNavigation() {
+  const [state, setState] = _react.useState.call(void 0, 
+    () => _chunkWJ3HK3LJcjs.getRouter.call(void 0, ).getNavigationState()
+  );
+  _react.useEffect.call(void 0, () => {
+    if (typeof window === "undefined") return;
+    return _chunkWJ3HK3LJcjs.getRouter.call(void 0, ).subscribeNavigation(setState);
+  }, []);
+  return state;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, useNavigation, "useNavigation");
+function useBlocker(options) {
+  const optionsRef = _react.useRef.call(void 0, options);
+  optionsRef.current = options;
+  const active = Boolean(options.when);
+  _react.useEffect.call(void 0, () => {
+    if (typeof window === "undefined" || !active) {
+      return;
+    }
+    return _chunkWJ3HK3LJcjs.getRouter.call(void 0, ).addBlocker(
+      async (context) => {
+        const current = optionsRef.current;
+        const when = typeof current.when === "function" ? current.when(context) : current.when;
+        if (!when) return false;
+        if (current.shouldBlock && !await current.shouldBlock(context)) {
+          return false;
+        }
+        if (current.message && typeof window.confirm === "function") {
+          return !window.confirm(current.message);
+        }
+        return true;
+      },
+      () => shouldBlockUnload(optionsRef.current)
+    );
+  }, [active]);
+  return { active };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, useBlocker, "useBlocker");
+function useScrollRestoration(key) {
+  const ref = _react.useRef.call(void 0, null);
+  _react.useEffect.call(void 0, () => {
+    const element = ref.current;
+    if (!element) return;
+    return _chunkWJ3HK3LJcjs.getRouter.call(void 0, ).registerScrollElement(key, element);
+  }, [key]);
+  return ref;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, useScrollRestoration, "useScrollRestoration");
+function readRouterState(basePath, routeMatcher) {
+  const url = readCurrentUrl();
+  if (!url) {
+    return {
+      pathname: "/",
+      searchParams: new URLSearchParams(),
+      params: {},
+      pageState: null
+    };
+  }
+  const pathname = normalizeClientPathname(url.pathname, basePath);
+  const i18n = _chunk5OVTOKGHcjs.getFarmI18nClientState.call(void 0, );
+  const routePathname = i18n ? _chunkBIDYX3SLcjs.stripFarmLocaleFromPathname.call(void 0, pathname, i18n) : pathname;
+  return {
+    pathname,
+    searchParams: url.searchParams,
+    params: _optionalChain([routeMatcher, 'optionalAccess', _5 => _5.match, 'call', _6 => _6(routePathname), 'optionalAccess', _7 => _7.params]) || {},
+    pageState: typeof window === "undefined" ? null : _chunkWJ3HK3LJcjs.readPageState.call(void 0, )
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readRouterState, "readRouterState");
+function readCurrentUrl() {
+  if (typeof window !== "undefined") {
+    try {
+      return new URL(window.location.href);
+    } catch (e2) {
+      return void 0;
+    }
+  }
+  const request = _chunkU4KT7QP3cjs._resolveCurrentRequest.call(void 0, );
+  if (!request) return void 0;
+  try {
+    return new URL(request.url);
+  } catch (e3) {
+    return void 0;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readCurrentUrl, "readCurrentUrl");
+function normalizeClientPathname(pathname, basePath) {
+  return _chunkI57LW5VZcjs.stripFarmBasePath.call(void 0, pathname, basePath);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeClientPathname, "normalizeClientPathname");
+function resolveClientHref(href, basePath) {
+  if (!href) return void 0;
+  return _chunkI57LW5VZcjs.applyFarmBasePath.call(void 0, href, basePath);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveClientHref, "resolveClientHref");
+
+
+
+
+
+
+
+exports.useRouter = useRouter; exports.usePageState = usePageState; exports.useNavigation = useNavigation; exports.useBlocker = useBlocker; exports.useScrollRestoration = useScrollRestoration;