qalita 2.5.4__py3-none-any.whl → 2.6.1__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/build/templates/app-page.js

@@ -40,9 +40,8 @@ const _stripflightheaders = require("../../server/app-render/strip-flight-header
 const _node = require("../../server/base-http/node");
 const _ppr = require("../../server/lib/experimental/ppr");
 const _fallbackparams = require("../../server/request/fallback-params");
-const _encryptionutils = require("../../server/app-render/encryption-utils");
+const _manifestssingleton = require("../../server/app-render/manifests-singleton");
 const _streamingmetadata = require("../../server/lib/streaming-metadata");
-const _actionutils = require("../../server/app-render/action-utils");
 const _apppaths = require("../../shared/lib/router/utils/app-paths");
 const _serveractionrequestmeta = require("../../server/lib/server-action-request-meta");
 const _approuterheaders = require("../../client/components/app-router-headers");
@@ -144,6 +143,7 @@ async function handler(req, res, ctx) {
     if (routeModule.isDev) {
         (0, _requestmeta.addRequestMeta)(req, 'devRequestTimingInternalsEnd', process.hrtime.bigint());
     }
+    const isMinimalMode = Boolean(process.env.MINIMAL_MODE || (0, _requestmeta.getRequestMeta)(req, 'minimalMode'));
     let srcPage = 'VAR_DEFINITION_PAGE';
     // turbopack doesn't normalize `/index` in the page name
     // so we need to to process dynamic routes properly
@@ -155,7 +155,6 @@ async function handler(req, res, ctx) {
         srcPage = '/';
     }
     const multiZoneDraftMode = process.env.__NEXT_MULTI_ZONE_DRAFT_MODE;
-    const isMinimalMode = Boolean(process.env.MINIMAL_MODE || (0, _requestmeta.getRequestMeta)(req, 'minimalMode'));
     const prepareResult = await routeModule.prepare(req, res, {
         srcPage,
         multiZoneDraftMode
@@ -166,7 +165,7 @@ async function handler(req, res, ctx) {
         ctx.waitUntil == null ? void 0 : ctx.waitUntil.call(ctx, Promise.resolve());
         return null;
     }
-    const { buildId, query, params, pageIsDynamic, buildManifest, nextFontManifest, reactLoadableManifest, serverActionsManifest, clientReferenceManifest, subresourceIntegrityManifest, prerenderManifest, isDraftMode, resolvedPathname, revalidateOnlyGenerated, routerServerContext, nextConfig, parsedUrl, interceptionRoutePatterns } = prepareResult;
+    const { buildId, query, params, pageIsDynamic, buildManifest, nextFontManifest, reactLoadableManifest, serverActionsManifest, clientReferenceManifest, subresourceIntegrityManifest, prerenderManifest, isDraftMode, resolvedPathname, revalidateOnlyGenerated, routerServerContext, nextConfig, parsedUrl, interceptionRoutePatterns, deploymentId } = prepareResult;
     const normalizedSrcPage = (0, _apppaths.normalizeAppPath)(srcPage);
     let { isOnDemandRevalidate } = prepareResult;
     // We use the resolvedPathname instead of the parsedUrl.pathname because it
@@ -193,6 +192,17 @@ async function handler(req, res, ctx) {
    * If the route being rendered is an app page, and the ppr feature has been
    * enabled, then the given route _could_ support PPR.
    */ const couldSupportPPR = (0, _ppr.checkIsAppPPREnabled)(nextConfig.experimental.ppr);
+    if (!(0, _requestmeta.getRequestMeta)(req, 'postponed') && couldSupportPPR && req.headers[_constants1.NEXT_RESUME_HEADER] === '1' && req.method === 'POST') {
+        // Decode the postponed state from the request body, it will come as
+        // an array of buffers, so collect them and then concat them to form
+        // the string.
+        const body = [];
+        for await (const chunk of req){
+            body.push(chunk);
+        }
+        const postponed = Buffer.concat(body).toString('utf8');
+        (0, _requestmeta.addRequestMeta)(req, 'postponed', postponed);
+    }
     // When enabled, this will allow the use of the `?__nextppronly` query to
     // enable debugging of the static shell.
     const hasDebugStaticShellQuery = process.env.__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING === '1' && typeof query.__nextppronly !== 'undefined' && couldSupportPPR;
@@ -286,13 +296,10 @@ async function handler(req, res, ctx) {
     // set the reference manifests to our global store so Server Action's
     // encryption util can access to them at the top level of the page module.
     if (serverActionsManifest && clientReferenceManifest) {
-        (0, _encryptionutils.setReferenceManifestsSingleton)({
+        (0, _manifestssingleton.setManifestsSingleton)({
             page: srcPage,
             clientReferenceManifest,
-            serverActionsManifest,
-            serverModuleMap: (0, _actionutils.createServerModuleMap)({
-                serverActionsManifest
-            })
+            serverActionsManifest
         });
     }
     const method = req.method || 'GET';
@@ -370,11 +377,10 @@ async function handler(req, res, ctx) {
                     nextFontManifest,
                     reactLoadableManifest,
                     subresourceIntegrityManifest,
-                    serverActionsManifest,
-                    clientReferenceManifest,
                     setCacheStatus: routerServerContext == null ? void 0 : routerServerContext.setCacheStatus,
                     setIsrStatus: routerServerContext == null ? void 0 : routerServerContext.setIsrStatus,
                     setReactDebugChannel: routerServerContext == null ? void 0 : routerServerContext.setReactDebugChannel,
+                    sendErrorsToBrowser: routerServerContext == null ? void 0 : routerServerContext.sendErrorsToBrowser,
                     dir: process.env.NEXT_RUNTIME === 'nodejs' ? require('path').join(/* turbopackIgnore: true */ process.cwd(), routeModule.relativeProjectDir) : `${process.cwd()}/${routeModule.relativeProjectDir}`,
                     isDraftMode,
                     botType,
@@ -386,7 +392,7 @@ async function handler(req, res, ctx) {
                     trailingSlash: nextConfig.trailingSlash,
                     images: nextConfig.images,
                     previewProps: prerenderManifest.preview,
-                    deploymentId: nextConfig.deploymentId,
+                    deploymentId: deploymentId,
                     enableTainting: nextConfig.experimental.taint,
                     htmlLimitedBots: nextConfig.htmlLimitedBots,
                     reactMaxHeadersLength: nextConfig.reactMaxHeadersLength,
@@ -417,7 +423,7 @@ async function handler(req, res, ctx) {
                         res.on('close', cb);
                     },
                     onAfterTaskError: ()=>{},
-                    onInstrumentationRequestError: (error, _request, errorContext)=>routeModule.onRequestError(req, error, errorContext, routerServerContext),
+                    onInstrumentationRequestError: (error, _request, errorContext, silenceLog)=>routeModule.onRequestError(req, error, errorContext, silenceLog, routerServerContext),
                     err: (0, _requestmeta.getRequestMeta)(req, 'invokeError'),
                     dev: routeModule.isDev
                 }
@@ -1033,6 +1039,7 @@ async function handler(req, res, ctx) {
         }
     } catch (err) {
         if (!(err instanceof _nofallbackerrorexternal.NoFallbackError)) {
+            const silenceLog = false;
             await routeModule.onRequestError(req, err, {
                 routerKind: 'App Router',
                 routePath: srcPage,
@@ -1041,7 +1048,7 @@ async function handler(req, res, ctx) {
                     isStaticGeneration: isSSG,
                     isOnDemandRevalidate
                 })
-            }, routerServerContext);
+            }, silenceLog, routerServerContext);
         }
         // rethrow so that we can handle serving error page
         throw err;

qalita/_frontend/node_modules/next/dist/build/templates/app-route.js

@@ -41,8 +41,7 @@ const _routekind = require("../../server/route-kind");
 const _patchfetch = require("../../server/lib/patch-fetch");
 const _requestmeta = require("../../server/request-meta");
 const _tracer = require("../../server/lib/trace/tracer");
-const _encryptionutils = require("../../server/app-render/encryption-utils");
-const _actionutils = require("../../server/app-render/action-utils");
+const _manifestssingleton = require("../../server/app-render/manifests-singleton");
 const _apppaths = require("../../shared/lib/router/utils/app-paths");
 const _node = require("../../server/base-http/node");
 const _nextrequest = require("../../server/web/spec-extension/adapters/next-request");
@@ -191,13 +190,10 @@ async function handler(req, res, ctx) {
     // set the reference manifests to our global store so Server Action's
     // encryption util can access to them at the top level of the page module.
     if (serverActionsManifest && clientReferenceManifest) {
-        (0, _encryptionutils.setReferenceManifestsSingleton)({
+        (0, _manifestssingleton.setManifestsSingleton)({
             page: srcPage,
             clientReferenceManifest,
-            serverActionsManifest,
-            serverModuleMap: (0, _actionutils.createServerModuleMap)({
-                serverActionsManifest
-            })
+            serverActionsManifest
         });
     }
     const method = req.method || 'GET';
@@ -219,7 +215,7 @@ async function handler(req, res, ctx) {
                 res.on('close', cb);
             },
             onAfterTaskError: undefined,
-            onInstrumentationRequestError: (error, _request, errorContext)=>routeModule.onRequestError(req, error, errorContext, routerServerContext)
+            onInstrumentationRequestError: (error, _request, errorContext, silenceLog)=>routeModule.onRequestError(req, error, errorContext, silenceLog, routerServerContext)
         },
         sharedContext: {
             buildId
@@ -320,6 +316,7 @@ async function handler(req, res, ctx) {
                     // if this is a background revalidate we need to report
                     // the request error here as it won't be bubbled
                     if (previousCacheEntry == null ? void 0 : previousCacheEntry.isStale) {
+                        const silenceLog = false;
                         await routeModule.onRequestError(req, err, {
                             routerKind: 'App Router',
                             routePath: srcPage,
@@ -328,7 +325,7 @@ async function handler(req, res, ctx) {
                                 isStaticGeneration,
                                 isOnDemandRevalidate
                             })
-                        }, routerServerContext);
+                        }, silenceLog, routerServerContext);
                     }
                     throw err;
                 }
@@ -398,6 +395,7 @@ async function handler(req, res, ctx) {
         }
     } catch (err) {
         if (!(err instanceof _nofallbackerrorexternal.NoFallbackError)) {
+            const silenceLog = false;
             await routeModule.onRequestError(req, err, {
                 routerKind: 'App Router',
                 routePath: normalizedSrcPage,
@@ -406,7 +404,7 @@ async function handler(req, res, ctx) {
                     isStaticGeneration,
                     isOnDemandRevalidate
                 })
-            });
+            }, silenceLog, routerServerContext);
         }
         // rethrow so that we can handle serving error page
         // If this is during static generation, throw the error again.

qalita/_frontend/node_modules/next/dist/build/templates/edge-app-route.js

@@ -20,8 +20,7 @@ _export(exports, {
         return _default;
     }
 });
-const _actionutils = require("../../server/app-render/action-utils");
-const _encryptionutils = require("../../server/app-render/encryption-utils");
+const _manifestssingleton = require("../../server/app-render/manifests-singleton");
 const _edgeroutemodulewrapper = require("../../server/web/edge-route-module-wrapper");
 const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
 function _getRequireWildcardCache(nodeInterop) {
@@ -66,23 +65,21 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 var _self___RSC_MANIFEST;
-// INJECT:nextConfig
+// injected by the loader afterwards.
 const maybeJSONParse = (str)=>str ? JSON.parse(str) : undefined;
 const rscManifest = (_self___RSC_MANIFEST = self.__RSC_MANIFEST) == null ? void 0 : _self___RSC_MANIFEST['VAR_PAGE'];
 const rscServerManifest = maybeJSONParse(self.__RSC_SERVER_MANIFEST);
 if (rscManifest && rscServerManifest) {
-    (0, _encryptionutils.setReferenceManifestsSingleton)({
+    (0, _manifestssingleton.setManifestsSingleton)({
         page: 'VAR_PAGE',
         clientReferenceManifest: rscManifest,
-        serverActionsManifest: rscServerManifest,
-        serverModuleMap: (0, _actionutils.createServerModuleMap)({
-            serverActionsManifest: rscServerManifest
-        })
+        serverActionsManifest: rscServerManifest
     });
 }
 const ComponentMod = _VAR_USERLAND;
-const _default = _edgeroutemodulewrapper.EdgeRouteModuleWrapper.wrap(_VAR_USERLAND.routeModule, {
-    nextConfig
+const handler = _edgeroutemodulewrapper.EdgeRouteModuleWrapper.wrap(_VAR_USERLAND.routeModule, {
+    page: 'VAR_PAGE'
 });
+const _default = handler;
 
 //# sourceMappingURL=edge-app-route.js.map

qalita/_frontend/node_modules/next/dist/build/templates/edge-ssr-app.js

@@ -17,15 +17,14 @@ _export(exports, {
         return ComponentMod;
     },
     default: function() {
-        return nHandler;
+        return _default;
     }
 });
 require("../../server/web/globals");
 const _adapter = require("../../server/web/adapter");
 const _incrementalcache = require("../../server/lib/incremental-cache");
 const _VAR_USERLAND = /*#__PURE__*/ _interop_require_wildcard(require("VAR_USERLAND"));
-const _encryptionutils = require("../../server/app-render/encryption-utils");
-const _actionutils = require("../../server/app-render/action-utils");
+const _manifestssingleton = require("../../server/app-render/manifests-singleton");
 const _handlers = require("../../server/use-cache/handlers");
 const _constants = require("../../server/lib/trace/constants");
 const _tracer = require("../../server/lib/trace/tracer");
@@ -79,20 +78,14 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 var _self___RSC_MANIFEST;
 // OPTIONAL_IMPORT:incrementalCacheHandler
-// INJECT:nextConfig
-// Initialize the cache handlers interface.
-(0, _handlers.initializeCacheHandlers)(nextConfig.cacheMaxMemorySize);
 const maybeJSONParse = (str)=>str ? JSON.parse(str) : undefined;
 const rscManifest = (_self___RSC_MANIFEST = self.__RSC_MANIFEST) == null ? void 0 : _self___RSC_MANIFEST['VAR_PAGE'];
 const rscServerManifest = maybeJSONParse(self.__RSC_SERVER_MANIFEST);
 if (rscManifest && rscServerManifest) {
-    (0, _encryptionutils.setReferenceManifestsSingleton)({
+    (0, _manifestssingleton.setManifestsSingleton)({
         page: 'VAR_PAGE',
         clientReferenceManifest: rscManifest,
-        serverActionsManifest: rscServerManifest,
-        serverModuleMap: (0, _actionutils.createServerModuleMap)({
-            serverActionsManifest: rscServerManifest
-        })
+        serverActionsManifest: rscServerManifest
     });
 }
 const ComponentMod = _VAR_USERLAND;
@@ -112,7 +105,9 @@ async function requestHandler(req, event) {
             status: 400
         });
     }
-    const { query, params, buildId, buildManifest, prerenderManifest, reactLoadableManifest, clientReferenceManifest, subresourceIntegrityManifest, dynamicCssManifest, nextFontManifest, resolvedPathname, serverActionsManifest, interceptionRoutePatterns, routerServerContext } = prepareResult;
+    const { query, params, buildId, nextConfig, buildManifest, prerenderManifest, reactLoadableManifest, subresourceIntegrityManifest, dynamicCssManifest, nextFontManifest, resolvedPathname, interceptionRoutePatterns, routerServerContext, deploymentId } = prepareResult;
+    // Initialize the cache handlers interface.
+    (0, _handlers.initializeCacheHandlers)(nextConfig.cacheMaxMemorySize);
     const isPossibleServerAction = (0, _serveractionrequestmeta.getIsPossibleServerAction)(req);
     const botType = (0, _isbot.getBotType)(req.headers.get('User-Agent') || '');
     const { isOnDemandRevalidate } = (0, _apiutils.checkIsOnDemandRevalidate)(req, prerenderManifest.preview);
@@ -143,8 +138,6 @@ async function requestHandler(req, event) {
             reactLoadableManifest,
             subresourceIntegrityManifest,
             dynamicCssManifest,
-            serverActionsManifest,
-            clientReferenceManifest,
             setIsrStatus: routerServerContext == null ? void 0 : routerServerContext.setIsrStatus,
             dir: pageRouteModule.relativeProjectDir,
             botType,
@@ -157,7 +150,7 @@ async function requestHandler(req, event) {
             trailingSlash: nextConfig.trailingSlash,
             images: nextConfig.images,
             previewProps: prerenderManifest.preview,
-            deploymentId: nextConfig.deploymentId,
+            deploymentId,
             enableTainting: nextConfig.experimental.taint,
             htmlLimitedBots: nextConfig.htmlLimitedBots,
             reactMaxHeadersLength: nextConfig.reactMaxHeadersLength,
@@ -182,7 +175,7 @@ async function requestHandler(req, event) {
                 closeController.onClose(cb);
             },
             onAfterTaskError: ()=>{},
-            onInstrumentationRequestError: (error, _request, errorContext)=>pageRouteModule.onRequestError(baseReq, error, errorContext, routerServerContext),
+            onInstrumentationRequestError: (error, _request, errorContext, silenceLog)=>pageRouteModule.onRequestError(baseReq, error, errorContext, silenceLog, routerServerContext),
             dev: pageRouteModule.isDev
         }
     };
@@ -280,12 +273,13 @@ async function requestHandler(req, event) {
             });
             return renderResultToResponse(result);
         } catch (err) {
+            const silenceLog = false;
             await pageRouteModule.onRequestError(baseReq, err, {
                 routerKind: 'App Router',
                 routePath: normalizedSrcPage,
                 routeType: 'render',
                 revalidateReason: undefined
-            });
+            }, silenceLog);
             // rethrow so that we can handle serving error page
             throw err;
         }
@@ -301,13 +295,15 @@ async function requestHandler(req, event) {
             }
         }, invokeRender));
 }
