@wular/pnext 0.0.3 → 0.0.6

package/src/compat/client/{nav-compat-runtime.ts → nav-runtime.ts}

@@ -2,8 +2,8 @@
 // here is read by the router runtime and by nothing else, so it loads with the
 // runtime chunk — the installers finish before the facade hands the runtime out,
 // so the first fetch already sees Next's windows and caches.
-import { setSoftNavBoundary } from '../../api/router';
-import { setNavigationScrollAction } from '../../api/router/events';
+import { setSoftNavBoundary } from '../../client/router'
+import { setNavigationScrollAction } from '../../client/router/events'
 import {
   setLoadingShellPredictionPolicy,
   setPrefetchStaleTimePolicy,
@@ -11,44 +11,44 @@ import {
   setSegmentCachePolicy,
   setShellStaleTimePolicy,
   setStylesheetReconciler,
-} from '../../api/router/policies';
-import { installSegmentCachePolicy } from './segment-cache-policy';
+} from '../../client/router/policies'
+import { installSegmentCachePolicy } from './segment-cache-policy'
 // `output: 'export'` document fetching. Imported for its module-scope
 // registration, which has to beat the router's first prefetches — this module
 // resolving before the runtime is handed out is exactly that guarantee.
-import '../export/client';
-import { reconcileNextStylesheets } from './css-order';
-import { staleTimeForEntryMs, staticStaleTimeMs } from './prefetch-cache';
-import { isOutsideBasePath } from './base-path';
-import { predictNextLoadingShell } from './optimistic-routing';
-import { applyNextNavigationScroll } from './navigation-scroll';
-import { installRouteAnnouncer } from './route-announcer';
+import '../export/client'
+import { reconcileNextStylesheets } from './css-order'
+import { staleTimeForEntryMs, staticStaleTimeMs } from './prefetch-cache'
+import { isOutsideBasePath } from './base-path'
+import { predictNextLoadingShell } from './optimistic-routing'
+import { applyNextNavigationScroll } from './navigation-scroll'
+import { installRouteAnnouncer } from './route-announcer'
 
 export function installNavPolicies() {
   // Route announcer: mount the empty `<next-route-announcer>` and update it on
   // every soft-nav commit (a11y — announce client route changes to AT). Next
   // mounts it at hydration; it announces nothing until the first navigation, and
   // this tier lands on idle, long before one can happen.
-  installRouteAnnouncer();
+  installRouteAnnouncer()
   // Prefetch staleTime policy: static 300s / dynamic 0, with the
   // experimental.staleTimes override injected as window.__PNEXT_STALE_TIMES__,
   // and a response `x-nextjs-stale-time` header overriding both when present.
-  setPrefetchStaleTimePolicy(staleTimeForEntryMs);
-  setRevalidationPrefetchDelay(300);
+  setPrefetchStaleTimePolicy(staleTimeForEntryMs)
+  setRevalidationPrefetchDelay(300)
   // Loading-shell window: a route's cached loading boundary (and the prefetch
   // entry carrying it) reuses for the STATIC window even when its dynamic data
   // is immediately stale — Next's split staleness model.
-  setShellStaleTimePolicy(staticStaleTimeMs);
-  setLoadingShellPredictionPolicy(predictNextLoadingShell);
+  setShellStaleTimePolicy(staticStaleTimeMs)
+  setLoadingShellPredictionPolicy(predictNextLoadingShell)
   // Per-segment (vary-params) client cache — Segment-M2 deliverable 3. Entries
   // are keyed on the params a segment provably reads, so one entry serves every
   // param value it does not depend on.
-  setSegmentCachePolicy(installSegmentCachePolicy());
-  setNavigationScrollAction(applyNextNavigationScroll);
-  setStylesheetReconciler(reconcileNextStylesheets);
+  setSegmentCachePolicy(installSegmentCachePolicy())
+  setNavigationScrollAction(applyNextNavigationScroll)
+  setStylesheetReconciler(reconcileNextStylesheets)
   // basePath boundary: a same-origin URL outside the configured basePath must
   // hard-navigate (a `basePath:false` target), not soft-swap.
-  setSoftNavBoundary(isOutsideBasePath);
+  setSoftNavBoundary(isOutsideBasePath)
   // NOTE: the standalone segment-prefetch wire runtime (segment-prefetch.ts) is
   // deliberately NOT installed: its intent-time tree/body fetches fed caches
   // nothing consumed and broke Next's request-count contracts (a hover inside a

package/src/compat/client/{nav-compat.ts → nav.ts}

@@ -10,33 +10,32 @@ import {
   registerDeferredInstall,
   setBlockedJavascriptUrlReporter,
   softNavigate,
-} from '../../api/router';
+} from '../../client/router'
 
