@wular/pnext 0.0.3 → 0.0.6

package/src/compat/client/errors/install.ts

@@ -18,28 +18,28 @@
 //
 // Client-escaped errors carry NO digest, matching Next.
 
-import { h, options, render } from 'preact';
-import { handleControlFlowError, isControlFlowError } from './control-flow';
+import { h, options, render } from 'preact'
+import { handleControlFlowError, isControlFlowError } from './control-flow'
 import {
   wasErrorHandled,
   type RouteErrorComponent,
   type RouteNotFoundComponent,
-} from './error-boundary';
+} from './error-boundary'
 import {
   escalateToGlobalError,
   mountGlobalError,
   registerGlobalErrorComponent,
   wasReportedUncaught,
   type GlobalErrorComponent,
-} from './global-error';
-import { softRefreshRoute } from './soft-refresh';
+} from './global-error'
+import { softRefreshRoute } from './soft-refresh'
 
-export { ClientErrorBoundary, toClientError } from './error-boundary';
-export { markErrorHandled, wasErrorHandled } from './error-boundary';
-export type { RouteErrorComponent } from './error-boundary';
-export { isControlFlowError, handleControlFlowError } from './control-flow';
-export { mountGlobalError } from './global-error';
-export { softRefreshRoute } from './soft-refresh';
+export { ClientErrorBoundary, toClientError } from './error-boundary'
+export { markErrorHandled, wasErrorHandled } from './error-boundary'
+export type { RouteErrorComponent } from './error-boundary'
+export { isControlFlowError, handleControlFlowError } from './control-flow'
+export { mountGlobalError } from './global-error'
+export { softRefreshRoute } from './soft-refresh'
 
 export interface InstallOptions {
   /**
@@ -47,77 +47,77 @@ export interface InstallOptions {
    * ClientErrorBoundary (nearest-boundary primary path); retained here so the
    * install signature stays stable and callers can still thread it.
    */
-  errorComponent?: RouteErrorComponent;
-  notFoundComponent?: RouteNotFoundComponent;
+  errorComponent?: RouteErrorComponent
+  notFoundComponent?: RouteNotFoundComponent
   /** The app's global-error.js component, when available (see gaps: build thread). */
-  globalErrorComponent?: GlobalErrorComponent;
+  globalErrorComponent?: GlobalErrorComponent
   /**
    * Predicate identifying action errors already handled by the action overlay,
    * so this runtime skips them. Defaults to never-skip when omitted.
    */
-  isActionError?: (error: unknown) => boolean;
+  isActionError?: (error: unknown) => boolean
 }
 
-let installed = false;
+let installed = false
 
 // Set by installClientErrors so ./lazy can replay the errors that escaped
 // before this chunk landed (a throw during hydration or in a first-paint
 // effect) through exactly the same triage.