-function nHandler(opts) {
+const handler = (opts)=>{
     return (0, _adapter.adapter)({
         ...opts,
         IncrementalCache: _incrementalcache.IncrementalCache,
         handler: requestHandler,
-        incrementalCacheHandler
+        incrementalCacheHandler,
+        page: 'VAR_PAGE'
     });
-}
+};
+const _default = handler;
 
 //# sourceMappingURL=edge-ssr-app.js.map

qalita/_frontend/node_modules/next/dist/build/templates/edge-ssr.js

@@ -17,7 +17,7 @@ _export(exports, {
         return ComponentMod;
     },
     default: function() {
-        return nHandler;
+        return _default;
     }
 });
 require("../../server/web/globals");
@@ -79,13 +79,9 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-// INJECT:nextConfig
 // INJECT:pageRouteModuleOptions
 // INJECT:errorRouteModuleOptions
 // INJECT:user500RouteModuleOptions
-// Initialize the cache handlers interface.
-(0, _handlers.initializeCacheHandlers)(nextConfig.cacheMaxMemorySize);
-globalThis.nextConfig = nextConfig;
 const pageMod = {
     ..._VAR_USERLAND,
     routeModule: new _module.default({
@@ -94,7 +90,9 @@ const pageMod = {
             App: _VAR_MODULE_APP.default,
             Document: _VAR_MODULE_DOCUMENT.default
         },
-        userland: _VAR_USERLAND
+        userland: _VAR_USERLAND,
+        distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+        relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || ''
     })
 };
 const errorMod = {
@@ -105,7 +103,9 @@ const errorMod = {
             App: _VAR_MODULE_APP.default,
             Document: _VAR_MODULE_DOCUMENT.default
         },
-        userland: _VAR_MODULE_GLOBAL_ERROR
+        userland: _VAR_MODULE_GLOBAL_ERROR,
+        distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+        relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || ''
     })
 };
 // FIXME: this needs to be made compatible with the template
