@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/build/get-supported-browsers.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getSupportedBrowsers", {
+    enumerable: true,
+    get: function() {
+        return getSupportedBrowsers;
+    }
+});
+const _browserslist = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/browserslist"));
+const _constants = require("../shared/lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getSupportedBrowsers(dir, isDevelopment) {
+    let browsers;
+    try {
+        const browsersListConfig = _browserslist.default.loadConfig({
+            path: dir,
+            env: isDevelopment ? 'development' : 'production'
+        });
+        // Running `browserslist` resolves `extends` and other config features into a list of browsers
+        if (browsersListConfig && browsersListConfig.length > 0) {
+            browsers = (0, _browserslist.default)(browsersListConfig);
+        }
+    } catch  {}
+    // When user has browserslist use that target
+    if (browsers && browsers.length > 0) {
+        return browsers;
+    }
+    // Uses modern browsers as the default.
+    return _constants.MODERN_BROWSERSLIST_TARGET;
+}
+
+//# sourceMappingURL=get-supported-browsers.js.map

package/standalone/node_modules/next/dist/build/load-jsconfig.js

@@ -26,6 +26,7 @@ const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
 const _getTypeScriptConfiguration = require("../lib/typescript/getTypeScriptConfiguration");
 const _iserror = /*#__PURE__*/ _interop_require_default(require("../lib/is-error"));
 const _hasnecessarydependencies = require("../lib/has-necessary-dependencies");