-const BLOCKED_JS_URL_MESSAGE =
-  'Next.js has blocked a javascript: URL as a security precaution.';
+const BLOCKED_JS_URL_MESSAGE = 'Next.js has blocked a javascript: URL as a security precaution.'
 
 export function installNavCompat() {
-  if (!process.browser && typeof window === 'undefined') return;
-  setBlockedJavascriptUrlReporter(() => console.error(BLOCKED_JS_URL_MESSAGE));
-  const windowWithReporter = window as typeof window & { __PNEXT_JS_URL_REPORTER__?: boolean };
+  if (!process.browser && typeof window === 'undefined') return
+  setBlockedJavascriptUrlReporter(() => console.error(BLOCKED_JS_URL_MESSAGE))
+  const windowWithReporter = window as typeof window & { __PNEXT_JS_URL_REPORTER__?: boolean }
   if (!windowWithReporter.__PNEXT_JS_URL_REPORTER__) {
-    windowWithReporter.__PNEXT_JS_URL_REPORTER__ = true;
+    windowWithReporter.__PNEXT_JS_URL_REPORTER__ = true
     window.addEventListener('pnext:blocked-javascript-url', () => {
-      console.error(BLOCKED_JS_URL_MESSAGE);
-    });
+      console.error(BLOCKED_JS_URL_MESSAGE)
+    })
   }
-  installNextRouterGlobal();
-  registerDeferredInstall(() => import('./nav-compat-runtime').then(m => m.installNavPolicies()));
+  installNextRouterGlobal()
+  registerDeferredInstall(() => import('./nav-runtime').then(m => m.installNavPolicies()))
 }
 
 // `window.next.router` — Next's own global handle. Pure-core apps have no such
 // namespace, so it installs from compat rather than from the router hub.
 function installNextRouterGlobal() {
-  window.next ??= {};
+  window.next ??= {}
   window.next.router = {
     ...window.next.router,
     push: href => softNavigate(String(href)),
     replace: href => softNavigate(String(href), { replace: true }),
     prefetch: href => prefetchRoute(String(href), { strict: true }),
-  };
+  }
 }

package/src/compat/client/navigation-scroll.ts

@@ -1,54 +1,54 @@
-import type { NavigationScrollAction, NavigationScrollOptions } from '../../api/router';
+import type { NavigationScrollAction, NavigationScrollOptions } from '../../client/router'
 
-const RECT_PROPERTIES = ['bottom', 'height', 'left', 'right', 'top', 'width', 'x', 'y'] as const;
+const RECT_PROPERTIES = ['bottom', 'height', 'left', 'right', 'top', 'width', 'x', 'y'] as const
 
