@absolutejs/absolute 0.20.0-beta.169 → 0.20.0-beta.170

package/dist/client/navigation.js

@@ -0,0 +1,764 @@
+import {
+  readPageNonce,
+  consumePrefetch2
+} from "./chunks/index-6b66nzyf.js";
+
+// src/client/navigation.ts
+var RUNTIME_KEY = Symbol.for("absolutejs.navigation");
+var STATE_KEY = "__absoluteNavigation";
+var OPT_OUT_SELECTOR = '[data-absolute-navigation="off"]';
+var MODULE_RUN_PARAM = "absolute-nav";
+var ANNOUNCER_ID = "absolute-navigation-announcer";
+var ISLAND_STATE_GLOBAL = "__ABS_ISLAND_STATE__";
+var DISPOSE_GLOBAL = "__ABSOLUTE_PAGE_DISPOSE__";
+var READY_GLOBAL = "__ABSOLUTE_PAGE_READY__";
+var STYLESHEET_TIMEOUT_MS = 5000;
+var PAGE_READY_TIMEOUT_MS = 1e4;
+var PAGE_READY_POLL_MS = 16;
+var SCRIPT_PLACEHOLDER = "absolute-navigation-script";
+var ID_RADIX = 36;
+var PAGE_GLOBALS = [
+  "__INITIAL_PROPS__",
+  "__SSR_DIRTY__",
+  "__ABS_SLOT_HYDRATION_PENDING__",
+  "__ABS_SVELTE_LAZY_ROUTES__",
+  "__ABS_SVELTE_ISLAND_HTML__",
+  "__ABS_SERVER_ISLAND_HTML__",
+  "__ABSOLUTE_SERVER_DATA__",
+  "__ABS_ANGULAR_REQUEST_CONTEXT__",
+  DISPOSE_GLOBAL,
+  READY_GLOBAL
+];
+var JAVASCRIPT_TYPES = new Set([
+  "",
+  "application/ecmascript",
+  "application/javascript",
+  "module",
+  "speculationrules",
+  "text/ecmascript",
+  "text/javascript"
+]);
+var runtime;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var createId = () => typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(ID_RADIX)}-${Math.random().toString(ID_RADIX).slice(2)}`;
+var delay = (millis) => new Promise((resolve) => {
+  setTimeout(resolve, millis);
+});
+var readPublicRuntime = () => {
+  const value = Reflect.get(globalThis, RUNTIME_KEY);
+  if (!isRecord(value))
+    return;
+  const { disable, navigate } = value;
+  if (typeof disable !== "function" || typeof navigate !== "function") {
+    return;
+  }
+  return value;
+};
+var prefersReducedMotion = () => typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+var isNavigationLike = (value) => typeof value === "object" && value !== null && ("currentEntry" in value) && typeof Reflect.get(value, "addEventListener") === "function";
+var readNavigationApi = () => {
+  const value = Reflect.get(window, "navigation");
+  return isNavigationLike(value) ? value : undefined;
+};
+var readEntryKey = (api) => {
+  const entry = api.currentEntry;
+  if (typeof entry !== "object" || entry === null)
+    return;
+  const key = Reflect.get(entry, "key");
+  return typeof key === "string" ? key : undefined;
+};
+var readStamp = (state) => {
+  if (!isRecord(state))
+    return;
+  const stamp = state[STATE_KEY];
+  if (!isRecord(stamp))
+    return;
+  const { doc, key } = stamp;
+  if (typeof doc !== "string" || typeof key !== "string")
+    return;
+  return { doc, key };
+};
+var isStampable = (state) => state === null || isRecord(state);
+var stampState = (state, doc, key) => {
+  if (!isStampable(state))
+    return state;
+  return { ...isRecord(state) ? state : {}, [STATE_KEY]: { doc, key } };
+};
+var currentEntryKey = (nav) => nav.navigationApi ? readEntryKey(nav.navigationApi) : readStamp(window.history.state)?.key;
+var currentEntryOwner = (nav) => {
+  if (!nav.navigationApi)
+    return readStamp(window.history.state)?.doc;
+  const key = readEntryKey(nav.navigationApi);
+  return key === undefined ? undefined : nav.entryOwners.get(key);
+};
+var isForeignEntry = (nav) => {
+  const owner = currentEntryOwner(nav);
+  if (owner === nav.documentId)
+    return false;
+  return owner !== undefined || nav.navigationApi !== undefined;
+};
+var recordCurrentEntry = (nav) => {
+  if (!nav.navigationApi)
+    return;
+  const key = readEntryKey(nav.navigationApi);
+  if (key !== undefined)
+    nav.entryOwners.set(key, nav.documentId);
+};
+var trackEntries = (nav, api) => {
+  const onEntryChange = (event) => {
+    if (Reflect.get(event, "navigationType") === "traverse")
+      return;
+    recordCurrentEntry(nav);
+  };
+  api.addEventListener("currententrychange", onEntryChange);
+  nav.teardown.push(() => api.removeEventListener("currententrychange", onEntryChange));
+  recordCurrentEntry(nav);
+};
+var patchHistory = (nav) => {
+  const { history } = window;
+  const originalPush = history.pushState;
+  const originalReplace = history.replaceState;
+  history.pushState = (state, unused, url) => Reflect.apply(originalPush, history, [
+    stampState(state, nav.documentId, createId()),
+    unused,
+    url
+  ]);
+  history.replaceState = (state, unused, url) => Reflect.apply(originalReplace, history, [
+    stampState(state, nav.documentId, readStamp(history.state)?.key ?? createId()),
+    unused,
+    url
+  ]);
+  history.replaceState(history.state, "");
+  nav.restoreHistory = () => {
+    history.pushState = originalPush;
+    history.replaceState = originalReplace;
+  };
+};
+var recordScroll = (nav) => {
+  if (nav.navigating)
+    return;
+  const key = currentEntryKey(nav);
+  if (key === undefined)
+    return;
+  nav.scroll.set(key, { left: window.scrollX, top: window.scrollY });
+};
+var trackScroll = (nav) => {
+  const onScroll = () => {
+    if (nav.scrollFrame !== 0)
+      return;
+    nav.scrollFrame = window.requestAnimationFrame(() => {
+      nav.scrollFrame = 0;
+      recordScroll(nav);
+    });
+  };
+  window.addEventListener("scroll", onScroll, { passive: true });
+  nav.teardown.push(() => {
+    window.removeEventListener("scroll", onScroll);
+    if (nav.scrollFrame !== 0)
+      window.cancelAnimationFrame(nav.scrollFrame);
+  });
+};
+var scrollToHash = (hash) => {
+  if (hash === "" || hash === "#")
+    return false;
+  const id = decodeURIComponent(hash.slice(1));
+  const target = document.getElementById(id) ?? document.getElementsByName(id)[0];
+  if (!target)
+    return false;
+  target.scrollIntoView();
+  return true;
+};
+var applyScroll = (request, url) => {
+  if (request.scroll) {
+    window.scrollTo(request.scroll.left, request.scroll.top);
+    return;
+  }
+  if (scrollToHash(url.hash))
+    return;
+  window.scrollTo(0, 0);
+};
+var reapplyScroll = (request, url) => {
+  if (window.scrollY !== 0 || window.scrollX !== 0)
+    return;
+  if (request.scroll && request.scroll.top + request.scroll.left > 0) {
+    window.scrollTo(request.scroll.left, request.scroll.top);
+    return;
+  }
+  if (!request.scroll)
+    scrollToHash(url.hash);
+};
+var RELATIVE_SPECIFIER = /^(?:\/|\.\.?\/|https?:)/;
+var IMPORT_CALL_RE = /\bimport\(\s*(["'])([^"'\n]+)\1\s*\)/g;
+var IMPORT_FROM_RE = /\b(from|import)\s*(["'])([^"'\n]+)\2/g;
+var resolveSameOrigin = (specifier) => {
+  if (!RELATIVE_SPECIFIER.test(specifier))
+    return;
+  try {
+    const url = new URL(specifier, window.location.href);
+    return url.origin === window.location.origin ? url : undefined;
+  } catch {
+    return;
+  }
+};
+var moduleUrlFor = (nav, specifier) => {
+  const url = resolveSameOrigin(specifier);
+  if (!url)
+    return specifier;
+  if (!nav.evaluatedModules.has(url.href)) {
+    nav.evaluatedModules.add(url.href);
+    return specifier;
+  }
+  nav.moduleRun += 1;
+  url.searchParams.set(MODULE_RUN_PARAM, String(nav.moduleRun));
+  return url.href;
+};
+var rewriteModuleSpecifiers = (nav, source) => source.replace(IMPORT_CALL_RE, (_match, _quote, specifier) => `import(${JSON.stringify(moduleUrlFor(nav, specifier))})`).replace(IMPORT_FROM_RE, (match, keyword, _quote, specifier) => resolveSameOrigin(specifier) ? `${keyword} ${JSON.stringify(moduleUrlFor(nav, specifier))}` : match);
+var rememberSpecifier = (nav, specifier) => {
+  const url = resolveSameOrigin(specifier);
+  if (url)
+    nav.evaluatedModules.add(url.href);
+};
+var rememberImportCalls = (nav, text) => {
+  for (const match of text.matchAll(IMPORT_CALL_RE)) {
+    rememberSpecifier(nav, match[2] ?? "");
+  }
+};
+var rememberDocumentModules = (nav) => {
+  for (const script of Array.from(document.scripts)) {
+    const src = script.getAttribute("src");
+    if (src && script.type === "module")
+      rememberSpecifier(nav, src);
+    rememberImportCalls(nav, script.textContent ?? "");
+  }
+};
+var TRUST_ALL = { kind: "all" };
+var TRUST_NONE = { kind: "none" };
+var readTrust = (response) => {
+  const policy = response.headers.get("content-security-policy");
+  if (!policy)
+    return TRUST_ALL;
+  const nonce = /'nonce-([^']+)'/.exec(policy)?.[1];
+  if (!nonce)
+    return TRUST_NONE;
+  const trust = { kind: "nonce", nonce };
+  return trust;
+};
+var isTrusted = (element, trust) => {
+  if (trust.kind === "all")
+    return true;
+  if (trust.kind === "none")
+    return false;
+  return element.getAttribute("nonce") === trust.nonce;
+};
+var takePrefetched = async (url) => {
+  const pending = consumePrefetch2(url.href) ?? consumePrefetch2(`${url.pathname}${url.search}`);
+  if (!pending)
+    return;
+  const response = await pending;
+  return response.ok ? response : undefined;
+};
+var fetchDocument = async (url, signal) => await takePrefetched(url) ?? fetch(url.href, {
+  credentials: "same-origin",
+  headers: { Accept: "text/html" },
+  signal
+});
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var adoptResponseNonce = (nav, html, trust) => {
+  if (trust.kind !== "nonce" || !nav.nonce)
+    return { html, trust };
+  const pattern = new RegExp(`\\bnonce=(["'])${escapeRegExp(trust.nonce)}\\1`, "g");
+  const adopted = { kind: "nonce", nonce: nav.nonce };
+  return {
+    html: html.replace(pattern, `nonce="${nav.nonce}"`),
+    trust: adopted
+  };
+};
+var loadDocument = async (nav, url, signal) => {
+  const response = await fetchDocument(url, signal);
+  const contentType = response.headers.get("content-type") ?? "";
+  const finalUrl = new URL(response.url || url.href);
+  finalUrl.hash = url.hash;
+  if (!response.ok || !contentType.includes("text/html") || finalUrl.origin !== window.location.origin) {
+    await response.body?.cancel().catch(() => {
+      return;
+    });
+    return;
+  }
+  const { html, trust } = adoptResponseNonce(nav, await response.text(), readTrust(response));
+  const parsed = new DOMParser().parseFromString(html, "text/html");
+  const loaded = {
+    document: parsed,
+    trust,
+    url: finalUrl
+  };
+  return loaded;
+};
+var isExecutableScript = (script) => JAVASCRIPT_TYPES.has((script.getAttribute("type") ?? "").trim().toLowerCase());
+var extractScripts = (loaded) => Array.from(loaded.document.querySelectorAll("script")).filter(isExecutableScript).map((source) => {
+  const placeholder = loaded.document.createComment(SCRIPT_PLACEHOLDER);
+  const trusted = isTrusted(source, loaded.trust);
+  source.replaceWith(placeholder);
+  const pending = { placeholder, source, trusted };
+  return pending;
+});
+var applyNonce = (nav, element, trusted) => {
+  element.removeAttribute("nonce");
+  if (trusted && nav.nonce)
+    element.setAttribute("nonce", nav.nonce);
+};
+var waitForStylesheet = (link) => new Promise((resolve) => {
+  const timer = setTimeout(resolve, STYLESHEET_TIMEOUT_MS);
+  const done = () => {
+    clearTimeout(timer);
+    resolve();
+  };
+  link.addEventListener("load", done, { once: true });
+  link.addEventListener("error", done, { once: true });
+});
+var preloadStylesheets = async (loaded) => {
+  const links = Array.from(loaded.document.head.querySelectorAll('link[rel~="stylesheet"]'));
+  const media = new Map;
+  for (const link of links) {
+    media.set(link, link.getAttribute("media"));
+    link.setAttribute("media", "not all");
+    document.head.append(document.adoptNode(link));
+  }
+  await Promise.all(links.map(waitForStylesheet));
+  return media;
+};
+var restoreMedia = (media) => {
+  for (const [link, value] of media) {
+    if (value === null)
+      link.removeAttribute("media");
+    else
+      link.setAttribute("media", value);
+  }
+};
+var elementKey = (element) => {
+  const attributes = Array.from(element.attributes).filter((attribute) => attribute.name !== "nonce").map((attribute) => `${attribute.name}=${attribute.value}`).sort().join("\x00");
+  return `${element.tagName}\x01${attributes}\x01${element.textContent ?? ""}`;
+};
+var takeMatch = (available, node) => available.get(elementKey(node))?.shift();
+var syncAttributes = (target, source) => {
+  for (const attribute of Array.from(target.attributes)) {
+    if (!source.hasAttribute(attribute.name))
+      target.removeAttribute(attribute.name);
+  }
+  for (const attribute of Array.from(source.attributes)) {
+    target.setAttribute(attribute.name, attribute.value);
+  }
+};
+var indexHead = (preloaded) => {
+  const available = new Map;
+  for (const child of Array.from(document.head.children)) {
+    if (preloaded.has(child) || child.tagName === "SCRIPT")
+      continue;
+    const key = elementKey(child);
+    available.set(key, [...available.get(key) ?? [], child]);
+  }
+  return available;
+};
+var resolveHeadNode = (nav, node, context) => {
+  if (!(node instanceof Element) || context.preloaded.has(node))
+    return node;
+  const existing = takeMatch(context.available, node);
+  if (existing)
+    return existing;
+  if (node.tagName === "STYLE") {
+    applyNonce(nav, node, isTrusted(node, context.trust));
+  }
+  return document.adoptNode(node);
+};
+var swapHead = (nav, loaded, headNodes, preloaded) => {
+  const context = {
+    available: indexHead(preloaded),
+    preloaded,
+    trust: loaded.trust
+  };
+  const nextNodes = headNodes.map((node) => resolveHeadNode(nav, node, context));
+  syncAttributes(document.head, loaded.document.head);
+  document.head.replaceChildren(...nextNodes);
+};
+var swapBody = (nav, loaded) => {
+  for (const style of Array.from(loaded.document.body.querySelectorAll("style"))) {
+    applyNonce(nav, style, isTrusted(style, loaded.trust));
+  }
+  const nextBody = document.adoptNode(loaded.document.body);
+  document.body.replaceWith(nextBody);
+};
+var disposeCurrentPage = async () => {
+  const dispose = Reflect.get(window, DISPOSE_GLOBAL);
+  Reflect.set(window, DISPOSE_GLOBAL, undefined);
+  Reflect.set(window, READY_GLOBAL, undefined);
+  if (typeof dispose === "function")
+    await Reflect.apply(dispose, window, []);
+};
+var canTearDown = () => typeof Reflect.get(window, DISPOSE_GLOBAL) === "function";
+var islandStateOf = (value) => isRecord(value) ? value : undefined;
+var keepIslandState = (live) => {
+  const current = islandStateOf(Reflect.get(globalThis, ISLAND_STATE_GLOBAL));
+  if (!live || current === live)
+    return live;
+  const merged = { ...current ?? {}, ...live };
+  Reflect.set(globalThis, ISLAND_STATE_GLOBAL, merged);
+  return merged;
+};
+var loadEvent = (script) => new Promise((resolve) => {
+  script.addEventListener("load", () => resolve(), { once: true });
+  script.addEventListener("error", () => resolve(), { once: true });
+});
+var createScript = (nav, pending) => {
+  const { source } = pending;
+  const script = document.createElement("script");
+  Array.from(source.attributes).filter(({ name }) => name !== "nonce" && name !== "src").forEach(({ name, value }) => script.setAttribute(name, value));
+  applyNonce(nav, script, pending.trusted);
+  const src = source.getAttribute("src");
+  const isModule = source.type === "module";
+  if (src)
+    script.src = isModule ? moduleUrlFor(nav, src) : src;
+  if (!src)
+    script.text = rewriteModuleSpecifiers(nav, source.text);
+  if (src && !source.hasAttribute("async"))
+    script.async = false;
+  return script;
+};
+var runScript = async (nav, pending, islandState) => {
+  if (!pending.placeholder.isConnected)
+    return;
+  const script = createScript(nav, pending);
+  const loaded = script.src ? loadEvent(script) : Promise.resolve();
+  pending.placeholder.replaceWith(script);
+  islandState.live = keepIslandState(islandState.live);
+  await loaded;
+  islandState.live = keepIslandState(islandState.live);
+};
+var clearPageGlobals = () => {
+  for (const name of PAGE_GLOBALS)
+    Reflect.deleteProperty(window, name);
+};
+var runScripts = (nav, scripts) => {
+  const islandState = {
+    live: islandStateOf(Reflect.get(globalThis, ISLAND_STATE_GLOBAL))
+  };
+  return scripts.reduce((previous, pending) => previous.then(() => runScript(nav, pending, islandState)), Promise.resolve());
+};
+var pollForPage = async (deadline) => {
+  if (canTearDown() || Date.now() >= deadline)
+    return;
+  await delay(PAGE_READY_POLL_MS);
+  await pollForPage(deadline);
+};
+var waitForPageReady = async (hasModules) => {
+  if (hasModules)
+    await pollForPage(Date.now() + PAGE_READY_TIMEOUT_MS);
+  const ready = Reflect.get(window, READY_GLOBAL);
+  if (ready instanceof Promise)
+    await ready.catch(() => {
+      return;
+    });
+};
+var loadsModules = (scripts) => scripts.some(({ source }) => source.type === "module" || /\bimport\s*\(/.test(source.text));
+var ensureAnnouncer = () => {
+  const existing = document.getElementById(ANNOUNCER_ID);
+  if (existing)
+    return existing;
+  const region = document.createElement("div");
+  region.id = ANNOUNCER_ID;
+  region.setAttribute("aria-live", "assertive");
+  region.setAttribute("aria-atomic", "true");
+  region.setAttribute("role", "status");
+  Object.assign(region.style, {
+    border: "0",
+    clip: "rect(0 0 0 0)",
+    height: "1px",
+    margin: "-1px",
+    overflow: "hidden",
+    padding: "0",
+    position: "absolute",
+    whiteSpace: "nowrap",
+    width: "1px"
+  });
+  document.body.append(region);
+  return region;
+};
+var announcePage = () => {
+  const heading = document.querySelector("h1")?.textContent?.trim();
+  const text = document.title || heading || window.location.pathname;
+  ensureAnnouncer().textContent = text;
+};
+var resetFocus = () => {
+  const autofocus = document.querySelector("[autofocus]");
+  if (autofocus) {
+    autofocus.focus();
+    return;
+  }
+  if (document.activeElement instanceof HTMLElement) {
+    document.activeElement.blur();
+  }
+};
+var dispatch = (name, detail, cancelable) => window.dispatchEvent(new CustomEvent(name, { cancelable, detail }));
+var outcome = (value) => value;
+var reload = (request, committed) => {
+  if (committed || request.type === "traverse")
+    window.location.reload();
+  else if (request.replace)
+    window.location.replace(request.url.href);
+  else
+    window.location.assign(request.url.href);
+  return outcome("reloaded");
+};
+var commitHistory = (nav, request, url) => {
+  nav.documentId = request.documentId ?? createId();
+  if (request.type === "traverse") {
+    recordCurrentEntry(nav);
+    return;
+  }
+  const key = currentEntryKey(nav);
+  if (key !== undefined) {
+    nav.scroll.set(key, { left: window.scrollX, top: window.scrollY });
+  }
+  const state = stampState(null, nav.documentId, createId());
+  if (request.replace)
+    window.history.replaceState(state, "", url.href);
+  else
+    window.history.pushState(state, "", url.href);
+  recordCurrentEntry(nav);
+};
+var shouldAnimate = (nav) => nav.options.viewTransition !== false && typeof Reflect.get(document, "startViewTransition") === "function" && !prefersReducedMotion();
+var readPromise = (value, name) => {
+  if (typeof value !== "object" || value === null)
+    return;
+  const promise = Reflect.get(value, name);
+  return promise instanceof Promise ? promise : undefined;
+};
+var runSwap = async (nav, swap) => {
+  const start = Reflect.get(document, "startViewTransition");
+  if (!shouldAnimate(nav) || typeof start !== "function") {
+    await swap();
+    return;
+  }
+  const transition = Reflect.apply(start, document, [swap]);
+  readPromise(transition, "ready")?.catch(() => {
+    return;
+  });
+  readPromise(transition, "finished")?.catch(() => {
+    return;
+  });
+  await readPromise(transition, "updateCallbackDone");
+};
+var swapDocument = async (nav, request, loaded, isStale) => {
+  const scripts = extractScripts(loaded);
+  const headNodes = Array.from(loaded.document.head.childNodes);
+  const media = await preloadStylesheets(loaded);
+  const preloaded = new Set(media.keys());
+  if (isStale()) {
+    preloaded.forEach((link) => link.remove());
+    return false;
+  }
+  commitHistory(nav, request, loaded.url);
+  const swap = async () => {
+    await disposeCurrentPage();
+    clearPageGlobals();
+    syncAttributes(document.documentElement, loaded.document.documentElement);
+    swapHead(nav, loaded, headNodes, preloaded);
+    swapBody(nav, loaded);
+    restoreMedia(media);
+    applyScroll(request, loaded.url);
+  };
+  await runSwap(nav, swap);
+  resetFocus();
+  await runScripts(nav, scripts);
+  await waitForPageReady(loadsModules(scripts));
+  reapplyScroll(request, loaded.url);
+  announcePage();
+  return true;
+};
+var isCurrent = (nav, token) => nav.token === token;
+var performNavigation = async (nav, request) => {
+  nav.token += 1;
+  const { token } = nav;
+  nav.controller?.abort();
+  const controller = new AbortController;
+  nav.controller = controller;
+  const detail = {
+    type: request.type,
+    url: request.url.href
+  };
+  const proceed = dispatch("absolute:before-navigate", detail, request.type !== "traverse");
+  if (!proceed)
+    return outcome("cancelled");
+  if (!canTearDown())
+    return reload(request, false);
+  const committedBefore = nav.documentId;
+  try {
+    const loaded = await loadDocument(nav, request.url, controller.signal);
+    if (!isCurrent(nav, token))
+      return outcome("superseded");
+    if (!loaded)
+      return reload(request, false);
+    nav.navigating = true;
+    const swapped = await swapDocument(nav, request, loaded, () => !isCurrent(nav, token));
+    if (!swapped)
+      return outcome("superseded");
+    dispatch("absolute:after-navigate", detail, false);
+    return outcome("swapped");
+  } catch (error) {
+    if (!isCurrent(nav, token))
+      return outcome("superseded");
+    console.error("[absolute] navigation failed, loading the page:", error);
+    return reload(request, nav.documentId !== committedBefore);
+  } finally {
+    if (isCurrent(nav, token))
+      nav.navigating = false;
+  }
+};
+var isModifiedClick = (event) => event.metaKey || event.ctrlKey || event.shiftKey || event.altKey;
+var isSamePageFragment = (url) => url.hash !== "" && url.pathname === window.location.pathname && url.search === window.location.search;
+var findAnchor = (event) => {
+  const { target } = event;
+  if (!(target instanceof Element))
+    return null;
+  return target.closest("a[href]");
+};
+var isPlainClick = (event) => !event.defaultPrevented && event.button === 0 && !isModifiedClick(event);
+var isOptedOut = (anchor) => anchor.target !== "" && anchor.target !== "_self" || anchor.hasAttribute("download") || anchor.relList.contains("external") || anchor.closest(OPT_OUT_SELECTOR) !== null;
+var interceptableUrl = (nav, anchor) => {
+  if (isOptedOut(anchor))
+    return;
+  const url = new URL(anchor.href, window.location.href);
+  if (url.origin !== window.location.origin)
+    return;
+  if (isSamePageFragment(url))
+    return;
+  if (nav.options.shouldIntercept?.(url) === false)
+    return;
+  return url;
+};
+var listenForClicks = (nav) => {
+  const onClick = (event) => {
+    if (!isPlainClick(event))
+      return;
+    const anchor = findAnchor(event);
+    const url = anchor ? interceptableUrl(nav, anchor) : undefined;
+    if (!url || !canTearDown())
+      return;
+    event.preventDefault();
+    performNavigation(nav, { replace: false, type: "link", url });
+  };
+  window.addEventListener("click", onClick);
+  nav.teardown.push(() => window.removeEventListener("click", onClick));
+};
+var listenForTraversals = (nav) => {
+  const onPopState = (event) => {
+    if (!isForeignEntry(nav))
+      return;
+    event.stopImmediatePropagation();
+    const owner = currentEntryOwner(nav);
+    const key = currentEntryKey(nav);
+    performNavigation(nav, {
+      documentId: owner,
+      replace: false,
+      scroll: key === undefined ? undefined : nav.scroll.get(key),
+      type: "traverse",
+      url: new URL(window.location.href)
+    });
+  };
+  window.addEventListener("popstate", onPopState, { capture: true });
+  nav.teardown.push(() => window.removeEventListener("popstate", onPopState, { capture: true }));
+};
+var disableNavigation = () => {
+  const installed = readPublicRuntime();
+  if (installed && typeof installed.disable === "function") {
+    Reflect.apply(installed.disable, undefined, []);
+  }
+};
+var teardownRuntime = (nav) => {
+  nav.controller?.abort();
+  for (const cleanup of nav.teardown.splice(0))
+    cleanup();
+  nav.restoreHistory?.();
+  Reflect.deleteProperty(globalThis, RUNTIME_KEY);
+  if (runtime === nav)
+    runtime = undefined;
+};
+var navigateWith = (nav) => (href, options = {}) => {
+  const url = new URL(href, window.location.href);
+  if (url.origin !== window.location.origin) {
+    window.location.assign(url.href);
+    return Promise.resolve("reloaded");
+  }
+  return performNavigation(nav, {
+    replace: options.replace === true,
+    type: "navigate",
+    url
+  });
+};
+var enableNavigation = (options = {}) => {
+  if (typeof window === "undefined" || readPublicRuntime())
+    return;
+  const navigationApi = readNavigationApi();
+  const nav = {
+    controller: undefined,
+    documentId: createId(),
+    entryOwners: new Map,
+    evaluatedModules: new Set,
+    moduleRun: 0,
+    navigating: false,
+    navigationApi,
+    nonce: readPageNonce(),
+    options,
+    restoreHistory: undefined,
+    scroll: new Map,
+    scrollFrame: 0,
+    teardown: [],
+    token: 0
+  };
+  runtime = nav;
+  if (navigationApi)
+    trackEntries(nav, navigationApi);
+  else
+    patchHistory(nav);
+  rememberDocumentModules(nav);
+  trackScroll(nav);
+  listenForClicks(nav);
+  listenForTraversals(nav);
+  const publicRuntime = {
+    navigate: navigateWith(nav),
+    disable: () => teardownRuntime(nav)
+  };
+  Reflect.set(globalThis, RUNTIME_KEY, publicRuntime);
+};
+var OUTCOMES = new Set([
+  "cancelled",
+  "reloaded",
+  "superseded",
+  "swapped"
+]);
+var isOutcome = (value) => OUTCOMES.has(value);
+var isNavigationEnabled = () => typeof window !== "undefined" && readPublicRuntime() !== undefined;
+var navigateDocument = async (href, options = {}) => {
+  const installed = readPublicRuntime();
+  const navigate = installed?.navigate;
+  if (typeof navigate === "function") {
+    const result = await Reflect.apply(navigate, undefined, [
+      href,
+      options
+    ]);
+    if (isOutcome(result))
+      return result;
+  }
+  if (options.replace)
+    window.location.replace(href);
+  else
+    window.location.assign(href);
+  return outcome("reloaded");
+};
+export {
+  disableNavigation,
+  enableNavigation,
+  isNavigationEnabled,
+  navigateDocument
+};
+
+//# debugId=4ABAC329D93956C564756E2164756E21
+//# sourceMappingURL=navigation.js.map