@@ -117,13 +117,15 @@ const error500Mod = userland500Page ? {
             App: _VAR_MODULE_APP.default,
             Document: _VAR_MODULE_DOCUMENT.default
         },
-        userland: userland500Page
+        userland: userland500Page,
+        distDir: process.env.__NEXT_RELATIVE_DIST_DIR || '',
+        relativeProjectDir: process.env.__NEXT_RELATIVE_PROJECT_DIR || ''
     })
 } : null;
 const ComponentMod = pageMod;
 async function requestHandler(req, _event) {
     var _nextConfig_i18n;
-    let srcPage = 'VAR_PAGE';
+    let srcPage = 'VAR_DEFINITION_PATHNAME';
     const relativeUrl = `${req.nextUrl.pathname}${req.nextUrl.search}`;
     const baseReq = new _web.WebNextRequest(req);
     const pageRouteModule = pageMod.routeModule;
@@ -136,7 +138,8 @@ async function requestHandler(req, _event) {
             status: 400
         });
     }
-    const { query, params, buildId, isNextDataRequest, buildManifest, prerenderManifest, reactLoadableManifest, clientReferenceManifest, subresourceIntegrityManifest, dynamicCssManifest } = prepareResult;
+    const { query, params, buildId, nextConfig, isNextDataRequest, buildManifest, prerenderManifest, reactLoadableManifest, clientReferenceManifest, subresourceIntegrityManifest, dynamicCssManifest } = prepareResult;
+    (0, _handlers.initializeCacheHandlers)(nextConfig.cacheMaxMemorySize);
     const renderContext = {
         page: srcPage,
         query,
@@ -284,12 +287,13 @@ async function requestHandler(req, _event) {
             if (errRouteModule.isDev) {
                 throw err;
             }
+            const silenceLog = false;
             await errRouteModule.onRequestError(baseReq, err, {
                 routerKind: 'Pages Router',
                 routePath: srcPage,
                 routeType: 'render',
                 revalidateReason: undefined
-            });
+            }, silenceLog);
             const errResult = await errRouteModule.render(// @ts-expect-error we don't type this for edge
             baseReq, new _web.WebNextResponse(undefined), {
                 ...renderContext,
@@ -316,14 +320,16 @@ async function requestHandler(req, _event) {
             }
         }, invokeRender));
 }
