@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/build/collect-build-traces.js

@@ -0,0 +1,536 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    collectBuildTraces: null,
+    makeIgnoreFn: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    collectBuildTraces: function() {
+        return collectBuildTraces;
+    },
+    makeIgnoreFn: function() {
+        return makeIgnoreFn;
+    }
+});
+const _trace = require("../trace");
+const _nexttraceentrypointsplugin = require("./webpack/plugins/next-trace-entrypoints-plugin");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _nonnullable = require("../lib/non-nullable");
+const _ciinfo = /*#__PURE__*/ _interop_require_wildcard(require("../server/ci-info"));
+const _debug = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/debug"));
+const _picomatch = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/picomatch"));
+const _requirehook = require("../server/require-hook");
+const _nft = require("next/dist/compiled/@vercel/nft");
+const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path");
+const _apppaths = require("../shared/lib/router/utils/app-paths");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("../lib/is-error"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const debug = (0, _debug.default)('next:build:build-traces');
+const makeIgnoreFn = (root, ignores)=>{
+    // pre compile the ignore globs
+    const isMatch = (0, _picomatch.default)(ignores, {
+        contains: true,
+        dot: true
+    });
+    return (pathname)=>{
+        if (_path.default.isAbsolute(pathname) && !pathname.startsWith(root)) {
+            return true;
+        }
+        return isMatch(pathname);
+    };
+};
+function shouldIgnore(file, serverIgnoreFn, reasons, cachedIgnoreFiles, children = new Set()) {
+    if (cachedIgnoreFiles.has(file)) {
+        return cachedIgnoreFiles.get(file);
+    }
+    if (serverIgnoreFn(file)) {
+        cachedIgnoreFiles.set(file, true);
+        return true;
+    }
+    children.add(file);
+    const reason = reasons.get(file);
+    if (!reason || reason.parents.size === 0 || reason.type.includes('initial')) {
+        cachedIgnoreFiles.set(file, false);
+        return false;
+    }
+    // if all parents are ignored the child file
+    // should be ignored as well
+    let allParentsIgnored = true;
+    for (const parent of reason.parents.values()){
+        if (!children.has(parent)) {
+            children.add(parent);
+            if (!shouldIgnore(parent, serverIgnoreFn, reasons, cachedIgnoreFiles, children)) {
+                allParentsIgnored = false;
+                break;
+            }
+        }
+    }
+    cachedIgnoreFiles.set(file, allParentsIgnored);
+    return allParentsIgnored;
+}
+async function collectBuildTraces({ dir, config, distDir, edgeRuntimeRoutes, staticPages, nextBuildSpan = new _trace.Span({
+    name: 'build'
+}), buildTraceContext, outputFileTracingRoot }) {
+    const startTime = Date.now();
+    debug('starting build traces');
+    const { outputFileTracingIncludes = {}, outputFileTracingExcludes = {} } = config;
+    const excludeGlobKeys = Object.keys(outputFileTracingExcludes);
+    const includeGlobKeys = Object.keys(outputFileTracingIncludes);
+    await nextBuildSpan.traceChild('node-file-trace-build', {
+        isTurbotrace: 'false'
+    }).traceAsyncFn(async ()=>{
+        const nextServerTraceOutput = _path.default.join(distDir, 'next-server.js.nft.json');
+        const nextMinimalTraceOutput = _path.default.join(distDir, 'next-minimal-server.js.nft.json');
+        const root = outputFileTracingRoot;
+        // Under standalone mode, we need to trace the extra IPC server and
+        // worker files.
+        const isStandalone = config.output === 'standalone';
+        const sharedEntriesSet = Object.keys(_requirehook.defaultOverrides).map((value)=>require.resolve(value, {
+                paths: [
+                    require.resolve('next/dist/server/require-hook')
+                ]
+            }));
+        const { cacheHandler, cacheHandlers } = config;
+        // ensure we trace any dependencies needed for custom
+        // incremental cache handler
+        if (cacheHandler) {
+            sharedEntriesSet.push(require.resolve(_path.default.isAbsolute(cacheHandler) ? cacheHandler : _path.default.join(dir, cacheHandler)));
+        }
+        // Under standalone mode, we need to ensure that the cache entry debug
+        // handler is traced so it can be copied. This is only used for testing,
+        // and is not used in production.
+        if (process.env.__NEXT_TEST_MODE && process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS) {
+            sharedEntriesSet.push(require.resolve(_path.default.isAbsolute(process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS) ? process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS : _path.default.join(dir, process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS)));
+        }
+        if (cacheHandlers) {
+            for (const handlerPath of Object.values(cacheHandlers)){
+                if (handlerPath) {
+                    sharedEntriesSet.push(require.resolve(_path.default.isAbsolute(handlerPath) ? handlerPath : _path.default.join(dir, handlerPath)));
+                }
+            }
+        }
+        const serverEntries = [
+            ...sharedEntriesSet,
+            ...isStandalone ? [
+                require.resolve('next/dist/server/lib/start-server'),
+                require.resolve('next/dist/server/next'),
+                require.resolve('next/dist/server/require-hook')
+            ] : [],
+            require.resolve('next/dist/server/next-server')
+        ].filter(Boolean);
+        const minimalServerEntries = [
+            ...sharedEntriesSet,
+            require.resolve('next/dist/compiled/next-server/server.runtime.prod')
+        ].filter(Boolean);
+        const additionalIgnores = new Set();
+        for (const glob of excludeGlobKeys){
+            if ((0, _picomatch.default)(glob)('next-server')) {
+                outputFileTracingExcludes[glob].forEach((exclude)=>{
+                    additionalIgnores.add(exclude);
+                });
+            }
+        }
+        const sharedIgnores = [
+            '**/next/dist/compiled/next-server/**/*.dev.js',
+            ...isStandalone ? [] : [
+                '**/next/dist/compiled/jest-worker/**/*'
+            ],
+            '**/next/dist/compiled/webpack/*',
+            '**/node_modules/webpack5/**/*',
+            '**/next/dist/server/lib/route-resolver*',
+            'next/dist/compiled/semver/semver/**/*.js',
+            ..._ciinfo.hasNextSupport ? [
+                // only ignore image-optimizer code when
+                // this is being handled outside of next-server
+                '**/next/dist/server/image-optimizer.js'
+            ] : [],
+            ...isStandalone ? [] : _nexttraceentrypointsplugin.TRACE_IGNORES,
+            ...additionalIgnores
+        ];
+        const sharedIgnoresFn = makeIgnoreFn(root, sharedIgnores);
+        const serverIgnores = [
+            ...sharedIgnores,
+            '**/node_modules/react{,-dom,-dom-server-turbopack}/**/*.development.js',
+            '**/*.d.ts',
+            '**/*.map',
+            '**/next/dist/pages/**/*',
+            ..._ciinfo.hasNextSupport ? [
+                '**/node_modules/sharp/**/*',
+                '**/@img/sharp-libvips*/**/*'
+            ] : []
+        ].filter(_nonnullable.nonNullable);
+        const serverIgnoreFn = makeIgnoreFn(root, serverIgnores);
+        const minimalServerIgnores = [
+            ...serverIgnores,
+            '**/next/dist/compiled/edge-runtime/**/*',
+            '**/next/dist/server/web/sandbox/**/*',
+            '**/next/dist/server/post-process.js'
+        ];
+        const minimalServerIgnoreFn = makeIgnoreFn(root, minimalServerIgnores);
+        const routesIgnores = [
+            ...sharedIgnores,
+            // server chunks are provided via next-trace-entrypoints-plugin plugin
+            // as otherwise all chunks are traced here and included for all pages
+            // whether they are needed or not
+            '**/.next/server/chunks/**',
+            '**/next/dist/server/post-process.js'
+        ].filter(_nonnullable.nonNullable);
+        const routeIgnoreFn = makeIgnoreFn(root, routesIgnores);
+        const serverTracedFiles = new Set();
+        const minimalServerTracedFiles = new Set();
+        function addToTracedFiles(base, file, dest) {
+            dest.add(_path.default.relative(distDir, _path.default.join(base, file)).replace(/\\/g, '/'));
+        }
+        if (isStandalone) {
+            addToTracedFiles('', require.resolve('next/dist/compiled/jest-worker/processChild'), serverTracedFiles);
+            addToTracedFiles('', require.resolve('next/dist/compiled/jest-worker/threadChild'), serverTracedFiles);
+        }
+        {
+            var _buildTraceContext_chunksTrace;
+            const chunksToTrace = [
+                ...(buildTraceContext == null ? void 0 : (_buildTraceContext_chunksTrace = buildTraceContext.chunksTrace) == null ? void 0 : _buildTraceContext_chunksTrace.action.input) || [],
+                ...serverEntries,
+                ...minimalServerEntries
+            ];
+            const result = await (0, _nft.nodeFileTrace)(chunksToTrace, {
+                base: outputFileTracingRoot,
+                processCwd: dir,
+                mixedModules: true,
+                async readFile (p) {
+                    try {
+                        return await _promises.default.readFile(p, 'utf8');
+                    } catch (e) {
+                        if ((0, _iserror.default)(e) && (e.code === 'ENOENT' || e.code === 'EISDIR')) {
+                            // since tracing runs in parallel with static generation server
+                            // files might be removed from that step so tolerate ENOENT
+                            // errors gracefully
+                            return '';
+                        }
+                        throw e;
+                    }
+                },
+                async readlink (p) {
+                    try {
+                        return await _promises.default.readlink(p);
+                    } catch (e) {
+                        if ((0, _iserror.default)(e) && (e.code === 'EINVAL' || e.code === 'ENOENT' || e.code === 'UNKNOWN')) {
+                            return null;
+                        }
+                        throw e;
+                    }
+                },
+                async stat (p) {
+                    try {
+                        return await _promises.default.stat(p);
+                    } catch (e) {
+                        if ((0, _iserror.default)(e) && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) {
+                            return null;
+                        }
+                        throw e;
+                    }
+                },
+                // handle shared ignores at top-level as it
+                // avoids over-tracing when we don't need to
+                // and speeds up total trace time
+                ignore (p) {
+                    if (sharedIgnoresFn(p)) {
+                        return true;
+                    }
+                    // if a chunk is attempting to be traced that isn't
+                    // in our initial list we need to ignore it to prevent
+                    // over tracing as webpack needs to be the source of
+                    // truth for which chunks should be included for each entry
+                    if (p.includes('.next/server/chunks') && !chunksToTrace.includes(_path.default.join(outputFileTracingRoot, p))) {
+                        return true;
+                    }
+                    return false;
+                }
+            });
+            const reasons = result.reasons;
+            const fileList = result.fileList;
+            for (const file of result.esmFileList){
+                fileList.add(file);
+            }
+            const parentFilesMap = (0, _nexttraceentrypointsplugin.getFilesMapFromReasons)(fileList, reasons);
+            const cachedLookupIgnore = new Map();
+            const cachedLookupIgnoreMinimal = new Map();
+            for (const [entries, tracedFiles] of [
+                [
+                    serverEntries,
+                    serverTracedFiles
+                ],
+                [
+                    minimalServerEntries,
+                    minimalServerTracedFiles
+                ]
+            ]){
+                for (const file of entries){
+                    var _parentFilesMap_get;
+                    const curFiles = [
+                        ...((_parentFilesMap_get = parentFilesMap.get(_path.default.relative(outputFileTracingRoot, file))) == null ? void 0 : _parentFilesMap_get.keys()) || []
+                    ];
+                    tracedFiles.add(_path.default.relative(distDir, file).replace(/\\/g, '/'));
+                    for (const curFile of curFiles || []){
+                        const filePath = _path.default.join(outputFileTracingRoot, curFile);
+                        if (!shouldIgnore(curFile, tracedFiles === minimalServerTracedFiles ? minimalServerIgnoreFn : serverIgnoreFn, reasons, tracedFiles === minimalServerTracedFiles ? cachedLookupIgnoreMinimal : cachedLookupIgnore)) {
+                            tracedFiles.add(_path.default.relative(distDir, filePath).replace(/\\/g, '/'));
+                        }
+                    }
+                }
+            }
+            const { entryNameFilesMap } = (buildTraceContext == null ? void 0 : buildTraceContext.chunksTrace) || {};
+            const cachedLookupIgnoreRoutes = new Map();
+            await Promise.all([
+                ...entryNameFilesMap ? Object.entries(entryNameFilesMap) : new Map()
+            ].map(async ([entryName, entryNameFiles])=>{
+                const isApp = entryName.startsWith('app/');
+                const isPages = entryName.startsWith('pages/');
+                let route = entryName;
+                if (isApp) {
+                    route = (0, _apppaths.normalizeAppPath)(route.substring('app'.length));
+                }
+                if (isPages) {
+                    route = (0, _normalizepagepath.normalizePagePath)(route.substring('pages'.length));
+                }
+                // we don't need to trace for automatically statically optimized
+                // pages as they don't have server bundles, note there is
+                // the caveat with flying shuttle mode as it needs this for
+                // detecting changed entries
+                if (staticPages.includes(route)) {
+                    return;
+                }
+                const entryOutputPath = _path.default.join(distDir, 'server', `${entryName}.js`);
+                const traceOutputPath = `${entryOutputPath}.nft.json`;
+                const existingTrace = JSON.parse(await _promises.default.readFile(traceOutputPath, 'utf8'));
+                const traceOutputDir = _path.default.dirname(traceOutputPath);
+                const curTracedFiles = new Set();
+                for (const file of [
+                    ...entryNameFiles,
+                    entryOutputPath
+                ]){
+                    var _parentFilesMap_get;
+                    const curFiles = [
+                        ...((_parentFilesMap_get = parentFilesMap.get(_path.default.relative(outputFileTracingRoot, file))) == null ? void 0 : _parentFilesMap_get.keys()) || []
+                    ];
+                    for (const curFile of curFiles || []){
+                        if (!shouldIgnore(curFile, routeIgnoreFn, reasons, cachedLookupIgnoreRoutes)) {
+                            const filePath = _path.default.join(outputFileTracingRoot, curFile);
+                            const outputFile = _path.default.relative(traceOutputDir, filePath).replace(/\\/g, '/');
+                            curTracedFiles.add(outputFile);
+                        }
+                    }
+                }
+                for (const file of existingTrace.files || []){
+                    curTracedFiles.add(file);
+                }
+                await _promises.default.writeFile(traceOutputPath, JSON.stringify({
+                    ...existingTrace,
+                    files: [
+                        ...curTracedFiles
+                    ].sort()
+                }));
+            }));
+        }
+        const moduleTypes = [
+            'app-page',
+            'pages'
+        ];
+        for (const type of moduleTypes){
+            const modulePath = require.resolve(`next/dist/server/route-modules/${type}/module.compiled`);
+            const relativeModulePath = _path.default.relative(root, modulePath);
+            const contextDir = _path.default.join(_path.default.dirname(modulePath), 'vendored', 'contexts');
+            for (const item of (await _promises.default.readdir(contextDir))){
+                const itemPath = _path.default.relative(root, _path.default.join(contextDir, item));
+                if (!serverIgnoreFn(itemPath)) {
+                    addToTracedFiles(root, itemPath, serverTracedFiles);
+                    addToTracedFiles(root, itemPath, minimalServerTracedFiles);
+                }
+            }
+            addToTracedFiles(root, relativeModulePath, serverTracedFiles);
+            addToTracedFiles(root, relativeModulePath, minimalServerTracedFiles);
+        }
+        const serverTracedFilesSorted = Array.from(serverTracedFiles);
+        serverTracedFilesSorted.sort();
+        const minimalServerTracedFilesSorted = Array.from(minimalServerTracedFiles);
+        minimalServerTracedFilesSorted.sort();
+        await Promise.all([
+            _promises.default.writeFile(nextServerTraceOutput, JSON.stringify({
+                version: 1,
+                files: serverTracedFilesSorted
+            })),
+            _promises.default.writeFile(nextMinimalTraceOutput, JSON.stringify({
+                version: 1,
+                files: minimalServerTracedFilesSorted
+            }))
+        ]);
+    });
+    // apply outputFileTracingIncludes/outputFileTracingExcludes after runTurbotrace
+    const includeExcludeSpan = nextBuildSpan.traceChild('apply-include-excludes');
+    await includeExcludeSpan.traceAsyncFn(async ()=>{
+        const globOrig = require('next/dist/compiled/glob');
+        const glob = (pattern)=>{
+            return new Promise((resolve, reject)=>{
+                globOrig(pattern, {
+                    cwd: dir,
+                    nodir: true,
+                    dot: true
+                }, (err, files)=>{
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve(files);
+                });
+            });
+        };
+        const { entryNameFilesMap } = (buildTraceContext == null ? void 0 : buildTraceContext.chunksTrace) || {};
+        await Promise.all([
+            ...entryNameFilesMap ? Object.entries(entryNameFilesMap) : new Map()
+        ].map(async ([entryName])=>{
+            const isApp = entryName.startsWith('app/');
+            const isPages = entryName.startsWith('pages/');
+            let route = entryName;
+            if (isApp) {
+                route = (0, _apppaths.normalizeAppPath)(entryName);
+            }
+            if (isPages) {
+                route = (0, _normalizepagepath.normalizePagePath)(entryName);
+            }
+            if (staticPages.includes(route)) {
+                return;
+            }
+            // edge routes have no trace files
+            if (edgeRuntimeRoutes.hasOwnProperty(route)) {
+                return;
+            }
+            const combinedIncludes = new Set();
+            const combinedExcludes = new Set();
+            for (const curGlob of includeGlobKeys){
+                const isMatch = (0, _picomatch.default)(curGlob, {
+                    dot: true,
+                    contains: true
+                });
+                if (isMatch(route)) {
+                    for (const include of outputFileTracingIncludes[curGlob]){
+                        combinedIncludes.add(include.replace(/\\/g, '/'));
+                    }
+                }
+            }
+            for (const curGlob of excludeGlobKeys){
+                const isMatch = (0, _picomatch.default)(curGlob, {
+                    dot: true,
+                    contains: true
+                });
+                if (isMatch(route)) {
+                    for (const exclude of outputFileTracingExcludes[curGlob]){
+                        combinedExcludes.add(exclude);
+                    }
+                }
+            }
+            if (!(combinedIncludes == null ? void 0 : combinedIncludes.size) && !(combinedExcludes == null ? void 0 : combinedExcludes.size)) {
+                return;
+            }
+            const traceFile = _path.default.join(distDir, `server`, `${entryName}.js.nft.json`);
+            const pageDir = _path.default.dirname(traceFile);
+            const traceContent = JSON.parse(await _promises.default.readFile(traceFile, 'utf8'));
+            const includes = [];
+            const resolvedTraceIncludes = new Map();
+            if (combinedIncludes == null ? void 0 : combinedIncludes.size) {
+                await Promise.all([
+                    ...combinedIncludes
+                ].map(async (includeGlob)=>{
+                    const results = await glob(includeGlob);
+                    const resolvedInclude = resolvedTraceIncludes.get(includeGlob) || [
+                        ...results.map((file)=>{
+                            return _path.default.relative(pageDir, _path.default.join(dir, file));
+                        })
+                    ];
+                    includes.push(...resolvedInclude);
+                    resolvedTraceIncludes.set(includeGlob, resolvedInclude);
+                }));
+            }
+            const combined = new Set([
+                ...traceContent.files,
+                ...includes
+            ]);
+            if (combinedExcludes == null ? void 0 : combinedExcludes.size) {
+                const resolvedGlobs = [
+                    ...combinedExcludes
+                ].map((exclude)=>_path.default.join(dir, exclude));
+                // pre compile before forEach
+                const isMatch = (0, _picomatch.default)(resolvedGlobs, {
+                    dot: true,
+                    contains: true
+                });
+                combined.forEach((file)=>{
+                    if (isMatch(_path.default.join(pageDir, file))) {
+                        combined.delete(file);
+                    }
+                });
+            }
+            // overwrite trace file with custom includes/excludes
+            await _promises.default.writeFile(traceFile, JSON.stringify({
+                version: traceContent.version,
+                files: [
+                    ...combined
+                ]
+            }));
+        }));
+    });
+    debug(`finished build tracing ${Date.now() - startTime}ms`);
+}
+
+//# sourceMappingURL=collect-build-traces.js.map

package/webapp-dist/vendor/next/dist/build/compiler.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runCompiler", {
+    enumerable: true,
+    get: function() {
+        return runCompiler;
+    }
+});
+const _getwebpackbundler = /*#__PURE__*/ _interop_require_default(require("../shared/lib/get-webpack-bundler"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function generateStats(result, stat) {
+    const { errors, warnings } = stat.toJson({
+        preset: 'errors-warnings',
+        moduleTrace: true
+    });
+    if (errors && errors.length > 0) {
+        result.errors.push(...errors);
+    }
+    if (warnings && warnings.length > 0) {
+        result.warnings.push(...warnings);
+    }
+    return result;
+}
+// Webpack 5 requires the compiler to be closed (to save caches)
+// Webpack 4 does not have this close method so in order to be backwards compatible we check if it exists
+function closeCompiler(compiler) {
+    return new Promise((resolve, reject)=>{
+        // @ts-ignore Close only exists on the compiler in webpack 5
+        return compiler.close((err)=>err ? reject(err) : resolve());
+    });
+}
+function runCompiler(config, { runWebpackSpan, inputFileSystem }) {
+    return new Promise((resolve, reject)=>{
+        const compiler = (0, _getwebpackbundler.default)()(config);
+        // Ensure we use the previous inputFileSystem
+        if (inputFileSystem) {
+            compiler.inputFileSystem = inputFileSystem;
+        }
+        compiler.fsStartTime = Date.now();
+        compiler.run((err, stats)=>{
+            const webpackCloseSpan = runWebpackSpan.traceChild('webpack-close', {
+                name: config.name || 'unknown'
+            });
+            webpackCloseSpan.traceAsyncFn(()=>closeCompiler(compiler)).then(()=>{
+                if (err) {
+                    const reason = err.stack ?? err.toString();
+                    if (reason) {
+                        return resolve([
+                            {
+                                errors: [
+                                    {
+                                        message: reason,
+                                        details: err.details
+                                    }
+                                ],
+                                warnings: [],
+                                stats
+                            },
+                            compiler.inputFileSystem
+                        ]);
+                    }
+                    return reject(err);
+                } else if (!stats) throw Object.defineProperty(new Error('No Stats from webpack'), "__NEXT_ERROR_CODE", {
+                    value: "E370",
+                    enumerable: false,
+                    configurable: true
+                });
+                const result = webpackCloseSpan.traceChild('webpack-generate-error-stats').traceFn(()=>generateStats({
+                        errors: [],
+                        warnings: [],
+                        stats
+                    }, stats));
+                return resolve([
+                    result,
+                    compiler.inputFileSystem
+                ]);
+            });
+        });
+    });
+}
+
+//# sourceMappingURL=compiler.js.map