@nilsr0711/drydock 0.1.0 → 0.1.1

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/webpack/plugins/pages-manifest-plugin.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    edgeServerAppPaths: null,
+    edgeServerPages: null,
+    nodeServerAppPaths: null,
+    nodeServerPages: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    // This plugin creates a pages-manifest.json from page entrypoints.
+    // This is used for mapping paths like `/` to `.next/server/static/<buildid>/pages/index.js` when doing SSR
+    // It's also used by next export to provide defaultPathMap
+    default: function() {
+        return PagesManifestPlugin;
+    },
+    edgeServerAppPaths: function() {
+        return edgeServerAppPaths;
+    },
+    edgeServerPages: function() {
+        return edgeServerPages;
+    },
+    nodeServerAppPaths: function() {
+        return nodeServerAppPaths;
+    },
+    nodeServerPages: function() {
+        return nodeServerPages;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _webpack = require("next/dist/compiled/webpack/webpack");
+const _constants = require("../../../shared/lib/constants");
+const _getroutefromentrypoint = /*#__PURE__*/ _interop_require_default(require("../../../server/get-route-from-entrypoint"));
+const _normalizepathsep = require("../../../shared/lib/page-path/normalize-path-sep");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+let edgeServerPages = {};
+let nodeServerPages = {};
+let edgeServerAppPaths = {};
+let nodeServerAppPaths = {};
+class PagesManifestPlugin {
+    constructor({ dev, distDir, isEdgeRuntime, appDirEnabled }){
+        this.dev = dev;
+        this.distDir = distDir;
+        this.isEdgeRuntime = isEdgeRuntime;
+        this.appDirEnabled = appDirEnabled;
+    }
+    async createAssets(compilation) {
+        const entrypoints = compilation.entrypoints;
+        const pages = {};
+        const appPaths = {};
+        for (const entrypoint of entrypoints.values()){
+            const pagePath = (0, _getroutefromentrypoint.default)(entrypoint.name, this.appDirEnabled);
+            if (!pagePath) {
+                continue;
+            }
+            const files = entrypoint.getFiles().filter((file)=>!file.includes('webpack-runtime') && !file.includes('webpack-api-runtime') && file.endsWith('.js'));
+            // Skip entries which are empty
+            if (!files.length) {
+                continue;
+            }
+            // Write filename, replace any backslashes in path (on windows) with forwardslashes for cross-platform consistency.
+            let file = files[files.length - 1];
+            if (!this.dev) {
+                if (!this.isEdgeRuntime) {
+                    file = file.slice(3);
+                }
+            }
+            file = (0, _normalizepathsep.normalizePathSep)(file);
+            if (entrypoint.name.startsWith('app/')) {
+                appPaths[pagePath] = file;
+            } else {
+                pages[pagePath] = file;
+            }
+        }
+        // This plugin is used by both the Node server and Edge server compilers,
+        // we need to merge both pages to generate the full manifest.
+        if (this.isEdgeRuntime) {
+            edgeServerPages = pages;
+            edgeServerAppPaths = appPaths;
+        } else {
+            nodeServerPages = pages;
+            nodeServerAppPaths = appPaths;
+        }
+        // handle parallel compilers writing to the same
+        // manifest path by merging existing manifest with new
+        const writeMergedManifest = async (manifestPath, entries)=>{
+            await _promises.default.mkdir(_path.default.dirname(manifestPath), {
+                recursive: true
+            });
+            await _promises.default.writeFile(manifestPath, JSON.stringify({
+                ...await _promises.default.readFile(manifestPath, 'utf8').then((res)=>JSON.parse(res)).catch(()=>({})),
+                ...entries
+            }, null, 2));
+        };
+        if (this.distDir) {
+            const pagesManifestPath = _path.default.join(this.distDir, 'server', _constants.PAGES_MANIFEST);
+            await writeMergedManifest(pagesManifestPath, {
+                ...edgeServerPages,
+                ...nodeServerPages
+            });
+        } else {
+            const pagesManifestPath = (!this.dev && !this.isEdgeRuntime ? '../' : '') + _constants.PAGES_MANIFEST;
+            compilation.emitAsset(pagesManifestPath, new _webpack.sources.RawSource(JSON.stringify({
+                ...edgeServerPages,
+                ...nodeServerPages
+            }, null, 2)));
+        }
+        if (this.appDirEnabled) {
+            if (this.distDir) {
+                const appPathsManifestPath = _path.default.join(this.distDir, 'server', _constants.APP_PATHS_MANIFEST);
+                await writeMergedManifest(appPathsManifestPath, {
+                    ...edgeServerAppPaths,
+                    ...nodeServerAppPaths
+                });
+            } else {
+                compilation.emitAsset((!this.dev && !this.isEdgeRuntime ? '../' : '') + _constants.APP_PATHS_MANIFEST, new _webpack.sources.RawSource(JSON.stringify({
+                    ...edgeServerAppPaths,
+                    ...nodeServerAppPaths
+                }, null, 2)));
+            }
+        }
+    }
+    apply(compiler) {
+        compiler.hooks.make.tap('NextJsPagesManifest', (compilation)=>{
+            compilation.hooks.processAssets.tapPromise({
+                name: 'NextJsPagesManifest',
+                stage: _webpack.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            }, ()=>this.createAssets(compilation));
+        });
+    }
+}
+
+//# sourceMappingURL=pages-manifest-plugin.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/webpack/plugins/profiling-plugin.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    ProfilingPlugin: null,
+    spans: null,
+    webpackInvalidSpans: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ProfilingPlugin: function() {
+        return ProfilingPlugin;
+    },
+    spans: function() {
+        return spans;
+    },
+    webpackInvalidSpans: function() {
+        return webpackInvalidSpans;
+    }
+});
+const _webpack = require("next/dist/compiled/webpack/webpack");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const pluginName = 'ProfilingPlugin';
+const spans = new WeakMap();
+const moduleSpansByCompilation = new WeakMap();
+const makeSpanByCompilation = new WeakMap();
+const sealSpanByCompilation = new WeakMap();
+const webpackInvalidSpans = new WeakMap();
+const TRACE_LABELS_SEAL = [
+    'module assets',
+    'create chunk assets',
+    'asset render',
+    'asset emit',
+    'store asset'
+];
+function inTraceLabelsSeal(label) {
+    return TRACE_LABELS_SEAL.some((l)=>label.startsWith(l));
+}
+class ProfilingPlugin {
+    constructor({ runWebpackSpan, rootDir }){
+        this.runWebpackSpan = runWebpackSpan;
+        this.rootDir = rootDir;
+    }
+    apply(compiler) {
+        this.traceTopLevelHooks(compiler);
+        this.traceCompilationHooks(compiler);
+        this.compiler = compiler;
+    }
+    traceHookPair(spanName, startHook, stopHook, { parentSpan, attrs, onStart, onStop } = {}) {
+        let span;
+        startHook.tap({
+            name: pluginName,
+            stage: -Infinity
+        }, (...params)=>{
+            const name = typeof spanName === 'function' ? spanName() : spanName;
+            const attributes = attrs ? attrs(...params) : attrs;
+            span = parentSpan ? parentSpan(...params).traceChild(name, attributes) : this.runWebpackSpan.traceChild(name, attributes);
+            if (onStart) onStart(span, ...params);
+        });
+        stopHook.tap({
+            name: pluginName,
+            stage: Infinity
+        }, (...params)=>{
+            // `stopHook` may be triggered when `startHook` has not in cases
+            // where `stopHook` is used as the terminating event for more
+            // than one pair of hooks.
+            if (!span) {
+                return;
+            }
+            if (onStop) onStop(span, ...params);
+            span.stop();
+        });
+    }
+    traceTopLevelHooks(compiler) {
+        this.traceHookPair('webpack-compilation', compiler.hooks.compilation, compiler.hooks.afterCompile, {
+            parentSpan: ()=>webpackInvalidSpans.get(compiler) || this.runWebpackSpan,
+            attrs: ()=>({
+                    name: compiler.name
+                }),
+            onStart: (span, compilation)=>{
+                spans.set(compilation, span);
+                spans.set(compiler, span);
+                moduleSpansByCompilation.set(compilation, new WeakMap());
+            }
+        });
+        if (compiler.options.mode === 'development') {
+            this.traceHookPair(()=>`webpack-invalidated-${compiler.name}`, compiler.hooks.invalid, compiler.hooks.done, {
+                onStart: (span)=>webpackInvalidSpans.set(compiler, span),
+                onStop: ()=>webpackInvalidSpans.delete(compiler),
+                attrs: (fileName)=>({
+                        trigger: fileName ? _path.default.relative(this.rootDir, fileName).replaceAll(_path.default.sep, '/') : 'manual'
+                    })
+            });
+        }
+    }
+    traceCompilationHooks(compiler) {
+        this.traceHookPair('emit', compiler.hooks.emit, compiler.hooks.afterEmit, {
+            parentSpan: ()=>webpackInvalidSpans.get(compiler) || this.runWebpackSpan
+        });
+        this.traceHookPair('make', compiler.hooks.make, compiler.hooks.finishMake, {
+            parentSpan: (compilation)=>{
+                const compilationSpan = spans.get(compilation);
+                if (!compilationSpan) {
+                    return webpackInvalidSpans.get(compiler) || this.runWebpackSpan;
+                }
+                return compilationSpan;
+            },
+            onStart: (span, compilation)=>{
+                makeSpanByCompilation.set(compilation, span);
+            },
+            onStop: (_span, compilation)=>{
+                makeSpanByCompilation.delete(compilation);
+            }
+        });
+        compiler.hooks.compilation.tap({
+            name: pluginName,
+            stage: -Infinity
+        }, (compilation)=>{
+            compilation.hooks.buildModule.tap(pluginName, (module1)=>{
+                var _compilation_moduleGraph;
+                const moduleType = (()=>{
+                    const r = module1.userRequest;
+                    if (!r || r.endsWith('!')) {
+                        return '';
+                    } else {
+                        const resource = r.split('!').pop();
+                        const match = /^[^?]+\.([^?]+)$/.exec(resource);
+                        return match ? match[1] : '';
+                    }
+                })();
+                const issuerModule = compilation == null ? void 0 : (_compilation_moduleGraph = compilation.moduleGraph) == null ? void 0 : _compilation_moduleGraph.getIssuer(module1);
+                let span;
+                const moduleSpans = moduleSpansByCompilation.get(compilation);
+                const spanName = `build-module${moduleType ? `-${moduleType}` : ''}`;
+                const issuerSpan = issuerModule && (moduleSpans == null ? void 0 : moduleSpans.get(issuerModule));
+                if (issuerSpan) {
+                    span = issuerSpan.traceChild(spanName);
+                } else {
+                    let parentSpan;
+                    for (const incomingConnection of compilation.moduleGraph.getIncomingConnections(module1)){
+                        const entrySpan = spans.get(incomingConnection.dependency);
+                        if (entrySpan) {
+                            parentSpan = entrySpan;
+                            break;
+                        }
+                    }
+                    if (!parentSpan) {
+                        const compilationSpan = spans.get(compilation);
+                        if (!compilationSpan) {
+                            return;
+                        }
+                        parentSpan = compilationSpan;
+                    }
+                    span = parentSpan.traceChild(spanName);
+                }
+                span.setAttribute('name', module1.userRequest);
+                span.setAttribute('layer', module1.layer);
+                moduleSpans.set(module1, span);
+            });
+            const moduleHooks = _webpack.NormalModule.getCompilationHooks(compilation);
+            moduleHooks.readResource.for(undefined).intercept({
+                register (tapInfo) {
+                    const fn = tapInfo.fn;
+                    tapInfo.fn = (loaderContext, callback)=>{
+                        fn(loaderContext, (err, result)=>{
+                            callback(err, result);
+                        });
+                    };
+                    return tapInfo;
+                }
+            });
+            moduleHooks.loader.tap(pluginName, (loaderContext, module1)=>{
+                var _moduleSpansByCompilation_get;
+                const moduleSpan = (_moduleSpansByCompilation_get = moduleSpansByCompilation.get(compilation)) == null ? void 0 : _moduleSpansByCompilation_get.get(module1);
+                loaderContext.currentTraceSpan = moduleSpan;
+            });
+            compilation.hooks.succeedModule.tap(pluginName, (module1)=>{
+                var _moduleSpansByCompilation_get_get, _moduleSpansByCompilation_get;
+                moduleSpansByCompilation == null ? void 0 : (_moduleSpansByCompilation_get = moduleSpansByCompilation.get(compilation)) == null ? void 0 : (_moduleSpansByCompilation_get_get = _moduleSpansByCompilation_get.get(module1)) == null ? void 0 : _moduleSpansByCompilation_get_get.stop();
+            });
+            compilation.hooks.failedModule.tap(pluginName, (module1)=>{
+                var _moduleSpansByCompilation_get_get, _moduleSpansByCompilation_get;
+                moduleSpansByCompilation == null ? void 0 : (_moduleSpansByCompilation_get = moduleSpansByCompilation.get(compilation)) == null ? void 0 : (_moduleSpansByCompilation_get_get = _moduleSpansByCompilation_get.get(module1)) == null ? void 0 : _moduleSpansByCompilation_get_get.stop();
+            });
+            this.traceHookPair('seal', compilation.hooks.seal, compilation.hooks.afterSeal, {
+                parentSpan: ()=>spans.get(compilation),
+                onStart (span) {
+                    sealSpanByCompilation.set(compilation, span);
+                },
+                onStop () {
+                    sealSpanByCompilation.delete(compilation);
+                }
+            });
+            compilation.hooks.addEntry.tap(pluginName, (entry)=>{
+                const parentSpan = makeSpanByCompilation.get(compilation) || spans.get(compilation);
+                if (!parentSpan) {
+                    return;
+                }
+                const addEntrySpan = parentSpan.traceChild('add-entry');
+                addEntrySpan.setAttribute('request', entry.request);
+                spans.set(entry, addEntrySpan);
+            });
+            compilation.hooks.succeedEntry.tap(pluginName, (entry)=>{
+                var _spans_get;
+                (_spans_get = spans.get(entry)) == null ? void 0 : _spans_get.stop();
+                spans.delete(entry);
+            });
+            compilation.hooks.failedEntry.tap(pluginName, (entry)=>{
+                var _spans_get;
+                (_spans_get = spans.get(entry)) == null ? void 0 : _spans_get.stop();
+                spans.delete(entry);
+            });
+            this.traceHookPair('chunk-graph', compilation.hooks.beforeChunks, compilation.hooks.afterChunks, {
+                parentSpan: ()=>sealSpanByCompilation.get(compilation) || spans.get(compilation)
+            });
+            this.traceHookPair('optimize', compilation.hooks.optimize, compilation.hooks.reviveModules, {
+                parentSpan: ()=>sealSpanByCompilation.get(compilation) || spans.get(compilation)
+            });
+            this.traceHookPair('optimize-modules', compilation.hooks.optimizeModules, compilation.hooks.afterOptimizeModules, {
+                parentSpan: ()=>sealSpanByCompilation.get(compilation) || spans.get(compilation)
+            });
+            this.traceHookPair('optimize-chunks', compilation.hooks.optimizeChunks, compilation.hooks.afterOptimizeChunks, {
+                parentSpan: ()=>sealSpanByCompilation.get(compilation) || spans.get(compilation)
+            });
+            this.traceHookPair('optimize-tree', compilation.hooks.optimizeTree, compilation.hooks.afterOptimizeTree, {
+                parentSpan: ()=>sealSpanByCompilation.get(compilation) || spans.get(compilation)
+            });
+            this.traceHookPair('optimize-chunk-modules', compilation.hooks.optimizeChunkModules, compilation.hooks.afterOptimizeChunkModules, {
+                parentSpan: ()=>sealSpanByCompilation.get(compilation) || spans.get(compilation)
+            });
+            this.traceHookPair('module-hash', compilation.hooks.beforeModuleHash, compilation.hooks.afterModuleHash, {
+                parentSpan: ()=>sealSpanByCompilation.get(compilation) || spans.get(compilation)
+            });
+            this.traceHookPair('code-generation', compilation.hooks.beforeCodeGeneration, compilation.hooks.afterCodeGeneration, {
+                parentSpan: ()=>sealSpanByCompilation.get(compilation) || spans.get(compilation)
+            });
+            this.traceHookPair('hash', compilation.hooks.beforeHash, compilation.hooks.afterHash, {
+                parentSpan: ()=>sealSpanByCompilation.get(compilation) || spans.get(compilation)
+            });
+            this.traceHookPair('code-generation-jobs', compilation.hooks.afterHash, compilation.hooks.beforeModuleAssets, {
+                parentSpan: ()=>sealSpanByCompilation.get(compilation) || spans.get(compilation)
+            });
+            const logs = new Map();
+            const originalTime = compilation.logger.time;
+            const originalTimeEnd = compilation.logger.timeEnd;
+            compilation.logger.time = (label)=>{
+                if (!inTraceLabelsSeal(label)) {
+                    return originalTime.call(compilation.logger, label);
+                }
+                const span = sealSpanByCompilation.get(compilation);
+                if (span) {
+                    logs.set(label, span.traceChild(label.replace(/ /g, '-')));
+                }
+                return originalTime.call(compilation.logger, label);
+            };
+            compilation.logger.timeEnd = (label)=>{
+                if (!inTraceLabelsSeal(label)) {
+                    return originalTimeEnd.call(compilation.logger, label);
+                }
+                const span = logs.get(label);
+                if (span) {
+                    span.stop();
+                    logs.delete(label);
+                }
+                return originalTimeEnd.call(compilation.logger, label);
+            };
+        });
+    }
+}
+
+//# sourceMappingURL=profiling-plugin.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/webpack/plugins/react-loadable-plugin.js