-let escapedErrorHandler: ((error: unknown) => void) | undefined;
+let escapedErrorHandler: ((error: unknown) => void) | undefined
 
 /** Replay pre-runtime escapes (./lazy buffers them) through the last resort. */
 export function drainEscapedErrors(errors: unknown[]): void {
-  for (const error of errors) escapedErrorHandler?.(error);
+  for (const error of errors) escapedErrorHandler?.(error)
 }
 
 export function installClientErrors(options: InstallOptions = {}): void {
-  if ((!process.browser && typeof window === 'undefined') || installed) return;
-  installed = true;
+  if ((!process.browser && typeof window === 'undefined') || installed) return
+  installed = true
 
-  const { globalErrorComponent, isActionError } = options;
+  const { globalErrorComponent, isActionError } = options
   // Register so the in-tree ClientErrorBoundary can escalate a no-error.js route
   // straight to global-error (handles `throw undefined`/`null`, which the window
   // channel would drop).
-  registerGlobalErrorComponent(globalErrorComponent);
+  registerGlobalErrorComponent(globalErrorComponent)
 
   const onError = (error: unknown): void => {
     // Already caught + rendered by a route boundary: the boundary owns it.
-    if (wasErrorHandled(error)) return;
+    if (wasErrorHandled(error)) return
     // Control-flow first: navigate, never render (covers control errors thrown
     // outside any boundary, and boundary-rethrown ones that reach the window).
     if (isControlFlowError(error)) {
-      handleControlFlowError(error);
-      return;
+      handleControlFlowError(error)
+      return
     }
     // Action errors belong to the action-error overlay.
-    if (isActionError?.(error)) return;
+    if (isActionError?.(error)) return
 
     // A genuinely uncaught client error with no route error.js to catch it —
     // the global-error last resort replaces the document. Pass the raw value so
     // a non-Error throw renders unwrapped in global-error.js (`${error}`).
-    mountGlobalError(error, globalErrorComponent);
-  };
-  escapedErrorHandler = onError;
+    mountGlobalError(error, globalErrorComponent)
+  }
+  escapedErrorHandler = onError
 
   window.addEventListener('error', event => {
     // Ignore ResourceLoad errors (no `error` object) — only script throws carry one.
-    if ('error' in event && event.error === undefined) return;
+    if ('error' in event && event.error === undefined) return
     // Our own synchronous reportUncaught echo: already mounted + reported.
-    if (wasReportedUncaught(event.error)) return;
-    if (event.error !== undefined) onError(event.error);
-  });
+    if (wasReportedUncaught(event.error)) return
+    if (event.error !== undefined) onError(event.error)
+  })
   window.addEventListener('unhandledrejection', event => {
     // The escape below already reported this value synchronously; without
     // preventDefault the page would emit a SECOND uncaught-error report.
     if (wasReportedUncaught(event.reason)) {
-      event.preventDefault();
-      return;
+      event.preventDefault()
+      return
     }
-    onError(event.reason);
-  });
+    onError(event.reason)
+  })
 
-  installRenderEscapeEscalation(globalErrorComponent, isActionError);
-  installStreamErrorBoundaries(options.errorComponent, globalErrorComponent);
+  installRenderEscapeEscalation(globalErrorComponent, isActionError)
+  installStreamErrorBoundaries(options.errorComponent, globalErrorComponent)
 }
 
 // Synchronous global-error escalation for a render throw no boundary held. Preact signals "nothing
@@ -131,24 +131,24 @@ function installRenderEscapeEscalation(
   isActionError?: (error: unknown) => boolean,
 ): void {
   // `_catchError` in preact's source; `__e` in its published (mangled) build.
-  const hooks = options as unknown as Record<string, unknown>;
-  const key = (['_catchError', '__e'] as const).find(name => typeof hooks[name] === 'function');
-  if (!key) return;
-  const walkBoundaries = hooks[key] as (...args: unknown[]) => unknown;
+  const hooks = options as unknown as Record<string, unknown>
+  const key = (['_catchError', '__e'] as const).find(name => typeof hooks[name] === 'function')
+  if (!key) return
+  const walkBoundaries = hooks[key] as (...args: unknown[]) => unknown
   hooks[key] = function patchedCatchError(this: unknown, ...args: unknown[]) {
     try {
-      return walkBoundaries.apply(this, args);
+      return walkBoundaries.apply(this, args)
     } catch (error) {
       // Handled by a boundary, control flow, or an action error: those already
       // have an owner — only a genuinely uncaught error escapes to global-error.
       // escalate (not mount): the error must also report as uncaught in THIS
       // task, not a task later via the natural unhandled rejection.
       if (!wasErrorHandled(error) && !isControlFlowError(error) && !isActionError?.(error)) {
-        escalateToGlobalError(error);
+        escalateToGlobalError(error)
       }
-      throw error;
+      throw error
     }
-  };
+  }
 }
 
 // Streamed-Suspense server errors, routed to the route error.js boundary.
