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/reducers/server-action-reducer.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "serverActionReducer", {
+    enumerable: true,
+    get: function() {
+        return serverActionReducer;
+    }
+});
+const _appcallserver = require("../../../app-call-server");
+const _appfindsourcemapurl = require("../../../app-find-source-map-url");
+const _approuterheaders = require("../../app-router-headers");
+const _unrecognizedactionerror = require("../../unrecognized-action-error");
+const _client = require("react-server-dom-webpack/client");
+const _assignlocation = require("../../../assign-location");
+const _createhreffromurl = require("../create-href-from-url");
+const _navigatereducer = require("./navigate-reducer");
+const _applyrouterstatepatchtotree = require("../apply-router-state-patch-to-tree");
+const _isnavigatingtonewrootlayout = require("../is-navigating-to-new-root-layout");
+const _handlemutable = require("../handle-mutable");
+const _filllazyitemstillleafwithhead = require("../fill-lazy-items-till-leaf-with-head");
+const _approuter = require("../../app-router");
+const _hasinterceptionrouteincurrenttree = require("./has-interception-route-in-current-tree");
+const _handlesegmentmismatch = require("../handle-segment-mismatch");
+const _refetchinactiveparallelsegments = require("../refetch-inactive-parallel-segments");
+const _flightdatahelpers = require("../../../flight-data-helpers");
+const _redirect = require("../../redirect");
+const _redirecterror = require("../../redirect-error");
+const _removebasepath = require("../../../remove-base-path");
+const _hasbasepath = require("../../../has-base-path");
+const _serverreferenceinfo = require("../../../../shared/lib/server-reference-info");
+const _cache = require("../../segment-cache/cache");
+const createFromFetch = _client.createFromFetch;
+let createDebugChannel;
+if (process.env.NODE_ENV !== 'production' && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
+    createDebugChannel = require('../../../dev/debug-channel').createDebugChannel;
+}
+async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
+    const temporaryReferences = (0, _client.createTemporaryReferenceSet)();
+    const info = (0, _serverreferenceinfo.extractInfoFromServerReferenceId)(actionId);
+    // TODO: Currently, we're only omitting unused args for the experimental "use
+    // cache" functions. Once the server reference info byte feature is stable, we
+    // should apply this to server actions as well.
+    const usedArgs = info.type === 'use-cache' ? (0, _serverreferenceinfo.omitUnusedArgs)(actionArgs, info) : actionArgs;
+    const body = await (0, _client.encodeReply)(usedArgs, {
+        temporaryReferences
+    });
+    const headers = {
+        Accept: _approuterheaders.RSC_CONTENT_TYPE_HEADER,
+        [_approuterheaders.ACTION_HEADER]: actionId,
+        [_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER]: (0, _flightdatahelpers.prepareFlightRouterStateForRequest)(state.tree)
+    };
+    if (process.env.NEXT_DEPLOYMENT_ID) {
+        headers['x-deployment-id'] = process.env.NEXT_DEPLOYMENT_ID;
+    }
+    if (nextUrl) {
+        headers[_approuterheaders.NEXT_URL] = nextUrl;
+    }
+    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 res = await fetch(state.canonicalUrl, {
+        method: 'POST',
+        headers,
+        body
+    });
+    // Handle server actions that the server didn't recognize.
+    const unrecognizedActionHeader = res.headers.get(_approuterheaders.NEXT_ACTION_NOT_FOUND_HEADER);
+    if (unrecognizedActionHeader === '1') {
+        throw Object.defineProperty(new _unrecognizedactionerror.UnrecognizedActionError(`Server Action "${actionId}" was not found on the server. \nRead more: https://nextjs.org/docs/messages/failed-to-find-server-action`), "__NEXT_ERROR_CODE", {
+            value: "E715",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const redirectHeader = res.headers.get('x-action-redirect');
+    const [location, _redirectType] = redirectHeader?.split(';') || [];
+    let redirectType;
+    switch(_redirectType){
+        case 'push':
+            redirectType = _redirecterror.RedirectType.push;
+            break;
+        case 'replace':
+            redirectType = _redirecterror.RedirectType.replace;
+            break;
+        default:
+            redirectType = undefined;
+    }
+    const isPrerender = !!res.headers.get(_approuterheaders.NEXT_IS_PRERENDER_HEADER);
+    let revalidatedParts;
+    try {
+        const revalidatedHeader = JSON.parse(res.headers.get('x-action-revalidated') || '[[],0,0]');
+        revalidatedParts = {
+            paths: revalidatedHeader[0] || [],
+            tag: !!revalidatedHeader[1],
+            cookie: revalidatedHeader[2]
+        };
+    } catch (e) {
+        revalidatedParts = NO_REVALIDATED_PARTS;
+    }
+    const redirectLocation = location ? (0, _assignlocation.assignLocation)(location, new URL(state.canonicalUrl, window.location.href)) : undefined;
+    const contentType = res.headers.get('content-type');
+    const isRscResponse = !!(contentType && contentType.startsWith(_approuterheaders.RSC_CONTENT_TYPE_HEADER));
+    // Handle invalid server action responses.
+    // A valid response must have `content-type: text/x-component`, unless it's an external redirect.
+    // (external redirects have an 'x-action-redirect' header, but the body is an empty 'text/plain')
+    if (!isRscResponse && !redirectLocation) {
+        // The server can respond with a text/plain error message, but we'll fallback to something generic
+        // if there isn't one.
+        const message = res.status >= 400 && contentType === 'text/plain' ? await res.text() : 'An unexpected response was received from the server.';
+        throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    let actionResult;
+    let actionFlightData;
+    if (isRscResponse) {
+        const response = await createFromFetch(Promise.resolve(res), {
+            callServer: _appcallserver.callServer,
+            findSourceMapURL: _appfindsourcemapurl.findSourceMapURL,
+            temporaryReferences,
+            debugChannel: createDebugChannel && createDebugChannel(headers)
+        });
+        // An internal redirect can send an RSC response, but does not have a useful `actionResult`.
+        actionResult = redirectLocation ? undefined : response.a;
+        actionFlightData = (0, _flightdatahelpers.normalizeFlightData)(response.f);
+    } else {
+        // An external redirect doesn't contain RSC data.
+        actionResult = undefined;
+        actionFlightData = undefined;
+    }
+    return {
+        actionResult,
+        actionFlightData,
+        redirectLocation,
+        redirectType,
+        revalidatedParts,
+        isPrerender
+    };
+}
+const NO_REVALIDATED_PARTS = {
+    paths: [],
+    tag: false,
+    cookie: false
+};
+function serverActionReducer(state, action) {
+    const { resolve, reject } = action;
+    const mutable = {};
+    let currentTree = state.tree;
+    mutable.preserveCustomHistoryState = false;
+    // only pass along the `nextUrl` param (used for interception routes) if the current route was intercepted.
+    // If the route has been intercepted, the action should be as well.
+    // Otherwise the server action might be intercepted with the wrong action id
+    // (ie, one that corresponds with the intercepted route)
+    const nextUrl = // We always send the last next-url, not the current when
+    // performing a dynamic request. This is because we update
+    // the next-url after a navigation, but we want the same
+    // interception route to be matched that used the last
+    // next-url.
+    (state.previousNextUrl || state.nextUrl) && (0, _hasinterceptionrouteincurrenttree.hasInterceptionRouteInCurrentTree)(state.tree) ? state.previousNextUrl || state.nextUrl : null;
+    const navigatedAt = Date.now();
+    return fetchServerAction(state, nextUrl, action).then(async ({ actionResult, actionFlightData: flightData, redirectLocation, redirectType, revalidatedParts })=>{
+        let redirectHref;
+        // honor the redirect type instead of defaulting to push in case of server actions.
+        if (redirectLocation) {
+            if (redirectType === _redirecterror.RedirectType.replace) {
+                state.pushRef.pendingPush = false;
+                mutable.pendingPush = false;
+            } else {
+                state.pushRef.pendingPush = true;
+                mutable.pendingPush = true;
+            }
+            redirectHref = (0, _createhreffromurl.createHrefFromUrl)(redirectLocation, false);
+            mutable.canonicalUrl = redirectHref;
+        }
+        if (!flightData) {
+            resolve(actionResult);
+            // If there is a redirect but no flight data we need to do a mpaNavigation.
+            if (redirectLocation) {
+                return (0, _navigatereducer.handleExternalUrl)(state, mutable, redirectLocation.href, state.pushRef.pendingPush);
+            }
+            return state;
+        }
+        if (typeof flightData === 'string') {
+            // Handle case when navigating to page in `pages` from `app`
+            resolve(actionResult);
+            return (0, _navigatereducer.handleExternalUrl)(state, mutable, flightData, state.pushRef.pendingPush);
+        }
+        const actionRevalidated = revalidatedParts.paths.length > 0 || revalidatedParts.tag || revalidatedParts.cookie;
+        // Store whether this action triggered any revalidation
+        // The action queue will use this information to potentially
+        // trigger a refresh action if the action was discarded
+        // (ie, due to a navigation, before the action completed)
+        if (actionRevalidated) {
+            action.didRevalidate = true;
+        }
+        for (const normalizedFlightData of flightData){
+            const { tree: treePatch, seedData: cacheNodeSeedData, head, isRootRender } = normalizedFlightData;
+            if (!isRootRender) {
+                // TODO-APP: handle this case better
+                console.log('SERVER ACTION APPLY FAILED');
+                resolve(actionResult);
+                return state;
+            }
+            // Given the path can only have two items the items are only the router state and rsc for the root.
+            const newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTree)(// TODO-APP: remove ''
+            [
+                ''
+            ], currentTree, treePatch, redirectHref ? redirectHref : state.canonicalUrl);
+            if (newTree === null) {
+                resolve(actionResult);
+                return (0, _handlesegmentmismatch.handleSegmentMismatch)(state, action, treePatch);
+            }
+            if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
+                resolve(actionResult);
+                return (0, _navigatereducer.handleExternalUrl)(state, mutable, redirectHref || state.canonicalUrl, state.pushRef.pendingPush);
+            }
+            // The server sent back RSC data for the server action, so we need to apply it to the cache.
+            if (cacheNodeSeedData !== null) {
+                const rsc = cacheNodeSeedData[0];
+                const cache = (0, _approuter.createEmptyCacheNode)();
+                cache.rsc = rsc;
+                cache.prefetchRsc = null;
+                cache.loading = cacheNodeSeedData[2];
+                (0, _filllazyitemstillleafwithhead.fillLazyItemsTillLeafWithHead)(navigatedAt, cache, // Existing cache is not passed in as server actions have to invalidate the entire cache.
+                undefined, treePatch, cacheNodeSeedData, head);
+                mutable.cache = cache;
+                (0, _cache.revalidateEntireCache)(state.nextUrl, newTree);
+                if (actionRevalidated) {
+                    await (0, _refetchinactiveparallelsegments.refreshInactiveParallelSegments)({
+                        navigatedAt,
+                        state,
+                        updatedTree: newTree,
+                        updatedCache: cache,
+                        includeNextUrl: Boolean(nextUrl),
+                        canonicalUrl: mutable.canonicalUrl || state.canonicalUrl
+                    });
+                }
+            }
+            mutable.patchedTree = newTree;
+            currentTree = newTree;
+        }
+        if (redirectLocation && redirectHref) {
+            // If the action triggered a redirect, the action promise will be rejected with
+            // a redirect so that it's handled by RedirectBoundary as we won't have a valid
+            // action result to resolve the promise with. This will effectively reset the state of
+            // the component that called the action as the error boundary will remount the tree.
+            // The status code doesn't matter here as the action handler will have already sent
+            // a response with the correct status code.
+            const redirectError = (0, _redirect.getRedirectError)((0, _hasbasepath.hasBasePath)(redirectHref) ? (0, _removebasepath.removeBasePath)(redirectHref) : redirectHref, redirectType || _redirecterror.RedirectType.push);
+            redirectError.handled = true;
+            reject(redirectError);
+        } else {
+            resolve(actionResult);
+        }
+        return (0, _handlemutable.handleMutable)(state, mutable);
+    }, (e)=>{
+        // When the server action is rejected we don't update the state and instead call the reject handler of the promise.
+        reject(e);
+        return state;
+    });
+}
+
+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=server-action-reducer.js.map

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/reducers/server-patch-reducer.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "serverPatchReducer", {
+    enumerable: true,
+    get: function() {
+        return serverPatchReducer;
+    }
+});
+const _createhreffromurl = require("../create-href-from-url");
+const _applyrouterstatepatchtotree = require("../apply-router-state-patch-to-tree");
+const _isnavigatingtonewrootlayout = require("../is-navigating-to-new-root-layout");
+const _navigatereducer = require("./navigate-reducer");
+const _applyflightdata = require("../apply-flight-data");
+const _handlemutable = require("../handle-mutable");
+const _approuter = require("../../app-router");
+function serverPatchReducer(state, action) {
+    const { serverResponse, navigatedAt } = action;
+    const mutable = {};
+    mutable.preserveCustomHistoryState = false;
+    // Handle case when navigating to page in `pages` from `app`
+    if (typeof serverResponse === 'string') {
+        return (0, _navigatereducer.handleExternalUrl)(state, mutable, serverResponse, state.pushRef.pendingPush);
+    }
+    const { flightData, canonicalUrl, renderedSearch } = serverResponse;
+    let currentTree = state.tree;
+    let currentCache = state.cache;
+    for (const normalizedFlightData of flightData){
+        const { segmentPath: flightSegmentPath, tree: treePatch } = normalizedFlightData;
+        const newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTree)(// TODO-APP: remove ''
+        [
+            '',
+            ...flightSegmentPath
+        ], currentTree, treePatch, state.canonicalUrl);
+        // `applyRouterStatePatchToTree` returns `null` when it determined that the server response is not applicable to the current tree.
+        // In other words, the server responded with a tree that doesn't match what the client is currently rendering.
+        // This can happen if the server patch action took longer to resolve than a subsequent navigation which would have changed the tree.
+        // Previously this case triggered an MPA navigation but it should be safe to simply discard the server response rather than forcing
+        // the entire page to reload.
+        if (newTree === null) {
+            return state;
+        }
+        if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
+            return (0, _navigatereducer.handleExternalUrl)(state, mutable, state.canonicalUrl, state.pushRef.pendingPush);
+        }
+        mutable.canonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl);
+        const cache = (0, _approuter.createEmptyCacheNode)();
+        (0, _applyflightdata.applyFlightData)(navigatedAt, currentCache, cache, normalizedFlightData);
+        mutable.patchedTree = newTree;
+        mutable.renderedSearch = renderedSearch;
+        mutable.cache = cache;
+        currentCache = cache;
+        currentTree = newTree;
+    }
+    return (0, _handlemutable.handleMutable)(state, mutable);
+}
+
+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=server-patch-reducer.js.map

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/refetch-inactive-parallel-segments.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    addRefreshMarkerToActiveParallelSegments: null,
+    refreshInactiveParallelSegments: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    addRefreshMarkerToActiveParallelSegments: function() {
+        return addRefreshMarkerToActiveParallelSegments;
+    },
+    refreshInactiveParallelSegments: function() {
+        return refreshInactiveParallelSegments;
+    }
+});
+const _applyflightdata = require("./apply-flight-data");
+const _fetchserverresponse = require("./fetch-server-response");
+const _segment = require("../../../shared/lib/segment");
+async function refreshInactiveParallelSegments(options) {
+    const fetchedSegments = new Set();
+    await refreshInactiveParallelSegmentsImpl({
+        ...options,
+        rootTree: options.updatedTree,
+        fetchedSegments
+    });
+}
+async function refreshInactiveParallelSegmentsImpl({ navigatedAt, state, updatedTree, updatedCache, includeNextUrl, fetchedSegments, rootTree = updatedTree, canonicalUrl }) {
+    const [, parallelRoutes, refetchPath, refetchMarker] = updatedTree;
+    const fetchPromises = [];
+    if (refetchPath && refetchPath !== canonicalUrl && refetchMarker === 'refresh' && // it's possible for the tree to contain multiple segments that contain data at the same URL
+    // we keep track of them so we can dedupe the requests
+    !fetchedSegments.has(refetchPath)) {
+        fetchedSegments.add(refetchPath) // Mark this URL as fetched
+        ;
+        // Eagerly kick off the fetch for the refetch path & the parallel routes. This should be fine to do as they each operate
+        // independently on their own cache nodes, and `applyFlightData` will copy anything it doesn't care about from the existing cache.
+        const fetchPromise = (0, _fetchserverresponse.fetchServerResponse)(new URL(refetchPath, location.origin), {
+            // refetch from the root of the updated tree, otherwise it will be scoped to the current segment
+            // and might not contain the data we need to patch in interception route data (such as dynamic params from a previous segment)
+            flightRouterState: [
+                rootTree[0],
+                rootTree[1],
+                rootTree[2],
+                'refetch'
+            ],
+            nextUrl: includeNextUrl ? state.nextUrl : null
+        }).then((result)=>{
+            if (typeof result !== 'string') {
+                const { flightData } = result;
+                for (const flightDataPath of flightData){
+                    // we only pass the new cache as this function is called after clearing the router cache
+                    // and filling in the new page data from the server. Meaning the existing cache is actually the cache that's
+                    // just been created & has been written to, but hasn't been "committed" yet.
+                    (0, _applyflightdata.applyFlightData)(navigatedAt, updatedCache, updatedCache, flightDataPath);
+                }
+            } else {
+            // When result is a string, it suggests that the server response should have triggered an MPA navigation
+            // I'm not 100% sure of this decision, but it seems unlikely that we'd want to introduce a redirect side effect
+            // when refreshing on-screen data, so handling this has been ommitted.
+            }
+        });
+        fetchPromises.push(fetchPromise);
+    }
+    for(const key in parallelRoutes){
+        const parallelFetchPromise = refreshInactiveParallelSegmentsImpl({
+            navigatedAt,
+            state,
+            updatedTree: parallelRoutes[key],
+            updatedCache,
+            includeNextUrl,
+            fetchedSegments,
+            rootTree,
+            canonicalUrl
+        });
+        fetchPromises.push(parallelFetchPromise);
+    }
+    await Promise.all(fetchPromises);
+}
+function addRefreshMarkerToActiveParallelSegments(tree, path) {
+    const [segment, parallelRoutes, , refetchMarker] = tree;
+    // a page segment might also contain concatenated search params, so we do a partial match on the key
+    if (segment.includes(_segment.PAGE_SEGMENT_KEY) && refetchMarker !== 'refresh') {
+        tree[2] = path;
+        tree[3] = 'refresh';
+    }
+    for(const key in parallelRoutes){
+        addRefreshMarkerToActiveParallelSegments(parallelRoutes[key], path);
+    }
+}
+
+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=refetch-inactive-parallel-segments.js.map

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ACTION_HMR_REFRESH: null,
+    ACTION_NAVIGATE: null,
+    ACTION_REFRESH: null,
+    ACTION_RESTORE: null,
+    ACTION_SERVER_ACTION: null,
+    ACTION_SERVER_PATCH: null,
+    PrefetchKind: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ACTION_HMR_REFRESH: function() {
+        return ACTION_HMR_REFRESH;
+    },
+    ACTION_NAVIGATE: function() {
+        return ACTION_NAVIGATE;
+    },
+    ACTION_REFRESH: function() {
+        return ACTION_REFRESH;
+    },
+    ACTION_RESTORE: function() {
+        return ACTION_RESTORE;
+    },
+    ACTION_SERVER_ACTION: function() {
+        return ACTION_SERVER_ACTION;
+    },
+    ACTION_SERVER_PATCH: function() {
+        return ACTION_SERVER_PATCH;
+    },
+    PrefetchKind: function() {
+        return PrefetchKind;
+    }
+});
+const ACTION_REFRESH = 'refresh';
+const ACTION_NAVIGATE = 'navigate';
+const ACTION_RESTORE = 'restore';
+const ACTION_SERVER_PATCH = 'server-patch';
+const ACTION_HMR_REFRESH = 'hmr-refresh';
+const ACTION_SERVER_ACTION = 'server-action';
+var PrefetchKind = /*#__PURE__*/ function(PrefetchKind) {
+    PrefetchKind["AUTO"] = "auto";
+    PrefetchKind["FULL"] = "full";
+    PrefetchKind["TEMPORARY"] = "temporary";
+    return PrefetchKind;
+}({});
+
+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=router-reducer-types.js.map

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "reducer", {
+    enumerable: true,
+    get: function() {
+        return reducer;
+    }
+});
+const _routerreducertypes = require("./router-reducer-types");
+const _navigatereducer = require("./reducers/navigate-reducer");
+const _serverpatchreducer = require("./reducers/server-patch-reducer");
+const _restorereducer = require("./reducers/restore-reducer");
+const _refreshreducer = require("./reducers/refresh-reducer");
+const _hmrrefreshreducer = require("./reducers/hmr-refresh-reducer");
+const _serveractionreducer = require("./reducers/server-action-reducer");
+/**
+ * Reducer that handles the app-router state updates.
+ */ function clientReducer(state, action) {
+    switch(action.type){
+        case _routerreducertypes.ACTION_NAVIGATE:
+            {
+                return (0, _navigatereducer.navigateReducer)(state, action);
+            }
+        case _routerreducertypes.ACTION_SERVER_PATCH:
+            {
+                return (0, _serverpatchreducer.serverPatchReducer)(state, action);
+            }
+        case _routerreducertypes.ACTION_RESTORE:
+            {
+                return (0, _restorereducer.restoreReducer)(state, action);
+            }
+        case _routerreducertypes.ACTION_REFRESH:
+            {
+                return (0, _refreshreducer.refreshReducer)(state, action);
+            }
+        case _routerreducertypes.ACTION_HMR_REFRESH:
+            {
+                return (0, _hmrrefreshreducer.hmrRefreshReducer)(state, action);
+            }
+        case _routerreducertypes.ACTION_SERVER_ACTION:
+            {
+                return (0, _serveractionreducer.serverActionReducer)(state, action);
+            }
+        // This case should never be hit as dispatch is strongly typed.
+        default:
+            throw Object.defineProperty(new Error('Unknown action'), "__NEXT_ERROR_CODE", {
+                value: "E295",
+                enumerable: false,
+                configurable: true
+            });
+    }
+}
+function serverReducer(state, _action) {
+    return state;
+}
+const reducer = typeof window === 'undefined' ? serverReducer : clientReducer;
+
+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=router-reducer.js.map

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/set-cache-busting-search-param.js

