qalita 2.3.2__py3-none-any.whl → 2.5.3__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/fetch-server-response.js

@@ -0,0 +1,352 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createFetch: null,
+    createFromNextReadableStream: null,
+    fetchServerResponse: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createFetch: function() {
+        return createFetch;
+    },
+    createFromNextReadableStream: function() {
+        return createFromNextReadableStream;
+    },
+    fetchServerResponse: function() {
+        return fetchServerResponse;
+    }
+});
+const _client = require("react-server-dom-webpack/client");
+const _approuterheaders = require("../app-router-headers");
+const _appcallserver = require("../../app-call-server");
+const _appfindsourcemapurl = require("../../app-find-source-map-url");
+const _routerreducertypes = require("./router-reducer-types");
+const _flightdatahelpers = require("../../flight-data-helpers");
+const _appbuildid = require("../../app-build-id");
+const _setcachebustingsearchparam = require("./set-cache-busting-search-param");
+const _routeparams = require("../../route-params");
+const createFromReadableStream = _client.createFromReadableStream;
+const createFromFetch = _client.createFromFetch;
+let createDebugChannel;
+if (process.env.NODE_ENV !== 'production' && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
+    createDebugChannel = require('../../dev/debug-channel').createDebugChannel;
+}
+function doMpaNavigation(url) {
+    return (0, _routeparams.urlToUrlWithoutFlightMarker)(new URL(url, location.origin)).toString();
+}
+let isPageUnloading = false;
+if (typeof window !== 'undefined') {
+    // Track when the page is unloading, e.g. due to reloading the page or
+    // performing hard navigations. This allows us to suppress error logging when
+    // the browser cancels in-flight requests during page unload.
+    window.addEventListener('pagehide', ()=>{
+        isPageUnloading = true;
+    });
+    // Reset the flag on pageshow, e.g. when navigating back and the JavaScript
+    // execution context is restored by the browser.
+    window.addEventListener('pageshow', ()=>{
+        isPageUnloading = false;
+    });
+}
+async function fetchServerResponse(url, options) {
+    const { flightRouterState, nextUrl, prefetchKind } = options;
+    const headers = {
+        // Enable flight response
+        [_approuterheaders.RSC_HEADER]: '1',
+        // Provide the current router state
+        [_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER]: (0, _flightdatahelpers.prepareFlightRouterStateForRequest)(flightRouterState, options.isHmrRefresh)
+    };
+    /**
+   * Three cases:
+   * - `prefetchKind` is `undefined`, it means it's a normal navigation, so we want to prefetch the page data fully
+   * - `prefetchKind` is `full` - we want to prefetch the whole page so same as above
+   * - `prefetchKind` is `auto` - if the page is dynamic, prefetch the page data partially, if static prefetch the page data fully
+   */ if (prefetchKind === _routerreducertypes.PrefetchKind.AUTO) {
+        headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER] = '1';
+    }
+    if (process.env.NODE_ENV === 'development' && options.isHmrRefresh) {
+        headers[_approuterheaders.NEXT_HMR_REFRESH_HEADER] = '1';
+    }
+    if (nextUrl) {
+        headers[_approuterheaders.NEXT_URL] = nextUrl;
+    }
+    // In static export mode, we need to modify the URL to request the .txt file,
+    // but we should preserve the original URL for the canonical URL and error handling.
+    const originalUrl = url;
+    try {
+        // When creating a "temporary" prefetch (the "on-demand" prefetch that gets created on navigation, if one doesn't exist)
+        // we send the request with a "high" priority as it's in response to a user interaction that could be blocking a transition.
+        // Otherwise, all other prefetches are sent with a "low" priority.
+        // We use "auto" for in all other cases to match the existing default, as this function is shared outside of prefetching.
+        const fetchPriority = prefetchKind ? prefetchKind === _routerreducertypes.PrefetchKind.TEMPORARY ? 'high' : 'low' : 'auto';
+        if (process.env.NODE_ENV === 'production') {
+            if (process.env.__NEXT_CONFIG_OUTPUT === 'export') {
+                // In "output: export" mode, we can't rely on headers to distinguish
+                // between HTML and RSC requests. Instead, we append an extra prefix
+                // to the request.
+                url = new URL(url);
+                if (url.pathname.endsWith('/')) {
+                    url.pathname += 'index.txt';
+                } else {
+                    url.pathname += '.txt';
+                }
+            }
+        }
+        // Typically, during a navigation, we decode the response using Flight's
+        // `createFromFetch` API, which accepts a `fetch` promise.
+        // TODO: Remove this check once the old PPR flag is removed
+        const isLegacyPPR = process.env.__NEXT_PPR && !process.env.__NEXT_CACHE_COMPONENTS;
+        const shouldImmediatelyDecode = !isLegacyPPR;
+        const res = await createFetch(url, headers, fetchPriority, shouldImmediatelyDecode);
+        const responseUrl = (0, _routeparams.urlToUrlWithoutFlightMarker)(new URL(res.url));
+        const canonicalUrl = res.redirected ? responseUrl : originalUrl;
+        const contentType = res.headers.get('content-type') || '';
+        const interception = !!res.headers.get('vary')?.includes(_approuterheaders.NEXT_URL);
+        const postponed = !!res.headers.get(_approuterheaders.NEXT_DID_POSTPONE_HEADER);
+        const staleTimeHeaderSeconds = res.headers.get(_approuterheaders.NEXT_ROUTER_STALE_TIME_HEADER);
+        const staleTime = staleTimeHeaderSeconds !== null ? parseInt(staleTimeHeaderSeconds, 10) * 1000 : -1;
+        let isFlightResponse = contentType.startsWith(_approuterheaders.RSC_CONTENT_TYPE_HEADER);
+        if (process.env.NODE_ENV === 'production') {
+            if (process.env.__NEXT_CONFIG_OUTPUT === 'export') {
+                if (!isFlightResponse) {
+                    isFlightResponse = contentType.startsWith('text/plain');
+                }
+            }
+        }
+        // If fetch returns something different than flight response handle it like a mpa navigation
+        // If the fetch was not 200, we also handle it like a mpa navigation
+        if (!isFlightResponse || !res.ok || !res.body) {
+            // in case the original URL came with a hash, preserve it before redirecting to the new URL
+            if (url.hash) {
+                responseUrl.hash = url.hash;
+            }
+            return doMpaNavigation(responseUrl.toString());
+        }
+        // We may navigate to a page that requires a different Webpack runtime.
+        // In prod, every page will have the same Webpack runtime.
+        // In dev, the Webpack runtime is minimal for each page.
+        // We need to ensure the Webpack runtime is updated before executing client-side JS of the new page.
+        // TODO: This needs to happen in the Flight Client.
+        // Or Webpack needs to include the runtime update in the Flight response as
+        // a blocking script.
+        if (process.env.NODE_ENV !== 'production' && !process.env.TURBOPACK) {
+            await require('../../dev/hot-reloader/app/hot-reloader-app').waitForWebpackRuntimeHotUpdate();
+        }
+        let flightResponsePromise = res.flightResponse;
+        if (flightResponsePromise === null) {
+            // Typically, `createFetch` would have already started decoding the
+            // Flight response. If it hasn't, though, we need to decode it now.
+            // TODO: This should only be reachable if legacy PPR is enabled (i.e. PPR
+            // without Cache Components). Remove this branch once legacy PPR
+            // is deleted.
+            const flightStream = postponed ? createUnclosingPrefetchStream(res.body) : res.body;
+            flightResponsePromise = createFromNextReadableStream(flightStream, headers);
+        }
+        const flightResponse = await flightResponsePromise;
+        if ((0, _appbuildid.getAppBuildId)() !== flightResponse.b) {
+            return doMpaNavigation(res.url);
+        }
+        const normalizedFlightData = (0, _flightdatahelpers.normalizeFlightData)(flightResponse.f);
+        if (typeof normalizedFlightData === 'string') {
+            return doMpaNavigation(normalizedFlightData);
+        }
+        return {
+            flightData: normalizedFlightData,
+            canonicalUrl: canonicalUrl,
+            renderedSearch: (0, _routeparams.getRenderedSearch)(res),
+            couldBeIntercepted: interception,
+            prerendered: flightResponse.S,
+            postponed,
+            staleTime,
+            debugInfo: flightResponsePromise._debugInfo ?? null
+        };
+    } catch (err) {
+        if (!isPageUnloading) {
+            console.error(`Failed to fetch RSC payload for ${originalUrl}. Falling back to browser navigation.`, err);
+        }
+        // If fetch fails handle it like a mpa navigation
+        // TODO-APP: Add a test for the case where a CORS request fails, e.g. external url redirect coming from the response.
+        // See https://github.com/vercel/next.js/issues/43605#issuecomment-1451617521 for a reproduction.
+        return originalUrl.toString();
+    }
+}
+async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode, signal) {
+    // TODO: In output: "export" mode, the headers do nothing. Omit them (and the
+    // cache busting search param) from the request so they're
+    // maximally cacheable.
+    if (process.env.__NEXT_TEST_MODE && fetchPriority !== null) {
+        headers['Next-Test-Fetch-Priority'] = fetchPriority;
+    }
+    if (process.env.NEXT_DEPLOYMENT_ID) {
+        headers['x-deployment-id'] = process.env.NEXT_DEPLOYMENT_ID;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+        if (self.__next_r) {
+            headers[_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER] = self.__next_r;
+        }
+        // Create a new request ID for the server action request. The server uses
+        // this to tag debug information sent via WebSocket to the client, which
+        // then routes those chunks to the debug channel associated with this ID.
+        headers[_approuterheaders.NEXT_REQUEST_ID_HEADER] = crypto.getRandomValues(new Uint32Array(1))[0].toString(16);
+    }
+    const fetchOptions = {
+        // Backwards compat for older browsers. `same-origin` is the default in modern browsers.
+        credentials: 'same-origin',
+        headers,
+        priority: fetchPriority || undefined,
+        signal
+    };
+    // `fetchUrl` is slightly different from `url` because we add a cache-busting
+    // search param to it. This should not leak outside of this function, so we
+    // track them separately.
+    let fetchUrl = new URL(url);
+    (0, _setcachebustingsearchparam.setCacheBustingSearchParam)(fetchUrl, headers);
+    let fetchPromise = fetch(fetchUrl, fetchOptions);
+    // Immediately pass the fetch promise to the Flight client so that the debug
+    // info includes the latency from the client to the server. The internal timer
+    // in React starts as soon as `createFromFetch` is called.
+    //
+    // The only case where we don't do this is during a prefetch, because we have
+    // to do some extra processing of the response stream (see
+    // `createUnclosingPrefetchStream`). But this is fine, because a top-level
+    // prefetch response never blocks a navigation; if it hasn't already been
+    // written into the cache by the time the navigation happens, the router will
+    // go straight to a dynamic request.
+    let flightResponsePromise = shouldImmediatelyDecode ? createFromNextFetch(fetchPromise, headers) : null;
+    let browserResponse = await fetchPromise;
+    // If the server responds with a redirect (e.g. 307), and the redirected
+    // location does not contain the cache busting search param set in the
+    // original request, the response is likely invalid — when following the
+    // redirect, the browser forwards the request headers, but since the cache
+    // busting search param is missing, the server will reject the request due to
+    // a mismatch.
+    //
+    // Ideally, we would be able to intercept the redirect response and perform it
+    // manually, instead of letting the browser automatically follow it, but this
+    // is not allowed by the fetch API.
+    //
+    // So instead, we must "replay" the redirect by fetching the new location
+    // again, but this time we'll append the cache busting search param to prevent
+    // a mismatch.
+    //
+    // TODO: We can optimize Next.js's built-in middleware APIs by returning a
+    // custom status code, to prevent the browser from automatically following it.
+    //
+    // This does not affect Server Action-based redirects; those are encoded
+    // differently, as part of the Flight body. It only affects redirects that
+    // occur in a middleware or a third-party proxy.
+    let redirected = browserResponse.redirected;
+    if (process.env.__NEXT_CLIENT_VALIDATE_RSC_REQUEST_HEADERS) {
+        // This is to prevent a redirect loop. Same limit used by Chrome.
+        const MAX_REDIRECTS = 20;
+        for(let n = 0; n < MAX_REDIRECTS; n++){
+            if (!browserResponse.redirected) {
+                break;
+            }
+            const responseUrl = new URL(browserResponse.url, fetchUrl);
+            if (responseUrl.origin !== fetchUrl.origin) {
+                break;
+            }
+            if (responseUrl.searchParams.get(_approuterheaders.NEXT_RSC_UNION_QUERY) === fetchUrl.searchParams.get(_approuterheaders.NEXT_RSC_UNION_QUERY)) {
+                break;
+            }
+            // The RSC request was redirected. Assume the response is invalid.
+            //
+            // Append the cache busting search param to the redirected URL and
+            // fetch again.
+            // TODO: We should abort the previous request.
+            fetchUrl = new URL(responseUrl);
+            (0, _setcachebustingsearchparam.setCacheBustingSearchParam)(fetchUrl, headers);
+            fetchPromise = fetch(fetchUrl, fetchOptions);
+            flightResponsePromise = shouldImmediatelyDecode ? createFromNextFetch(fetchPromise, headers) : null;
+            browserResponse = await fetchPromise;
+            // We just performed a manual redirect, so this is now true.
+            redirected = true;
+        }
+    }
+    // Remove the cache busting search param from the response URL, to prevent it
+    // from leaking outside of this function.
+    const responseUrl = new URL(browserResponse.url, fetchUrl);
+    responseUrl.searchParams.delete(_approuterheaders.NEXT_RSC_UNION_QUERY);
+    const rscResponse = {
+        url: responseUrl.href,
+        // This is true if any redirects occurred, either automatically by the
+        // browser, or manually by us. So it's different from
+        // `browserResponse.redirected`, which only tells us whether the browser
+        // followed a redirect, and only for the last response in the chain.
+        redirected,
+        // These can be copied from the last browser response we received. We
+        // intentionally only expose the subset of fields that are actually used
+        // elsewhere in the codebase.
+        ok: browserResponse.ok,
+        headers: browserResponse.headers,
+        body: browserResponse.body,
+        status: browserResponse.status,
+        // This is the exact promise returned by `createFromFetch`. It contains
+        // debug information that we need to transfer to any derived promises that
+        // are later rendered by React.
+        flightResponse: flightResponsePromise
+    };
+    return rscResponse;
+}
+function createFromNextReadableStream(flightStream, requestHeaders) {
+    return createFromReadableStream(flightStream, {
+        callServer: _appcallserver.callServer,
+        findSourceMapURL: _appfindsourcemapurl.findSourceMapURL,
+        debugChannel: createDebugChannel && createDebugChannel(requestHeaders)
+    });
+}
+function createFromNextFetch(promiseForResponse, requestHeaders) {
+    return createFromFetch(promiseForResponse, {
+        callServer: _appcallserver.callServer,
+        findSourceMapURL: _appfindsourcemapurl.findSourceMapURL,
+        debugChannel: createDebugChannel && createDebugChannel(requestHeaders)
+    });
+}
+function createUnclosingPrefetchStream(originalFlightStream) {
+    // When PPR is enabled, prefetch streams may contain references that never
+    // resolve, because that's how we encode dynamic data access. In the decoded
+    // object returned by the Flight client, these are reified into hanging
+    // promises that suspend during render, which is effectively what we want.
+    // The UI resolves when it switches to the dynamic data stream
+    // (via useDeferredValue(dynamic, static)).
+    //
+    // However, the Flight implementation currently errors if the server closes
+    // the response before all the references are resolved. As a cheat to work
+    // around this, we wrap the original stream in a new stream that never closes,
+    // and therefore doesn't error.
+    const reader = originalFlightStream.getReader();
+    return new ReadableStream({
+        async pull (controller) {
+            while(true){
+                const { done, value } = await reader.read();
+                if (!done) {
+                    // Pass to the target stream and keep consuming the Flight response
+                    // from the server.
+                    controller.enqueue(value);
+                    continue;
+                }
+                // The server stream has closed. Exit, but intentionally do not close
+                // the target stream.
+                return;
+            }
+        }
+    });
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=fetch-server-response.js.map

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/fill-cache-with-new-subtree-data.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    fillCacheWithNewSubTreeData: null,
+    fillCacheWithNewSubTreeDataButOnlyLoading: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    fillCacheWithNewSubTreeData: function() {
+        return fillCacheWithNewSubTreeData;
+    },
+    fillCacheWithNewSubTreeDataButOnlyLoading: function() {
+        return fillCacheWithNewSubTreeDataButOnlyLoading;
+    }
+});
+const _invalidatecachebyrouterstate = require("./invalidate-cache-by-router-state");
+const _filllazyitemstillleafwithhead = require("./fill-lazy-items-till-leaf-with-head");
+const _createroutercachekey = require("./create-router-cache-key");
+const _segment = require("../../../shared/lib/segment");
+/**
+ * Common logic for filling cache with new sub tree data.
+ */ function fillCacheHelper(navigatedAt, newCache, existingCache, flightData, fillLazyItems) {
+    const { segmentPath, seedData: cacheNodeSeedData, tree: treePatch, head } = flightData;
+    let newCacheNode = newCache;
+    let existingCacheNode = existingCache;
+    for(let i = 0; i < segmentPath.length; i += 2){
+        const parallelRouteKey = segmentPath[i];
+        const segment = segmentPath[i + 1];
+        // segmentPath is a repeating tuple of parallelRouteKey and segment
+        // we know we've hit the last entry we've reached our final pair
+        const isLastEntry = i === segmentPath.length - 2;
+        const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segment);
+        const existingChildSegmentMap = existingCacheNode.parallelRoutes.get(parallelRouteKey);
+        if (!existingChildSegmentMap) {
+            continue;
+        }
+        let childSegmentMap = newCacheNode.parallelRoutes.get(parallelRouteKey);
+        if (!childSegmentMap || childSegmentMap === existingChildSegmentMap) {
+            childSegmentMap = new Map(existingChildSegmentMap);
+            newCacheNode.parallelRoutes.set(parallelRouteKey, childSegmentMap);
+        }
+        const existingChildCacheNode = existingChildSegmentMap.get(cacheKey);
+        let childCacheNode = childSegmentMap.get(cacheKey);
+        if (isLastEntry) {
+            if (cacheNodeSeedData && (!childCacheNode || !childCacheNode.lazyData || childCacheNode === existingChildCacheNode)) {
+                const rsc = cacheNodeSeedData[0];
+                const loading = cacheNodeSeedData[2];
+                childCacheNode = {
+                    lazyData: null,
+                    // When `fillLazyItems` is false, we only want to fill the RSC data for the layout,
+                    // not the page segment.
+                    rsc: fillLazyItems || segment !== _segment.PAGE_SEGMENT_KEY ? rsc : null,
+                    prefetchRsc: null,
+                    head: null,
+                    prefetchHead: null,
+                    loading,
+                    parallelRoutes: fillLazyItems && existingChildCacheNode ? new Map(existingChildCacheNode.parallelRoutes) : new Map(),
+                    navigatedAt
+                };
+                if (existingChildCacheNode && fillLazyItems) {
+                    (0, _invalidatecachebyrouterstate.invalidateCacheByRouterState)(childCacheNode, existingChildCacheNode, treePatch);
+                }
+                if (fillLazyItems) {
+                    (0, _filllazyitemstillleafwithhead.fillLazyItemsTillLeafWithHead)(navigatedAt, childCacheNode, existingChildCacheNode, treePatch, cacheNodeSeedData, head);
+                }
+                childSegmentMap.set(cacheKey, childCacheNode);
+            }
+            continue;
+        }
+        if (!childCacheNode || !existingChildCacheNode) {
+            continue;
+        }
+        if (childCacheNode === existingChildCacheNode) {
+            childCacheNode = {
+                lazyData: childCacheNode.lazyData,
+                rsc: childCacheNode.rsc,
+                prefetchRsc: childCacheNode.prefetchRsc,
+                head: childCacheNode.head,
+                prefetchHead: childCacheNode.prefetchHead,
+                parallelRoutes: new Map(childCacheNode.parallelRoutes),
+                loading: childCacheNode.loading
+            };
+            childSegmentMap.set(cacheKey, childCacheNode);
+        }
+        // Move deeper into the cache nodes
+        newCacheNode = childCacheNode;
+        existingCacheNode = existingChildCacheNode;
+    }
+}
+function fillCacheWithNewSubTreeData(navigatedAt, newCache, existingCache, flightData) {
+    fillCacheHelper(navigatedAt, newCache, existingCache, flightData, true);
+}
+function fillCacheWithNewSubTreeDataButOnlyLoading(navigatedAt, newCache, existingCache, flightData) {
+    fillCacheHelper(navigatedAt, newCache, existingCache, flightData, false);
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=fill-cache-with-new-subtree-data.js.map

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/fill-lazy-items-till-leaf-with-head.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "fillLazyItemsTillLeafWithHead", {
+    enumerable: true,
+    get: function() {
+        return fillLazyItemsTillLeafWithHead;
+    }
+});
+const _createroutercachekey = require("./create-router-cache-key");
+function fillLazyItemsTillLeafWithHead(navigatedAt, newCache, existingCache, routerState, cacheNodeSeedData, head) {
+    const isLastSegment = Object.keys(routerState[1]).length === 0;
+    if (isLastSegment) {
+        newCache.head = head;
+        return;
+    }
+    // Remove segment that we got data for so that it is filled in during rendering of rsc.
+    for(const key in routerState[1]){
+        const parallelRouteState = routerState[1][key];
+        const segmentForParallelRoute = parallelRouteState[0];
+        const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segmentForParallelRoute);
+        // TODO: We should traverse the cacheNodeSeedData tree instead of the router
+        // state tree. Ideally, they would always be the same shape, but because of
+        // the loading.js pattern, cacheNodeSeedData sometimes only represents a
+        // partial tree. That's why this node is sometimes null. Once PPR lands,
+        // loading.js will no longer have special behavior and we can traverse the
+        // data tree instead.
+        //
+        // We should also consider merging the router state tree and the data tree
+        // in the response format, so that we don't have to send the keys twice.
+        // Then the client can convert them into separate representations.
+        const parallelSeedData = cacheNodeSeedData !== null && cacheNodeSeedData[1][key] !== undefined ? cacheNodeSeedData[1][key] : null;
+        if (existingCache) {
+            const existingParallelRoutesCacheNode = existingCache.parallelRoutes.get(key);
+            if (existingParallelRoutesCacheNode) {
+                let parallelRouteCacheNode = new Map(existingParallelRoutesCacheNode);
+                const existingCacheNode = parallelRouteCacheNode.get(cacheKey);
+                let newCacheNode;
+                if (parallelSeedData !== null) {
+                    // New data was sent from the server.
+                    const seedNode = parallelSeedData[0];
+                    const loading = parallelSeedData[2];
+                    newCacheNode = {
+                        lazyData: null,
+                        rsc: seedNode,
+                        // This is a PPR-only field. When PPR is enabled, we shouldn't hit
+                        // this path during a navigation, but until PPR is fully implemented
+                        // yet it's possible the existing node does have a non-null
+                        // `prefetchRsc`. As an incremental step, we'll just de-opt to the
+                        // old behavior — no PPR value.
+                        prefetchRsc: null,
+                        head: null,
+                        prefetchHead: null,
+                        loading,
+                        parallelRoutes: new Map(existingCacheNode?.parallelRoutes),
+                        navigatedAt
+                    };
+                } else {
+                    // No data available for this node. This will trigger a lazy fetch
+                    // during render.
+                    newCacheNode = {
+                        lazyData: null,
+                        rsc: null,
+                        prefetchRsc: null,
+                        head: null,
+                        prefetchHead: null,
+                        parallelRoutes: new Map(existingCacheNode?.parallelRoutes),
+                        loading: null,
+                        navigatedAt
+                    };
+                }
+                // Overrides the cache key with the new cache node.
+                parallelRouteCacheNode.set(cacheKey, newCacheNode);
+                // Traverse deeper to apply the head / fill lazy items till the head.
+                fillLazyItemsTillLeafWithHead(navigatedAt, newCacheNode, existingCacheNode, parallelRouteState, parallelSeedData ? parallelSeedData : null, head);
+                newCache.parallelRoutes.set(key, parallelRouteCacheNode);
+                continue;
+            }
+        }
+        let newCacheNode;
+        if (parallelSeedData !== null) {
+            // New data was sent from the server.
+            const seedNode = parallelSeedData[0];
+            const loading = parallelSeedData[2];
+            newCacheNode = {
+                lazyData: null,
+                rsc: seedNode,
+                prefetchRsc: null,
+                head: null,
+                prefetchHead: null,
+                parallelRoutes: new Map(),
+                loading,
+                navigatedAt
+            };
+        } else {
+            // No data available for this node. This will trigger a lazy fetch
+            // during render.
+            newCacheNode = {
+                lazyData: null,
+                rsc: null,
+                prefetchRsc: null,
+                head: null,
+                prefetchHead: null,
+                parallelRoutes: new Map(),
+                loading: null,
+                navigatedAt
+            };
+        }
+        const existingParallelRoutes = newCache.parallelRoutes.get(key);
+        if (existingParallelRoutes) {
+            existingParallelRoutes.set(cacheKey, newCacheNode);
+        } else {
+            newCache.parallelRoutes.set(key, new Map([
+                [
+                    cacheKey,
+                    newCacheNode
+                ]
+            ]));
+        }
+        fillLazyItemsTillLeafWithHead(navigatedAt, newCacheNode, undefined, parallelRouteState, parallelSeedData, head);
+    }
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=fill-lazy-items-till-leaf-with-head.js.map

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/handle-mutable.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "handleMutable", {
+    enumerable: true,
+    get: function() {
+        return handleMutable;
+    }
+});
+const _computechangedpath = require("./compute-changed-path");
+function isNotUndefined(value) {
+    return typeof value !== 'undefined';
+}
+function handleMutable(state, mutable) {
+    // shouldScroll is true by default, can override to false.
+    const shouldScroll = mutable.shouldScroll ?? true;
+    let previousNextUrl = state.previousNextUrl;
+    let nextUrl = state.nextUrl;
+    if (isNotUndefined(mutable.patchedTree)) {
+        // If we received a patched tree, we need to compute the changed path.
+        const changedPath = (0, _computechangedpath.computeChangedPath)(state.tree, mutable.patchedTree);
+        if (changedPath) {
+            // If the tree changed, we need to update the nextUrl
+            previousNextUrl = nextUrl;
+            nextUrl = changedPath;
+        } else if (!nextUrl) {
+            // if the tree ends up being the same (ie, no changed path), and we don't have a nextUrl, then we should use the canonicalUrl
+            nextUrl = state.canonicalUrl;
+        }
+    // otherwise this will be a no-op and continue to use the existing nextUrl
+    }
+    return {
+        // Set href.
+        canonicalUrl: mutable.canonicalUrl ?? state.canonicalUrl,
+        renderedSearch: mutable.renderedSearch ?? state.renderedSearch,
+        pushRef: {
+            pendingPush: isNotUndefined(mutable.pendingPush) ? mutable.pendingPush : state.pushRef.pendingPush,
+            mpaNavigation: isNotUndefined(mutable.mpaNavigation) ? mutable.mpaNavigation : state.pushRef.mpaNavigation,
+            preserveCustomHistoryState: isNotUndefined(mutable.preserveCustomHistoryState) ? mutable.preserveCustomHistoryState : state.pushRef.preserveCustomHistoryState
+        },
+        // All navigation requires scroll and focus management to trigger.
+        focusAndScrollRef: {
+            apply: shouldScroll ? isNotUndefined(mutable?.scrollableSegments) ? true : state.focusAndScrollRef.apply : false,
+            onlyHashChange: mutable.onlyHashChange || false,
+            hashFragment: shouldScroll ? // #top is handled in layout-router.
+            mutable.hashFragment && mutable.hashFragment !== '' ? decodeURIComponent(mutable.hashFragment.slice(1)) : state.focusAndScrollRef.hashFragment : null,
+            segmentPaths: shouldScroll ? mutable?.scrollableSegments ?? state.focusAndScrollRef.segmentPaths : []
+        },
+        // Apply cache.
+        cache: mutable.cache ? mutable.cache : state.cache,
+        // Apply patched router state.
+        tree: isNotUndefined(mutable.patchedTree) ? mutable.patchedTree : state.tree,
+        nextUrl,
+        previousNextUrl: previousNextUrl,
+        debugInfo: mutable.collectedDebugInfo ?? null
+    };
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=handle-mutable.js.map