@@ -160,58 +160,57 @@ function installRenderEscapeEscalation(
 // here we watch for those markers (initial scan plus a MutationObserver, since stream chunks land after
 // the entry module runs) and mount the route error.js over them. Both callbacks soft-refresh, so a
 // since-recovered server render replaces the boundary with real content.
-const STREAM_ERROR_SELECTOR = 'pnext-error[data-pnext-stream-error][data-pnext-error-message]';
+const STREAM_ERROR_SELECTOR = 'pnext-error[data-pnext-stream-error][data-pnext-error-message]'
 
 function installStreamErrorBoundaries(
   errorComponent?: RouteErrorComponent,
   globalErrorComponent?: GlobalErrorComponent,
 ): void {
-  if (typeof document === 'undefined') return;
+  if (typeof document === 'undefined') return
   // Announce the runtime so the server's inline stream-error fallback script
   // (renderer streamErrorDocumentScript) defers to this handler.
-  (window as unknown as Record<string, unknown>).__PNEXT_STREAM_ERROR_RUNTIME__ = true;
+  ;(window as unknown as Record<string, unknown>).__PNEXT_STREAM_ERROR_RUNTIME__ = true
 
   const mountMarker = (marker: Element): void => {
-    const message = marker.getAttribute('data-pnext-error-message') ?? '';
-    const digest = marker.getAttribute('data-pnext-error-digest') ?? undefined;
-    const error = new Error(message) as Error & { digest?: string };
-    if (digest) error.digest = digest;
+    const message = marker.getAttribute('data-pnext-error-message') ?? ''
+    const digest = marker.getAttribute('data-pnext-error-digest') ?? undefined
+    const error = new Error(message) as Error & { digest?: string }
+    if (digest) error.digest = digest
     if (!errorComponent) {
       // No route error.js: Next escalates a streamed-Suspense server error to
       // global-error (the built-in "This page couldn't load" document with the
       // ERROR <digest> footer when none exists — default-error-page-ui suite).
-      mountGlobalError(error, globalErrorComponent);
-      return;
+      mountGlobalError(error, globalErrorComponent)
+      return
     }
-    const host = document.createElement('div');
-    marker.replaceWith(host);
-    const reset = () => softRefreshRoute();
-    render(h(errorComponent, { error, reset, unstable_retry: reset }), host);
-  };
+    const host = document.createElement('div')
+    marker.replaceWith(host)
+    const reset = () => softRefreshRoute()
+    render(h(errorComponent, { error, reset, unstable_retry: reset }), host)
+  }
 
   const scan = (root: ParentNode): void => {
     for (const marker of Array.from(root.querySelectorAll(STREAM_ERROR_SELECTOR))) {
-      mountMarker(marker);
+      mountMarker(marker)
     }
-  };
+  }
 
   const observe = () => {
-    scan(document);
+    scan(document)
     new MutationObserver(mutations => {
       for (const mutation of mutations) {
         for (const node of Array.from(mutation.addedNodes)) {
-          if (!(node instanceof Element)) continue;
-          if (node.matches(STREAM_ERROR_SELECTOR)) mountMarker(node);
-          else scan(node);
+          if (!(node instanceof Element)) continue
+          if (node.matches(STREAM_ERROR_SELECTOR)) mountMarker(node)
+          else scan(node)
         }
       }
-    }).observe(document.documentElement, { childList: true, subtree: true });
-  };
+    }).observe(document.documentElement, { childList: true, subtree: true })
+  }
 
   if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', observe, { once: true });
+    document.addEventListener('DOMContentLoaded', observe, { once: true })
   } else {
-    observe();
+    observe()
   }
 }
-

package/src/compat/client/errors/lazy.ts

@@ -6,48 +6,48 @@
 // a first-paint effect fires long before the idle tier lands, and Next still shows global-error for
 // it. They buffer the value, pull ./install right away, and hand it over - so a healthy page still
 // never fetches the chunk.
-import { registerDeferredInstall } from '../../../api/router';
-import type { InstallOptions } from './install';
+import { registerDeferredInstall } from '../../../client/router'
+import type { InstallOptions } from './install'
 