@@ -0,0 +1,60 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    setCacheBustingSearchParam: null,
+    setCacheBustingSearchParamWithHash: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    setCacheBustingSearchParam: function() {
+        return setCacheBustingSearchParam;
+    },
+    setCacheBustingSearchParamWithHash: function() {
+        return setCacheBustingSearchParamWithHash;
+    }
+});
+const _cachebustingsearchparam = require("../../../shared/lib/router/utils/cache-busting-search-param");
+const _approuterheaders = require("../app-router-headers");
+const setCacheBustingSearchParam = (url, headers)=>{
+    const uniqueCacheKey = (0, _cachebustingsearchparam.computeCacheBustingSearchParam)(headers[_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER], headers[_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER], headers[_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER], headers[_approuterheaders.NEXT_URL]);
+    setCacheBustingSearchParamWithHash(url, uniqueCacheKey);
+};
+const setCacheBustingSearchParamWithHash = (url, hash)=>{
+    /**
+   * Note that we intentionally do not use `url.searchParams.set` here:
+   *
+   * const url = new URL('https://example.com/search?q=custom%20spacing');
+   * url.searchParams.set('_rsc', 'abc123');
+   * console.log(url.toString()); // Outputs: https://example.com/search?q=custom+spacing&_rsc=abc123
+   *                                                                             ^ <--- this is causing confusion
+   * This is in fact intended based on https://url.spec.whatwg.org/#interface-urlsearchparams, but
+   * we want to preserve the %20 as %20 if that's what the user passed in, hence the custom
+   * logic below.
+   */ const existingSearch = url.search;
+    const rawQuery = existingSearch.startsWith('?') ? existingSearch.slice(1) : existingSearch;
+    // Always remove any existing cache busting param and add a fresh one to ensure
+    // we have the correct value based on current request headers
+    const pairs = rawQuery.split('&').filter((pair)=>pair && !pair.startsWith(`${_approuterheaders.NEXT_RSC_UNION_QUERY}=`));
+    if (hash.length > 0) {
+        pairs.push(`${_approuterheaders.NEXT_RSC_UNION_QUERY}=${hash}`);
+    } else {
+        pairs.push(`${_approuterheaders.NEXT_RSC_UNION_QUERY}`);
+    }
+    url.search = pairs.length ? `?${pairs.join('&')}` : '';
+};
+
+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=set-cache-busting-search-param.js.map

qalita/_frontend/node_modules/next/dist/client/components/segment-cache/cache-key.js

@@ -0,0 +1,28 @@
+// TypeScript trick to simulate opaque types, like in Flow.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createCacheKey", {
+    enumerable: true,
+    get: function() {
+        return createCacheKey;
+    }
+});
+function createCacheKey(originalHref, nextUrl) {
+    const originalUrl = new URL(originalHref);
+    const cacheKey = {
+        pathname: originalUrl.pathname,
+        search: originalUrl.search,
+        nextUrl: nextUrl
+    };
+    return cacheKey;
+}
+
+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=cache-key.js.map