@nogataka/cc-search 0.1.0

package/dist/standalone/node_modules/next/dist/build/webpack/plugins/css-chunking-plugin.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CssChunkingPlugin", {
+    enumerable: true,
+    get: function() {
+        return CssChunkingPlugin;
+    }
+});
+const PLUGIN_NAME = 'CssChunkingPlugin';
+/**
+ * Merge chunks until they are bigger than the target size.
+ */ const MIN_CSS_CHUNK_SIZE = 30 * 1024;
+/**
+ * Avoid merging chunks when they would be bigger than this size.
+ */ const MAX_CSS_CHUNK_SIZE = 100 * 1024;
+function isGlobalCss(module) {
+    return !/\.module\.(css|scss|sass)$/.test(module.nameForCondition() || '');
+}
+class CssChunkingPlugin {
+    constructor(strict){
+        this.strict = strict;
+    }
+    apply(compiler) {
+        const strict = this.strict;
+        const summary = !!process.env.CSS_CHUNKING_SUMMARY;
+        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
+            let once = false;
+            compilation.hooks.optimizeChunks.tap({
+                name: PLUGIN_NAME,
+                stage: 5
+            }, ()=>{
+                if (once) {
+                    return;
+                }
+                once = true;
+                const chunkGraph = compilation.chunkGraph;
+                let changed = undefined;
+                const chunkStates = new Map();
+                const chunkStatesByModule = new Map();
+                // Collect all css modules in chunks and the execpted order of them
+                for (const chunk of compilation.chunks){
+                    var _chunk_name;
+                    if ((_chunk_name = chunk.name) == null ? void 0 : _chunk_name.startsWith('pages/')) continue;
+                    const modules = [];
+                    for (const module of chunkGraph.getChunkModulesIterable(chunk)){
+                        var _module_type;
+                        if (!((_module_type = module.type) == null ? void 0 : _module_type.startsWith('css'))) continue;
+                        modules.push(module);
+                    }
+                    if (!modules.length) continue;
+                    const chunkState = {
+                        chunk,
+                        modules,
+                        order: 0,
+                        requests: modules.length
+                    };
+                    chunkStates.set(chunk, chunkState);
+                    for(let i = 0; i < modules.length; i++){
+                        const module = modules[i];
+                        let moduleChunkStates = chunkStatesByModule.get(module);
+                        if (!moduleChunkStates) {
+                            moduleChunkStates = new Map();
+                            chunkStatesByModule.set(module, moduleChunkStates);
+                        }
+                        moduleChunkStates.set(chunkState, i);
+                        chunkStatesByModule.set(module, moduleChunkStates);
+                    }
+                }
+                // Sort modules by their index sum
+                const orderedModules = [];
+                for (const [module, moduleChunkStates] of chunkStatesByModule){
+                    let sum = 0;
+                    for (const i of moduleChunkStates.values()){
+                        sum += i;
+                    }
+                    orderedModules.push({
+                        module,
+                        sum
+                    });
+                }
+                orderedModules.sort((a, b)=>a.sum - b.sum);
+                // A queue of modules that still need to be processed
+                const remainingModules = new Set(orderedModules.map(({ module })=>module));
+                // In loose mode we guess the dependents of modules from the order
+                // assuming that when a module is a dependency of another module
+                // it will always appear before it in every chunk.
+                const allDependents = new Map();
+                if (!this.strict) {
+                    for (const b of remainingModules){
+                        const dependent = new Set();
+                        loop: for (const a of remainingModules){
+                            if (a === b) continue;
+                            // check if a depends on b
+                            for (const [chunkState, ia] of chunkStatesByModule.get(a)){
+                                const bChunkStates = chunkStatesByModule.get(b);
+                                const ib = bChunkStates.get(chunkState);
+                                if (ib === undefined) {
+                                    continue loop;
+                                }
+                                if (ib > ia) {
+                                    continue loop;
+                                }
+                            }
+                            dependent.add(a);
+                        }
+                        if (dependent.size > 0) allDependents.set(b, dependent);
+                    }
+                }
+                // Stores the new chunk for every module
+                const newChunksByModule = new Map();
+                // Process through all modules
+                for (const startModule of remainingModules){
+                    let globalCssMode = isGlobalCss(startModule);
+                    // The current position of processing in all selected chunks
+                    let allChunkStates = new Map(chunkStatesByModule.get(startModule));
+                    // The list of modules that goes into the new chunk
+                    const newChunkModules = new Set([
+                        startModule
+                    ]);
+                    // The current size of the new chunk
+                    let currentSize = startModule.size();
+                    // A pool of potential modules where the next module is selected from.
+                    // It's filled from the next module of the selected modules in every chunk.
+                    // It also keeps some metadata to improve performance [size, chunkStates].
+                    const potentialNextModules = new Map();
+                    for (const [chunkState, i] of allChunkStates){
+                        const nextModule = chunkState.modules[i + 1];
+                        if (nextModule && remainingModules.has(nextModule)) {
+                            potentialNextModules.set(nextModule, [
+                                nextModule.size(),
+                                chunkStatesByModule.get(nextModule)
+                            ]);
+                        }
+                    }
+                    // Try to add modules to the chunk until a break condition is met
+                    let cont;
+                    do {
+                        cont = false;
+                        // We try to select a module that reduces request count and
+                        // has the highest number of requests
+                        const orderedPotentialNextModules = [];
+                        for (const [nextModule, [size, nextChunkStates]] of potentialNextModules){
+                            let maxRequests = 0;
+                            for (const chunkState of nextChunkStates.keys()){
+                                // There is always some overlap
+                                if (allChunkStates.has(chunkState)) {
+                                    maxRequests = Math.max(maxRequests, chunkState.requests);
+                                }
+                            }
+                            orderedPotentialNextModules.push([
+                                nextModule,
+                                size,
+                                nextChunkStates,
+                                maxRequests
+                            ]);
+                        }
+                        orderedPotentialNextModules.sort((a, b)=>b[3] - a[3] || (a[0].identifier() < b[0].identifier() ? -1 : 1));
+                        // Try every potential module
+                        loop: for (const [nextModule, size, nextChunkStates] of orderedPotentialNextModules){
+                            if (currentSize + size > MAX_CSS_CHUNK_SIZE) {
+                                continue;
+                            }
+                            if (!strict) {
+                                // In loose mode we only check if the dependencies are not violated
+                                const dependent = allDependents.get(nextModule);
+                                if (dependent) {
+                                    for (const dep of dependent){
+                                        if (newChunkModules.has(dep)) {
+                                            continue loop;
+                                        }
+                                    }
+                                }
+                            } else {
+                                // In strict mode we check that none of the order in any chunk is changed by adding the module
+                                for (const [chunkState, i] of nextChunkStates){
+                                    const prevState = allChunkStates.get(chunkState);
+                                    if (prevState === undefined) {
+                                        // New chunk group, can add it, but should we?
+                                        // We only add that if below min size
+                                        if (currentSize < MIN_CSS_CHUNK_SIZE) {
+                                            continue;
+                                        } else {
+                                            continue loop;
+                                        }
+                                    } else if (prevState + 1 === i) {
+                                        continue;
+                                    } else {
+                                        continue loop;
+                                    }
+                                }
+                            }
+                            // Global CSS must not leak into unrelated chunks
+                            const nextIsGlobalCss = isGlobalCss(nextModule);
+                            if (nextIsGlobalCss && globalCssMode) {
+                                if (allChunkStates.size !== nextChunkStates.size) {
+                                    continue;
+                                }
+                            }
+                            if (globalCssMode) {
+                                for (const chunkState of nextChunkStates.keys()){
+                                    if (!allChunkStates.has(chunkState)) {
+                                        continue loop;
+                                    }
+                                }
+                            }
+                            if (nextIsGlobalCss) {
+                                for (const chunkState of allChunkStates.keys()){
+                                    if (!nextChunkStates.has(chunkState)) {
+                                        continue loop;
+                                    }
+                                }
+                            }
+                            potentialNextModules.delete(nextModule);
+                            currentSize += size;
+                            if (nextIsGlobalCss) {
+                                globalCssMode = true;
+                            }
+                            for (const [chunkState, i] of nextChunkStates){
+                                if (allChunkStates.has(chunkState)) {
+                                    // This reduces the request count of the chunk group
+                                    chunkState.requests--;
+                                }
+                                allChunkStates.set(chunkState, i);
+                                const newNextModule = chunkState.modules[i + 1];
+                                if (newNextModule && remainingModules.has(newNextModule) && !newChunkModules.has(newNextModule)) {
+                                    potentialNextModules.set(newNextModule, [
+                                        newNextModule.size(),
+                                        chunkStatesByModule.get(newNextModule)
+                                    ]);
+                                }
+                            }
+                            newChunkModules.add(nextModule);
+                            cont = true;
+                            break;
+                        }
+                    }while (cont);
+                    const newChunk = compilation.addChunk();
+                    newChunk.preventIntegration = true;
+                    newChunk.idNameHints.add('css');
+                    for (const module of newChunkModules){
+                        remainingModules.delete(module);
+                        chunkGraph.connectChunkAndModule(newChunk, module);
+                        newChunksByModule.set(module, newChunk);
+                    }
+                    changed = true;
+                }
+                for (const { chunk, modules } of chunkStates.values()){
+                    const chunks = new Set();
+                    for (const module of modules){
+                        const newChunk = newChunksByModule.get(module);
+                        if (newChunk) {
+                            chunkGraph.disconnectChunkAndModule(chunk, module);
+                            if (chunks.has(newChunk)) continue;
+                            chunks.add(newChunk);
+                            chunk.split(newChunk);
+                        }
+                    }
+                }
+                if (summary) {
+                    console.log('Top 20 chunks by request count:');
+                    const orderedChunkStates = [
+                        ...chunkStates.values()
+                    ];
+                    orderedChunkStates.sort((a, b)=>b.requests - a.requests);
+                    for (const { chunk, modules, requests } of orderedChunkStates.slice(0, 20)){
+                        console.log(`- ${requests} requests for ${chunk.name} (has ${modules.length} modules)`);
+                    }
+                }
+                return changed;
+            });
+        });
+    }
+}
+
+//# sourceMappingURL=css-chunking-plugin.js.map