-type ErrorRuntime = typeof import('./install');
+type ErrorRuntime = typeof import('./install')
 
 export function installClientErrors(options: InstallOptions = {}): void {
-  if (!process.browser && typeof window === 'undefined') return;
+  if (!process.browser && typeof window === 'undefined') return
 
-  let runtime: Promise<ErrorRuntime> | undefined;
+  let runtime: Promise<ErrorRuntime> | undefined
   const load = () =>
     (runtime ??= import('./install').then(module => {
       // Drop the capture listeners before the runtime's own go in, so a later
       // error is triaged once rather than by both paths.
-      window.removeEventListener('error', onError);
-      window.removeEventListener('unhandledrejection', onRejection);
-      module.installClientErrors(options);
-      return module;
-    }));
+      window.removeEventListener('error', onError)
+      window.removeEventListener('unhandledrejection', onRejection)
+      module.installClientErrors(options)
+      return module
+    }))
 
-  const escaped: unknown[] = [];
-  const seen = new WeakSet<object>();
+  const escaped: unknown[] = []
+  const seen = new WeakSet<object>()
   const capture = (error: unknown) => {
     // The replay itself can throw (control-flow handling, a global-error
     // render), which surfaces as another rejection here. Capturing the same
     // value twice would loop, so object throws are only ever queued once and
     // the chain swallows its own failures.
     if (error !== null && typeof error === 'object') {
-      if (seen.has(error)) return;
-      seen.add(error);
+      if (seen.has(error)) return
+      seen.add(error)
     }
-    escaped.push(error);
+    escaped.push(error)
     void load()
       .then(module => module.drainEscapedErrors(escaped.splice(0)))
-      .catch(() => undefined);
-  };
+      .catch(() => undefined)
+  }
   // Resource-load failures carry no `error` object; only script throws do.
   const onError = (event: ErrorEvent) => {
-    if (event.error !== undefined) capture(event.error);
-  };
-  const onRejection = (event: PromiseRejectionEvent) => capture(event.reason);
-  window.addEventListener('error', onError);
-  window.addEventListener('unhandledrejection', onRejection);
+    if (event.error !== undefined) capture(event.error)
+  }
+  const onRejection = (event: PromiseRejectionEvent) => capture(event.reason)
+  window.addEventListener('error', onError)
+  window.addEventListener('unhandledrejection', onRejection)
 
-  registerDeferredInstall(load);
+  registerDeferredInstall(load)
 }

package/src/compat/client/errors/primitive-throw.ts

@@ -12,26 +12,26 @@
 // has no `.then`, so preact proceeds normally into `options._catchError` and the normal boundary walk
 // runs. Boundaries unwrap the tag to recover the original raw value before handing it to the error UI.
 
