vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

package/dist/esm/client/client-routing-runtime/prefetch.js

@@ -0,0 +1,89 @@
+export { prefetch };
+export { addLinkPrefetchHandlers };
+import { assert, assertClientRouting, assertUsage, checkIfClientRouting } from './utils.js';
+import { isErrorFetchingStaticAssets, loadPageFilesClientSide } from '../shared/loadPageFilesClientSide.js';
+import { isClientSideRoutable, skipLink } from './skipLink.js';
+import { getPageId } from './getPageId.js';
+import { getPrefetchSettings } from './prefetch/getPrefetchSettings.js';
+import { isAlreadyPrefetched, markAsAlreadyPrefetched } from './prefetch/alreadyPrefetched.js';
+import { disableClientRouting } from './useClientRouter.js';
+import { isExternalLink } from './isExternalLink.js';
+assertClientRouting();
+const linkPrefetchHandlerAdded = new Map();
+/**
+ * Programmatically prefetch client assets.
+ *
+ * https://vike.dev/prefetch
+ *
+ * @param url - The URL of the page you want to prefetch.
+ */
+async function prefetch(url) {
+    assertUsage(checkIfClientRouting(), 'prefetch() only works with Client Routing, see https://vike.dev/prefetch', { showStackTrace: true });
+    assertUsage(!isExternalLink(url), `You are trying to prefetch the URL ${url} of another domain which cannot be prefetched`, { showStackTrace: true });
+    if (isAlreadyPrefetched(url))
+        return;
+    markAsAlreadyPrefetched(url);
+    const { pageId, pageFilesAll, pageConfigs } = await getPageId(url);
+    if (pageId) {
+        try {
+            await loadPageFilesClientSide(pageFilesAll, pageConfigs, pageId);
+        }
+        catch (err) {
+            if (isErrorFetchingStaticAssets(err)) {
+                disableClientRouting(err, true);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+}
+function addLinkPrefetchHandlers(pageContext) {
+    // Current URL is already prefetched
+    markAsAlreadyPrefetched(pageContext.urlPathname);
+    const linkTags = [...document.getElementsByTagName('A')];
+    linkTags.forEach((linkTag) => {
+        if (linkPrefetchHandlerAdded.has(linkTag))
+            return;
+        linkPrefetchHandlerAdded.set(linkTag, true);
+        const url = linkTag.getAttribute('href');
+        if (skipLink(linkTag))
+            return;
+        assert(url);
+        if (isAlreadyPrefetched(url))
+            return;
+        const { prefetchStaticAssets } = getPrefetchSettings(pageContext, linkTag);
+        if (!prefetchStaticAssets)
+            return;
+        if (prefetchStaticAssets === 'hover') {
+            linkTag.addEventListener('mouseover', () => {
+                prefetchIfClientSideRoutable(url);
+            });
+            linkTag.addEventListener('touchstart', () => {
+                prefetchIfClientSideRoutable(url);
+            }, { passive: true });
+        }
+        if (prefetchStaticAssets === 'viewport') {
+            const observer = new IntersectionObserver((entries) => {
+                entries.forEach((entry) => {
+                    if (entry.isIntersecting) {
+                        prefetchIfClientSideRoutable(url);
+                        observer.disconnect();
+                    }
+                });
+            });
+            observer.observe(linkTag);
+        }
+    });
+}
+async function prefetchIfClientSideRoutable(url) {
+    try {
+        if (!(await isClientSideRoutable(url)))
+            return;
+    }
+    catch {
+        // If a route() hook has a bug or `throw render()` / `throw redirect()`
+        return;
+    }
+    await prefetch(url);
+}

package/dist/esm/client/client-routing-runtime/skipLink/isClientSideRoutable.d.ts

@@ -0,0 +1,2 @@
+export { isClientSideRoutable };
+declare function isClientSideRoutable(url: string): Promise<boolean>;

package/dist/esm/client/client-routing-runtime/skipLink/isClientSideRoutable.js

@@ -0,0 +1,15 @@
+export { isClientSideRoutable };
+import { getPageId } from '../getPageId.js';
+import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
+import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
+import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
+async function isClientSideRoutable(url) {
+    const { pageId, pageFilesAll, pageConfigs } = await getPageId(url);
+    if (!pageId) {
+        return false;
+    }
+    await analyzePageClientSideInit(pageFilesAll, pageId, { sharedPageFilesAlreadyLoaded: false });
+    const pageConfig = findPageConfig(pageConfigs, pageId);
+    const { isClientSideRenderable, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
+    return isClientSideRenderable && isClientRouting;
+}

package/dist/esm/client/client-routing-runtime/skipLink.d.ts

@@ -0,0 +1,3 @@
+export { skipLink };
+export { isClientSideRoutable } from './skipLink/isClientSideRoutable.js';
+declare function skipLink(linkTag: HTMLElement): boolean;

package/dist/esm/client/client-routing-runtime/skipLink.js

@@ -0,0 +1,61 @@
+export { skipLink };
+export { isClientSideRoutable } from './skipLink/isClientSideRoutable.js';
+import { getBaseServer } from './getBaseServer.js';
+import { isExternalLink } from './isExternalLink.js';
+import { assert, parseUrl, isBaseServer, isParsable } from './utils.js';
+import { isDisableAutomaticLinkInterception } from './useClientRouter.js';
+function skipLink(linkTag) {
+    const url = linkTag.getAttribute('href');
+    if (url === null)
+        return true;
+    if (url === '')
+        return true;
+    if (isExternalLink(url))
+        return true;
+    if (isNewTabLink(linkTag))
+        return true;
+    if (isHashUrl(url))
+        return true;
+    if (!hasBaseServer(url)) {
+        return true;
+    }
+    if (!isParsable(url)) {
+        return true;
+    }
+    // Purposely last because disableAutomaticLinkInterception will be removed in the major release
+    if (!isVikeLink(linkTag))
+        return true;
+    return false;
+}
+// TODO/v1-release: remove this in favor of synchronously checking whether URL matches the route of a page (possible since Async Route Functions are now deprecated)
+function isVikeLink(linkTag) {
+    const disableAutomaticLinkInterception = isDisableAutomaticLinkInterception();
+    if (!disableAutomaticLinkInterception) {
+        return true;
+    }
+    else {
+        const target = linkTag.getAttribute('data-vike-link');
+        return target !== null && target !== 'false';
+    }
+}
+function isNewTabLink(linkTag) {
+    const target = linkTag.getAttribute('target');
+    const rel = linkTag.getAttribute('rel');
+    return target === '_blank' || target === '_external' || rel === 'external' || linkTag.hasAttribute('download');
+}
+function isHashUrl(url) {
+    if (url.startsWith('#')) {
+        return true;
+    }
+    const removeHash = (url) => url.split('#')[0];
+    if (url.includes('#') && removeHash(url) === removeHash(window.location.href)) {
+        return true;
+    }
+    return false;
+}
+function hasBaseServer(url) {
+    const baseServer = getBaseServer();
+    assert(isBaseServer(baseServer));
+    const { hasBaseServer } = parseUrl(url, baseServer);
+    return hasBaseServer;
+}

package/dist/esm/client/client-routing-runtime/useClientRouter.d.ts

@@ -0,0 +1,6 @@
+export { useClientRouter };
+export { disableClientRouting };
+export { isDisableAutomaticLinkInterception };
+declare function disableClientRouting(err: unknown, log: boolean): void;
+declare function useClientRouter(): void;
+declare function isDisableAutomaticLinkInterception(): boolean;

package/dist/esm/client/client-routing-runtime/useClientRouter.js

@@ -0,0 +1,493 @@
+export { useClientRouter };
+export { disableClientRouting };
+export { isDisableAutomaticLinkInterception };
+import { assert, getCurrentUrl, isEquivalentError, objectAssign, serverSideRouteTo, throttle, sleep, getGlobalObject, executeHook } from './utils.js';
+import { navigationState } from './navigationState.js';
+import { checkIf404, getPageContext, getPageContextErrorPage, isAlreadyServerSideRouted } from './getPageContext.js';
+import { createPageContext } from './createPageContext.js';
+import { addLinkPrefetchHandlers } from './prefetch.js';
+import { assertInfo, assertWarning, isReact } from './utils.js';
+import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
+import { assertHook } from '../../shared/hooks/getHook.js';
+import { isClientSideRoutable, skipLink } from './skipLink.js';
+import { isErrorFetchingStaticAssets } from '../shared/loadPageFilesClientSide.js';
+import { initHistoryState, getHistoryState, pushHistory, saveScrollPosition } from './history.js';
+import { defineNavigate } from './navigate.js';
+import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
+const globalObject = getGlobalObject('useClientRouter.ts', { previousState: getState() });
+setupNativeScrollRestoration();
+initHistoryState();
+function disableClientRouting(err, log) {
+    assert(isErrorFetchingStaticAssets(err));
+    globalObject.clientRoutingIsDisabled = true;
+    if (log) {
+        // We don't use console.error() to avoid flooding error trackers such as Sentry
+        console.log(err);
+    }
+    // @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
+    const isProd = import.meta.env.PROD;
+    assertInfo(false, [
+        'Failed to fetch static asset.',
+        isProd ? 'This usually happens when a new frontend is deployed.' : null,
+        'Falling back to Server Routing.',
+        '(The next page navigation will use Server Routing instead of Client Routing.)'
+    ]
+        .filter(Boolean)
+        .join(' '), { onlyOnce: true });
+}
+function useClientRouter() {
+    autoSaveScrollPosition();
+    onLinkClick((url, { keepScrollPosition }) => {
+        const scrollTarget = keepScrollPosition ? 'preserve-scroll' : 'scroll-to-top-or-hash';
+        fetchAndRender({
+            scrollTarget,
+            urlOriginal: url,
+            isBackwardNavigation: false,
+            checkClientSideRenderable: true
+        });
+    });
+    onBrowserHistoryNavigation((scrollTarget, isBackwardNavigation) => {
+        fetchAndRender({ scrollTarget, isBackwardNavigation });
+    });
+    defineNavigate(async (url, { keepScrollPosition = false, overwriteLastHistoryEntry = false } = {}) => {
+        const scrollTarget = keepScrollPosition ? 'preserve-scroll' : 'scroll-to-top-or-hash';
+        await fetchAndRender({
+            scrollTarget,
+            urlOriginal: url,
+            overwriteLastHistoryEntry,
+            isBackwardNavigation: false,
+            checkClientSideRenderable: true
+        });
+    });
+    let renderingCounter = 0;
+    let renderPromise;
+    let isTransitioning = false;
+    fetchAndRender({ scrollTarget: 'preserve-scroll', isBackwardNavigation: null });
+    return;
+    async function fetchAndRender({ scrollTarget, urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, checkClientSideRenderable, pageContextsFromRewrite = [], redirectCount = 0 }) {
+        assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, redirectCount);
+        if (globalObject.clientRoutingIsDisabled) {
+            serverSideRouteTo(urlOriginal);
+            return;
+        }
+        const pageContextFromAllRewrites = getPageContextFromAllRewrites(pageContextsFromRewrite);
+        if (checkClientSideRenderable) {
+            const urlLogical = pageContextFromAllRewrites._urlRewrite ?? urlOriginal;
+            let isClientRoutable;
+            try {
+                isClientRoutable = await isClientSideRoutable(urlLogical);
+            }
+            catch (err) {
+                if (!isAbortError(err)) {
+                    // If a route() hook has a bug
+                    throw err;
+                }
+                else {
+                    // If the user's route() hook throw redirect() / throw render()
+                    // We handle the abort error down below: the user's route() hook is called again in getPageContext()
+                    isClientRoutable = true;
+                }
+            }
+            if (!isClientRoutable) {
+                serverSideRouteTo(urlOriginal);
+                return;
+            }
+        }
+        const pageContextBase = {
+            urlOriginal,
+            isBackwardNavigation,
+            ...pageContextFromAllRewrites
+        };
+        const renderingNumber = ++renderingCounter;
+        assert(renderingNumber >= 1);
+        // Start transition before any await's
+        if (renderingNumber > 1) {
+            if (isTransitioning === false) {
+                globalObject.onPageTransitionStart?.(pageContextBase);
+                isTransitioning = true;
+            }
+        }
+        let hydrationCanBeAborted = false;
+        const shouldAbort = () => {
+            {
+                // We should never abort the hydration if `hydrationCanBeAborted` isn't `true`
+                const isHydration = renderingNumber === 1;
+                if (isHydration && hydrationCanBeAborted === false) {
+                    return false;
+                }
+            }
+            // If there is a newer rendering, we should abort all previous renderings
+            if (renderingNumber !== renderingCounter) {
+                return true;
+            }
+            return false;
+        };
+        const pageContext = await createPageContext(pageContextBase);
+        if (shouldAbort()) {
+            return;
+        }
+        const isFirstRenderAttempt = renderingNumber === 1;
+        objectAssign(pageContext, {
+            _isFirstRenderAttempt: isFirstRenderAttempt
+        });
+        let pageContextAddendum;
+        let err;
+        let hasError = false;
+        try {
+            pageContextAddendum = await getPageContext(pageContext);
+        }
+        catch (err_) {
+            hasError = true;
+            err = err_;
+        }
+        if (hasError) {
+            if (!isAbortError(err)) {
+                // We don't swallow 404 errors:
+                //  - On the server-side, Vike swallows / doesn't show any 404 error log because it's expected that a user may go to some random non-existent URL. (We don't want to flood the app's error tracking with 404 logs.)
+                //  - On the client-side, if the user navigates to a 404 then it means that the UI has a broken link. (It isn't expected that users can go to some random URL using the client-side router, as it would require, for example, the user to manually change the URL of a link by manually manipulating the DOM which highly unlikely.)
+                console.error(err);
+            }
+            else {
+                // We swallow throw redirect()/render() called by client-side hooks onBeforeRender() and guard()
+                // We handle the abort error down below.
+            }
+            if (shouldSwallowAndInterrupt(err, pageContext))
+                return;
+            if (isAbortError(err)) {
+                const errAbort = err;
+                logAbortErrorHandled(err, pageContext._isProduction, pageContext);
+                const pageContextAbort = errAbort._pageContextAbort;
+                // throw render('/some-url')
+                if (pageContextAbort._urlRewrite) {
+                    await fetchAndRender({
+                        scrollTarget,
+                        urlOriginal,
+                        overwriteLastHistoryEntry,
+                        isBackwardNavigation,
+                        pageContextsFromRewrite: [...pageContextsFromRewrite, pageContextAbort],
+                        redirectCount
+                    });
+                    return;
+                }
+                // throw redirect('/some-url')
+                if (pageContextAbort._urlRedirect) {
+                    const urlRedirect = pageContextAbort._urlRedirect.url;
+                    if (urlRedirect.startsWith('http')) {
+                        // External redirection
+                        window.location.href = urlRedirect;
+                        return;
+                    }
+                    else {
+                        await fetchAndRender({
+                            scrollTarget: 'scroll-to-top-or-hash',
+                            urlOriginal: urlRedirect,
+                            overwriteLastHistoryEntry: false,
+                            isBackwardNavigation: false,
+                            checkClientSideRenderable: true,
+                            pageContextsFromRewrite,
+                            redirectCount: redirectCount++
+                        });
+                    }
+                    return;
+                }
+                // throw render(statusCode)
+                assert(pageContextAbort.abortStatusCode);
+                objectAssign(pageContext, pageContextAbort);
+                if (pageContextAbort.abortStatusCode === 404) {
+                    objectAssign(pageContext, { is404: true });
+                }
+            }
+            else {
+                objectAssign(pageContext, { is404: checkIf404(err) });
+            }
+            try {
+                pageContextAddendum = await getPageContextErrorPage(pageContext);
+            }
+            catch (err2) {
+                // - When user hasn't defined a `_error.page.js` file
+                // - Some unpexected vike internal error
+                if (shouldSwallowAndInterrupt(err2, pageContext))
+                    return;
+                if (!isFirstRenderAttempt) {
+                    setTimeout(() => {
+                        // We let the server show the 404 page
+                        window.location.pathname = urlOriginal;
+                    }, 0);
+                }
+                if (!isEquivalentError(err, err2)) {
+                    throw err2;
+                }
+                else {
+                    // Abort
+                    return;
+                }
+            }
+        }
+        assert(pageContextAddendum);
+        objectAssign(pageContext, pageContextAddendum);
+        assertHook(pageContext, 'onPageTransitionStart');
+        globalObject.onPageTransitionStart = pageContext.exports.onPageTransitionStart;
+        if (pageContext.exports.hydrationCanBeAborted) {
+            hydrationCanBeAborted = true;
+        }
+        else {
+            assertWarning(!isReact(), 'You seem to be using React; we recommend setting hydrationCanBeAborted to true, see https://vike.dev/clientRouting', { onlyOnce: true });
+        }
+        if (shouldAbort()) {
+            return;
+        }
+        if (renderPromise) {
+            // Always make sure that the previous render has finished,
+            // otherwise that previous render may finish after this one.
+            await renderPromise;
+        }
+        if (shouldAbort()) {
+            return;
+        }
+        changeUrl(urlOriginal, overwriteLastHistoryEntry);
+        navigationState.markNavigationChange();
+        assert(renderPromise === undefined);
+        renderPromise = (async () => {
+            await executeOnRenderClientHook(pageContext, true);
+            addLinkPrefetchHandlers(pageContext);
+        })();
+        await renderPromise;
+        renderPromise = undefined;
+        if (pageContext._isFirstRenderAttempt) {
+            assertHook(pageContext, 'onHydrationEnd');
+            const { onHydrationEnd } = pageContext.exports;
+            if (onHydrationEnd) {
+                const hookFilePath = pageContext.exportsAll.onHydrationEnd[0].exportSource;
+                assert(hookFilePath);
+                await executeHook(() => onHydrationEnd(pageContext), 'onHydrationEnd', hookFilePath);
+            }
+        }
+        else if (renderingNumber === renderingCounter) {
+            if (pageContext.exports.onPageTransitionEnd) {
+                assertHook(pageContext, 'onPageTransitionEnd');
+                pageContext.exports.onPageTransitionEnd(pageContext);
+            }
+            isTransitioning = false;
+        }
+        setScrollPosition(scrollTarget);
+        browserNativeScrollRestoration_disable();
+        globalObject.initialRenderIsDone = true;
+    }
+}
+function onLinkClick(callback) {
+    document.addEventListener('click', onClick);
+    return;
+    // Code adapted from https://github.com/HenrikJoreteg/internal-nav-helper/blob/5199ec5448d0b0db7ec63cf76d88fa6cad878b7d/src/index.js#L11-L29
+    function onClick(ev) {
+        if (!isNormalLeftClick(ev))
+            return;
+        const linkTag = findLinkTag(ev.target);
+        if (!linkTag)
+            return;
+        const url = linkTag.getAttribute('href');
+        if (skipLink(linkTag))
+            return;
+        assert(url);
+        ev.preventDefault();
+        const keepScrollPosition = ![null, 'false'].includes(linkTag.getAttribute('keep-scroll-position'));
+        callback(url, { keepScrollPosition });
+    }
+    function isNormalLeftClick(ev) {
+        return ev.button === 0 && !ev.ctrlKey && !ev.shiftKey && !ev.altKey && !ev.metaKey;
+    }
+    function findLinkTag(target) {
+        while (target.tagName !== 'A') {
+            const { parentNode } = target;
+            if (!parentNode) {
+                return null;
+            }
+            target = parentNode;
+        }
+        return target;
+    }
+}
+function onBrowserHistoryNavigation(callback) {
+    // The `event` of `window.addEventListener('popstate', (event) => /*...*/)` is useless:
+    //  - The History API doesn't provide the previous state (the popped state): https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
+    window.addEventListener('popstate', () => {
+        const currentState = getState();
+        const scrollTarget = currentState.historyState.scrollPosition || 'scroll-to-top-or-hash';
+        const isHashNavigation = currentState.urlWithoutHash === globalObject.previousState.urlWithoutHash;
+        const isBackwardNavigation = !currentState.historyState.timestamp || !globalObject.previousState.historyState.timestamp
+            ? null
+            : currentState.historyState.timestamp < globalObject.previousState.historyState.timestamp;
+        globalObject.previousState = currentState;
+        if (isHashNavigation) {
+            // - `history.state` is uninitialized (`null`) when:
+            //   - The vike app runs `window.location.hash = '#section'`.
+            //   - The user clicks on an anchor link `<a href="#section">Section</a>`. (Because vike's `onLinkClick()` handler skips hash links.)
+            // - `history.state` is `null` when uninitialized: https://developer.mozilla.org/en-US/docs/Web/API/History/state
+            // - Alternatively, we completely take over hash navigation and reproduce the browser's native behavior upon hash navigation.
+            //   - Problem: we cannot intercept `window.location.hash = '#section'`. (Or maybe we can with the `hashchange` event?)
+            //   - Other potential problem: would there be a conflict when the user wants to override the browser's default behavior? E.g. for smooth scrolling, or when using hashes for saving states of some fancy animations.
+            // - Another alternative: we use the browser's scroll restoration mechanism (see `browserNativeScrollRestoration_enable()` below).
+            //   - Problem: not clear when to call `browserNativeScrollRestoration_disable()`/`browserNativeScrollRestoration_enable()`
+            //   - Other potential problem are inconsistencies between browsers: specification says that setting `window.history.scrollRestoration` only affects the current entry in the session history. But this seems to contradict what folks saying.
+            //     - Specification: https://html.spec.whatwg.org/multipage/history.html#the-history-interface
+            //     - https://stackoverflow.com/questions/70188241/history-scrollrestoration-manual-doesnt-prevent-safari-from-restoring-scrol
+            if (window.history.state === null) {
+                // The browser already scrolled to `#${hash}` => the current scroll position is the right one => we save it with `initHistoryState()`.
+                initHistoryState();
+                globalObject.previousState = getState();
+            }
+            else {
+                // If `history.state !== null` then it means that `popstate` was triggered by the user clicking on his browser's forward/backward history button.
+                setScrollPosition(scrollTarget);
+            }
+        }
+        else {
+            // Fetch & render new page
+            callback(scrollTarget, isBackwardNavigation);
+        }
+    });
+}
+function changeUrl(url, overwriteLastHistoryEntry) {
+    if (getCurrentUrl() === url)
+        return;
+    browserNativeScrollRestoration_disable();
+    pushHistory(url, overwriteLastHistoryEntry);
+    globalObject.previousState = getState();
+}
+function getState() {
+    return {
+        urlWithoutHash: getCurrentUrl({ withoutHash: true }),
+        historyState: getHistoryState()
+    };
+}
+function setScrollPosition(scrollTarget) {
+    if (scrollTarget === 'preserve-scroll') {
+        return;
+    }
+    let scrollPosition;
+    if (scrollTarget === 'scroll-to-top-or-hash') {
+        const hash = getUrlHash();
+        // We replicate the browser's native behavior
+        if (hash && hash !== 'top') {
+            const hashTarget = document.getElementById(hash) || document.getElementsByName(hash)[0];
+            if (hashTarget) {
+                hashTarget.scrollIntoView();
+                return;
+            }
+        }
+        scrollPosition = { x: 0, y: 0 };
+    }
+    else {
+        assert('x' in scrollTarget && 'y' in scrollTarget);
+        scrollPosition = scrollTarget;
+    }
+    setScroll(scrollPosition);
+}
+/** Change the browser's scoll position, in a way that works during a repaint. */
+function setScroll(scrollPosition) {
+    const scroll = () => window.scrollTo(scrollPosition.x, scrollPosition.y);
+    const done = () => window.scrollX === scrollPosition.x && window.scrollY === scrollPosition.y;
+    // In principle, this `done()` call should force the repaint to be finished. But that doesn't seem to be the case with `Firefox 97.0.1`.
+    if (done())
+        return;
+    scroll();
+    // Because `done()` doesn't seem to always force the repaint to be finished, we potentially need to retry again.
+    if (done())
+        return;
+    requestAnimationFrame(() => {
+        scroll();
+        if (done())
+            return;
+        setTimeout(async () => {
+            scroll();
+            if (done())
+                return;
+            // In principle, `requestAnimationFrame() -> setTimeout(, 0)` should be enough.
+            //  - https://stackoverflow.com/questions/61281139/waiting-for-repaint-in-javascript
+            //  - But it's not enough for `Firefox 97.0.1`.
+            //  - The following strategy is very agressive. It doesn't need to be that aggressive for Firefox. But we do it to be safe.
+            const start = new Date().getTime();
+            while (true) {
+                await sleep(10);
+                scroll();
+                if (done())
+                    return;
+                const millisecondsElapsed = new Date().getTime() - start;
+                if (millisecondsElapsed > 100)
+                    return;
+            }
+        }, 0);
+    });
+}
+function autoSaveScrollPosition() {
+    // Safari cannot handle more than 100 `history.replaceState()` calls within 30 seconds (https://github.com/vikejs/vike/issues/46)
+    window.addEventListener('scroll', throttle(saveScrollPosition, Math.ceil(1000 / 3)), { passive: true });
+    onPageHide(saveScrollPosition);
+}
+function getUrlHash() {
+    let { hash } = window.location;
+    if (hash === '')
+        return null;
+    assert(hash.startsWith('#'));
+    hash = hash.slice(1);
+    return hash;
+}
+// We use the browser's native scroll restoration mechanism only for the first render
+function setupNativeScrollRestoration() {
+    browserNativeScrollRestoration_enable();
+    onPageHide(browserNativeScrollRestoration_enable);
+    onPageShow(() => globalObject.initialRenderIsDone && browserNativeScrollRestoration_disable());
+}
+function browserNativeScrollRestoration_disable() {
+    if ('scrollRestoration' in window.history) {
+        window.history.scrollRestoration = 'manual';
+    }
+}
+function browserNativeScrollRestoration_enable() {
+    if ('scrollRestoration' in window.history) {
+        window.history.scrollRestoration = 'auto';
+    }
+}
+function onPageHide(listener) {
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+            listener();
+        }
+    });
+}
+function onPageShow(listener) {
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'visible') {
+            listener();
+        }
+    });
+}
+function shouldSwallowAndInterrupt(err, pageContext) {
+    if (isAlreadyServerSideRouted(err))
+        return true;
+    if (handleErrorFetchingStaticAssets(err, pageContext))
+        return true;
+    return false;
+}
+function handleErrorFetchingStaticAssets(err, pageContext) {
+    if (!isErrorFetchingStaticAssets(err)) {
+        return false;
+    }
+    if (pageContext._isFirstRenderAttempt) {
+        disableClientRouting(err, false);
+        // This may happen if the frontend was newly deployed during hydration.
+        // Ideally: re-try a couple of times by reloading the page (not entirely trivial to implement since `localStorage` is needed.)
+        throw err;
+    }
+    else {
+        disableClientRouting(err, true);
+    }
+    serverSideRouteTo(pageContext.urlOriginal);
+    return true;
+}
+function isDisableAutomaticLinkInterception() {
+    // @ts-ignore
+    return !!window._disableAutomaticLinkInterception;
+    /* globalObject should be used if we want to make disableAutomaticLinkInterception a page-by-page setting
+    return globalObject.disableAutomaticLinkInterception ?? false
+    */
+}