package/dist/standalone/node_modules/next/dist/build/webpack/plugins/css-minimizer-plugin.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CssMinimizerPlugin", {
+    enumerable: true,
+    get: function() {
+        return CssMinimizerPlugin;
+    }
+});
+const _cssnanosimple = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/cssnano-simple"));
+const _postcssscss = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/postcss-scss"));
+const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
+const _webpack = require("next/dist/compiled/webpack/webpack");
+const _utils = require("../utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// https://github.com/NMFR/optimize-css-assets-webpack-plugin/blob/0a410a9bf28c7b0e81a3470a13748e68ca2f50aa/src/index.js#L20
+const CSS_REGEX = /\.css(\?.*)?$/i;
+class CssMinimizerPlugin {
+    constructor(options){
+        this.__next_css_remove = true;
+        this.options = options;
+    }
+    optimizeAsset(file, asset) {
+        const postcssOptions = {
+            ...this.options.postcssOptions,
+            to: file,
+            from: file,
+            // We don't actually add this parser to support Sass. It can also be used
+            // for inline comment support. See the README:
+            // https://github.com/postcss/postcss-scss/blob/master/README.md#2-inline-comments-for-postcss
+            parser: _postcssscss.default
+        };
+        let input;
+        if (postcssOptions.map && asset.sourceAndMap) {
+            const { source, map } = asset.sourceAndMap();
+            input = source;
+            postcssOptions.map.prev = map ? map : false;
+        } else {
+            input = asset.source();
+        }
+        return (0, _postcss.default)([
+            (0, _cssnanosimple.default)({
+                colormin: false
+            }, _postcss.default)
+        ]).process(input, postcssOptions).then((res)=>{
+            if (res.map) {
+                return new _webpack.sources.SourceMapSource(res.css, file, res.map.toJSON());
+            } else {
+                return new _webpack.sources.RawSource(res.css);
+            }
+        });
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('CssMinimizerPlugin', (compilation)=>{
+            const cache = compilation.getCache('CssMinimizerPlugin');
+            compilation.hooks.processAssets.tapPromise({
+                name: 'CssMinimizerPlugin',
+                stage: _webpack.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE
+            }, async (assets)=>{
+                const compilationSpan = (0, _utils.getCompilationSpan)(compilation) || (0, _utils.getCompilationSpan)(compiler);
+                const cssMinimizerSpan = compilationSpan.traceChild('css-minimizer-plugin');
+                return cssMinimizerSpan.traceAsyncFn(async ()=>{
+                    const files = Object.keys(assets);
+                    await Promise.all(files.filter((file)=>CSS_REGEX.test(file)).map(async (file)=>{
+                        const assetSpan = cssMinimizerSpan.traceChild('minify-css');
+                        assetSpan.setAttribute('file', file);
+                        return assetSpan.traceAsyncFn(async ()=>{
+                            const assetSource = compilation.getAsset(file).source;
+                            const etag = cache.getLazyHashedEtag(assetSource);
+                            const cachedResult = await cache.getPromise(file, etag);
+                            assetSpan.setAttribute('cache', cachedResult ? 'HIT' : 'MISS');
+                            if (cachedResult) {
+                                compilation.updateAsset(file, cachedResult);
+                                return;
+                            }
+                            const result = await this.optimizeAsset(file, assetSource);
+                            await cache.storePromise(file, etag, result);
+                            compilation.updateAsset(file, result);
+                        });
+                    }));
+                });
+            });
+        });
+    }
+}
+
+//# sourceMappingURL=css-minimizer-plugin.js.map

package/dist/standalone/node_modules/next/dist/build/webpack/plugins/define-env-plugin.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getDefineEnv: null,
+    getDefineEnvPlugin: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getDefineEnv: function() {
+        return getDefineEnv;
+    },
+    getDefineEnvPlugin: function() {
+        return getDefineEnvPlugin;
+    }
+});
+const _needsexperimentalreact = require("../../../lib/needs-experimental-react");
+const _ppr = require("../../../server/lib/experimental/ppr");
+const _staticenv = require("../../../lib/static-env");
+const _getwebpackbundler = /*#__PURE__*/ _interop_require_default(require("../../../shared/lib/get-webpack-bundler"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/**
+ * Serializes the DefineEnv config so that it can be inserted into the code by Webpack/Turbopack, JSON stringifies each value.
+ */ function serializeDefineEnv(defineEnv) {
+    const defineEnvStringified = {};
+    for(const key in defineEnv){
+        const value = defineEnv[key];
+        defineEnvStringified[key] = JSON.stringify(value);
+    }
+    return defineEnvStringified;
+}
+function getImageConfig(config, dev) {
+    var _config_images, _config_images1, _config_images2;
+    return {
+        'process.env.__NEXT_IMAGE_OPTS': {
+            deviceSizes: config.images.deviceSizes,
+            imageSizes: config.images.imageSizes,
+            qualities: config.images.qualities,
+            path: config.images.path,
+            loader: config.images.loader,
+            dangerouslyAllowSVG: config.images.dangerouslyAllowSVG,
+            unoptimized: config == null ? void 0 : (_config_images = config.images) == null ? void 0 : _config_images.unoptimized,
+            ...dev ? {
+                // additional config in dev to allow validating on the client
+                domains: config.images.domains,
+                remotePatterns: (_config_images1 = config.images) == null ? void 0 : _config_images1.remotePatterns,
+                localPatterns: (_config_images2 = config.images) == null ? void 0 : _config_images2.localPatterns,
+                output: config.output
+            } : {}
+        }
+    };
+}
+function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir, fetchCacheKeyPrefix, hasRewrites, isClient, isEdgeServer, isNodeOrEdgeCompilation, isNodeServer, middlewareMatchers, omitNonDeterministic }) {
+    var _config_experimental_staleTimes, _config_experimental_staleTimes1, _config_experimental_staleTimes2, _config_experimental_staleTimes3, _config_i18n, _config_compiler;
+    const nextPublicEnv = (0, _staticenv.getNextPublicEnvironmentVariables)();
+    const nextConfigEnv = (0, _staticenv.getNextConfigEnv)(config);
+    const isPPREnabled = (0, _ppr.checkIsAppPPREnabled)(config.experimental.ppr);
+    const isDynamicIOEnabled = !!config.experimental.dynamicIO;
+    const isUseCacheEnabled = !!config.experimental.useCache;
+    const defineEnv = {
+        // internal field to identify the plugin config
+        __NEXT_DEFINE_ENV: true,
+        ...nextPublicEnv,
+        ...nextConfigEnv,
+        ...!isEdgeServer ? {} : {
+            EdgeRuntime: /**
+             * Cloud providers can set this environment variable to allow users
+             * and library authors to have different implementations based on
+             * the runtime they are running with, if it's not using `edge-runtime`
+             */ process.env.NEXT_EDGE_RUNTIME_PROVIDER ?? 'edge-runtime',
+            // process should be only { env: {...} } for edge runtime.
+            // For ignore avoid warn on `process.emit` usage but directly omit it.
+            'process.emit': false
+        },
+        'process.turbopack': isTurbopack,
+        'process.env.TURBOPACK': isTurbopack,
+        'process.env.__NEXT_BUNDLER': isTurbopack ? 'Turbopack' : process.env.NEXT_RSPACK ? 'Rspack' : 'Webpack',
+        // TODO: enforce `NODE_ENV` on `process.env`, and add a test:
+        'process.env.NODE_ENV': dev || config.experimental.allowDevelopmentBuild ? 'development' : 'production',
+        'process.env.NEXT_RUNTIME': isEdgeServer ? 'edge' : isNodeServer ? 'nodejs' : '',
+        'process.env.NEXT_MINIMAL': '',
+        'process.env.__NEXT_APP_NAV_FAIL_HANDLING': Boolean(config.experimental.appNavFailHandling),
+        'process.env.__NEXT_PPR': isPPREnabled,
+        'process.env.__NEXT_DYNAMIC_IO': isDynamicIOEnabled,
+        'process.env.__NEXT_USE_CACHE': isUseCacheEnabled,
+        'process.env.NEXT_DEPLOYMENT_ID': config.deploymentId || false,
+        // Propagates the `__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING` environment
+        // variable to the client.
+        'process.env.__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING': process.env.__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING || false,
+        'process.env.__NEXT_FETCH_CACHE_KEY_PREFIX': fetchCacheKeyPrefix ?? '',
+        ...isTurbopack ? {} : {
+            'process.env.__NEXT_MIDDLEWARE_MATCHERS': middlewareMatchers ?? []
+        },
+        'process.env.__NEXT_MANUAL_CLIENT_BASE_PATH': config.experimental.manualClientBasePath ?? false,
+        'process.env.__NEXT_CLIENT_ROUTER_DYNAMIC_STALETIME': JSON.stringify(isNaN(Number((_config_experimental_staleTimes = config.experimental.staleTimes) == null ? void 0 : _config_experimental_staleTimes.dynamic)) ? 0 : (_config_experimental_staleTimes1 = config.experimental.staleTimes) == null ? void 0 : _config_experimental_staleTimes1.dynamic),
+        'process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME': JSON.stringify(isNaN(Number((_config_experimental_staleTimes2 = config.experimental.staleTimes) == null ? void 0 : _config_experimental_staleTimes2.static)) ? 5 * 60 // 5 minutes
+         : (_config_experimental_staleTimes3 = config.experimental.staleTimes) == null ? void 0 : _config_experimental_staleTimes3.static),
+        'process.env.__NEXT_CLIENT_ROUTER_FILTER_ENABLED': config.experimental.clientRouterFilter ?? true,
+        'process.env.__NEXT_CLIENT_ROUTER_S_FILTER': (clientRouterFilters == null ? void 0 : clientRouterFilters.staticFilter) ?? false,
+        'process.env.__NEXT_CLIENT_ROUTER_D_FILTER': (clientRouterFilters == null ? void 0 : clientRouterFilters.dynamicFilter) ?? false,
+        'process.env.__NEXT_CLIENT_SEGMENT_CACHE': Boolean(config.experimental.clientSegmentCache),
+        'process.env.__NEXT_DYNAMIC_ON_HOVER': Boolean(config.experimental.dynamicOnHover),
+        'process.env.__NEXT_ROUTER_BF_CACHE': Boolean(config.experimental.routerBFCache),
+        'process.env.__NEXT_OPTIMISTIC_CLIENT_CACHE': config.experimental.optimisticClientCache ?? true,
+        'process.env.__NEXT_MIDDLEWARE_PREFETCH': config.experimental.middlewarePrefetch ?? 'flexible',
+        'process.env.__NEXT_CROSS_ORIGIN': config.crossOrigin,
+        'process.browser': isClient,
+        'process.env.__NEXT_TEST_MODE': process.env.__NEXT_TEST_MODE ?? false,
+        // This is used in client/dev-error-overlay/hot-dev-client.js to replace the dist directory
+        ...dev && (isClient ?? isEdgeServer) ? {
+            'process.env.__NEXT_DIST_DIR': distDir
+        } : {},
+        'process.env.__NEXT_TRAILING_SLASH': config.trailingSlash,
+        'process.env.__NEXT_DEV_INDICATOR': config.devIndicators !== false,
+        'process.env.__NEXT_DEV_INDICATOR_POSITION': config.devIndicators === false ? 'bottom-left' // This will not be used as the indicator is disabled.
+         : config.devIndicators.position ?? 'bottom-left',
+        'process.env.__NEXT_STRICT_MODE': config.reactStrictMode === null ? false : config.reactStrictMode,
+        'process.env.__NEXT_STRICT_MODE_APP': // When next.config.js does not have reactStrictMode it's enabled by default.
+        config.reactStrictMode === null ? true : config.reactStrictMode,
+        'process.env.__NEXT_OPTIMIZE_CSS': (config.experimental.optimizeCss && !dev) ?? false,
+        'process.env.__NEXT_SCRIPT_WORKERS': (config.experimental.nextScriptWorkers && !dev) ?? false,
+        'process.env.__NEXT_SCROLL_RESTORATION': config.experimental.scrollRestoration ?? false,
+        ...getImageConfig(config, dev),
+        'process.env.__NEXT_ROUTER_BASEPATH': config.basePath,
+        'process.env.__NEXT_STRICT_NEXT_HEAD': config.experimental.strictNextHead ?? true,
+        'process.env.__NEXT_HAS_REWRITES': hasRewrites,
+        'process.env.__NEXT_CONFIG_OUTPUT': config.output,
+        'process.env.__NEXT_I18N_SUPPORT': !!config.i18n,
+        'process.env.__NEXT_I18N_DOMAINS': ((_config_i18n = config.i18n) == null ? void 0 : _config_i18n.domains) ?? false,
+        'process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE': config.skipMiddlewareUrlNormalize,
+        'process.env.__NEXT_EXTERNAL_MIDDLEWARE_REWRITE_RESOLVE': config.experimental.externalMiddlewareRewritesResolve ?? false,
+        'process.env.__NEXT_MANUAL_TRAILING_SLASH': config.skipTrailingSlashRedirect,
+        'process.env.__NEXT_HAS_WEB_VITALS_ATTRIBUTION': (config.experimental.webVitalsAttribution && config.experimental.webVitalsAttribution.length > 0) ?? false,
+        'process.env.__NEXT_WEB_VITALS_ATTRIBUTION': config.experimental.webVitalsAttribution ?? false,
+        'process.env.__NEXT_LINK_NO_TOUCH_START': config.experimental.linkNoTouchStart ?? false,
+        'process.env.__NEXT_ASSET_PREFIX': config.assetPrefix,
+        'process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS': !!config.experimental.authInterrupts,
+        'process.env.__NEXT_TELEMETRY_DISABLED': Boolean(process.env.NEXT_TELEMETRY_DISABLED),
+        ...isNodeOrEdgeCompilation ? {
+            // Fix bad-actors in the npm ecosystem (e.g. `node-formidable`)
+            // This is typically found in unmaintained modules from the
+            // pre-webpack era (common in server-side code)
+            'global.GENTLY': false
+        } : undefined,
+        ...isNodeOrEdgeCompilation ? {
+            'process.env.__NEXT_EXPERIMENTAL_REACT': (0, _needsexperimentalreact.needsExperimentalReact)(config)
+        } : undefined
+    };
+    const userDefines = ((_config_compiler = config.compiler) == null ? void 0 : _config_compiler.define) ?? {};
+    for(const key in userDefines){
+        if (defineEnv.hasOwnProperty(key)) {
+            throw Object.defineProperty(new Error(`The \`compiler.define\` option is configured to replace the \`${key}\` variable. This variable is either part of a Next.js built-in or is already configured via the \`env\` option.`), "__NEXT_ERROR_CODE", {
+                value: "E430",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        defineEnv[key] = userDefines[key];
+    }
+    const serializedDefineEnv = serializeDefineEnv(defineEnv);
+    // we delay inlining these values until after the build
+    // with flying shuttle enabled so we can update them
+    // without invalidating entries
+    if (!dev && omitNonDeterministic) {
+        // client uses window. instead of leaving process.env
+        // in case process isn't polyfilled on client already
+        // since by this point it won't be added by webpack
+        const safeKey = (key)=>isClient ? `window.${key.split('.').pop()}` : key;
+        for(const key in nextPublicEnv){
+            serializedDefineEnv[key] = safeKey(key);
+        }
+        for(const key in nextConfigEnv){
+            serializedDefineEnv[key] = safeKey(key);
+        }
+        for (const key of [
+            'process.env.NEXT_DEPLOYMENT_ID'
+        ]){
+            serializedDefineEnv[key] = safeKey(key);
+        }
+    }
+    return serializedDefineEnv;
+}
+function getDefineEnvPlugin(options) {
+    return new ((0, _getwebpackbundler.default)()).DefinePlugin(getDefineEnv(options));
+}
+
+//# sourceMappingURL=define-env-plugin.js.map

package/dist/standalone/node_modules/next/dist/build/webpack/plugins/devtools-ignore-list-plugin.js

@@ -0,0 +1,68 @@
+// Source: https://github.com/mondaychen/devtools-ignore-webpack-plugin/blob/e35ce41d9606a92a455ef247f509a1c2ccab5778/src/index.ts
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * This plugin adds a field to source maps that identifies which sources are
+ * vendored or runtime-injected (aka third-party) sources. These are consumed by
+ * Chrome DevTools to automatically ignore-list sources.
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return DevToolsIgnorePlugin;
+    }
+});
+const _webpack = require("next/dist/compiled/webpack/webpack");
+// Following the naming conventions from
+// https://tc39.es/source-map/#source-map-format
+const IGNORE_LIST = 'ignoreList';
+const PLUGIN_NAME = 'devtools-ignore-plugin';
+function defaultShouldIgnorePath(path) {
+    return path.includes('/node_modules/') || path.includes('/webpack/');
+}
+function defaultIsSourceMapAsset(name) {
+    return name.endsWith('.map');
+}
+class DevToolsIgnorePlugin {
+    constructor(options = {}){
+        this.options = {
+            shouldIgnorePath: options.shouldIgnorePath ?? defaultShouldIgnorePath,
+            isSourceMapAsset: options.isSourceMapAsset ?? defaultIsSourceMapAsset
+        };
+    }
+    apply(compiler) {
+        const { RawSource } = compiler.webpack.sources;
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: PLUGIN_NAME,
+                stage: _webpack.webpack.Compilation.PROCESS_ASSETS_STAGE_DEV_TOOLING,
+                additionalAssets: true
+            }, (assets)=>{
+                for (const [name, asset] of Object.entries(assets)){
+                    // Instead of using `asset.map()` to fetch the source maps from
+                    // SourceMapSource assets, process them directly as a RawSource.
+                    // This is because `.map()` is slow and can take several seconds.
+                    if (!this.options.isSourceMapAsset(name)) {
+                        continue;
+                    }
+                    const mapContent = asset.source().toString();
+                    if (!mapContent) {
+                        continue;
+                    }
+                    const sourcemap = JSON.parse(mapContent);
+                    const ignoreList = [];
+                    for (const [index, path] of sourcemap.sources.entries()){
+                        if (this.options.shouldIgnorePath(path)) {
+                            ignoreList.push(index);
+                        }
+                    }
+                    sourcemap[IGNORE_LIST] = ignoreList;
+                    compilation.updateAsset(name, new RawSource(JSON.stringify(sourcemap)));
+                }
+            });
+        });
+    }
+}
+
+//# sourceMappingURL=devtools-ignore-list-plugin.js.map