-const RAW_VALUE = Symbol('pnext.primitiveThrowValue');
+const RAW_VALUE = Symbol('pnext.primitiveThrowValue')
 
 export interface TaggedPrimitiveThrow extends Error {
-  [RAW_VALUE]: unknown;
+  [RAW_VALUE]: unknown
 }
 
 export function tagPrimitiveThrow(value: unknown): TaggedPrimitiveThrow {
-  const message = typeof value === 'string' ? value : String(value);
-  const error = new Error(message) as TaggedPrimitiveThrow;
-  error[RAW_VALUE] = value;
-  return error;
+  const message = typeof value === 'string' ? value : String(value)
+  const error = new Error(message) as TaggedPrimitiveThrow
+  error[RAW_VALUE] = value
+  return error
 }
 
 export function isTaggedPrimitiveThrow(error: unknown): error is TaggedPrimitiveThrow {
-  return error instanceof Error && RAW_VALUE in error;
+  return error instanceof Error && RAW_VALUE in error
 }
 
 /** Unwrap a tagged primitive-throw Error back to the raw value; pass through anything else. */
 export function untagPrimitiveThrow(error: unknown): unknown {
-  return isTaggedPrimitiveThrow(error) ? error[RAW_VALUE] : error;
+  return isTaggedPrimitiveThrow(error) ? error[RAW_VALUE] : error
 }
 
 /**
@@ -41,13 +41,13 @@ export function untagPrimitiveThrow(error: unknown): unknown {
  * the bare one pulling in the full cluster.
  */
 export function normalizeBoundaryError(error: unknown): unknown {
-  const untagged = untagPrimitiveThrow(error);
-  if (untagged !== error) return untagged;
+  const untagged = untagPrimitiveThrow(error)
+  if (untagged !== error) return untagged
   if (error instanceof Error) {
-    if (error.message === "Cannot read properties of undefined (reading 'then')") return undefined;
-    if (error.message === "Cannot read properties of null (reading 'then')") return null;
+    if (error.message === "Cannot read properties of undefined (reading 'then')") return undefined
+    if (error.message === "Cannot read properties of null (reading 'then')") return null
   }
-  return error;
+  return error
 }
 
 /**
@@ -55,7 +55,7 @@ export function normalizeBoundaryError(error: unknown): unknown {
  * (`e.then`): null and undefined - the only two JS values where the property access itself throws.
  */
 function crashesPreactThenCheck(value: unknown): boolean {
-  return value === null || value === undefined;
+  return value === null || value === undefined
 }
 
 /**
@@ -63,7 +63,7 @@ function crashesPreactThenCheck(value: unknown): boolean {
  * check is re-thrown as a tagged Error instead. Safe to call repeatedly on the same component type -
  * the wrapper is cached.
  */
-const wrapped = new WeakMap<object, unknown>();
+const wrapped = new WeakMap<object, unknown>()
 
 // Marks a value this function already produced, so re-wrapping is a no-op. REQUIRED for idempotency
 // across preact's own vnode clone-and-re-render path: a component that re-renders IN PLACE
@@ -74,69 +74,71 @@ const wrapped = new WeakMap<object, unknown>();
 // same component position resolves back to the first, singly-wrapped value. Two different function
 // references at the same tree position make preact treat it as a different component type - a full
 // unmount and remount of that subtree instead of an update.
