@rangojs/router 0.22.1 → 0.24.0

package/src/browser/prefetch/fetch.ts

@@ -35,6 +35,7 @@ import { shouldPrefetch } from "./policy.js";
 import { debugLog, IS_BROWSER_DEBUG } from "../logging.js";
 import { teeWithCompletion, isForeignRouterId } from "../response-adapter.js";
 import { SEGMENT_FRAGMENT_CAPABILITY_HEADER } from "../../segment-fragments.js";
+import { PREFETCH_HEADER } from "../../prefetch-markers.js";
 import type { RscPayload } from "../types.js";
 
 /**
@@ -263,7 +264,7 @@ function executePrefetchFetch(
     headers: {
       "X-Rango-State": rangoState,
       "X-RSC-Router-Client-Path": window.location.href,
-      "X-Rango-Prefetch": "1",
+      [PREFETCH_HEADER]: "1",
       ...(isFragmentPassthroughEnabled() && {
         [SEGMENT_FRAGMENT_CAPABILITY_HEADER]: "1",
       }),

package/src/browser/react/Link.tsx

@@ -42,6 +42,7 @@ import {
   subscribeToAdaptiveStrategyChange,
 } from "../prefetch/default-strategy.js";
 import { getAppVersion } from "../app-version.js";
+import { prefixBasename } from "../../router/basename.js";
 import type { PrefetchStrategy } from "../../router/prefetch-default.js";
 
 // The PrefetchStrategy union is defined in router/prefetch-default.ts (both
@@ -244,15 +245,12 @@ export const Link: ForwardRefExoticComponent<
   // store and no origin: links stay internal.
   const isExternal = isExternalUrl(to, ctx?.origin);
 
-  // Auto-prefix with basename for app-local paths.
-  // Skip if external, already prefixed, or not a root-relative path.
-  const resolvedTo = useMemo(() => {
-    if (isExternal) return to;
-    const bn = ctx?.basename;
-    if (!bn || !to.startsWith("/") || to.startsWith(bn + "/") || to === bn)
-      return to;
-    return to === "/" ? bn : bn + to;
-  }, [to, isExternal, ctx?.basename]);
+  // Auto-prefix with basename for app-local paths (prefixBasename: not when
+  // external, already prefixed, or not root-relative).
+  const resolvedTo = useMemo(
+    () => (isExternal ? to : prefixBasename(to, ctx?.basename)),
+    [to, isExternal, ctx?.basename],
+  );
 
   // No explicit `prefetch` prop: fall back to the router-wide default from
   // the router store. Adaptive is resolved against the input capability when a

package/src/browser/react/NavigationProvider.tsx

@@ -22,6 +22,7 @@ import type {
   NavigationUpdate,
   NavigateOptionsInternal,
   NavigationBridge,
+  RscMetadata,
 } from "../types.js";
 import type { EventController } from "../event-controller.js";
 import { RootErrorBoundary } from "../../root-error-boundary.js";
@@ -211,6 +212,30 @@ async function processHandles(
   }
 }
 
+/**
+ * Read the handle stream of `metadata` into the event controller and the
+ * entry on screen. The provider's own call for every payload it is handed,
+ * and the one write for a response that hands React nothing (a fill,
+ * browser/partial-update.ts fillHoles).
+ */
+export function consumeHandles(
+  metadata: RscMetadata,
+  eventController: EventController,
+  store: NavigationStore,
+): void {
+  processHandles(metadata.handles!, {
+    eventController,
+    store,
+    matched: metadata.matched,
+    isPartial: metadata.isPartial,
+    resolvedIds: metadata.resolvedIds,
+    // Now: by the time the stream ends the user may be elsewhere.
+    historyKey: store.getHistoryKey(),
+  }).catch((err) =>
+    console.error("[NavigationProvider] Error consuming handles:", err),
+  );
+}
+
 /**
  * Props for NavigationProvider
  */