-export type NextScrollPlan = 'hash' | 'preserve' | 'restore' | 'top' | 'top-then-target';
+export type NextScrollPlan = 'hash' | 'preserve' | 'restore' | 'top' | 'top-then-target'
 
 export function nextScrollPlan(
   url: URL,
   options: NavigationScrollOptions,
   targetInViewport: boolean | undefined,
 ): NextScrollPlan {
-  if (options.pop) return 'restore';
-  if (options.scroll === false) return 'preserve';
-  if (url.hash) return 'hash';
-  if (targetInViewport === undefined) return 'top';
-  return targetInViewport ? 'preserve' : 'top-then-target';
+  if (options.pop) return 'restore'
+  if (options.scroll === false) return 'preserve'
+  if (url.hash) return 'hash'
+  if (targetInViewport === undefined) return 'top'
+  return targetInViewport ? 'preserve' : 'top-then-target'
 }
 
 export function firstScrollCandidate<T>(
   candidates: Iterable<T>,
   shouldSkip: (candidate: T) => boolean,
 ): T | undefined {
-  for (const candidate of candidates) if (!shouldSkip(candidate)) return candidate;
-  return undefined;
+  for (const candidate of candidates) if (!shouldSkip(candidate)) return candidate
+  return undefined
 }
 
 export function deepestSingleChild<T>(node: T | undefined, onlyChild: (node: T) => T | undefined) {
   while (node) {
-    const child = onlyChild(node);
-    if (!child) return node;
-    node = child;
+    const child = onlyChild(node)
+    if (!child) return node
+    node = child
   }
-  return undefined;
+  return undefined
 }
 
 export function topOnlyScrollPosition(scrollX: number): [number, number] {
-  return [scrollX, 0];
+  return [scrollX, 0]
 }
 
 export const applyNextNavigationScroll: NavigationScrollAction = (url, options) => {
-  const target = scrollFocusTarget();
+  const target = scrollFocusTarget()
   const plan = nextScrollPlan(
     url,
     options,
     target ? targetTopInViewport(target, document.documentElement.clientHeight) : undefined,
-  );
+  )
   if (plan === 'restore') {
-    const state = history.state as { __pnextScroll?: [number, number] } | null;
-    const [x, y] = state?.__pnextScroll ?? [0, 0];
-    window.scrollTo(x, y);
-    return;
+    const state = history.state as { __pnextScroll?: [number, number] } | null
+    const [x, y] = state?.__pnextScroll ?? [0, 0]
+    window.scrollTo(x, y)
+    return
   }
   // React hoists a rendered <style precedence>/<link rel=stylesheet>/metadata element out of the segment
   // and into <head>. Next resolves its scroll target with findDOMNode() on the changed segment, so when
@@ -56,43 +56,43 @@ export const applyNextNavigationScroll: NavigationScrollAction = (url, options)
   // zero-rect sibling there and runs out - the navigation scrolls nowhere and focuses nothing. pnext
   // renders those elements in place, so recognize the leading hoisted element and reproduce the same
   // no-op. Placed after `restore` so history traversal still restores its saved position.
-  if (segmentLeadsWithHoistedElement()) return;
+  if (segmentLeadsWithHoistedElement()) return
   if (plan === 'hash') {
-    scrollToHash(url.hash);
-    return;
+    scrollToHash(url.hash)
+    return
   }
   if (plan === 'preserve') {
-    if (target && options.scroll !== false) focusSegment(target);
-    return;
+    if (target && options.scroll !== false) focusSegment(target)
+    return
   }
   if (plan === 'top') {
-    window.scrollTo(...topOnlyScrollPosition(window.scrollX));
-    return;
+    window.scrollTo(...topOnlyScrollPosition(window.scrollX))
+    return
   }