-const ALREADY_WRAPPED = Symbol('pnext.primitiveThrowWrapped');
+const ALREADY_WRAPPED = Symbol('pnext.primitiveThrowWrapped')
 
 function copyMetadata(from: object, to: object): void {
   for (const key of Object.getOwnPropertyNames(from)) {
-    if (key === 'length' || key === 'name' || key === 'prototype') continue;
-    const descriptor = Object.getOwnPropertyDescriptor(from, key);
-    if (descriptor) Object.defineProperty(to, key, descriptor);
+    if (key === 'length' || key === 'name' || key === 'prototype') continue
+    const descriptor = Object.getOwnPropertyDescriptor(from, key)
+    if (descriptor) Object.defineProperty(to, key, descriptor)
   }
   for (const symbol of Object.getOwnPropertySymbols(from)) {
-    const descriptor = Object.getOwnPropertyDescriptor(from, symbol);
-    if (descriptor) Object.defineProperty(to, symbol, descriptor);
+    const descriptor = Object.getOwnPropertyDescriptor(from, symbol)
+    if (descriptor) Object.defineProperty(to, symbol, descriptor)
   }
 }
 
 export function wrapComponentForPrimitiveThrows<T extends object>(type: T): T {
-  if ((type as { [ALREADY_WRAPPED]?: true })[ALREADY_WRAPPED]) return type;
-  const cached = wrapped.get(type);
-  if (cached) return cached as T;
-  if (typeof type !== 'function') return type;
+  if ((type as { [ALREADY_WRAPPED]?: true })[ALREADY_WRAPPED]) return type
+  const cached = wrapped.get(type)
+  if (cached) return cached as T
+  if (typeof type !== 'function') return type
 
-  const isClassComponent = Boolean((type as { prototype?: { render?: unknown } }).prototype?.render);
-  let result: unknown;
+  const isClassComponent = Boolean((type as { prototype?: { render?: unknown } }).prototype?.render)
+  let result: unknown
 
   if (isClassComponent) {
     // Class components: preact does `new Type(props, context)` then calls
     // `.render()`. Subclass so `render()` is wrapped; static lifecycle methods
     // (getDerivedStateFromError, etc.) and everything else pass through
     // untouched via normal prototype-chain inheritance.
-    const Base = type as unknown as new (...args: unknown[]) => { render(...args: unknown[]): unknown };
+    const Base = type as unknown as new (...args: unknown[]) => {
+      render(...args: unknown[]): unknown
+    }
     class PrimitiveThrowSafe extends Base {
       render(...args: unknown[]) {
         try {
-          return super.render(...args);
+          return super.render(...args)
         } catch (e) {
-          if (crashesPreactThenCheck(e)) throw tagPrimitiveThrow(e);
-          throw e;
+          if (crashesPreactThenCheck(e)) throw tagPrimitiveThrow(e)
+          throw e
         }
       }
     }
-    Object.defineProperty(PrimitiveThrowSafe, 'name', { value: Base.name });
+    Object.defineProperty(PrimitiveThrowSafe, 'name', { value: Base.name })
     // Copy static properties AND symbol-keyed metadata (displayName, getDerivedStateFromError,
     // contextType, defaultProps, plus the framework's own client-reference/dynamic-reference/params-
     // scope symbol markers stashed directly on component function objects). resolveServerTree branches
     // on those, so losing them mis-routes a client-reference class through the server-component call
     // path instead of the island path.
-    copyMetadata(Base, PrimitiveThrowSafe);
-    result = PrimitiveThrowSafe;
+    copyMetadata(Base, PrimitiveThrowSafe)
+    result = PrimitiveThrowSafe
   } else {
-    const fn = type as unknown as (...args: unknown[]) => unknown;
+    const fn = type as unknown as (...args: unknown[]) => unknown
     const wrappedFn = function pnextPrimitiveThrowSafe(this: unknown, ...args: unknown[]) {
       try {
-        return fn.apply(this, args);
+        return fn.apply(this, args)
       } catch (e) {
-        if (crashesPreactThenCheck(e)) throw tagPrimitiveThrow(e);
-        throw e;
+        if (crashesPreactThenCheck(e)) throw tagPrimitiveThrow(e)
+        throw e
       }
-    };
-    Object.defineProperty(wrappedFn, 'name', { value: fn.name });
-    copyMetadata(fn, wrappedFn);
-    result = wrappedFn;
+    }
+    Object.defineProperty(wrappedFn, 'name', { value: fn.name })
+    copyMetadata(fn, wrappedFn)
+    result = wrappedFn
   }
 
-  Object.defineProperty(result as object, ALREADY_WRAPPED, { value: true });
-  wrapped.set(type, result);
-  return result as T;
+  Object.defineProperty(result as object, ALREADY_WRAPPED, { value: true })
+  wrapped.set(type, result)
+  return result as T
 }

package/src/compat/client/errors/soft-refresh.ts

@@ -1,4 +1,4 @@
-import { softNavigate } from '../../../api/router';
+import { softNavigate } from '../../../client/router'
 
 /**
  * Soft-refresh the current URL from the server (re-runs the hydrated subtree so a data-dependent
@@ -7,8 +7,8 @@ import { softNavigate } from '../../../api/router';
  * ./install - which rides the deferred tier - into first paint.
  */
 export function softRefreshRoute(): void {
-  if (!process.browser && typeof window === 'undefined') return;
+  if (!process.browser && typeof window === 'undefined') return
   void softNavigate(location.href, { replace: true, scroll: false, remount: true }).catch(() => {
-    location.reload();
-  });
+    location.reload()
+  })
 }

package/src/compat/client/link-status.ts