-function nHandler(opts) {
+const handler = (opts)=>{
     return (0, _adapter.adapter)({
         ...opts,
         IncrementalCache: _incrementalcache.IncrementalCache,
         handler: requestHandler,
         incrementalCacheHandler,
-        bypassNextUrl: true
+        bypassNextUrl: true,
+        page: 'VAR_DEFINITION_PATHNAME'
     });
-}
+};
+const _default = handler;
 
 //# sourceMappingURL=edge-ssr.js.map

qalita/_frontend/node_modules/next/dist/build/templates/edge-wrapper.js

@@ -0,0 +1,24 @@
+// The wrapped module could be an async module, we handle that with the proxy
+// here. The comma expression makes sure we don't call the function with the
+// module as the "this" arg.
+// Turn exports into functions that are also a thenable. This way you can await the whole object
+// or  exports (e.g. for Components) or call them directly as though they are async functions
+// (e.g. edge functions/middleware, this is what the Edge Runtime does).
+// Catch promise to prevent UnhandledPromiseRejectionWarning, this will be propagated through
+// the awaited export(s) anyway.
+"use strict";
+self._ENTRIES ||= {};
+const modProm = import('MODULE');
+modProm.catch(()=>{});
+self._ENTRIES['VAR_ENTRY_NAME'] = new Proxy(modProm, {
+    get (innerModProm, name) {
+        if (name === 'then') {
+            return (res, rej)=>innerModProm.then(res, rej);
+        }
+        let result = (...args)=>innerModProm.then((mod)=>(0, mod[name])(...args));
+        result.then = (res, rej)=>innerModProm.then((mod)=>mod[name]).then(res, rej);
+        return result;
+    }
+});
+
+//# sourceMappingURL=edge-wrapper.js.map