+const _codeframe = require("../shared/lib/errors/code-frame");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -84,18 +85,17 @@ function parseJsonFile(filePath) {
         return JSON5.parse(contents);
     } catch (err) {
         if (!(0, _iserror.default)(err)) throw err;
-        const { codeFrameColumns } = require('next/dist/compiled/babel/code-frame');
-        const codeFrame = codeFrameColumns(String(contents), {
+        const codeFrame = (0, _codeframe.codeFrameColumns)(String(contents), {
             start: {
-                line: err.lineNumber || 0,
-                column: err.columnNumber || 0
+                line: err.lineNumber || 1,
+                column: err.columnNumber || undefined
             }
         }, {
             message: err.message,
-            highlightCode: true
+            color: true
         });
-        throw Object.defineProperty(new Error(`Failed to parse "${filePath}":\n${codeFrame}`), "__NEXT_ERROR_CODE", {
-            value: "E232",
+        throw Object.defineProperty(new Error(`Failed to parse "${filePath}":\n${codeFrame ?? err.message}`), "__NEXT_ERROR_CODE", {
+            value: "E1087",
             enumerable: false,
             configurable: true
         });

package/standalone/node_modules/next/dist/build/lockfile.js

@@ -2,15 +2,38 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "Lockfile", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    Lockfile: null,
+    parseDevServerInfo: null,
+    readLockfileContent: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Lockfile: function() {
         return Lockfile;
+    },
+    parseDevServerInfo: function() {
+        return parseDevServerInfo;
+    },
+    readLockfileContent: function() {
+        return readLockfileContent;
     }
 });
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _picocolors = require("../lib/picocolors");
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
 const _swc = require("./swc");
+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();
@@ -54,6 +77,20 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 const RETRY_DELAY_MS = 10;
 const MAX_RETRY_MS = 1000;
+function readLockfileContent(lockfilePath) {
+    try {
+        return _fs.default.readFileSync(lockfilePath, 'utf-8');
+    } catch  {
+        return undefined;
+    }
+}
+function parseDevServerInfo(content) {
+    try {
+        return JSON.parse(content);
+    } catch  {
+        return undefined;
+    }
+}
 class Lockfile {
     constructor(bindings, nativeLockfile){
         this.bindings = bindings;
@@ -65,7 +102,11 @@ class Lockfile {
    *
    * - If we fail to acquire the lock, we return `undefined`.
    * - If we're on wasm, this always returns a dummy `Lockfile` object.
-   */ static tryAcquire(path, unlockOnExit = true) {
+   *
+   * @param path - Path to the lock file
+   * @param unlockOnExit - Whether to unlock the file on process exit
+   * @param content - Optional content to write to the lockfile (e.g., JSON with server info)
+   */ static tryAcquire(path, unlockOnExit = true, content) {
         const bindings = (0, _swc.getBindingsSync)();
         if (bindings.isWasm) {
             _log.info(`Skipping creating a lockfile at ${(0, _picocolors.cyan)(path)} because we're using WASM bindings`);
@@ -73,7 +114,7 @@ class Lockfile {
         } else {
             let nativeLockfile;
             try {
-                nativeLockfile = bindings.lockfileTryAcquireSync(path);
+                nativeLockfile = bindings.lockfileTryAcquireSync(path, content);
             } catch (e) {
                 // this happens if there's an IO error (e.g. `ENOENT`), which is
                 // different than if we just didn't acquire the lock
@@ -115,17 +156,57 @@ class Lockfile {
    * This will retry a small number of times. This can be useful when running
    * processes in a loop, e.g. if cleanup isn't fully synchronous due to child
    * parent/processes.
-   */ static async acquireWithRetriesOrExit(path, processName, unlockOnExit = true) {
+   *
+   * @param path - Path to the lock file
+   * @param processName - Name of the process for error messages (e.g., 'next dev')
+   * @param unlockOnExit - Whether to unlock the file on process exit
+   * @param content - Optional content to write to the lockfile (e.g., JSON with server info)
+   * @param projectDir - Optional project directory for enhanced error messages
+   * @param relativeDistDir - Optional relative dist directory path (e.g., '.next/dev')
+   */ static async acquireWithRetriesOrExit(path, processName, unlockOnExit = true, content, projectDir, relativeDistDir) {
         const startMs = Date.now();
         let lockfile;
         while(Date.now() - startMs < MAX_RETRY_MS){
-            lockfile = Lockfile.tryAcquire(path, unlockOnExit);
+            lockfile = Lockfile.tryAcquire(path, unlockOnExit, content);
             if (lockfile !== undefined) break;
             await new Promise((resolve)=>setTimeout(resolve, RETRY_DELAY_MS));
         }
         if (lockfile === undefined) {
-            _log.error(`Unable to acquire lock at ${(0, _picocolors.cyan)(path)}, is another instance of ${(0, _picocolors.cyan)(processName)} running?`);
-            _log.info(`${(0, _picocolors.bold)('Suggestion:')} If you intended to restart ${(0, _picocolors.cyan)(processName)}, terminate the other process, and then try again.`);
+            const isDev = processName === 'next dev';
+            if (isDev) {
+                // For dev server, try to read server info from the lockfile itself
+                const lockfileContent = readLockfileContent(path);
+                const serverInfo = lockfileContent ? parseDevServerInfo(lockfileContent) : undefined;
+                if (serverInfo) {
+                    _log.error(`Another ${(0, _picocolors.cyan)(processName)} server is already running.`);
+                    console.error();
+                    console.error(`- Local:        ${(0, _picocolors.cyan)(serverInfo.appUrl)}`);
+                    console.error(`- PID:          ${serverInfo.pid}`);
+                    if (projectDir) {
+                        console.error(`- Dir:          ${projectDir}`);
+                    }
+                    if (relativeDistDir) {
+                        console.error(`- Log:          ${_path.default.join(relativeDistDir, 'logs', 'next-development.log')}`);
+                    }
+                    console.error();
+                    // Use platform-appropriate kill command
+                    const killCommand = process.platform === 'win32' ? `taskkill /PID ${serverInfo.pid} /F` : `kill ${serverInfo.pid}`;
+                    console.error(`Run ${(0, _picocolors.cyan)(killCommand)} to stop it.`);
+                } else {
+                    // Fallback when we can't read server info from the lockfile
+                    _log.error(`Another ${(0, _picocolors.cyan)(processName)} server is already running in this directory.`);
+                    console.error(`Stop the other server before starting a new one.`);
+                }
+            } else {
+                // For build, show that a build is in progress
+                _log.error(`Another ${(0, _picocolors.cyan)(processName)} process is already running.`);
+                console.error();
+                console.error(`  This could be:`);
+                console.error(`  - A ${(0, _picocolors.cyan)('next build')} still in progress`);
+                console.error(`  - A previous build that didn't exit cleanly`);
+                console.error();
+                _log.info(`${(0, _picocolors.bold)('Suggestion:')} Wait for the build to complete.`);
+            }
             process.exit(1);
         }
         return lockfile;

package/standalone/node_modules/next/dist/build/next-config-ts/transpile-config.js

@@ -8,13 +8,59 @@ Object.defineProperty(exports, "transpileConfig", {
         return transpileConfig;
     }
 });
-const _nodepath = require("node:path");
-const _promises = require("node:fs/promises");
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _nodefs = require("node:fs");
 const _nodeurl = require("node:url");
+const _commentjson = /*#__PURE__*/ _interop_require_wildcard(require("next/dist/compiled/comment-json"));
 const _requirehook = require("./require-hook");
 const _log = require("../output/log");
-const _installdependencies = require("../../lib/install-dependencies");
 const _utils = require("../../server/lib/utils");
+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;
+}
 function resolveSWCOptions(cwd, compilerOptions) {
     var _process_versions, _process;
     return {
@@ -26,7 +72,7 @@ function resolveSWCOptions(cwd, compilerOptions) {
                 paths: compilerOptions.paths
             } : {},
             ...compilerOptions.baseUrl ? {
-                baseUrl: (0, _nodepath.resolve)(cwd, compilerOptions.baseUrl)
+                baseUrl: _nodepath.default.resolve(cwd, compilerOptions.baseUrl)
             } : compilerOptions.paths ? {
                 baseUrl: cwd
             } : {}
@@ -43,54 +89,89 @@ function resolveSWCOptions(cwd, compilerOptions) {
         }
     };
 }
-// Ported from next/src/lib/verify-typescript-setup.ts
-// Although this overlaps with the later `verifyTypeScriptSetup`,
-// it is acceptable since the time difference in the worst case is trivial,
-// as we are only preparing to install the dependencies once more.
-async function verifyTypeScriptSetup(cwd, configFileName) {
+function resolveExtends(extendsPath, currentConfigDir) {
+    // Relative paths are resolved relative to the current config's directory
+    if (extendsPath.startsWith('./') || extendsPath.startsWith('../') || _nodepath.default.isAbsolute(extendsPath)) {
+        const resolved = _nodepath.default.resolve(currentConfigDir, extendsPath);
+        // TypeScript allows omitting .json extension
+        if ((0, _nodefs.existsSync)(resolved)) {
+            return resolved;
+        }
+        if (!resolved.endsWith('.json') && (0, _nodefs.existsSync)(resolved + '.json')) {
+            return resolved + '.json';
+        }
+        return resolved;
+    }
+    // Package paths - use require.resolve to find the package
     try {
-        // Quick module check.
-        require.resolve('typescript', {
+        // Try resolving as a direct path within the package
+        return require.resolve(extendsPath, {
             paths: [
-                cwd
+                currentConfigDir
             ]
         });
-    } catch (error) {
-        if (error && typeof error === 'object' && 'code' in error && error.code === 'MODULE_NOT_FOUND') {
-            (0, _log.warn)(`Installing TypeScript as it was not found while loading "${configFileName}".`);
-            await (0, _installdependencies.installDependencies)(cwd, [
-                {
-                    pkg: 'typescript'
-                }
-            ], true).catch((err)=>{
-                if (err && typeof err === 'object' && 'command' in err) {
-                    console.error(`Failed to install TypeScript, please install it manually to continue:\n` + err.command + '\n');
-                }
-                throw err;
+    } catch  {
+        // If that fails, try appending tsconfig.json for package names like "@tsconfig/node18"
+        try {
+            return require.resolve(extendsPath + '/tsconfig.json', {
+                paths: [
+                    currentConfigDir
+                ]
             });
+        } catch  {
+            // Return the original path and let it fail later with a clear error
+            return _nodepath.default.resolve(currentConfigDir, extendsPath);
         }
     }
 }
-async function getTsConfig(cwd) {
-    const ts = require(require.resolve('typescript', {
-        paths: [
-            cwd
-        ]
-    }));
+function loadTsConfigFile(configPath, visited) {
+    const resolvedPath = _nodepath.default.resolve(configPath);
+    if (visited.has(resolvedPath)) {
+        return {};
+    }
+    visited.add(resolvedPath);
+    if (!(0, _nodefs.existsSync)(resolvedPath)) {
+        return {};
+    }
+    const configContent = (0, _nodefs.readFileSync)(resolvedPath, 'utf8');
+    const config = _commentjson.parse(configContent);
+    const configDir = _nodepath.default.dirname(resolvedPath);
+    let mergedOptions = {};
+    // Note that config options from `extends` should get overwritten, not merged
+    if (config.extends) {
+        const extendsList = Array.isArray(config.extends) ? config.extends : [
+            config.extends
+        ];
+        for (const extendsPath of extendsList){
+            const parentConfigPath = resolveExtends(extendsPath, configDir);
+            const parentOptions = loadTsConfigFile(parentConfigPath, visited);
+            mergedOptions = {
+                ...mergedOptions,
+                ...parentOptions
+            };
+        }
+    }
+    const currentOptions = config.compilerOptions ?? {};
+    mergedOptions = {
+        ...mergedOptions,
+        paths: currentOptions.paths ?? mergedOptions.paths,
+        baseUrl: currentOptions.baseUrl ?? mergedOptions.baseUrl
+    };
+    return mergedOptions;
+}
+async function loadTsConfig(dir) {
     // NOTE: This doesn't fully cover the edge case for setting
     // "typescript.tsconfigPath" in next config which is currently
     // a restriction.
-    const tsConfigPath = ts.findConfigFile(cwd, ts.sys.fileExists, 'tsconfig.json');
-    if (!tsConfigPath) {
-        // It is ok to not return ts.getDefaultCompilerOptions() because
-        // we are only looking for paths and baseUrl from tsConfig.
+    // It's a chicken-and-egg problem since we need to transpile
+    // the next config to get that value.
+    const resolvedTsConfigPath = _nodepath.default.join(dir, 'tsconfig.json');
+    if (!(0, _nodefs.existsSync)(resolvedTsConfigPath)) {
         return {};
     }
-    const configFile = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
-    const parsedCommandLine = ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd);
-    return parsedCommandLine.options;
+    return loadTsConfigFile(resolvedTsConfigPath, new Set());
 }
-async function transpileConfig({ nextConfigPath, configFileName, cwd }) {
+async function transpileConfig({ nextConfigPath, dir }) {
     try {
         // envs are passed to the workers and preserve the flag
         if (process.env.__NEXT_NODE_NATIVE_TS_LOADER_ENABLED === 'true') {
@@ -104,28 +185,26 @@ async function transpileConfig({ nextConfigPath, configFileName, cwd }) {
                     return (await import((0, _nodeurl.pathToFileURL)(nextConfigPath).href)).default;
                 }
                 if ((0, _utils.getNodeOptionsArgs)().includes('--no-experimental-strip-types') || process.execArgv.includes('--no-experimental-strip-types')) {
-                    (0, _log.warnOnce)(`Skipped resolving "${configFileName}" using Node.js native TypeScript resolution because it was disabled by the "--no-experimental-strip-types" flag.` + ' Falling back to legacy resolution.' + ' Learn more: https://nextjs.org/docs/app/api-reference/config/typescript#using-nodejs-native-typescript-resolver-for-nextconfigts');
+                    (0, _log.warnOnce)(`Skipped resolving "${_nodepath.default.basename(nextConfigPath)}" using Node.js native TypeScript resolution because it was disabled by the "--no-experimental-strip-types" flag.` + ' Falling back to legacy resolution.' + ' Learn more: https://nextjs.org/docs/app/api-reference/config/typescript#using-nodejs-native-typescript-resolver-for-nextconfigts');
                 }
                 // Feature is not enabled, fallback to legacy resolution for current session.
                 process.env.__NEXT_NODE_NATIVE_TS_LOADER_ENABLED = 'false';
             } catch (cause) {
-                (0, _log.warnOnce)(`Failed to import "${configFileName}" using Node.js native TypeScript resolution.` + ' Falling back to legacy resolution.' + ' Learn more: https://nextjs.org/docs/app/api-reference/config/typescript#using-nodejs-native-typescript-resolver-for-nextconfigts', {
+                (0, _log.warnOnce)(`Failed to import "${_nodepath.default.basename(nextConfigPath)}" using Node.js native TypeScript resolution.` + ' Falling back to legacy resolution.' + ' Learn more: https://nextjs.org/docs/app/api-reference/config/typescript#using-nodejs-native-typescript-resolver-for-nextconfigts', {
                     cause
                 });
                 // Once failed, fallback to legacy resolution for current session.
                 process.env.__NEXT_NODE_NATIVE_TS_LOADER_ENABLED = 'false';
             }
         }
-        // Ensure TypeScript is installed to use the API.
-        await verifyTypeScriptSetup(cwd, configFileName);
-        const compilerOptions = await getTsConfig(cwd);
+        const compilerOptions = await loadTsConfig(dir);
         return handleCJS({
-            cwd,
+            dir,
             nextConfigPath,
             compilerOptions
         });
     } catch (cause) {
-        throw Object.defineProperty(new Error(`Failed to transpile "${configFileName}".`, {
+        throw Object.defineProperty(new Error(`Failed to transpile "${_nodepath.default.basename(nextConfigPath)}".`, {
             cause
         }), "__NEXT_ERROR_CODE", {
             value: "E797",
@@ -134,12 +213,12 @@ async function transpileConfig({ nextConfigPath, configFileName, cwd }) {
         });
     }
 }
-async function handleCJS({ cwd, nextConfigPath, compilerOptions }) {
-    const swcOptions = resolveSWCOptions(cwd, compilerOptions);
+async function handleCJS({ dir, nextConfigPath, compilerOptions }) {
+    const swcOptions = resolveSWCOptions(dir, compilerOptions);
     let hasRequire = false;
     try {
         var _config_experimental;
-        const nextConfigString = await (0, _promises.readFile)(nextConfigPath, 'utf8');
+        const nextConfigString = (0, _nodefs.readFileSync)(nextConfigPath, 'utf8');
         // lazy require swc since it loads React before even setting NODE_ENV
         // resulting loading Development React on Production
         const { loadBindings } = require('../swc');
@@ -151,7 +230,7 @@ async function handleCJS({ cwd, nextConfigPath, compilerOptions }) {
             hasRequire = true;
         }
         // filename & extension don't matter here
-        const config = (0, _requirehook.requireFromString)(code, (0, _nodepath.resolve)(cwd, 'next.config.compiled.js'));
+        const config = (0, _requirehook.requireFromString)(code, _nodepath.default.resolve(dir, 'next.config.compiled.js'));
         // At this point we have already loaded the bindings without this configuration setting due to the `transform` call above.
         // Possibly we fell back to wasm in which case, it all works out but if not we need to warn
         // that the configuration was ignored.

package/standalone/node_modules/next/dist/build/print-build-errors.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "printBuildErrors", {
+    enumerable: true,
+    get: function() {
+        return printBuildErrors;
+    }
+});
+const _utils = require("../shared/lib/turbopack/utils");
+function printBuildErrors(entrypoints, isDev) {
+    // Issues that we want to stop the server from executing
+    const topLevelFatalIssues = [];
+    // Issues that are true errors, but we believe we can keep running and allow the user to address the issue
+    const topLevelErrors = [];
+    // Issues that are warnings but should not affect the running of the build
+    const topLevelWarnings = [];
+    // Track seen formatted error messages to avoid duplicates
+    const seenFatalIssues = new Set();
+    const seenErrors = new Set();
+    const seenWarnings = new Set();
+    for (const issue of entrypoints.issues){
+        // We only want to completely shut down the server
+        if (issue.severity === 'fatal' || issue.severity === 'bug') {
+            const formatted = (0, _utils.formatIssue)(issue);
+            if (!seenFatalIssues.has(formatted)) {
+                seenFatalIssues.add(formatted);
+                topLevelFatalIssues.push(formatted);
+            }
+        } else if ((0, _utils.isRelevantWarning)(issue)) {
+            const formatted = (0, _utils.formatIssue)(issue);
+            if (!seenWarnings.has(formatted)) {
+                seenWarnings.add(formatted);
+                topLevelWarnings.push(formatted);
+            }
+        } else if (issue.severity === 'error') {
+            const formatted = (0, _utils.formatIssue)(issue);
+            if (isDev) {
+                // We want to treat errors as recoverable in development
+                // so that we can show the errors in the site and allow users
+                // to respond to the errors when necessary. In production builds
+                // though we want to error out and stop the build process.
+                if (!seenErrors.has(formatted)) {
+                    seenErrors.add(formatted);
+                    topLevelErrors.push(formatted);
+                }
+            } else {
+                if (!seenFatalIssues.has(formatted)) {
+                    seenFatalIssues.add(formatted);
+                    topLevelFatalIssues.push(formatted);
+                }
+            }
+        }
+    }
+    // TODO: print in order by source location so issues from the same file are displayed together and then add a summary at the end about the number of warnings/errors
+    if (topLevelWarnings.length > 0) {
+        console.warn(`Turbopack build encountered ${topLevelWarnings.length} warnings:\n${topLevelWarnings.join('\n')}`);
+    }
+    if (topLevelErrors.length > 0) {
+        console.error(`Turbopack build encountered ${topLevelErrors.length} errors:\n${topLevelErrors.join('\n')}`);
+    }
+    if (topLevelFatalIssues.length > 0) {
+        throw Object.defineProperty(new Error(`Turbopack build failed with ${topLevelFatalIssues.length} errors:\n${topLevelFatalIssues.join('\n')}`), "__NEXT_ERROR_CODE", {
+            value: "E425",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+
+//# sourceMappingURL=print-build-errors.js.map