-  if (!target) return;
-  window.scrollTo(...topOnlyScrollPosition(window.scrollX));
-  if (!targetTopInViewport(target, document.documentElement.clientHeight)) target.scrollIntoView();
-  focusSegment(target);
-};
+  if (!target) return
+  window.scrollTo(...topOnlyScrollPosition(window.scrollX))
+  if (!targetTopInViewport(target, document.documentElement.clientHeight)) target.scrollIntoView()
+  focusSegment(target)
+}
 
 function shouldSkipScrollElement(element: HTMLElement) {
-  const position = getComputedStyle(element).position;
-  if (position === 'sticky' || position === 'fixed') return true;
-  const rect = element.getBoundingClientRect();
-  return RECT_PROPERTIES.every(item => rect[item] === 0);
+  const position = getComputedStyle(element).position
+  if (position === 'sticky' || position === 'fixed') return true
+  const rect = element.getBoundingClientRect()
+  return RECT_PROPERTIES.every(item => rect[item] === 0)
 }
 
 function targetTopInViewport(element: HTMLElement, viewportHeight: number) {
-  const rects = element.getClientRects();
-  if (rects.length === 0) return false;
-  let top = Number.POSITIVE_INFINITY;
-  for (const rect of rects) top = Math.min(top, rect.top);
-  return top >= 0 && top <= viewportHeight;
+  const rects = element.getClientRects()
+  if (rects.length === 0) return false
+  let top = Number.POSITIVE_INFINITY
+  for (const rect of rects) top = Math.min(top, rect.top)
+  return top >= 0 && top <= viewportHeight
 }
 
 function scrollFocusTarget(): HTMLElement | null {
-  const segment = changedSegmentRoot();
-  if (!segment) return null;
+  const segment = changedSegmentRoot()
+  if (!segment) return null
   // Next resolves the target with findDOMNode() on the changed segment: the
   // FIRST host element the segment rendered, never a descendant of it. The page
   // container IS that segment, so its first element child is the target as-is.
@@ -103,51 +103,51 @@ function scrollFocusTarget(): HTMLElement | null {
       ? (segment.firstElementChild ?? undefined)
       : deepestSingleChild(segment.firstElementChild ?? undefined, node =>
           node.nextElementSibling === null ? (node.firstElementChild ?? undefined) : undefined,
-        );
-  const nodes: HTMLElement[] = [];
+        )
+  const nodes: HTMLElement[] = []
   for (let node = first; node; node = node.nextElementSibling ?? undefined) {
-    if (node instanceof HTMLElement) nodes.push(node);
+    if (node instanceof HTMLElement) nodes.push(node)
   }
-  return firstScrollCandidate(nodes, shouldSkipScrollElement) ?? null;
+  return firstScrollCandidate(nodes, shouldSkipScrollElement) ?? null
 }
 
 /** The renderer's page-slot wrapper — the segment a navigation replaced. */
-const PAGE_CONTAINER_ID = 'pnext-page';
+const PAGE_CONTAINER_ID = 'pnext-page'
 
 // Elements React relocates into <head> when a component renders them.