qalita/_frontend/node_modules/next/dist/build/templates/middleware.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 Object.defineProperty(exports, "default", {
     enumerable: true,
     get: function() {
-        return nHandler;
+        return _default;
     }
 });
 const _globals = require("../../server/web/globals");
@@ -58,7 +58,7 @@ const mod = {
 };
 const page = 'VAR_DEFINITION_PAGE';
 const isProxy = page === '/proxy' || page === '/src/proxy';
-const handler = (isProxy ? mod.proxy : mod.middleware) || mod.default;
+const handlerUserland = (isProxy ? mod.proxy : mod.middleware) || mod.default;
 class ProxyMissingExportError extends Error {
     constructor(message){
         super(message);
@@ -68,7 +68,7 @@ class ProxyMissingExportError extends Error {
 }
 // TODO: This spams logs during development. Find a better way to handle this.
 // Removing this will spam "fn is not a function" logs which is worse.
-if (typeof handler !== 'function') {
+if (typeof handlerUserland !== 'function') {
     throw new ProxyMissingExportError(`The ${isProxy ? 'Proxy' : 'Middleware'} file "${page}" must export a function named \`${isProxy ? 'proxy' : 'middleware'}\` or a default function.`);
 }
 // Proxy will only sent out the FetchEvent to next server,
@@ -103,12 +103,13 @@ function errorHandledHandler(fn) {
         }
     };
 }
-function nHandler(opts) {
+const handler = (opts)=>{
     return (0, _adapter.adapter)({
         ...opts,
         page,
-        handler: errorHandledHandler(handler)
+        handler: errorHandledHandler(handlerUserland)
     });
-}
+};
+const _default = handler;
 
 //# sourceMappingURL=middleware.js.map

qalita/_frontend/node_modules/next/dist/build/templates/pages-edge-api.js

@@ -26,13 +26,14 @@ if (typeof _VAR_USERLAND.default !== 'function') {
         configurable: true
     });
 }