@@ -1,34 +1,34 @@
 // Per-link navigation pending state for `useLinkStatus()` (next/link). A single link is "pending" at a
 // time: the last one whose click started an in-flight soft navigation. It clears on completion, and on
 // any navigation started elsewhere - all of which broadcast a location change.
-import { createContext } from 'preact';
-import { softNavigate } from '../../api/router';
-import { locationListeners, onNavigationStart } from '../../api/router/events';
-import { patchHistory } from '../../api/client-navigation';
+import { createContext } from 'preact'
+import { softNavigate } from '../../client/router'
+import { locationListeners, onNavigationStart } from '../../client/router/events'
+import { patchHistory } from '../../api/client-navigation'
 
 export interface LinkStatus {
-  pending: boolean;
+  pending: boolean
 }
 
-export const LinkStatusContext = createContext<LinkStatus>({ pending: false });
+export const LinkStatusContext = createContext<LinkStatus>({ pending: false })
 
-type Listener = () => void;
+type Listener = () => void
 
-let pendingToken: symbol | null = null;
+let pendingToken: symbol | null = null
 // Set right before navigateWithStatus starts its own soft-nav, so the resulting
 // synchronous nav-start is recognized as the link's own, not a supersession.
-let ownNavStart: symbol | null = null;
-const listeners = new Set<Listener>();
-let wired = false;
+let ownNavStart: symbol | null = null
+const listeners = new Set<Listener>()
+let wired = false
 
 function notify() {
-  for (const listener of [...listeners]) listener();
+  for (const listener of [...listeners]) listener()
 }
 
 function setPending(token: symbol | null) {
-  if (pendingToken === token) return;
-  pendingToken = token;
-  notify();
+  if (pendingToken === token) return
+  pendingToken = token
+  notify()
 }
 
 // A different navigation starting (router.push, refresh, another link)
@@ -36,38 +36,38 @@ function setPending(token: symbol | null) {
 // in flight — its synchronous start isn't the pending link's own.
 function onNavStart() {
   if (ownNavStart !== null) {
-    ownNavStart = null;
-    return;
+    ownNavStart = null
+    return
   }
-  setPending(null);
+  setPending(null)
 }
 
 // A location change ends the pending state: for the pending link's own nav this
 // only fires at completion (its pushState happens after the fetch resolves);
 // for shallow pushState / browser back it fires immediately. Both should clear.
 function onLocationChange() {
-  setPending(null);
+  setPending(null)
 }
 
 function wire() {
-  if (wired || (!process.browser && typeof window === 'undefined')) return;
-  wired = true;
+  if (wired || (!process.browser && typeof window === 'undefined')) return
+  wired = true
   // Raw window.history.pushState/replaceState (shallow routing) must clear the
   // pending link; the patch broadcasts them through locationListeners.
-  patchHistory();
-  onNavigationStart(onNavStart);
-  locationListeners().add(onLocationChange);
-  window.addEventListener('popstate', onLocationChange);
+  patchHistory()
+  onNavigationStart(onNavStart)
+  locationListeners().add(onLocationChange)
+  window.addEventListener('popstate', onLocationChange)
 }
 
 export function subscribeLinkStatus(_token: symbol, listener: Listener) {
-  wire();
-  listeners.add(listener);
-  return () => listeners.delete(listener);
+  wire()
+  listeners.add(listener)
+  return () => listeners.delete(listener)
 }
 
 export function linkPending(token: symbol) {
-  return pendingToken === token;
+  return pendingToken === token
 }
 
 // Start a soft navigation owned by this link: mark it pending, clear on
@@ -78,9 +78,9 @@ export function navigateWithStatus(
   href: string,
   options: { replace?: boolean; scroll?: boolean },
 ) {
-  ownNavStart = token;
-  setPending(token);
+  ownNavStart = token
+  setPending(token)
   void softNavigate(href, options).finally(() => {
-    if (pendingToken === token) setPending(null);
-  });
+    if (pendingToken === token) setPending(null)
+  })
 }