-const HOISTED_TAGS = new Set(['style', 'link', 'title', 'meta', 'base']);
+const HOISTED_TAGS = new Set(['style', 'link', 'title', 'meta', 'base'])
 
 /**
  * Whether the changed segment's first rendered element is one React would have hoisted into <head> -
  * the state in which Next's scroll walk never reaches the page content (see the call site).
  */
 function segmentLeadsWithHoistedElement(): boolean {
-  const segment = changedSegmentRoot();
-  const first = segment?.firstElementChild;
-  return first !== null && first !== undefined && HOISTED_TAGS.has(first.localName);
+  const segment = changedSegmentRoot()
+  const first = segment?.firstElementChild
+  return first !== null && first !== undefined && HOISTED_TAGS.has(first.localName)
 }
 
 function changedSegmentRoot(): HTMLElement | null {
-  const page = document.getElementById(PAGE_CONTAINER_ID);
-  if (page instanceof HTMLElement) return page;
-  const root = document.querySelector('[data-pnext-root]');
-  return root instanceof HTMLElement ? root : document.body;
+  const page = document.getElementById(PAGE_CONTAINER_ID)
+  if (page instanceof HTMLElement) return page
+  const root = document.querySelector('[data-pnext-root]')
+  return root instanceof HTMLElement ? root : document.body
 }
 
 function scrollToHash(hash: string) {
-  const id = decodeURIComponent(hash.slice(1));
-  const target = id === 'top' ? document.body : (document.getElementById(id) ?? namedTarget(id));
-  target?.scrollIntoView();
+  const id = decodeURIComponent(hash.slice(1))
+  const target = id === 'top' ? document.body : (document.getElementById(id) ?? namedTarget(id))
+  target?.scrollIntoView()
 }
 
 function namedTarget(name: string): HTMLElement | null {
-  const named = document.getElementsByName(name)[0];
-  return named instanceof HTMLElement ? named : null;
+  const named = document.getElementsByName(name)[0]
+  return named instanceof HTMLElement ? named : null
 }
 
 function focusSegment(target: HTMLElement) {
   try {
-    target.focus({ preventScroll: true });
+    target.focus({ preventScroll: true })
   } catch {
     // A swap can detach the target before focus runs.
   }

package/src/compat/client/optimistic-routing.ts

@@ -12,26 +12,26 @@
 //     produced by a rewrite. Such a response must never seed predictions - the rewrite may map a
 //     sibling URL somewhere else entirely, or vary on search params.
 
-import type { RouteParamValue } from '../../types';
+import type { RouteParamValue } from '../../types'
 
 interface RouteState {
   // Bracket-free colon form: `:id` for a dynamic segment, `:slug*` for a
   // catch-all; `catchAllOptional` distinguishes `[[...slug]]` (matches zero
   // segments) from `[...slug]` (requires at least one).
-  route: string;
-  params: Record<string, RouteParamValue>;
-  catchAllOptional?: boolean;
-  staticChildren?: string[];
-  staticChildrenBySegment?: Record<string, string[]>;
-  prefetchKind?: 'shell' | 'eager';
+  route: string
+  params: Record<string, RouteParamValue>
+  catchAllOptional?: boolean
+  staticChildren?: string[]
+  staticChildrenBySegment?: Record<string, string[]>
+  prefetchKind?: 'shell' | 'eager'
   /** `prefetch = 'allow-runtime'`: the shell is request-sampled PER URL. */
-  runtimePrefetch?: boolean;
+  runtimePrefetch?: boolean
 }
 
 interface PredictedShell {
-  html: string;
-  route: RouteState;
-  prefetch?: 'shell' | 'eager';
+  html: string
+  route: RouteState
+  prefetch?: 'shell' | 'eager'
   /**
    * True when the predicted shell belongs to an `allow-runtime` route. Its content is derived from the
    * sampled request's params, so a cached shell of ONE param value says nothing about another - the
@@ -41,13 +41,13 @@ interface PredictedShell {
    * with its `params` HANGING, so the cached shell IS the route's shared App Shell and says the same
    * thing for every param. Revealing another link of the route then has nothing to fetch.
    */
-  runtimePrefetch?: boolean;
+  runtimePrefetch?: boolean
 }
 
 /** `experimental.appShells`, stamped into the document by register-render. */
 function appShellsEnabled(): boolean {
-  if (!process.browser && typeof window === 'undefined') return false;
-  return (window as { __PNEXT_APP_SHELLS__?: boolean }).__PNEXT_APP_SHELLS__ === true;
+  if (!process.browser && typeof window === 'undefined') return false
+  return (window as { __PNEXT_APP_SHELLS__?: boolean }).__PNEXT_APP_SHELLS__ === true
 }
 
 export function predictNextLoadingShell(
@@ -56,13 +56,13 @@ export function predictNextLoadingShell(
 ): PredictedShell | undefined {
   // Most recently stored shells first (Map preserves insertion order).
   for (const [pathname, html] of [...shells.entries()].reverse()) {
-    const state = routeStateFromShell(html);
-    if (!state) continue;
+    const state = routeStateFromShell(html)
+    if (!state) continue
     // A shell's own URL must fit its route pattern before it can teach the
     // route trie. This catches rewrites, including a dynamic response served
     // for a known static sibling.
-    if (!matchRoute(state, pathname)) continue;
-    const params = matchRoute(state, url.pathname);
+    if (!matchRoute(state, pathname)) continue
+    const params = matchRoute(state, url.pathname)
     if (params) {
       return {
         html: reifyShellParams(html, state.params, params),
@@ -73,65 +73,69 @@ export function predictNextLoadingShell(
         },
         ...(state.prefetchKind ? { prefetch: state.prefetchKind } : {}),
         ...(state.runtimePrefetch && !appShellsEnabled() ? { runtimePrefetch: true } : {}),
-      };
+      }
     }
   }
-  return undefined;
+  return undefined
 }
 
 function routeStateFromShell(html: string): RouteState | undefined {
-  const raw = /window\.__PNEXT_ROUTE__=(\{.*?\});<\/script>/.exec(html)?.[1];
-  if (!raw) return undefined;
+  const raw = /window\.__PNEXT_ROUTE__=(\{.*?\});<\/script>/.exec(html)?.[1]
+  if (!raw) return undefined
   try {
-    const state = JSON.parse(raw) as RouteState;
+    const state = JSON.parse(raw) as RouteState
     return typeof state.route === 'string' && state.params && typeof state.params === 'object'
       ? state
-      : undefined;
+      : undefined
   } catch {
-    return undefined;
+    return undefined
   }
 }
 
-function matchRoute(state: RouteState, pathname: string): Record<string, RouteParamValue> | undefined {
-  const pattern = state.route.split('/').filter(Boolean);
-  const target = pathname.split('/').filter(Boolean).map(decodeSegment);
-  const params: Record<string, RouteParamValue> = {};
-  let cursor = 0;
+function matchRoute(
+  state: RouteState,
+  pathname: string,
+): Record<string, RouteParamValue> | undefined {
+  const pattern = state.route.split('/').filter(Boolean)
+  const target = pathname.split('/').filter(Boolean).map(decodeSegment)
+  const params: Record<string, RouteParamValue> = {}
+  let cursor = 0
   for (let index = 0; index < pattern.length; index++) {
-    const segment = pattern[index]!;
+    const segment = pattern[index]!
     // Colon form: `:slug*` is a catch-all, `:id` a single dynamic segment.
-    const catchAll = /^:([\w$]+)\*$/.exec(segment);
-    const dynamic = catchAll ? null : /^:([\w$]+)$/.exec(segment);
-    const siblingKey = String(index);
-    const siblings = state.staticChildrenBySegment?.[siblingKey] ??
-      (index === pattern.length - 1 ? state.staticChildren : undefined);
+    const catchAll = /^:([\w$]+)\*$/.exec(segment)
+    const dynamic = catchAll ? null : /^:([\w$]+)$/.exec(segment)
+    const siblingKey = String(index)
+    const siblings =
+      state.staticChildrenBySegment?.[siblingKey] ??
+      (index === pattern.length - 1 ? state.staticChildren : undefined)
     // A dynamic trie node is usable only after the server has said its static
     // siblings are complete. This is the production-only null-vs-empty rule.
-    if ((dynamic || catchAll) && siblings === undefined) return undefined;
-    if (siblings?.includes(target[cursor] ?? '')) return undefined;
+    if ((dynamic || catchAll) && siblings === undefined) return undefined
+    if (siblings?.includes(target[cursor] ?? '')) return undefined
     if (catchAll) {
-      const name = catchAll[1]!;
+      const name = catchAll[1]!
       if (state.catchAllOptional) {
         // `[[...slug]]`: matches the base path plus any nested tail.
-        const rest = target.slice(cursor);
-        if (rest.length > 0) params[name] = rest;
-        return params;
+        const rest = target.slice(cursor)
+        if (rest.length > 0) params[name] = rest
+        return params
       }
       // `[...slug]`: a catch-all learned from a parallel slot must not predict a
       // sibling URL for the primary route. Only reuse it when the source shell
       // itself was rendered through that catch-all, and require ≥1 segment.
-      if (!Array.isArray(state.params[name])) return undefined;
-      const rest = target.slice(cursor);
-      if (rest.length === 0) return undefined;
-      params[name] = rest;
-      return params;
+      if (!Array.isArray(state.params[name])) return undefined
+      const rest = target.slice(cursor)
+      if (rest.length === 0) return undefined
+      params[name] = rest
+      return params
     }
-    const value = target[cursor++];
-    if (value === undefined) return undefined;
-    if (dynamic) params[dynamic[1]!] = value;
-    else if (segment !== value) return undefined;
+    const value = target[cursor++]
+    if (value === undefined) return undefined
+    if (dynamic) params[dynamic[1]!] = value
+    else if (segment !== value) return undefined
   }
-  return cursor === target.length ? params : undefined;
+  return cursor === target.length ? params : undefined
 }
 
 function reifyShellParams(
@@ -139,45 +143,46 @@ function reifyShellParams(
   previous: Record<string, RouteParamValue>,
   params: Record<string, RouteParamValue>,
 ): string {
-  if (typeof DOMParser === 'undefined') return html;
-  const doc = new DOMParser().parseFromString(html, 'text/html');
-  materializeClientMarkers(doc);
+  if (typeof DOMParser === 'undefined') return html
+  const doc = new DOMParser().parseFromString(html, 'text/html')
+  materializeClientMarkers(doc)
   for (const root of doc.querySelectorAll<HTMLElement>('[data-pnext-params]')) {
-    const raw = root.getAttribute('data-pnext-params');
-    if (!raw) continue;
+    const raw = root.getAttribute('data-pnext-params')
+    if (!raw) continue
     try {
-      const scoped = JSON.parse(raw) as Record<string, RouteParamValue>;
-      if (sameParams(scoped, previous)) root.setAttribute('data-pnext-params', JSON.stringify(params));
+      const scoped = JSON.parse(raw) as Record<string, RouteParamValue>
+      if (sameParams(scoped, previous))
+        root.setAttribute('data-pnext-params', JSON.stringify(params))
     } catch {
       // A malformed island scope cannot safely be reified.
     }
   }
-  return `<!doctype html>${doc.documentElement.outerHTML}`;
+  return `<!doctype html>${doc.documentElement.outerHTML}`
 }
 
 function materializeClientMarkers(doc: Document): void {
-  const comments: Comment[] = [];
-  const walker = doc.createTreeWalker(doc, NodeFilter.SHOW_COMMENT);
-  while (walker.nextNode()) comments.push(walker.currentNode as Comment);
+  const comments: Comment[] = []
+  const walker = doc.createTreeWalker(doc, NodeFilter.SHOW_COMMENT)
+  while (walker.nextNode()) comments.push(walker.currentNode as Comment)
   for (const start of comments.reverse()) {
-    const match = /^(pnext-client|pnext-page):([^>]*)$/.exec(start.data);
-    const kind = match?.[1];
-    const encoded = match?.[2];
-    if (!kind || !encoded || !start.parentNode) continue;
-    const container = doc.createElement('div');
-    const tag = kind === 'pnext-page' ? 'div' : 'pnext-client';
-    container.innerHTML = `<${tag} ${encoded}></${tag}>`;
-    const island = container.firstElementChild;
-    if (!island) continue;
-    let node = start.nextSibling;
+    const match = /^(pnext-client|pnext-page):([^>]*)$/.exec(start.data)
+    const kind = match?.[1]
+    const encoded = match?.[2]
+    if (!kind || !encoded || !start.parentNode) continue
+    const container = doc.createElement('div')
+    const tag = kind === 'pnext-page' ? 'div' : 'pnext-client'
+    container.innerHTML = `<${tag} ${encoded}></${tag}>`
+    const island = container.firstElementChild
+    if (!island) continue
+    let node = start.nextSibling
     while (node && !(node.nodeType === Node.COMMENT_NODE && node.nodeValue === `/${kind}`)) {
-      const next = node.nextSibling;
-      island.append(node);
-      node = next;
+      const next = node.nextSibling
+      island.append(node)
+      node = next
     }
-    if (!node) continue;
-    start.replaceWith(island);
-    node.remove();
+    if (!node) continue
+    start.replaceWith(island)
+    node.remove()
   }
 }
 
@@ -185,22 +190,22 @@ function sameParams(
   left: Record<string, RouteParamValue>,
   right: Record<string, RouteParamValue>,
 ): boolean {
-  const leftKeys = Object.keys(left);
-  const rightKeys = Object.keys(right);
-  if (leftKeys.length !== rightKeys.length) return false;
+  const leftKeys = Object.keys(left)
+  const rightKeys = Object.keys(right)
+  if (leftKeys.length !== rightKeys.length) return false
   return leftKeys.every(key => {
-    const a = left[key];
-    const b = right[key];
+    const a = left[key]
+    const b = right[key]
     return Array.isArray(a)
       ? Array.isArray(b) && a.length === b.length && a.every((value, index) => value === b[index])
-      : a === b;
-  });
+      : a === b
+  })
 }
 
 function decodeSegment(segment: string) {
   try {
-    return decodeURIComponent(segment);
+    return decodeURIComponent(segment)
   } catch {
-    return segment;
+    return segment
   }
 }