-function _default(opts) {
+const handler = (opts)=>{
     return (0, _adapter.adapter)({
         ...opts,
         IncrementalCache: _incrementalcache.IncrementalCache,
         page: 'VAR_DEFINITION_PATHNAME',
         handler: (0, _apiutils.wrapApiHandler)(page, _VAR_USERLAND.default)
     });
-}
+};
+const _default = handler;
 
 //# sourceMappingURL=pages-edge-api.js.map

qalita/_frontend/node_modules/next/dist/build/turbopack-analyze/index.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    turbopackAnalyze: null,
+    waitForShutdown: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    turbopackAnalyze: function() {
+        return turbopackAnalyze;
+    },
+    waitForShutdown: function() {
+        return waitForShutdown;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _turbopackwarning = require("../../lib/turbopack-warning");
+const _utils = require("../../shared/lib/turbopack/utils");
+const _swc = require("../swc");
+const _ciinfo = require("../../server/ci-info");
+const _compilationevents = require("../../shared/lib/turbopack/compilation-events");
+const _utils1 = require("../utils");
+const _normalizepath = require("../../lib/normalize-path");
+const _constants = require("../../shared/lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function turbopackAnalyze(analyzeContext) {
+    var _config_experimental, _config_turbopack, _config_turbopack1, _config_experimental1;
+    await (0, _turbopackwarning.validateTurboNextConfig)({
+        dir: analyzeContext.dir,
+        configPhase: _constants.PHASE_PRODUCTION_BUILD
+    });
+    const { config, dir, distDir, noMangling } = analyzeContext;
+    const currentNodeJsVersion = process.versions.node;
+    const startTime = process.hrtime();
+    const bindings = await (0, _swc.loadBindings)(config == null ? void 0 : (_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useWasmBinary);
+    const dev = false;
+    const supportedBrowsers = (0, _utils1.getSupportedBrowsers)(dir, dev);
+    const persistentCaching = (0, _utils.isFileSystemCacheEnabledForBuild)(config);
+    const rootPath = ((_config_turbopack = config.turbopack) == null ? void 0 : _config_turbopack.root) || config.outputFileTracingRoot || dir;
+    const project = await bindings.turbo.createProject({
+        rootPath: ((_config_turbopack1 = config.turbopack) == null ? void 0 : _config_turbopack1.root) || config.outputFileTracingRoot || dir,
+        projectPath: (0, _normalizepath.normalizePath)(_path.default.relative(rootPath, dir) || '.'),
+        distDir,
+        nextConfig: config,
+        watch: {
+            enable: false
+        },
+        dev,
+        env: process.env,
+        defineEnv: (0, _swc.createDefineEnv)({
+            isTurbopack: true,
+            config,
+            dev,
+            distDir,
+            projectPath: dir,
+            fetchCacheKeyPrefix: config.experimental.fetchCacheKeyPrefix,
+            hasRewrites: false,
+            // Implemented separately in Turbopack, doesn't have to be passed here.
+            middlewareMatchers: undefined,
+            rewrites: {
+                beforeFiles: [],
+                afterFiles: [],
+                fallback: []
+            }
+        }),
+        buildId: 'analyze-build',
+        encryptionKey: '',
+        previewProps: {
+            previewModeId: '',
+            previewModeEncryptionKey: '',
+            previewModeSigningKey: ''
+        },
+        browserslistQuery: supportedBrowsers.join(', '),
+        noMangling,
+        writeRoutesHashesManifest: false,
+        currentNodeJsVersion
+    }, {
+        persistentCaching,
+        memoryLimit: (_config_experimental1 = config.experimental) == null ? void 0 : _config_experimental1.turbopackMemoryLimit,
+        dependencyTracking: persistentCaching,
+        isCi: _ciinfo.isCI,
+        isShortSession: true
+    });
+    try {
+        (0, _compilationevents.backgroundLogCompilationEvents)(project);
+        await project.writeAnalyzeData(analyzeContext.appDirOnly);
+        const shutdownPromise = project.shutdown();
+        const time = process.hrtime(startTime);
+        return {
+            duration: time[0] + time[1] / 1e9,
+            shutdownPromise
+        };
+    } catch (err) {
+        await project.shutdown();
+        throw err;
+    }
+}
+let shutdownPromise;
+async function waitForShutdown() {
+    if (shutdownPromise) {
+        await shutdownPromise;
+    }
+}
+
+//# sourceMappingURL=index.js.map

qalita/_frontend/node_modules/next/dist/build/turbopack-build/impl.js

@@ -51,7 +51,7 @@ async function turbopackBuild() {
     var _config_turbopack, _config_turbopack1, _config_experimental;
     await (0, _turbopackwarning.validateTurboNextConfig)({
         dir: _buildcontext.NextBuildContext.dir,
-        isDev: false
+        configPhase: _constants.PHASE_PRODUCTION_BUILD
     });
     const config = _buildcontext.NextBuildContext.config;
     const dir = _buildcontext.NextBuildContext.dir;
@@ -98,6 +98,7 @@ async function turbopackBuild() {
         previewProps,
         browserslistQuery: supportedBrowsers.join(', '),
         noMangling,
+        writeRoutesHashesManifest: !!process.env.NEXT_TURBOPACK_WRITE_ROUTES_HASHES_MANIFEST,
         currentNodeJsVersion
     }, {
         persistentCaching,