@@ -286,10 +311,17 @@ export interface NavigationProviderProps {
    * The document this provider hydrates (initBrowserApp; renderRoute with
    * `hydrate: true`), whose store EventController.lockHydration locked.
    * `settled` resolves once the stream has ended and React has revealed every
-   * boundary. Until then location state is `undefined`, as SSR rendered it;
-   * then one transition gives the entry's state and changes
-   * HydrationBarrierContext, and the store is released after that commit. A
-   * navigation committed earlier releases the store before its update.
+   * boundary. Then a transition changes HydrationBarrierContext alone, and
+   * React commits it once every boundary has hydrated, one still suspended on
+   * the client (a lazy chunk, a deferred-hydration gate) included. Until that
+   * commit location state is `undefined`, as SSR rendered it, through any
+   * commit no payload follows (a shallow navigation), and the store is
+   * locked; after it the entry's state lands in a transition of its own
+   * and the store is released (handle data lands in that release
+   * notification). A navigation committed earlier releases the store before
+   * its update, for the whole hold when the navigation is held: an old-page
+   * boundary hydrating meanwhile reads the destination's values and can
+   * mismatch.
    * Absent for a provider mounted on the client.
    */
   hydration?: { settled: Promise<void> };
@@ -368,6 +400,11 @@ export function NavigationProvider({
   }
   const shellRef = appShellRef ?? fallbackShellRef.current;
 
+  // Fixed for the document: read once on mount.
+  const [origin] = useState(
+    () => (eventController.getState().location as URL | undefined)?.origin,
+  );
+
   const contextValue = useMemo<NavigationStoreContextValue>(() => {
     const value = {
       store,
@@ -375,8 +412,7 @@ export function NavigationProvider({
       navigate,
       refresh,
       defaultPrefetch: initialPayload.metadata.defaultPrefetch,
-      // Fixed for the document: read once, with the stable value.
-      origin: (eventController.getState().location as URL | undefined)?.origin,
+      origin,
     } as NavigationStoreContextValue;
     Object.defineProperty(value, "basename", {
       configurable: true,
@@ -400,18 +436,18 @@ export function NavigationProvider({
     return startConnectionWarmup();
   }, [warmupEnabled]);
 
-  // The document has been revealed: one transition gives the entry's location
-  // state and moves the barrier, so React hydrates every boundary still
-  // dehydrated before it commits.
+  // The document has been revealed. The barrier must be the only update in
+  // its transition lane: then React holds the commit until every boundary
+  // still dehydrated beneath it has hydrated. Any other update in the lane
+  // (location state in its own startTransition here included) can let React
+  // commit around a boundary still suspended on the client. Why:
+  // docs/internal/execution-model.md, "The reveal barrier is alone in its lane".
   useEffect(() => {
     if (!hydration) return;
     let cancelled = false;
     void hydration.settled.then(() => {
       if (cancelled || !hydrationOpen.current) return;
-      startTransition(() => {
-        setLocationState(eventController.getLocationState());
-        setHydrationBarrier((n) => n + 1);
-      });
+      startTransition(() => setHydrationBarrier((n) => n + 1));
     });
     return () => {
       cancelled = true;
@@ -419,20 +455,31 @@ export function NavigationProvider({
   }, []);
 
   // After the barrier's commit no boundary under this provider is dehydrated:
-  // release the store, and its handle writes reach their readers.
+  // the entry's location state lands in a transition of its own, and the
+  // store is released so its handle writes reach their readers. A navigation
+  // that committed first has done both (store onUpdate below).
   useEffect(() => {
-    if (hydrationBarrier === 0) return;
+    if (hydrationBarrier === 0 || !hydrationOpen.current) return;
     hydrationOpen.current = false;
+    startTransition(() => setLocationState(eventController.getLocationState()));
     eventController.releaseHydrationLock();
   }, [hydrationBarrier]);
 
   // A commit no payload follows (a shallow navigation, a commit that keeps
   // every segment, merged server-set state): the tree on screen is already
-  // the entry's, so its state is taken with the commit's notification.
+  // the entry's, so its state is taken with the commit's notification. Not
+  // while the hydration window is open: a boundary of the document may still
+  // be dehydrated, an update a reader outside it takes commits around it, and
+  // it then hydrates against the new state. The barrier's effect gives the
+  // controller's state, this commit's included. The window stays open: this
+  // commit mounts nothing that must read the live store.
   useEffect(
     () =>
       eventController.subscribe(() => {
-        if (eventController.takeTreelessLocationState()) {
+        if (
+          eventController.takeTreelessLocationState() &&
+          !hydrationOpen.current
+        ) {
           setLocationState(eventController.getLocationState());
         }
       }),
@@ -456,7 +503,7 @@ export function NavigationProvider({
     return unsub;
   }, [eventController]);
 
-  // Pending scroll action to apply after React commits
+  // The last navigation's scroll decision, until React commits its update.
   const pendingScrollRef = useRef<NavigationUpdate["scroll"]>(undefined);
 
   // Apply scroll after React commits the new content to the DOM
@@ -478,11 +525,14 @@ export function NavigationProvider({
   useEffect(() => {
     const unsubscribe = store.onUpdate((update) => {
       if (process.env.NODE_ENV !== "production") auditTreeUpdate(update.root);
-      // Capture scroll intent — it will be applied in useLayoutEffect
-      // after React commits this state update to the DOM.
-      // Always assign (even undefined) to clear stale scroll from prior navigations,
-      // so server actions or error updates don't accidentally replay old scroll.
-      pendingScrollRef.current = update.scroll;
+      // Scroll belongs to the navigation transaction: only an update that
+      // carries one's decision sets the pending action, and the layout effect
+      // above consumes it once, after the commit that follows. An update with
+      // no decision (server action, error, prefetch: false fill) leaves a
+      // pending one alone. React can hold a navigation's commit, and whatever
+      // lands meanwhile must not cost the navigation its scroll. Nothing
+      // stale is replayed: every update commits, and that commit consumes.
+      if (update.scroll) pendingScrollRef.current = update.scroll;
 
       // Committed before the document finished hydrating: end the window
       // first, so the page this update mounts reads the live store. A
@@ -494,10 +544,7 @@ export function NavigationProvider({
         eventController.releaseHydrationLock();
       }
 
-      setPayload({
-        root: update.root,
-        metadata: update.metadata,
-      });
+      setPayload({ root: update.root, metadata: update.metadata });
       // The state of the entry this payload renders, as its commit recorded
       // it: one update, so one lane, so one React commit with the tree.
       setLocationState(eventController.getLocationState());
@@ -509,31 +556,23 @@ export function NavigationProvider({
         eventController.setParams(update.metadata.params);
       }
 
+      // A page rendered from a history-cache entry (back/forward, or a link
+      // to it) starts from the entry's pushes, and its response's handles
+      // merge onto them: the page on screen's pushes are not its segments'.
+      const { matched, cachedHandleData } = update.metadata;
+      if (matched && cachedHandleData) {
+        eventController.setHandleData(cachedHandleData, matched);
+      }
       // Update handle data progressively as it streams in
       if (update.metadata.handles) {
-        // Capture historyKey now - by the time async processing completes,
-        // the user might have navigated elsewhere
-        const historyKey = store.getHistoryKey();
-
-        processHandles(update.metadata.handles, {
-          eventController,
-          store,
-          matched: update.metadata.matched,
-          isPartial: update.metadata.isPartial,
-          resolvedIds: update.metadata.resolvedIds,
-          historyKey,
-        }).catch((err) =>
-          console.error("[NavigationProvider] Error consuming handles:", err),
-        );
-      } else if (update.metadata.matched) {
-        // cachedHandleData present -> full restore (back/forward); absent ->
-        // partial cleanup of segments no longer matched.
-        const cached = update.metadata.cachedHandleData;
+        consumeHandles(update.metadata, eventController, store);
+      } else if (matched && !cachedHandleData) {
+        // Partial cleanup of segments no longer matched.
         eventController.setHandleData(
-          cached ?? {},
-          update.metadata.matched,
-          cached === undefined,
-          cached === undefined ? update.metadata.resolvedIds : undefined,
+          {},
+          matched,
+          true,
+          update.metadata.resolvedIds,
         );
       }
 

package/src/browser/react/context.ts

@@ -91,8 +91,9 @@ export const LocationStateContext: Context<LocationStateSnapshot> =
  * Read by no component. NavigationProvider changes its value in a transition so
  * that React hydrates every boundary still dehydrated beneath it before that
  * commit: React hydrates a dehydrated boundary first when a provider above it
- * changes, and nothing re-renders for a value nobody reads. See
- * NavigationProviderProps.hydration.
+ * changes, and nothing re-renders for a value nobody reads. It must stay
+ * unread and alone in its lane (docs/internal/execution-model.md, "The reveal
+ * barrier is alone in its lane"). See NavigationProviderProps.hydration.
  */
 export const HydrationBarrierContext: Context<number> =
   createContext<number>(0);

package/src/browser/react/filter-segment-order.ts

@@ -1,3 +1,14 @@
+/**
+ * A loader sub-id carries a `D${index}.` marker ("M0L0D1.user"). Non-global,
+ * so `.test` and `.replace` are stateless.
+ */
+export const LOADER_SEGMENT_ID: RegExp = /D\d+\./;
+
+/** True for a loader sub-id ("M0L0D1.user"), false for a layout/route/slot id. */
+export function isLoaderSegmentId(id: string): boolean {
+  return LOADER_SEGMENT_ID.test(id);
+}
+
 /**
  * Build the handle-collection segment order from a raw `matched` list.
  *
@@ -24,7 +35,7 @@ export function filterSegmentOrder(matched: string[]): string[] {
   const nonSlotSet = new Set<string>();
 
   for (const id of matched) {
-    if (/D\d+\./.test(id)) continue;
+    if (isLoaderSegmentId(id)) continue;
     const slotIdx = id.indexOf(".@");
     if (slotIdx >= 0) {
       const parent = id.slice(0, slotIdx);
@@ -66,5 +77,5 @@ export function filterSegmentOrder(matched: string[]): string[] {
  * and React reports a hydration mismatch.
  */
 export function filterRouteSegmentIds(matched: string[]): string[] {
-  return matched.filter((id) => !id.includes(".@") && !/D\d+\./.test(id));
+  return matched.filter((id) => !id.includes(".@") && !isLoaderSegmentId(id));
 }

package/src/browser/react/use-router.ts

@@ -5,6 +5,7 @@ import { NavigationStoreContext } from "./context.js";
 import { useMount } from "./use-mount.js";
 import { prefetchDirect } from "../prefetch/loader.js";
 import { getAppVersion } from "../app-version.js";
+import { prefixBasename } from "../../router/basename.js";
 import type { RouterInstance, RouterNavigateOptions } from "../types.js";
 
 /**
@@ -51,10 +52,7 @@ export function useRouter(): RouterInstance {
   return useMemo<RouterInstance>(() => {
     /** Prefix a root-relative path with basename if not already prefixed. */
     function withBasename(url: string): string {
-      const bn = ctx!.basename;
-      if (!bn || !url.startsWith("/") || url.startsWith(bn + "/") || url === bn)
-        return url;
-      return url === "/" ? bn : bn + url;
+      return prefixBasename(url, ctx!.basename);
     }
 
     /**

package/src/browser/response-adapter.ts

@@ -26,6 +26,26 @@ export function extractRscHeaderUrl(
   return url ? { url } : "blocked";
 }
 
+/**
+ * Run `request` with a signal that `signal` aborts until the request settles,
+ * and only until then. A response that has arrived streams to its end:
+ * aborting a Flight body mid-read rejects every chunk a mounted tree may be
+ * reading. Aborted, the request rejects with `signal.reason`.
+ */
+export function abortUntilResponse<T>(
+  signal: AbortSignal | undefined,
+  request: (signal: AbortSignal | undefined) => Promise<T>,
+): Promise<T> {
+  if (!signal) return request(undefined);
+  const controller = new AbortController();
+  const cancel = (): void => controller.abort(signal.reason);
+  if (signal.aborted) cancel();
+  else signal.addEventListener("abort", cancel, { once: true });
+  return request(controller.signal).finally(() =>
+    signal.removeEventListener("abort", cancel),
+  );
+}
+
 /**
  * Empty 200 response that won't choke Flight parsing.
  * Used when a header URL is blocked by origin validation.

package/src/browser/rsc-router.tsx

@@ -11,6 +11,7 @@ import {
 import { createEventController } from "./event-controller.js";
 import { resolveDeferredHandleValues } from "../handles/deferred-resolution.js";
 import { validateRedirectOrigin } from "./validate-redirect-origin.js";
+import { awaitDocumentRevealed } from "./document-revealed.js";
 import { createNavigationClient } from "./navigation-client.js";
 import { createServerActionBridge } from "./server-action-bridge.js";
 import { createNavigationBridge } from "./navigation-bridge.js";
@@ -331,14 +332,23 @@ export async function initBrowserApp(
             // deferred values here exactly like the nav lane's processHandles
             // does before applying.
             const lateData = await resolveDeferredHandleValues(rawLateData);
-            bootLog("handles: late push applied", {
+            // Live store only while the document's page is on screen: a full
+            // replace with its `matched` would overwrite another page's handles.
+            const pageKeys = store.getPageHistoryKeys(initialHistoryKey);
+            const onScreen = pageKeys.includes(store.getHistoryKey());
+            bootLog("handles: late push", {
               segments: Object.keys(lateData),
+              onScreen,
             });
-            eventController.setHandleData(
-              lateData,
-              initialPayload.metadata?.matched,
-            );
-            store.updateCacheHandleData(initialHistoryKey, lateData);
+            if (onScreen) {
+              eventController.setHandleData(
+                lateData,
+                initialPayload.metadata?.matched,
+              );
+            }
+            for (const key of pageKeys) {
+              store.updateCacheHandleData(key, lateData);
+            }
           }
         } catch (err) {
           console.error("[rsc-router] Error consuming late handles:", err);
@@ -641,28 +651,7 @@ export async function initBrowserApp(
     linkInterceptionEnabled: linkInterception,
     version,
     appShellRef,
-    documentRevealed: new Promise<void>((resolve) => {
-      // Parsing ends with the stream, but React reveals a streamed boundary
-      // in batches up to 300 ms later (Fizz's $RC marks it `$~` and reveals
-      // it from a timer), so the boundary is still pending at
-      // DOMContentLoaded. A transition then would make React client-render
-      // it over its server HTML.
-      const start = (): void => {
-        // A reveal rewrites the same comment's data, or React removes the
-        // node; a boundary nested in revealed content joins the document
-        // only then, so resolve only once a full walk finds none.
-        let pending = unrevealedBoundaries();
-        const check = (): void => {
-          pending = pending.filter(isUnrevealed);
-          if (pending.length === 0) pending = unrevealedBoundaries();
-          if (pending.length > 0) requestAnimationFrame(check);
-          else resolve();
-        };
-        check();
-      };
-      if (document.readyState !== "loading") start();
-      else document.addEventListener("DOMContentLoaded", start, { once: true });
-    }),
+    documentRevealed: awaitDocumentRevealed(),
   };
   browserAppContext = context;
 
@@ -670,23 +659,6 @@ export async function initBrowserApp(
   return context;
 }
 
-/**
- * A Suspense boundary of the document React has not revealed yet: Fizz marks
- * one `$?` while its content streams and `$~` once its reveal is queued.
- */
-function isUnrevealed(node: Comment): boolean {
-  return node.isConnected && (node.data === "$?" || node.data === "$~");
-}
-
-function unrevealedBoundaries(): Comment[] {
-  const found: Comment[] = [];
-  const walker = document.createTreeWalker(document, NodeFilter.SHOW_COMMENT);
-  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
-    if (isUnrevealed(node as Comment)) found.push(node as Comment);
-  }
-  return found;
-}
-
 // Once-flag so the hydration-commit boot log fires a single time (StrictMode
 // re-runs the root effect; the second flush is not a second hydration).
 let hydrationCommitLogged = false;

package/src/browser/server-action-bridge.ts

@@ -26,8 +26,8 @@ import {
   startBrowserTransaction,
 } from "./logging.js";
 import {
+  validatePayloadRedirect,
   validateRedirectOrigin,
-  validateExternalRedirect,
 } from "./validate-redirect-origin.js";
 import {
   extractRscHeaderUrl,
@@ -40,13 +40,11 @@ import { mergeLocationState } from "./history-state.js";
 import { stampLocationState } from "./react/location-state-shared.js";
 import { classifyActionOutcome } from "./action-coordinator.js";
 import { getAppVersion } from "./app-version.js";
-import { collectClientRevalidationDecisions } from "../client-urls/navigation.js";
 import {
   decideCommitGatedOff,
   findActionFormData,
   type TransitionWhenActionInput,
 } from "./transition-when.js";
-import { CLIENT_REVALIDATION_HEADER } from "../client-urls/revalidation-protocol.js";
 import { auditTreeCause } from "../suspense-audit.js";
 
 // Polyfill Symbol.dispose/asyncDispose for Safari and older browsers
@@ -335,39 +333,12 @@ export function createServerActionBridge(
       const onHandleAbort = () => fetchAbort.abort();
       handle.signal.addEventListener("abort", onHandleAbort, { once: true });
 
-      // Client-run per-loader revalidation for the action follow-up render:
-      // run the held clientUrls route's revalidate() predicates with the
-      // action context and ship their decisions. Fails soft to null (locked
-      // server defaults).
-      let clientRevalidation: string | null = null;
-      try {
-        const actionPageUrl = new URL(
-          segmentState.currentUrl,
-          window.location.origin,
-        );
-        clientRevalidation = collectClientRevalidationDecisions({
-          currentUrl: actionPageUrl,
-          nextUrl: actionPageUrl,
-          // Decisions ride the action POST itself — the server evaluates it
-          // with actionContext, so the locked default is the action default.
-          actionRequest: true,
-          isAction: true,
-          actionId: id,
-          stale: false,
-        });
-      } catch {
-        clientRevalidation = null;
-      }
-
       // Send action request with stream tracking
       const responsePromise = fetch(url, {
         method: "POST",
         headers: {
           "rsc-action": id,
           "X-RSC-Router-Client-Path": segmentState.currentUrl,
-          ...(clientRevalidation && {
-            [CLIENT_REVALIDATION_HEADER]: clientRevalidation,
-          }),
           ...(tx && { "X-RSC-Router-Request-Id": tx.requestId }),
           ...(interceptSourceUrl && {
             "X-RSC-Router-Intercept-Source": interceptSourceUrl,
@@ -518,41 +489,26 @@ export function createServerActionBridge(
       // Check handle.signal.aborted to avoid redirecting from a stale action
       // when the user has already navigated away.
       if (metadata?.redirect && !handle.signal.aborted) {
-        // Explicit off-host redirect (redirect(url, { external: true })):
-        // hard-navigate, but still scheme-validate (http/https only). external
-        // waives the same-origin check, NOT scheme safety, so a forged payload
-        // carrying a javascript:/data: URL cannot script via location.assign.
-        if (metadata.redirect.external) {
-          const externalUrl = validateExternalRedirect(
-            metadata.redirect.url,
-            window.location.origin,
+        // An explicit off-host redirect is a hard navigation, still
+        // scheme-validated: a forged payload carrying a javascript:/data: URL
+        // cannot script via location.assign (validatePayloadRedirect).
+        const { redirect } = metadata;
+        const target = validatePayloadRedirect(redirect);
+        handle.complete(returnValue?.data);
+        if (!target) {
+          log(
+            redirect.external
+              ? "blocked external action redirect payload"
+              : "blocked action redirect payload",
+            { url: redirect.url },
           );
-          if (!externalUrl) {
-            log("blocked external action redirect payload", {
-              url: metadata.redirect.url,
-            });
-            handle.complete(returnValue?.data);
-            return returnValue?.data;
-          }
-          log("external action redirect", { url: externalUrl });
-          handle.complete(returnValue?.data);
-          window.location.assign(externalUrl);
-          return returnValue?.data;
+        } else if (redirect.external) {
+          log("external action redirect", { url: target });
+          window.location.assign(target);
+        } else {
+          log("action redirect", { url: target });
+          await dispatchRedirect(target, metadata.locationState);
         }
-        const redirectUrl = validateRedirectOrigin(
-          metadata.redirect.url,
-          window.location.origin,
-        );
-        if (!redirectUrl) {
-          log("blocked action redirect payload", {
-            url: metadata.redirect.url,
-          });
-          handle.complete(returnValue?.data);
-          return returnValue?.data;
-        }
-        log("action redirect", { url: redirectUrl });
-        handle.complete(returnValue?.data);
-        await dispatchRedirect(redirectUrl, metadata.locationState);
         return returnValue?.data;
       }
 
@@ -950,6 +906,12 @@ export function createServerActionBridge(
 
       handle.complete(returnData);
       return returnData;
+    } catch (error) {
+      // What the call rejects with (a revalidation render that threw, a
+      // failed decode) is the action's error, for useAction as for the
+      // caller. A no-op for an aborted or already-settled action.
+      handle.fail(error);
+      throw error;
     } finally {
       // The single deferred invalidation + fence release for this action. Runs
       // for every terminal that settles (normal, navigated-away, error, abort,