@sifxprime/krouter 0.5.166 → 0.5.167

package/app/node_modules/next/dist/build/utils.js

@@ -31,6 +31,7 @@ Object.defineProperty(exports, "__esModule", {
     isWebpackDefaultLayer: null,
     pageToRoute: null,
     printCustomRoutes: null,
+    printPrerenderMatchers: null,
     printTreeView: null,
     reduceAppConfig: null,
     shouldUseReactServerCondition: null,
@@ -127,6 +128,9 @@ _export(exports, {
     printCustomRoutes: function() {
         return printCustomRoutes;
     },
+    printPrerenderMatchers: function() {
+        return printPrerenderMatchers;
+    },
     printTreeView: function() {
         return printTreeView;
     },
@@ -140,7 +144,6 @@ _export(exports, {
         return unique;
     }
 });
-const _ppr = require("../server/lib/experimental/ppr");
 const _loadcustomroutes = require("../lib/load-custom-routes");
 const _constants = require("../lib/constants");
 require("../server/require-hook");
@@ -175,6 +178,7 @@ const _app1 = require("../shared/lib/router/routes/app");
 const _getmetadataroute = require("../lib/metadata/get-metadata-route");
 const _ismetadataroute = require("../lib/metadata/is-metadata-route");
 const _apppaths = require("../shared/lib/router/utils/app-paths");
+const _nft = require("./nft");
 const _getsupportedbrowsers = require("./get-supported-browsers");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -237,11 +241,7 @@ function buildStaticMetadataStaticPaths(page) {
     }
     const prerenderPathname = (0, _getmetadataroute.getStaticMetadataPrerenderPathname)(pathname);
     if (!prerenderPathname) {
-        throw Object.defineProperty(new Error(`Invariant: expected static metadata route to have a prerender pathname (${page})`), "__NEXT_ERROR_CODE", {
-            value: "E1280",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Invariant: expected static metadata route to have a prerender pathname (${page})`);
     }
     return {
         fallbackMode: undefined,
@@ -541,6 +541,62 @@ async function printTreeView(lists, pageInfos, { pagesDir, pageExtensions, middl
     }));
     print();
 }
+function countDynamicSegments(pathname) {
+    var _pathname_match;
+    return ((_pathname_match = pathname.match(/\[[^/]+\]/g)) == null ? void 0 : _pathname_match.length) ?? 0;
+}
+function printPrerenderMatchers(prerenderManifest, emittedDynamicRoutes) {
+    const sourceRoutes = new Set();
+    for (const route of Object.values(prerenderManifest.dynamicRoutes)){
+        if (route.fallbackSourceRoute) {
+            sourceRoutes.add(route.fallbackSourceRoute);
+        }
+    }
+    for (const route of Object.values(prerenderManifest.routes)){
+        if (route.srcRoute) {
+            sourceRoutes.add(route.srcRoute);
+        }
+    }
+    if (sourceRoutes.size === 0) return;
+    print((0, _picocolors.underline)('Experimental parameter matching'));
+    print('More-specific rows override broader rows for the same request.');
+    print();
+    for (const sourceRoute of [
+        ...sourceRoutes
+    ].sort()){
+        const matchers = Object.entries(prerenderManifest.dynamicRoutes).filter(([pathname, route])=>pathname === sourceRoute || route.fallbackSourceRoute === sourceRoute).map(([pathname, route])=>({
+                behavior: route.fallback === false ? 'not-found' : route.fallback === null ? 'blocking' : 'fallback',
+                pathname
+            })).sort((a, b)=>countDynamicSegments(b.pathname) - countDynamicSegments(a.pathname) || a.pathname.localeCompare(b.pathname));
+        const prerenders = Object.entries(prerenderManifest.routes).filter(([, route])=>route.srcRoute === sourceRoute).map(([pathname])=>({
+                behavior: 'prerender',
+                pathname
+            })).sort((a, b)=>a.pathname.localeCompare(b.pathname));
+        const entries = [
+            ...matchers,
+            ...prerenders
+        ];
+        const width = Math.max(...entries.map(({ behavior })=>behavior.length));
+        print(sourceRoute);
+        entries.forEach(({ behavior, pathname }, index)=>{
+            print(`  ${index === entries.length - 1 ? '└' : '├'} ${behavior.padEnd(width)}  ${pathname}`);
+        });
+        print();
+    }
+    print((0, _picocolors.underline)('Emitted dynamic route patterns'));
+    print('These are the patterns available to deployment routing metadata.');
+    print();
+    for (const sourceRoute of [
+        ...sourceRoutes
+    ].sort()){
+        const patterns = emittedDynamicRoutes.filter((route)=>route.page === sourceRoute || route.sourcePage === sourceRoute);
+        print(`${sourceRoute} (${patterns.length})`);
+        patterns.forEach((route, index)=>{
+            print(`  ${index === patterns.length - 1 ? '└' : '├'} ${route.page}`);
+        });
+        print();
+    }
+}
 function printCustomRoutes({ redirects, rewrites, headers, onMatchHeaders }) {
     const printRoutes = (routes, type)=>{
         const isRedirects = type === 'Redirects';
@@ -592,7 +648,7 @@ function printCustomRoutes({ redirects, rewrites, headers, onMatchHeaders }) {
         printRoutes(combinedRewrites, 'Rewrites');
     }
 }
-async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptions, locales, defaultLocale, parentId, pageRuntime, edgeInfo, pageType, cacheComponents, authInterrupts, useCacheTimeout, staticPageGenerationTimeout, originalAppPath, isrFlushToDisk, cacheMaxMemorySize, nextConfigOutput, cacheHandler, cacheHandlers, cacheLifeProfiles, pprConfig, buildId, deploymentId, clientAssetToken, sriEnabled }) {
+async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptions, locales, defaultLocale, parentId, pageRuntime, edgeInfo, pageType, cacheComponents, partialPrefetching, authInterrupts, useCacheTimeout, durableUseCacheEntries, staticPageGenerationTimeout, originalAppPath, isrFlushToDisk, cacheMaxMemorySize, nextConfigOutput, cacheHandler, cacheHandlers, cacheLifeProfiles, buildId, deploymentId, clientAssetToken, sriEnabled }) {
     // Skip page data collection for synthetic _global-error routes
     if (page === _constants1.UNDERSCORE_GLOBAL_ERROR_ROUTE) {
         return {
@@ -600,6 +656,8 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
             isRoutePPREnabled: false,
             prerenderFallbackMode: undefined,
             prerenderedRoutes: undefined,
+            prerenderRouteMatchers: undefined,
+            paramMatching: undefined,
             rootParamKeys: undefined,
             hasStaticProps: false,
             hasServerProps: false,
@@ -622,6 +680,8 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
         });
         let componentsResult;
         let prerenderedRoutes;
+        let prerenderRouteMatchers;
+        let paramMatching;
         let prerenderFallbackMode;
         let appConfig = {};
         let rootParamKeys;
@@ -674,29 +734,29 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
         if (pageType === 'app') {
             // @ts-expect-error pageType is app, so we can assume AppPageModule | AppRouteModule
             const ComponentMod = componentsResult.ComponentMod;
-            let segments;
+            let collectedSegments;
             try {
-                segments = await (0, _appsegments.collectSegments)(// We know this is an app page or app route module because we
+                collectedSegments = await (0, _appsegments.collectSegments)(// We know this is an app page or app route module because we
                 // checked above that the page type is 'app'.
-                routeModule);
+                routeModule, {
+                    cacheComponents,
+                    partialPrefetching
+                });
             } catch (err) {
-                throw Object.defineProperty(new Error(`Failed to collect configuration for ${page}`, {
+                throw new Error(`Failed to collect configuration for ${page}`, {
                     cause: err
-                }), "__NEXT_ERROR_CODE", {
-                    value: "E434",
-                    enumerable: false,
-                    configurable: true
                 });
             }
+            const { segments, segmentTree } = collectedSegments;
             appConfig = originalAppPath === _constants1.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY ? {} : reduceAppConfig(segments);
             if (appConfig.dynamic === 'force-static' && pathIsEdgeRuntime) {
                 _log.warn(`Page "${page}" is using runtime = 'edge' which is currently incompatible with dynamic = 'force-static'. Please remove either "runtime" or "force-static" for correct behavior`);
             }
             rootParamKeys = (0, _collectrootparamkeys.collectRootParamKeys)(routeModule);
-            // A page supports partial prerendering if it is an app page and either
-            // the whole app has PPR enabled or this page has PPR enabled when we're
-            // in incremental mode.
-            isRoutePPREnabled = routeModule.definition.kind === _routekind.RouteKind.APP_PAGE && (0, _ppr.checkIsRoutePPREnabled)(pprConfig);
+            // A page supports partial prerendering when it is an app page and
+            // Cache Components is enabled.
+            isRoutePPREnabled = routeModule.definition.kind === _routekind.RouteKind.APP_PAGE && cacheComponents;
+            const isEnsureStaticPage = cacheComponents && isRoutePPREnabled && appConfig.ensureStatic === 'navigation';
             // If force dynamic was set and we don't have PPR enabled, then set the
             // revalidate to 0.
             // TODO: (PPR) remove this once PPR is enabled by default
@@ -717,15 +777,17 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
                     ({ prerenderedRoutes, fallbackMode: prerenderFallbackMode } = buildStaticMetadataStaticPaths(page));
                 } else {
                     ;
-                    ({ prerenderedRoutes, fallbackMode: prerenderFallbackMode } = await (0, _app.buildAppStaticPaths)({
+                    ({ prerenderedRoutes, prerenderRouteMatchers, paramMatching, fallbackMode: prerenderFallbackMode } = await (0, _app.buildAppStaticPaths)({
                         dir,
                         page,
                         route,
                         cacheComponents,
                         authInterrupts,
                         useCacheTimeout,
+                        durableUseCacheEntries,
                         staticPageGenerationTimeout,
                         segments,
+                        segmentTree,
                         distDir,
                         requestHeaders: {},
                         isrFlushToDisk,
@@ -735,6 +797,7 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
                         ComponentMod,
                         nextConfigOutput,
                         isRoutePPREnabled,
+                        isEnsureStaticPage,
                         buildId,
                         deploymentId,
                         rootParamKeys
@@ -743,11 +806,7 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
             }
         } else {
             if (!Comp || !(0, _reactis.isValidElementType)(Comp) || typeof Comp === 'string') {
-                throw Object.defineProperty(new Error('INVALID_DEFAULT_EXPORT'), "__NEXT_ERROR_CODE", {
-                    value: "E457",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error('INVALID_DEFAULT_EXPORT');
             }
         }
         const hasGetInitialProps = !!(Comp == null ? void 0 : Comp.getInitialProps);
@@ -757,41 +816,21 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
         // A page cannot be prerendered _and_ define a data requirement. That's
         // contradictory!
         if (hasGetInitialProps && hasStaticProps) {
-            throw Object.defineProperty(new Error(_constants.SSG_GET_INITIAL_PROPS_CONFLICT), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(_constants.SSG_GET_INITIAL_PROPS_CONFLICT);
         }
         if (hasGetInitialProps && hasServerProps) {
-            throw Object.defineProperty(new Error(_constants.SERVER_PROPS_GET_INIT_PROPS_CONFLICT), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(_constants.SERVER_PROPS_GET_INIT_PROPS_CONFLICT);
         }
         if (hasStaticProps && hasServerProps) {
-            throw Object.defineProperty(new Error(_constants.SERVER_PROPS_SSG_CONFLICT), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(_constants.SERVER_PROPS_SSG_CONFLICT);
         }
         const pageIsDynamic = (0, _isdynamic.isDynamicRoute)(page);
         // A page cannot have static parameters if it is not a dynamic page.
         if (hasStaticProps && hasStaticPaths && !pageIsDynamic) {
-            throw Object.defineProperty(new Error(`getStaticPaths can only be used with dynamic pages, not '${page}'.` + `\nLearn more: https://nextjs.org/docs/routing/dynamic-routes`), "__NEXT_ERROR_CODE", {
-                value: "E356",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`getStaticPaths can only be used with dynamic pages, not '${page}'.` + `\nLearn more: https://nextjs.org/docs/routing/dynamic-routes`);
         }
         if (hasStaticProps && pageIsDynamic && !hasStaticPaths) {
-            throw Object.defineProperty(new Error(`getStaticPaths is required for dynamic SSG pages and is missing for '${page}'.` + `\nRead more: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`), "__NEXT_ERROR_CODE", {
-                value: "E255",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(`getStaticPaths is required for dynamic SSG pages and is missing for '${page}'.` + `\nRead more: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`);
         }
         if (hasStaticProps && hasStaticPaths) {
             ;
@@ -818,6 +857,8 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
             isRoutePPREnabled,
             prerenderFallbackMode,
             prerenderedRoutes,
+            prerenderRouteMatchers,
+            paramMatching,
             rootParamKeys,
             hasStaticProps,
             hasServerProps,
@@ -829,17 +870,13 @@ async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptio
             throw err;
         }
         console.error(err);
-        throw Object.defineProperty(new Error(`Failed to collect page data for ${page}`), "__NEXT_ERROR_CODE", {
-            value: "E414",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Failed to collect page data for ${page}`);
     });
 }
 function reduceAppConfig(segments) {
     const config = {};
     for (const segment of segments){
-        const { dynamic, fetchCache, preferredRegion, revalidate, runtime, maxDuration } = segment.config || {};
+        const { dynamic, fetchCache, preferredRegion, revalidate, runtime, maxDuration, prefetch, ensureStatic } = segment.config || {};
         // TODO: should conflicting configs here throw an error
         // e.g. if layout defines one region but page defines another
         if (typeof preferredRegion !== 'undefined') {
@@ -865,6 +902,14 @@ function reduceAppConfig(segments) {
         if (typeof maxDuration !== 'undefined') {
             config.maxDuration = maxDuration;
         }
+        // These two should be set uniformly across all segments
+        // in `collectAppPageSegments`, but we need to forward them here.
+        if (typeof prefetch !== 'undefined') {
+            config.prefetch = prefetch;
+        }
+        if (typeof ensureStatic !== 'undefined') {
+            config.ensureStatic = ensureStatic;
+        }
     }
     return config;
 }
@@ -994,45 +1039,80 @@ async function copyTracedFiles(dir, distDir, pageKeys, appPageKeys, tracingRoot,
         await _fs.promises.writeFile(packageJsonOutputPath, packageJsonContent);
     } catch  {}
     const copiedFiles = new Set();
+    const skippedTraceFiles = new Set();
+    async function createTracedSymlink(target, linkPath, sourcePath) {
+        let isDirectory = false;
+        if (process.platform === 'win32') {
+            // Windows requires the target type when creating a symlink. Files are
+            // copied in an arbitrary order, so the target might not exist in the
+            // output yet. Inspect the original target through the source symlink
+            // instead.
+            try {
+                isDirectory = (await _fs.promises.stat(sourcePath)).isDirectory();
+            } catch (err) {
+                if (err.code !== 'ENOENT' && err.code !== 'ELOOP') {
+                    throw err;
+                }
+            }
+        }
+        try {
+            // the target type argument is ignored on non-windows platforms
+            await _fs.promises.symlink(target, linkPath, isDirectory ? 'dir' : 'file');
+        } catch (err) {
+            // Windows doesn't support creating symlinks without elevated privileges,
+            // unless "Developer Mode" is turned on. If we failed to create a symlink
+            // due to EPERM, try creating a junction point instead.
+            //
+            // Ideally we'd just preserve the input file type (junction point or
+            // symlink), but there's no API in node.js to differentiate between a
+            // junction point and a symlink, so we just try making a symlink first.
+            // Symlinks are preferred because they support relative paths and
+            // non-directory (file) targets.
+            //
+            // Note: Junction targets are stored as absolute paths, so this fallback
+            // is not relocatable even when the preferred symlink above is relative,
+            // but it's the best we can do.
+            if (process.platform === 'win32' && err.code === 'EPERM' && isDirectory) {
+                try {
+                    await _fs.promises.symlink(_path.default.resolve(_path.default.dirname(linkPath), target), linkPath, 'junction');
+                } catch (junctionErr) {
+                    if (junctionErr.code !== 'EEXIST') {
+                        throw junctionErr;
+                    }
+                }
+            } else if (err.code !== 'EEXIST') {
+                throw err;
+            }
+        }
+    }
     async function handleTraceFiles(traceFilePath) {
         const traceData = JSON.parse(await _fs.promises.readFile(/* turbopackIgnore: true */ traceFilePath, 'utf8'));
+        const entries = (0, _nft.mapNftFileEntries)(traceData, traceFilePath, tracingRoot, {
+            skipBaseRootEscapes: true,
+            onBaseRootEscape: (source)=>skippedTraceFiles.add(source)
+        });
         const copySema = new _asyncsema.Sema(10, {
-            capacity: traceData.files.length
+            capacity: entries.length
         });
-        const traceFileDir = _path.default.dirname(traceFilePath);
-        await Promise.all(traceData.files.map(async (relativeFile)=>{
+        await Promise.all(entries.map(async (entry)=>{
             await copySema.acquire();
-            const tracedFilePath = _path.default.join(traceFileDir, relativeFile);
-            const fileOutputPath = _path.default.join(outputPath, _path.default.relative(tracingRoot, tracedFilePath));
+            const tracedFilePath = entry.source;
+            const fileOutputPath = (0, _nft.resolveNftOutputPath)(outputPath, entry.destination);
             if (!copiedFiles.has(fileOutputPath)) {
                 copiedFiles.add(fileOutputPath);
                 await _fs.promises.mkdir(_path.default.dirname(fileOutputPath), {
                     recursive: true
                 });
-                const symlink = await _fs.promises.readlink(tracedFilePath).catch(()=>null);
-                if (symlink) {
-                    try {
-                        await _fs.promises.symlink(symlink, fileOutputPath);
-                    } catch (err) {
-                        // Windows doesn't support creating symlinks without elevated privileges, unless
-                        // "Developer Mode" is turned on. If we failed to create a symlink due to EPERM, try
-                        // creating a junction point instead.
-                        //
-                        // Ideally we'd just preserve the input file type (junction point or symlink), but
-                        // there's no API in node.js to differentiate between a junction point and a symlink,
-                        // so we just try making a symlink first. Symlinks are preferred because they support
-                        // relative paths and non-directory (file) targets.
-                        if (process.platform === 'win32' && err.code === 'EPERM' && _path.default.isAbsolute(symlink)) {
-                            try {
-                                await _fs.promises.symlink(symlink, fileOutputPath, 'junction');
-                            } catch (junctionErr) {
-                                if (junctionErr.code !== 'EEXIST') {
-                                    throw junctionErr;
-                                }
-                            }
-                        } else if (err.code !== 'EEXIST') {
-                            throw err;
-                        }
+                if (entry.symlinkTarget !== undefined) {
+                    const targetOutputPath = (0, _nft.resolveNftOutputPath)(outputPath, entry.symlinkTarget);
+                    const target = _path.default.relative(_path.default.dirname(fileOutputPath), targetOutputPath) || '.';
+                    await createTracedSymlink(target, fileOutputPath, tracedFilePath);
+                } else if (traceData.symlinks === undefined) {
+                    const target = await _fs.promises.readlink(tracedFilePath).catch(()=>null);
+                    if (target) {
+                        await createTracedSymlink(target, fileOutputPath, tracedFilePath);
+                    } else {
+                        await _fs.promises.copyFile(tracedFilePath, fileOutputPath);
                     }
                 } else {
                     await _fs.promises.copyFile(tracedFilePath, fileOutputPath);
@@ -1152,6 +1232,21 @@ startServer({
   console.error(err);
   process.exit(1);
 });`);
+    if (skippedTraceFiles.size > 0) {
+        const count = skippedTraceFiles.size;
+        const skippedFilesOutput = [
+            ...skippedTraceFiles
+        ].slice(0, 100).map((file)=>`  - ${_path.default.relative(tracingRoot, file)}`).join('\n');
+        const warning = [
+            `${count} traced files were not included in the standalone output`,
+            'because their paths are outside of `outputFileTracingRoot`.',
+            'First 100 skipped files:',
+            skippedFilesOutput,
+            'Set `outputFileTracingRoot` to a common parent directory',
+            'to include these files.'
+        ].join('\n');
+        _log.warn(warning);
+    }
 }
 function isReservedPage(page) {
     return RESERVED_PAGE.test(page);
@@ -1187,11 +1282,6 @@ function getPossibleMiddlewareFilenames(folder, extensions) {
 class NestedMiddlewareError extends Error {
     constructor(nestedFileNames, mainDir, pagesOrAppDir){
         super(`Nested Middleware is not allowed, found:\n` + `${nestedFileNames.map((file)=>`pages${file}`).join('\n')}\n` + `Please move your code to a single file at ${_path.default.join(_path.default.posix.sep, _path.default.relative(mainDir, _path.default.resolve(pagesOrAppDir, '..')), 'middleware')} instead.\n` + `Read More - https://nextjs.org/docs/messages/nested-middleware`);
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E1173",
-            enumerable: false,
-            configurable: true
-        });
     }
 }
 function shouldUseReactServerCondition(layer) {

package/app/node_modules/next/dist/build/webpack/cache-invalidation.js

@@ -63,12 +63,8 @@ async function checkFileSystemCacheInvalidationAndCleanup(cacheDirectory) {
         await cleanupFileSystemCacheInner(cacheDirectory);
     } catch (e) {
         // generate a user-friendly error message
-        throw Object.defineProperty(new Error(`Unable to remove an invalidated webpack cache. If this issue persists ` + `you can work around it by deleting ${cacheDirectory}`, {
+        throw new Error(`Unable to remove an invalidated webpack cache. If this issue persists ` + `you can work around it by deleting ${cacheDirectory}`, {
             cause: e
-        }), "__NEXT_ERROR_CODE", {
-            value: "E710",
-            enumerable: false,
-            configurable: true
         });
     }
 }

package/app/node_modules/next/dist/build/webpack/config/blocks/css/plugins.js

@@ -44,11 +44,7 @@ async function loadPlugin(dir, pluginName, options) {
     }
     if (options == null) {
         console.error(getError_NullConfig(pluginName));
-        throw Object.defineProperty(new Error(genericErrorText), "__NEXT_ERROR_CODE", {
-            value: "E1036",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(genericErrorText);
     }
     const pluginPath = require.resolve(pluginName, {
         paths: [
@@ -97,11 +93,7 @@ async function getPostCssPlugins(dir, supportedBrowsers, disablePostcssPresetEnv
         };
     }
     if (typeof config === 'function') {
-        throw Object.defineProperty(new Error(`Your custom PostCSS configuration may not export a function. Please export a plain object instead.\n` + 'Read more: https://nextjs.org/docs/messages/postcss-function'), "__NEXT_ERROR_CODE", {
-            value: "E323",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Your custom PostCSS configuration may not export a function. Please export a plain object instead.\n` + 'Read more: https://nextjs.org/docs/messages/postcss-function');
     }
     // Warn user about configuration keys which are not respected
     const invalidKey = Object.keys(config).find((key)=>key !== 'plugins');
@@ -111,11 +103,7 @@ async function getPostCssPlugins(dir, supportedBrowsers, disablePostcssPresetEnv
     // Enforce the user provided plugins if the configuration file is present
     let plugins = config.plugins;
     if (plugins == null || typeof plugins !== 'object') {
-        throw Object.defineProperty(new Error(`Your custom PostCSS configuration must export a \`plugins\` key.`), "__NEXT_ERROR_CODE", {
-            value: "E347",
-            enumerable: false,
-            configurable: true
-        });
+        throw new Error(`Your custom PostCSS configuration must export a \`plugins\` key.`);
     }
     if (!Array.isArray(plugins)) {
         // Capture variable so TypeScript is happy
@@ -124,11 +112,7 @@ async function getPostCssPlugins(dir, supportedBrowsers, disablePostcssPresetEnv
             const p = pc[curr];
             if (typeof p === 'undefined') {
                 console.error(getError_NullConfig(curr));
-                throw Object.defineProperty(new Error(genericErrorText), "__NEXT_ERROR_CODE", {
-                    value: "E1036",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(genericErrorText);
             }
             acc.push([
                 curr,
@@ -160,26 +144,14 @@ async function getPostCssPlugins(dir, supportedBrowsers, disablePostcssPresetEnv
                 } else {
                     console.error(`${(0, _picocolors.red)((0, _picocolors.bold)('Error'))}: A PostCSS Plugin was passed as an array but did not provide its configuration ('${pluginName}').\n` + 'Read more: https://nextjs.org/docs/messages/postcss-shape');
                 }
-                throw Object.defineProperty(new Error(genericErrorText), "__NEXT_ERROR_CODE", {
-                    value: "E1036",
-                    enumerable: false,
-                    configurable: true
-                });
+                throw new Error(genericErrorText);
             }
         } else if (typeof plugin === 'function') {
             console.error(`${(0, _picocolors.red)((0, _picocolors.bold)('Error'))}: A PostCSS Plugin was passed as a function using require(), but it must be provided as a ${(0, _picocolors.bold)('string')}.\nRead more: https://nextjs.org/docs/messages/postcss-shape`);
-            throw Object.defineProperty(new Error(genericErrorText), "__NEXT_ERROR_CODE", {
-                value: "E1036",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(genericErrorText);
         } else {
             console.error(`${(0, _picocolors.red)((0, _picocolors.bold)('Error'))}: An unknown PostCSS plugin was provided (${plugin}).\n` + 'Read more: https://nextjs.org/docs/messages/postcss-shape');
-            throw Object.defineProperty(new Error(genericErrorText), "__NEXT_ERROR_CODE", {
-                value: "E1036",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error(genericErrorText);
         }
     });
     const resolved = await Promise.all(parsed.map((p)=>loadPlugin(dir, p[0], p[1])));

package/app/node_modules/next/dist/build/webpack/loaders/css-loader/src/CssSyntaxError.js

@@ -11,11 +11,6 @@ Object.defineProperty(exports, "default", {
 class CssSyntaxError extends Error {
     constructor(error){
         super(error);
-        Object.defineProperty(this, "__NEXT_ERROR_CODE", {
-            value: "E394",
-            enumerable: false,
-            configurable: true
-        });
         const { reason, line, column } = error;
         this.name = 'CssSyntaxError';
         // Based on https://github.com/postcss/postcss/blob/master/lib/css-syntax-error.es6#L132

package/app/node_modules/next/dist/build/webpack/loaders/css-loader/src/camelcase.js

@@ -51,11 +51,7 @@ const postProcess = (input, options)=>{
 };
 const camelCase = (input, options)=>{
     if (!(typeof input === 'string' || Array.isArray(input))) {
-        throw Object.defineProperty(new TypeError('Expected the input to be `string | string[]`'), "__NEXT_ERROR_CODE", {
-            value: "E613",
-            enumerable: false,
-            configurable: true
-        });
+        throw new TypeError('Expected the input to be `string | string[]`');
     }
     options = {
         pascalCase: false,

package/app/node_modules/next/dist/build/webpack/loaders/css-loader/src/index.js

@@ -77,29 +77,17 @@ function getModulesOptions(rawOptions, loaderContext) {
     }
     if (modulesOptions.namedExport === true) {
         if (rawOptions.esModule === false) {
-            throw Object.defineProperty(new Error('The "modules.namedExport" option requires the "esModules" option to be enabled'), "__NEXT_ERROR_CODE", {
-                value: "E103",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('The "modules.namedExport" option requires the "esModules" option to be enabled');
         }
         if (modulesOptions.exportLocalsConvention !== 'camelCaseOnly') {
-            throw Object.defineProperty(new Error('The "modules.namedExport" option requires the "modules.exportLocalsConvention" option to be "camelCaseOnly"'), "__NEXT_ERROR_CODE", {
-                value: "E23",
-                enumerable: false,
-                configurable: true
-            });
+            throw new Error('The "modules.namedExport" option requires the "modules.exportLocalsConvention" option to be "camelCaseOnly"');
         }
     }
     return modulesOptions;
 }
 function normalizeOptions(rawOptions, loaderContext) {
     if (rawOptions.icss) {
-        loaderContext.emitWarning(Object.defineProperty(new Error('The "icss" option is deprecated, use "modules.compileType: "icss"" instead'), "__NEXT_ERROR_CODE", {
-            value: "E476",
-            enumerable: false,
-            configurable: true
-        }));
+        loaderContext.emitWarning(new Error('The "icss" option is deprecated, use "modules.compileType: "icss"" instead'));
     }
     const modulesOptions = getModulesOptions(rawOptions, loaderContext);
     return {
@@ -246,18 +234,10 @@ async function loader(content, map, meta) {
             if (error.file) {
                 this.addDependency(error.file);
             }
-            throw error.name === 'CssSyntaxError' ? Object.defineProperty(new _CssSyntaxError.default(error), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            }) : error;
+            throw error.name === 'CssSyntaxError' ? new _CssSyntaxError.default(error) : error;
         }
         for (const warning of result.warnings()){
-            this.emitWarning(Object.defineProperty(new _Warning.default(warning), "__NEXT_ERROR_CODE", {
-                value: "E394",
-                enumerable: false,
-                configurable: true
-            }));
+            this.emitWarning(new _Warning.default(warning));
         }
         const imports = [
             ...icssPluginImports.sort(sort),