@@ -0,0 +1,169 @@
+/**
+COPYRIGHT (c) 2017-present James Kyle <me@thejameskyle.com>
+ MIT License
+ Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWAR
+*/ // Implementation of this PR: https://github.com/jamiebuilds/react-loadable/pull/132
+// Modified to strip out unneeded results for Next's specific use case
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ReactLoadablePlugin", {
+    enumerable: true,
+    get: function() {
+        return ReactLoadablePlugin;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _webpack = require("next/dist/compiled/webpack/webpack");
+const _constants = require("../../../shared/lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getModuleId(compilation, module) {
+    return compilation.chunkGraph.getModuleId(module);
+}
+function getModuleFromDependency(compilation, dep) {
+    return compilation.moduleGraph.getModule(dep);
+}
+function getOriginModuleFromDependency(compilation, dep) {
+    return compilation.moduleGraph.getParentModule(dep);
+}
+function getChunkGroupFromBlock(compilation, block) {
+    return compilation.chunkGraph.getBlockChunkGroup(block);
+}
+function buildManifest(_compiler, compilation, projectSrcDir, dev, shouldCreateDynamicCssManifest) {
+    if (!projectSrcDir) {
+        return {
+            reactLoadableManifest: {},
+            dynamicCssManifest: []
+        };
+    }
+    const dynamicCssManifestSet = new Set();
+    let manifest = {};
+    // This is allowed:
+    // import("./module"); <- ImportDependency
+    // We don't support that:
+    // import(/* webpackMode: "eager" */ "./module") <- ImportEagerDependency
+    // import(`./module/${param}`) <- ImportContextDependency
+    // Find all dependencies blocks which contains a `import()` dependency
+    const handleBlock = (block)=>{
+        block.blocks.forEach(handleBlock);
+        const chunkGroup = getChunkGroupFromBlock(compilation, block);
+        for (const dependency of block.dependencies){
+            if (dependency.type.startsWith('import()')) {
+                // get the referenced module
+                const module = getModuleFromDependency(compilation, dependency);
+                if (!module) return;
+                // get the module containing the import()
+                const originModule = getOriginModuleFromDependency(compilation, dependency);
+                const originRequest = originModule == null ? void 0 : originModule.resource;
+                if (!originRequest) return;
+                // We construct a "unique" key from origin module and request
+                // It's not perfect unique, but that will be fine for us.
+                // We also need to construct the same in the babel plugin.
+                const key = `${_path.default.relative(projectSrcDir, originRequest)} -> ${dependency.request}`;
+                // Capture all files that need to be loaded.
+                const files = new Set();
+                if (manifest[key]) {
+                    // In the "rare" case where multiple chunk groups
+                    // are created for the same `import()` or multiple
+                    // import()s reference the same module, we merge
+                    // the files to make sure to not miss files
+                    // This may cause overfetching in edge cases.
+                    for (const file of manifest[key].files){
+                        files.add(file);
+                    }
+                }
+                // There might not be a chunk group when all modules
+                // are already loaded. In this case we only need need
+                // the module id and no files
+                if (chunkGroup) {
+                    for (const chunk of chunkGroup.chunks){
+                        chunk.files.forEach((file)=>{
+                            if ((file.endsWith('.js') || file.endsWith('.css')) && file.match(/^static\/(chunks|css)\//)) {
+                                files.add(file);
+                                if (shouldCreateDynamicCssManifest && file.endsWith('.css')) {
+                                    dynamicCssManifestSet.add(file);
+                                }
+                            }
+                        });
+                    }
+                }
+                // usually we have to add the parent chunk groups too
+                // but we assume that all parents are also imported by
+                // next/dynamic so they are loaded by the same technique
+                // add the id and files to the manifest
+                const id = dev ? key : getModuleId(compilation, module);
+                manifest[key] = {
+                    id,
+                    files: Array.from(files)
+                };
+            }
+        }
+    };
+    for (const module of compilation.modules){
+        module.blocks.forEach(handleBlock);
+    }
+    manifest = Object.keys(manifest).sort()// eslint-disable-next-line no-sequences
+    .reduce((a, c)=>(a[c] = manifest[c], a), {});
+    return {
+        reactLoadableManifest: manifest,
+        dynamicCssManifest: Array.from(dynamicCssManifestSet)
+    };
+}
+class ReactLoadablePlugin {
+    constructor(opts){
+        this.filename = opts.filename;
+        this.pagesOrAppDir = opts.pagesDir || opts.appDir;
+        this.isPagesDir = Boolean(opts.pagesDir);
+        this.runtimeAsset = opts.runtimeAsset;
+        this.dev = opts.dev;
+    }
+    createAssets(compiler, compilation) {
+        const projectSrcDir = this.pagesOrAppDir ? _path.default.dirname(this.pagesOrAppDir) : undefined;
+        const shouldCreateDynamicCssManifest = !this.dev && this.isPagesDir;
+        const { reactLoadableManifest, dynamicCssManifest } = buildManifest(compiler, compilation, projectSrcDir, this.dev, shouldCreateDynamicCssManifest);
+        compilation.emitAsset(this.filename, new _webpack.sources.RawSource(JSON.stringify(reactLoadableManifest, null, 2)));
+        if (this.runtimeAsset) {
+            compilation.emitAsset(this.runtimeAsset, new _webpack.sources.RawSource(`self.__REACT_LOADABLE_MANIFEST=${JSON.stringify(JSON.stringify(reactLoadableManifest))}`));
+        }
+        // This manifest prevents removing server rendered <link> tags after client
+        // navigation. This is only needed under Pages dir && Production && Webpack.
+        // x-ref: https://github.com/vercel/next.js/pull/72959
+        if (shouldCreateDynamicCssManifest) {
+            compilation.emitAsset(`${_constants.DYNAMIC_CSS_MANIFEST}.json`, new _webpack.sources.RawSource(JSON.stringify(dynamicCssManifest, null, 2)));
+            // This is for edge runtime.
+            compilation.emitAsset(`server/${_constants.DYNAMIC_CSS_MANIFEST}.js`, new _webpack.sources.RawSource(`self.__DYNAMIC_CSS_MANIFEST=${JSON.stringify(JSON.stringify(dynamicCssManifest))}`));
+        }
+    }
+    apply(compiler) {
+        compiler.hooks.make.tap('ReactLoadableManifest', (compilation)=>{
+            compilation.hooks.processAssets.tap({
+                name: 'ReactLoadableManifest',
+                stage: _webpack.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            }, ()=>{
+                this.createAssets(compiler, compilation);
+            });
+        });
+    }
+}
+
+//# sourceMappingURL=react-loadable-plugin.js.map