@nuxt/rspack-builder 3.20.2 → 3.21.0

package/dist/index.mjs

@@ -1,193 +1,527 @@
-import pify from 'pify';
-import { fromNodeMiddleware, defineEventHandler, handleCors, getRequestHeader, createError, setHeader } from 'h3';
-import webpackDevMiddleware from 'webpack-dev-middleware';
-import webpackHotMiddleware from 'webpack-hot-middleware';
-import { defu } from 'defu';
-import { joinURL } from 'ufo';
-import { logger, useNitro, useNuxt } from '@nuxt/kit';
-import { createUnplugin } from 'unplugin';
-import MagicString from 'magic-string';
-import { webpack, WebpackBarPlugin, builder, MiniCssExtractPlugin, TsCheckerPlugin } from '#builder';
-import { join, resolve, normalize, isAbsolute } from 'pathe';
-import { createFsFromVolume, Volume } from 'memfs';
-import querystring from 'node:querystring';
-import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer';
-import { defineEnv } from 'unenv';
-import TimeFixPlugin from 'time-fix-plugin';
-import FriendlyErrorsWebpackPlugin from '@nuxt/friendly-errors-webpack-plugin';
-import escapeRegExp from 'escape-string-regexp';
-import { isTest } from 'std-env';
-import { genObjectFromRawEntries, genString } from 'knitwork';
-import { EsbuildPlugin } from 'esbuild-loader';
-import CssMinimizerPlugin from 'css-minimizer-webpack-plugin';
-import createResolver from 'postcss-import-resolver';
-import { createJiti } from 'jiti';
-import VueLoaderPlugin from 'vue-loader/dist/pluginWebpack5.js';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { normalizeWebpackManifest, precomputeDependencies } from 'vue-bundle-renderer';
-import { hash } from 'ohash';
-import { serialize } from 'seroval';
+import { createRequire } from "node:module";
+import pify from "pify";
+import webpackDevMiddleware from "webpack-dev-middleware";
+import webpackHotMiddleware from "webpack-hot-middleware";
+import { defu } from "defu";
+import { joinURL, parseURL, withTrailingSlash } from "ufo";
+import { directoryToURL, logger, resolveAlias, useNitro, useNuxt } from "@nuxt/kit";
+import { createUnplugin } from "unplugin";
+import MagicString from "magic-string";
+import { MiniCssExtractPlugin, TsCheckerPlugin, WebpackBarPlugin, builder, webpack } from "#builder";
+import { existsSync, readFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { isAbsolute, join, normalize, relative, resolve } from "pathe";
+import { genArrayFromRaw, genObjectFromRawEntries, genString } from "knitwork";
+import { compileStyle, parse } from "@vue/compiler-sfc";
+import { createHash } from "node:crypto";
+import { Volume, createFsFromVolume } from "memfs";
+import querystring from "node:querystring";
+import { BundleAnalyzerPlugin } from "webpack-bundle-analyzer";
+import { defineEnv } from "unenv";
+import TimeFixPlugin from "time-fix-plugin";
+import FriendlyErrorsWebpackPlugin from "@nuxt/friendly-errors-webpack-plugin";
+import escapeRegExp from "escape-string-regexp";
+import { isTest } from "std-env";
+import { EsbuildPlugin } from "esbuild-loader";
+import CssMinimizerPlugin from "css-minimizer-webpack-plugin";
+import createResolver from "postcss-import-resolver";
+import { createJiti } from "jiti";
+import VueLoaderPlugin from "vue-loader/dist/pluginWebpack5.js";
+import { resolveModulePath } from "exsolve";
+import { mkdir, writeFile } from "node:fs/promises";
+import { normalizeWebpackManifest, precomputeDependencies } from "vue-bundle-renderer";
+import { hash } from "ohash";
+import { serialize } from "seroval";
+import { parseNodeModulePath } from "mlly";
 
+//#region ../webpack/src/plugins/dynamic-base.ts
 const defaults = {
-  globalPublicPath: "__webpack_public_path__",
-  sourcemap: true
+	globalPublicPath: "__webpack_public_path__",
+	sourcemap: true
 };
 const ENTRY_RE = /import ["']#build\/css["'];/;
 const DynamicBasePlugin = createUnplugin((options = {}) => {
-  options = { ...defaults, ...options };
-  return {
-    name: "nuxt:dynamic-base-path",
-    enforce: "post",
-    transform: {
-      filter: {
-        id: { include: /entry/ },
-        code: { include: ENTRY_RE }
-      },
-      handler(code) {
-        const s = new MagicString(code);
-        s.prepend(`import { buildAssetsURL } from '#internal/nuxt/paths';
-${options.globalPublicPath} = buildAssetsURL();
-`);
-        return {
-          code: s.toString(),
-          map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
-        };
-      }
-    }
-  };
+	options = {
+		...defaults,
+		...options
+	};
+	return {
+		name: "nuxt:dynamic-base-path",
+		enforce: "post",
+		transform: {
+			filter: {
+				id: { include: /entry/ },
+				code: { include: ENTRY_RE }
+			},
+			handler(code) {
+				const s = new MagicString(code);
+				s.prepend(`import { buildAssetsURL } from '#internal/nuxt/paths';\n${options.globalPublicPath} = buildAssetsURL();\n`);
+				return {
+					code: s.toString(),
+					map: options.sourcemap ? s.generateMap({ hires: true }) : void 0
+				};
+			}
+		}
+	};
 });
 
+//#endregion
+//#region ../webpack/src/plugins/chunk.ts
 const pluginName = "ChunkErrorPlugin";
-class ChunkErrorPlugin {
-  script = `
-if (typeof ${webpack.RuntimeGlobals.require} !== "undefined") {
-  var _ensureChunk = ${webpack.RuntimeGlobals.ensureChunk};
-  ${webpack.RuntimeGlobals.ensureChunk} = function (chunkId) {
-    return Promise.resolve(_ensureChunk(chunkId)).catch(error => {
-      const e = new Event('nuxt:preloadError', { cancelable: true })
-      e.payload = error
-      window.dispatchEvent(e)
-      throw error
+var ChunkErrorPlugin = class {
+	apply(compiler) {
+		compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
+			compilation.hooks.runtimeRequirementInTree.for(webpack.RuntimeGlobals.ensureChunk).tap(pluginName, (chunk) => {
+				compilation.addRuntimeModule(chunk, new ChunkErrorRuntimeModule());
+			});
+		});
+	}
+};
+var ChunkErrorRuntimeModule = class extends webpack.RuntimeModule {
+	constructor() {
+		super("chunk preload error handler", webpack.RuntimeModule.STAGE_ATTACH);
+	}
+	generate() {
+		const { ensureChunk } = webpack.RuntimeGlobals;
+		return `
+if (typeof ${ensureChunk} !== "undefined") {
+  var _ensureChunk = ${ensureChunk};
+  ${ensureChunk} = function (chunkId) {
+    return Promise.resolve(_ensureChunk(chunkId)).catch(function(error) {
+      var e = new Event('nuxt:preloadError', { cancelable: true });
+      e.payload = error;
+      window.dispatchEvent(e);
+      throw error;
     });
   };
-};`;
-  apply(compiler) {
-    compiler.hooks.thisCompilation.tap(
-      pluginName,
-      (compilation) => compilation.mainTemplate.hooks.localVars.tap(
-        { name: pluginName, stage: 1 },
-        (source) => source + this.script
-      )
-    );
-  }
 }
+`;
+	}
+};
+
+//#endregion
+//#region ../webpack/src/plugins/ssr-styles.ts
+const CSS_URL_RE = /url\((['"]?)(\/[^)]+?)\1\)/g;
+const isVueFile = (id) => /\.vue(?:\?|$)/.test(id);
+const isCSSLike = (name) => /\.(?:css|scss|sass|less|styl(?:us)?|postcss|pcss)(?:\?|$)/.test(name);
+function normalizePath(nuxt$1, id) {
+	if (!id) return null;
+	const { pathname } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+	const rel = relative(nuxt$1.options.srcDir, pathname);
+	if (rel.startsWith("..")) return null;
+	return rel;
+}
+function resolveFilePath(id) {
+	if (!id) return null;
+	return parseURL(decodeURIComponent(pathToFileURL(id).href)).pathname || null;
+}
+function sanitizeStyleAssetName(rel) {
+	return rel.replace(/[\\/]/g, "_").replace(/\.{2,}/g, "_");
+}
+function normalizeCSSContent(css) {
+	return css.trim().replace(/(--[^:]+):\s*'([^']*)'/g, "$1:\"$2\"").replace(/:\s+/g, ":").replace(/\s*\{\s*/g, "{").replace(/;\s*\}/g, "}").replace(/\s*\}\s*/g, "}");
+}
+function extractVueStyles(filePath) {
+	try {
+		const { descriptor } = parse(readFileSync(filePath, "utf8"), { filename: filePath });
+		const styles = [];
+		const scopeId = createHash("sha256").update(filePath).digest("hex").slice(0, 8);
+		for (let i = 0; i < descriptor.styles.length; i++) {
+			const style$1 = descriptor.styles[i];
+			const result = compileStyle({
+				source: style$1.content,
+				filename: filePath,
+				id: `data-v-${scopeId}`,
+				scoped: style$1.scoped
+			});
+			if (!result.errors.length && result.code) styles.push(normalizeCSSContent(result.code));
+		}
+		return styles;
+	} catch {
+		return [];
+	}
+}
+var SSRStylesPlugin = class {
+	nuxt;
+	clientCSSByIssuer = /* @__PURE__ */ new Map();
+	chunksWithInlinedCSS = /* @__PURE__ */ new Set();
+	globalCSSPaths = /* @__PURE__ */ new Set();
+	constructor(nuxt$1) {
+		this.nuxt = nuxt$1;
+		this.globalCSSPaths = this.resolveGlobalCSS();
+		nuxt$1.hook("build:manifest", (manifest) => {
+			for (const [id, chunk] of Object.entries(manifest)) {
+				if (chunk.isEntry && chunk.src) this.chunksWithInlinedCSS.add(chunk.src);
+				else if (this.chunksWithInlinedCSS.has(id)) chunk.css &&= [];
+				if (chunk.css?.length) chunk.css = chunk.css.filter((cssPath) => {
+					for (const globalPath of this.globalCSSPaths) if (cssPath.includes(globalPath.split("/").pop() || "")) return false;
+					return true;
+				});
+			}
+		});
+	}
+	shouldInline(mod) {
+		const shouldInline = this.nuxt.options.features.inlineStyles;
+		if (typeof shouldInline === "boolean") return shouldInline;
+		return shouldInline(mod.identifier());
+	}
+	escapeTemplateLiteral(str) {
+		return str.replace(/[`\\$]/g, (m) => m === "$" ? "\\$" : `\\${m}`);
+	}
+	isBuildAsset(url) {
+		const buildDir = withTrailingSlash(this.nuxt.options.app.buildAssetsDir || "/_nuxt/");
+		return url.startsWith(buildDir);
+	}
+	isPublicAsset(url, nitro) {
+		const cleaned = url.replace(/[?#].*$/, "");
+		for (const dir of nitro.options.publicAssets) {
+			const base$1 = withTrailingSlash(dir.baseURL || "/");
+			if (!url.startsWith(base$1)) continue;
+			if (existsSync(cleaned.replace(base$1, withTrailingSlash(dir.dir)))) return true;
+		}
+		return false;
+	}
+	rewriteStyle(css, nitro) {
+		let changed = false;
+		let needsPublicAsset = false;
+		let needsBuildAsset = false;
+		let lastIndex = 0;
+		let out = "`";
+		for (const match of css.matchAll(CSS_URL_RE)) {
+			const index = match.index ?? 0;
+			const before = css.slice(lastIndex, index);
+			if (before) out += this.escapeTemplateLiteral(before);
+			const full = match[0];
+			const rawUrl = match[2] || "";
+			const stripped = rawUrl.replace(/[?#].*$/, "");
+			if (this.isPublicAsset(stripped, nitro)) {
+				needsPublicAsset = true;
+				changed = true;
+				out += "${publicAssetsURL(" + JSON.stringify(rawUrl) + ")}";
+			} else if (this.isBuildAsset(stripped)) {
+				needsBuildAsset = true;
+				changed = true;
+				out += "${buildAssetsURL(" + JSON.stringify(rawUrl) + ")}";
+			} else out += this.escapeTemplateLiteral(full);
+			lastIndex = index + full.length;
+		}
+		const tail = css.slice(lastIndex);
+		if (tail) out += this.escapeTemplateLiteral(tail);
+		out += "`";
+		return {
+			code: changed ? out : JSON.stringify(css),
+			needsPublicAsset,
+			needsBuildAsset
+		};
+	}
+	resolveGlobalCSS() {
+		const req = createRequire(this.nuxt.options.rootDir);
+		const resolved = /* @__PURE__ */ new Set();
+		const entries = this.nuxt.options.css || [];
+		for (const entry of entries) {
+			const src = typeof entry === "string" ? entry : entry?.src;
+			if (!src) continue;
+			const path = this.resolveCSSRequest(src, req);
+			if (path) resolved.add(path);
+		}
+		return resolved;
+	}
+	resolveCSSRequest(request, req) {
+		const candidates = /* @__PURE__ */ new Set();
+		const resolved = resolveAlias(request, this.nuxt.options.alias);
+		if (isAbsolute(resolved)) candidates.add(resolved);
+		else candidates.add(resolve(this.nuxt.options.srcDir, resolved));
+		try {
+			candidates.add(req.resolve(request));
+		} catch {}
+		for (const candidate of candidates) {
+			const path = resolveFilePath(candidate);
+			if (path) return path;
+		}
+		return null;
+	}
+	normalizeResourcePath(resource) {
+		if (!resource) return null;
+		const withoutQuery = resource.split("?")[0];
+		return resolveFilePath(withoutQuery);
+	}
+	apply(compiler) {
+		if (this.nuxt.options.dev) return;
+		const isClient = compiler.options.name === "client";
+		const isServer = compiler.options.name === "server";
+		if (!isClient && !isServer) return;
+		compiler.hooks.thisCompilation.tap("SSRStylesPlugin", (compilation) => {
+			this.collectCSS(compilation);
+			if (isClient) this.removeGlobalCSSFromClient(compilation);
+			if (isServer) this.emitServerStyles(compilation);
+		});
+	}
+	emitServerStyles(compilation) {
+		const { webpack: webpack$1 } = compilation.compiler;
+		const stage = webpack$1.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE;
+		compilation.hooks.processAssets.tap({
+			name: "SSRStylesPlugin",
+			stage
+		}, () => {
+			const nitro = useNitro();
+			const collected = new Map(this.clientCSSByIssuer);
+			const entryModules = /* @__PURE__ */ new Set();
+			for (const entrypoint of compilation.entrypoints.values()) {
+				const primaryChunk = typeof entrypoint.getEntrypointChunk === "function" ? entrypoint.getEntrypointChunk() : void 0;
+				const chunks = primaryChunk ? [primaryChunk] : entrypoint.chunks;
+				for (const chunk of chunks) for (const mod of compilation.chunkGraph.getChunkModulesIterable(chunk)) if ("resource" in mod && typeof mod.resource === "string") {
+					const resolved = resolveFilePath(mod.resource);
+					if (resolved) {
+						const rel = normalizePath(this.nuxt, resolved);
+						if (rel) entryModules.add(rel);
+						else entryModules.add(resolved);
+					}
+				}
+			}
+			for (const module of compilation.modules) {
+				const resource = module.resource;
+				if (!resource || !isVueFile(resource)) continue;
+				const rel = normalizePath(this.nuxt, resource);
+				if (!rel) continue;
+				if (collected.has(rel)) continue;
+				const vueStyles = extractVueStyles(resolveFilePath(resource) || resource);
+				if (vueStyles.length) collected.set(rel, new Set(vueStyles));
+			}
+			const emitted = {};
+			const rawSource = webpack$1.sources.RawSource;
+			for (const [rel, cssSet] of collected.entries()) {
+				if (!cssSet.size) continue;
+				const transformed = Array.from(cssSet).map((style$1) => this.rewriteStyle(style$1, nitro));
+				const needsPublicAssets = transformed.some((t) => t.needsPublicAsset);
+				const needsBuildAssets = transformed.some((t) => t.needsBuildAsset);
+				const imports = [];
+				if (needsPublicAssets || needsBuildAssets) {
+					const names = [];
+					if (needsBuildAssets) names.push("buildAssetsURL");
+					if (needsPublicAssets) names.push("publicAssetsURL");
+					imports.push(`import { ${names.join(", ")} } from '#internal/nuxt/paths'`);
+				}
+				const moduleSource = [...imports, `export default ${genArrayFromRaw(transformed.map((t) => t.code))}`].filter(Boolean).join("\n");
+				const styleModuleName = `${sanitizeStyleAssetName(rel)}-styles.mjs`;
+				compilation.emitAsset(styleModuleName, new rawSource(moduleSource));
+				emitted[rel] = styleModuleName;
+				this.chunksWithInlinedCSS.add(rel);
+			}
+			const stylesSource = ["const interopDefault = r => r.default || r || []", `export default ${genObjectFromRawEntries(Object.entries(emitted).map(([key, value]) => [key, `() => import('./${value}').then(interopDefault)`]))}`].join("\n");
+			compilation.emitAsset("styles.mjs", new rawSource(stylesSource));
+			const entryIds = Array.from(this.chunksWithInlinedCSS).filter((id) => entryModules.has(id));
+			nitro.options.virtual["#internal/nuxt/entry-ids.mjs"] = () => `export default ${JSON.stringify(entryIds)}`;
+			nitro.options._config.virtual ||= {};
+			nitro.options._config.virtual["#internal/nuxt/entry-ids.mjs"] = nitro.options.virtual["#internal/nuxt/entry-ids.mjs"];
+		});
+	}
+	findIssuerPath(compilation, mod) {
+		let issuer = compilation.moduleGraph.getIssuer(mod);
+		while (issuer) {
+			if ("resource" in issuer && typeof issuer.resource === "string") return issuer.resource;
+			issuer = compilation.moduleGraph.getIssuer(issuer);
+		}
+		return null;
+	}
+	removeGlobalCSSFromClient(compilation) {
+		compilation.hooks.processAssets.tap({
+			name: "SSRStylesPlugin:RemoveGlobalCSS",
+			stage: 650
+		}, () => {
+			for (const chunk of compilation.chunks) if (chunk.name === "nuxt-global-css") {
+				const cssAssets = [];
+				for (const file of Array.from(chunk.files)) {
+					const filename = String(file);
+					if (isCSSLike(filename)) {
+						const source = compilation.getAsset(filename)?.source;
+						const content = source && typeof source.source === "function" ? source.source() : null;
+						const text = typeof content === "string" ? content : content instanceof Buffer ? content.toString("utf8") : "";
+						if (text) cssAssets.push(text);
+					}
+				}
+				if (cssAssets.length > 0) for (const mod of compilation.chunkGraph.getChunkModulesIterable(chunk)) {
+					const issuerPath = this.findIssuerPath(compilation, mod) || ("resource" in mod && typeof mod.resource === "string" ? mod.resource : null);
+					const normalized = normalizePath(this.nuxt, issuerPath);
+					if (!normalized) continue;
+					const set = this.clientCSSByIssuer.get(normalized) || /* @__PURE__ */ new Set();
+					for (const css of cssAssets) set.add(normalizeCSSContent(css));
+					this.clientCSSByIssuer.set(normalized, set);
+				}
+				for (const file of Array.from(chunk.files)) {
+					const filename = String(file);
+					if (isCSSLike(filename)) {
+						compilation.deleteAsset(filename);
+						chunk.files.delete(file);
+					}
+				}
+			}
+		});
+	}
+	collectCSS(compilation) {
+		const { webpack: webpack$1 } = compilation.compiler;
+		const stage = compilation.compiler.options.name === "server" ? webpack$1.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS : webpack$1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER;
+		const chunkCSSMeta = /* @__PURE__ */ new Map();
+		compilation.hooks.processAssets.tap({
+			name: "SSRStylesPlugin",
+			stage
+		}, () => {
+			const cssAssetsByChunk = /* @__PURE__ */ new Map();
+			for (const chunk of compilation.chunks) {
+				const cssAssets = [];
+				const chunkCSSFiles = [];
+				for (const file of chunk.files) {
+					if (!isCSSLike(file)) continue;
+					chunkCSSFiles.push(file);
+					const source = compilation.getAsset(file)?.source;
+					const content = source && typeof source.source === "function" ? source.source() : null;
+					const text = typeof content === "string" ? content : content instanceof Buffer ? content.toString("utf8") : "";
+					if (text) cssAssets.push(text);
+				}
+				if (chunkCSSFiles.length) {
+					const chunkCSSModules = Array.from(compilation.chunkGraph.getChunkModulesIterable(chunk));
+					chunkCSSMeta.set(chunk, {
+						files: chunkCSSFiles,
+						modules: chunkCSSModules
+					});
+				}
+				if (cssAssets.length) cssAssetsByChunk.set(chunk, cssAssets);
+			}
+			for (const [chunk, cssAssets] of cssAssetsByChunk) for (const mod of compilation.chunkGraph.getChunkModulesIterable(chunk)) {
+				if (!this.shouldInline(mod)) continue;
+				const issuerPath = this.findIssuerPath(compilation, mod) || ("resource" in mod && typeof mod.resource === "string" ? mod.resource : null);
+				const normalized = normalizePath(this.nuxt, issuerPath);
+				if (!normalized) continue;
+				const set = this.clientCSSByIssuer.get(normalized) || /* @__PURE__ */ new Set();
+				for (const css of cssAssets) set.add(normalizeCSSContent(css));
+				this.clientCSSByIssuer.set(normalized, set);
+			}
+			for (const mod of compilation.modules) {
+				if (!this.shouldInline(mod)) continue;
+				const issuerPath = this.findIssuerPath(compilation, mod);
+				const normalized = normalizePath(this.nuxt, issuerPath);
+				if (!normalized) continue;
+				const cssChunks = this.getModuleCSS(mod, compilation);
+				if (!cssChunks.length) continue;
+				const set = this.clientCSSByIssuer.get(normalized) || /* @__PURE__ */ new Set();
+				set.add(cssChunks.join("\n"));
+				this.clientCSSByIssuer.set(normalized, set);
+			}
+		});
+	}
+	getModuleCSS(mod, _compilation) {
+		const cssModule = mod;
+		const cssChunks = [];
+		if (mod.type === "css/mini-extract" && Array.isArray(cssModule.content)) for (const part of cssModule.content) {
+			const css = part?.[1];
+			if (css && typeof css === "string") cssChunks.push(normalizeCSSContent(css));
+		}
+		return cssChunks;
+	}
+};
 
+//#endregion
+//#region ../webpack/src/utils/mfs.ts
 function createMFS() {
-  const fs = createFsFromVolume(new Volume());
-  const _fs = { ...fs };
-  _fs.join = join;
-  _fs.exists = (p) => Promise.resolve(_fs.existsSync(p));
-  _fs.readFile = pify(_fs.readFile);
-  return _fs;
+	const _fs = { ...createFsFromVolume(new Volume()) };
+	_fs.join = join;
+	_fs.exists = (p) => Promise.resolve(_fs.existsSync(p));
+	_fs.readFile = pify(_fs.readFile);
+	return _fs;
 }
 
+//#endregion
+//#region ../webpack/src/utils/index.ts
+/** @since 3.9.0 */
 function toArray(value) {
-  return Array.isArray(value) ? value : [value];
+	return Array.isArray(value) ? value : [value];
 }
 
-function createWebpackConfigContext(nuxt) {
-  return {
-    nuxt,
-    options: nuxt.options,
-    userConfig: nuxt.options.webpack,
-    config: {},
-    name: "base",
-    isDev: nuxt.options.dev,
-    isServer: false,
-    isClient: false,
-    alias: {},
-    transpile: []
-  };
+//#endregion
+//#region ../webpack/src/utils/config.ts
+function createWebpackConfigContext(nuxt$1) {
+	return {
+		nuxt: nuxt$1,
+		options: nuxt$1.options,
+		userConfig: nuxt$1.options.webpack,
+		config: {},
+		name: "base",
+		isDev: nuxt$1.options.dev,
+		isServer: false,
+		isClient: false,
+		alias: {},
+		transpile: []
+	};
 }
 async function applyPresets(ctx, presets) {
-  for (const preset of toArray(presets)) {
-    if (Array.isArray(preset)) {
-      await preset[0](ctx, preset[1]);
-    } else {
-      await preset(ctx);
-    }
-  }
+	for (const preset of toArray(presets)) if (Array.isArray(preset)) await preset[0](ctx, preset[1]);
+	else await preset(ctx);
 }
 function fileName(ctx, key) {
-  let fileName2 = ctx.userConfig.filenames[key];
-  if (typeof fileName2 === "function") {
-    fileName2 = fileName2(ctx);
-  }
-  if (typeof fileName2 === "string" && ctx.options.dev) {
-    const hash = /\[(chunkhash|contenthash|hash)(?::\d+)?\]/.exec(fileName2);
-    if (hash) {
-      logger.warn(`Notice: Please do not use ${hash[1]} in dev mode to prevent memory leak`);
-    }
-  }
-  return fileName2;
+	let fileName$1 = ctx.userConfig.filenames[key];
+	if (typeof fileName$1 === "function") fileName$1 = fileName$1(ctx);
+	if (typeof fileName$1 === "string" && ctx.options.dev) {
+		const hash$1 = /\[(chunkhash|contenthash|hash)(?::\d+)?\]/.exec(fileName$1);
+		if (hash$1) logger.warn(`Notice: Please do not use ${hash$1[1]} in dev mode to prevent memory leak`);
+	}
+	return fileName$1;
 }
 
+//#endregion
+//#region ../webpack/src/presets/assets.ts
 function assets(ctx) {
-  ctx.config.module.rules.push(
-    {
-      test: /\.(png|jpe?g|gif|svg|webp)$/i,
-      use: [{
-        loader: "url-loader",
-        options: {
-          ...ctx.userConfig.loaders.imgUrl,
-          name: fileName(ctx, "img")
-        }
-      }]
-    },
-    {
-      test: /\.(woff2?|eot|ttf|otf)(\?.*)?$/i,
-      use: [{
-        loader: "url-loader",
-        options: {
-          ...ctx.userConfig.loaders.fontUrl,
-          name: fileName(ctx, "font")
-        }
-      }]
-    },
-    {
-      test: /\.(webm|mp4|ogv)$/i,
-      use: [{
-        loader: "file-loader",
-        options: {
-          ...ctx.userConfig.loaders.file,
-          name: fileName(ctx, "video")
-        }
-      }]
-    }
-  );
+	ctx.config.module.rules.push({
+		test: /\.(png|jpe?g|gif|svg|webp)$/i,
+		use: [{
+			loader: "url-loader",
+			options: {
+				...ctx.userConfig.loaders.imgUrl,
+				name: fileName(ctx, "img")
+			}
+		}]
+	}, {
+		test: /\.(woff2?|eot|ttf|otf)(\?.*)?$/i,
+		use: [{
+			loader: "url-loader",
+			options: {
+				...ctx.userConfig.loaders.fontUrl,
+				name: fileName(ctx, "font")
+			}
+		}]
+	}, {
+		test: /\.(webm|mp4|ogv)$/i,
+		use: [{
+			loader: "file-loader",
+			options: {
+				...ctx.userConfig.loaders.file,
+				name: fileName(ctx, "video")
+			}
+		}]
+	});
 }
 
-class WarningIgnorePlugin {
-  filter;
-  constructor(filter) {
-    this.filter = filter;
-  }
-  apply(compiler) {
-    compiler.hooks.done.tap("warnfix-plugin", (stats) => {
-      stats.compilation.warnings = stats.compilation.warnings.filter(this.filter);
-    });
-  }
-}
+//#endregion
+//#region ../webpack/src/plugins/warning-ignore.ts
+var WarningIgnorePlugin = class {
+	filter;
+	constructor(filter) {
+		this.filter = filter;
+	}
+	apply(compiler) {
+		compiler.hooks.done.tap("warnfix-plugin", (stats) => {
+			stats.compilation.warnings = stats.compilation.warnings.filter(this.filter);
+		});
+	}
+};
 
+//#endregion
+//#region ../webpack/src/plugins/vue/util.ts
+/**
+* This file is based on Vue.js (MIT) webpack plugins
+* https://github.com/vuejs/vue/blob/dev/src/server/webpack-plugin/util.js
+*/
 const validate = (compiler) => {
-  if (compiler.options.target !== "node") {
-    logger.warn('webpack config `target` should be "node".');
-  }
-  if (!compiler.options.externals) {
-    logger.info(
-      "It is recommended to externalize dependencies in the server build for better build performance."
-    );
-  }
+	if (compiler.options.target !== "node") logger.warn("webpack config `target` should be \"node\".");
+	if (!compiler.options.externals) logger.info("It is recommended to externalize dependencies in the server build for better build performance.");
 };
 const isJSRegExp = /\.[cm]?js(\?[^.]+)?$/;
 const isJS = (file) => isJSRegExp.test(file);
@@ -196,87 +530,66 @@ const isCSSRegExp = /\.css(?:\?[^.]+)?$/;
 const isCSS = (file) => isCSSRegExp.test(file);
 const isHotUpdate = (file) => file.includes("hot-update");
 
+//#endregion
+//#region ../webpack/src/plugins/rollup-compat-dynamic-import.ts
 const DYNAMIC_IMPORT_RE = /import\([^)]*\+\s*__webpack_require__[^+]*\)\.then/;
 const DYNAMIC_IMPORT_REPLACE_RE = /import\([^)]*\+\s*(__webpack_require__[^+]*)\)\.then/g;
 const HELPER_FILENAME = "_dynamic-import-helper.mjs";
-const HELPER_IMPORT = `import { _rollupDynamicImport } from "./${HELPER_FILENAME}";
-`;
-class RollupCompatDynamicImportPlugin {
-  apply(compiler) {
-    compiler.hooks.compilation.tap("RollupCompatDynamicImportPlugin", (compilation) => {
-      compilation.hooks.processAssets.tapAsync(
-        {
-          name: "RollupCompatDynamicImportPlugin",
-          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE
-        },
-        (assets, callback) => {
-          try {
-            const targetFiles = /* @__PURE__ */ new Set();
-            for (const chunk of compilation.chunks) {
-              if (chunk.canBeInitial() || chunk.hasRuntime()) {
-                for (const file of chunk.files || []) {
-                  targetFiles.add(file);
-                }
-              }
-            }
-            for (const [filename, asset] of Object.entries(assets)) {
-              if (!isJS(filename)) {
-                continue;
-              }
-              if (!targetFiles.has(filename)) {
-                continue;
-              }
-              const source = asset.source();
-              const originalCode = typeof source === "string" ? source : source.toString();
-              if (!DYNAMIC_IMPORT_RE.test(originalCode)) {
-                continue;
-              }
-              const transformedCode = this.transformDynamicImports(originalCode);
-              if (transformedCode !== originalCode) {
-                assets[filename] = new compiler.webpack.sources.RawSource(transformedCode);
-              }
-            }
-            this.generateDynamicImportHelper(compilation);
-            callback();
-          } catch (error) {
-            callback(error);
-          }
-        }
-      );
-    });
-  }
-  transformDynamicImports(source) {
-    let transformed = source;
-    let needsHelperImport = false;
-    transformed = transformed.replace(DYNAMIC_IMPORT_REPLACE_RE, (match, filename) => {
-      needsHelperImport = true;
-      return `_rollupDynamicImport(${filename}).then`;
-    });
-    if (needsHelperImport && !transformed.includes(HELPER_IMPORT)) {
-      transformed = HELPER_IMPORT + transformed;
-    }
-    return transformed;
-  }
-  generateDynamicImportHelper(compilation) {
-    const chunkFiles = [];
-    for (const chunk of compilation.chunks) {
-      if (chunk.hasRuntime()) {
-        continue;
-      }
-      for (const filename of chunk.files) {
-        if (filename && isJS(filename)) {
-          chunkFiles.push(filename);
-        }
-      }
-    }
-    if (chunkFiles.length === 0) {
-      return;
-    }
-    const helperContent = this.generateHelperContent(chunkFiles);
-    compilation.emitAsset(HELPER_FILENAME, new compilation.compiler.webpack.sources.RawSource(helperContent));
-  }
-  generateHelperContent(chunkFiles) {
-    return `
+const HELPER_IMPORT = `import { _rollupDynamicImport } from "./${HELPER_FILENAME}";\n`;
+/**
+* Webpack plugin that generates rollup-compatible dynamic imports.
+* This plugin uses webpack's native compilation hooks to override dynamic import generation
+* and create rollup-compatible code directly during webpack's compilation process.
+*/
+var RollupCompatDynamicImportPlugin = class {
+	apply(compiler) {
+		compiler.hooks.compilation.tap("RollupCompatDynamicImportPlugin", (compilation) => {
+			compilation.hooks.processAssets.tapAsync({
+				name: "RollupCompatDynamicImportPlugin",
+				stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE
+			}, (assets$1, callback) => {
+				try {
+					const targetFiles = /* @__PURE__ */ new Set();
+					for (const chunk of compilation.chunks) if (chunk.canBeInitial() || chunk.hasRuntime()) for (const file of chunk.files || []) targetFiles.add(file);
+					for (const [filename, asset] of Object.entries(assets$1)) {
+						if (!isJS(filename)) continue;
+						if (!targetFiles.has(filename)) continue;
+						const source = asset.source();
+						const originalCode = typeof source === "string" ? source : source.toString();
+						if (!DYNAMIC_IMPORT_RE.test(originalCode)) continue;
+						const transformedCode = this.transformDynamicImports(originalCode);
+						if (transformedCode !== originalCode) assets$1[filename] = new compiler.webpack.sources.RawSource(transformedCode);
+					}
+					this.generateDynamicImportHelper(compilation);
+					callback();
+				} catch (error) {
+					callback(error);
+				}
+			});
+		});
+	}
+	transformDynamicImports(source) {
+		let transformed = source;
+		let needsHelperImport = false;
+		transformed = transformed.replace(DYNAMIC_IMPORT_REPLACE_RE, (match, filename) => {
+			needsHelperImport = true;
+			return `_rollupDynamicImport(${filename}).then`;
+		});
+		if (needsHelperImport && !transformed.includes(HELPER_IMPORT)) transformed = HELPER_IMPORT + transformed;
+		return transformed;
+	}
+	generateDynamicImportHelper(compilation) {
+		const chunkFiles = [];
+		for (const chunk of compilation.chunks) {
+			if (chunk.hasRuntime()) continue;
+			for (const filename of chunk.files) if (filename && isJS(filename)) chunkFiles.push(filename);
+		}
+		if (chunkFiles.length === 0) return;
+		const helperContent = this.generateHelperContent(chunkFiles);
+		compilation.emitAsset(HELPER_FILENAME, new compilation.compiler.webpack.sources.RawSource(helperContent));
+	}
+	generateHelperContent(chunkFiles) {
+		return `
 // Rollup-compatible dynamic import helper generated by webpack
 // This helper enables rollup to consume webpack chunks directly
 
@@ -293,993 +606,912 @@ export function _rollupDynamicImport(chunkId) {
   return chunk()
 }
 `;
-  }
-}
+	}
+};
 
+//#endregion
+//#region ../webpack/src/presets/base.ts
 async function base(ctx) {
-  await applyPresets(ctx, [
-    baseAlias,
-    baseConfig,
-    basePlugins,
-    baseResolve,
-    baseTranspile
-  ]);
+	await applyPresets(ctx, [
+		baseAlias,
+		baseConfig,
+		basePlugins,
+		baseResolve,
+		baseTranspile
+	]);
 }
 function baseConfig(ctx) {
-  ctx.config = defu({}, {
-    name: ctx.name,
-    entry: { app: [resolve(ctx.options.appDir, ctx.options.experimental.asyncEntry ? "entry.async" : "entry")] },
-    module: { rules: [] },
-    plugins: [],
-    externals: [],
-    optimization: {
-      ...ctx.userConfig.optimization,
-      minimizer: []
-    },
-    experiments: {
-      ...ctx.userConfig.experiments
-    },
-    mode: ctx.isDev ? "development" : "production",
-    cache: getCache(ctx),
-    output: getOutput(ctx),
-    stats: statsMap[ctx.nuxt.options.logLevel] ?? statsMap.info,
-    ...ctx.config
-  });
+	ctx.config = defu({}, {
+		name: ctx.name,
+		entry: { app: [resolve(ctx.options.appDir, ctx.options.experimental.asyncEntry ? "entry.async" : "entry")] },
+		module: { rules: [] },
+		plugins: [],
+		externals: [],
+		optimization: {
+			...ctx.userConfig.optimization,
+			minimizer: []
+		},
+		experiments: { ...ctx.userConfig.experiments },
+		mode: ctx.isDev ? "development" : "production",
+		cache: getCache(ctx),
+		output: getOutput(ctx),
+		stats: statsMap[ctx.nuxt.options.logLevel] ?? statsMap.info,
+		...ctx.config
+	});
 }
 function basePlugins(ctx) {
-  ctx.config.plugins ||= [];
-  if (ctx.options.dev) {
-    if (ctx.nuxt.options.builder !== "@nuxt/rspack-builder") {
-      ctx.config.plugins.push(new TimeFixPlugin());
-    }
-  }
-  ctx.config.plugins.push(...ctx.userConfig.plugins || []);
-  if (ctx.nuxt.options.builder !== "@nuxt/rspack-builder") {
-    ctx.config.plugins.push(new WarningIgnorePlugin(getWarningIgnoreFilter(ctx)));
-  }
-  ctx.config.plugins.push(new webpack.DefinePlugin(getEnv(ctx)));
-  if (ctx.isServer || ctx.isDev && ctx.userConfig.friendlyErrors) {
-    ctx.config.plugins.push(
-      new FriendlyErrorsWebpackPlugin({
-        clearConsole: false,
-        reporter: "consola",
-        logLevel: "ERROR"
-        // TODO
-      })
-    );
-  }
-  if (ctx.nuxt.options.webpack.profile) {
-    const colors = {
-      client: "green",
-      server: "orange",
-      modern: "blue"
-    };
-    ctx.config.plugins.push(new WebpackBarPlugin({
-      name: ctx.name,
-      color: colors[ctx.name],
-      reporters: ["stats"],
-      // @ts-expect-error TODO: this is a valid option for Webpack.ProgressPlugin and needs to be declared for WebpackBar
-      stats: !ctx.isDev,
-      reporter: {
-        reporter: {
-          change: (_, { shortPath }) => {
-            if (!ctx.isServer) {
-              ctx.nuxt.callHook(`${builder}:change`, shortPath);
-            }
-          },
-          done: (_, { stats }) => {
-            if (stats.hasErrors()) {
-              ctx.nuxt.callHook(`${builder}:error`);
-            } else {
-              logger.success(`Finished building ${stats.compilation.name ?? "Nuxt app"}`);
-            }
-          },
-          allDone: () => {
-            ctx.nuxt.callHook(`${builder}:done`);
-          },
-          progress: ({ webpackbar }) => {
-            ctx.nuxt.callHook(`${builder}:progress`, webpackbar.statesArray);
-          }
-        }
-      }
-    }));
-  }
-  if (ctx.isServer && !ctx.isDev) {
-    ctx.config.plugins.push(new RollupCompatDynamicImportPlugin());
-  }
+	ctx.config.plugins ||= [];
+	if (ctx.options.dev) {
+		if (ctx.nuxt.options.builder !== "@nuxt/rspack-builder") ctx.config.plugins.push(new TimeFixPlugin());
+	}
+	ctx.config.plugins.push(...ctx.userConfig.plugins || []);
+	if (ctx.nuxt.options.builder !== "@nuxt/rspack-builder") ctx.config.plugins.push(new WarningIgnorePlugin(getWarningIgnoreFilter(ctx)));
+	ctx.config.plugins.push(new webpack.DefinePlugin(getEnv(ctx)));
+	if (ctx.isServer || ctx.isDev && ctx.userConfig.friendlyErrors) ctx.config.plugins.push(new FriendlyErrorsWebpackPlugin({
+		clearConsole: false,
+		reporter: "consola",
+		logLevel: "ERROR"
+	}));
+	if (ctx.nuxt.options.webpack.profile) ctx.config.plugins.push(new WebpackBarPlugin({
+		name: ctx.name,
+		color: {
+			client: "green",
+			server: "orange",
+			modern: "blue"
+		}[ctx.name],
+		reporters: ["stats"],
+		stats: !ctx.isDev,
+		reporter: { reporter: {
+			change: (_, { shortPath }) => {
+				if (!ctx.isServer) ctx.nuxt.callHook(`${builder}:change`, shortPath);
+			},
+			done: (_, { stats }) => {
+				if (stats.hasErrors()) ctx.nuxt.callHook(`${builder}:error`);
+				else logger.success(`Finished building ${stats.compilation.name ?? "Nuxt app"}`);
+			},
+			allDone: () => {
+				ctx.nuxt.callHook(`${builder}:done`);
+			},
+			progress: ({ webpackbar }) => {
+				ctx.nuxt.callHook(`${builder}:progress`, webpackbar.statesArray);
+			}
+		} }
+	}));
+	if (ctx.isServer && !ctx.isDev) ctx.config.plugins.push(new RollupCompatDynamicImportPlugin());
 }
 function baseAlias(ctx) {
-  ctx.alias = {
-    "#app": ctx.options.appDir,
-    ...ctx.options.alias,
-    ...ctx.alias
-  };
-  if (ctx.isClient) {
-    ctx.alias["#internal/nitro"] = resolve(ctx.nuxt.options.buildDir, "nitro.client.mjs");
-  }
+	ctx.alias = {
+		"#app": ctx.options.appDir,
+		...ctx.options.alias,
+		...ctx.alias
+	};
+	if (ctx.isClient) ctx.alias["#internal/nitro"] = resolve(ctx.nuxt.options.buildDir, "nitro.client.mjs");
 }
 function baseResolve(ctx) {
-  const webpackModulesDir = ["node_modules"].concat(ctx.options.modulesDir);
-  ctx.config.resolve = {
-    extensions: [".wasm", ".mjs", ".js", ".ts", ".json", ".vue", ".jsx", ".tsx"],
-    alias: ctx.alias,
-    modules: webpackModulesDir,
-    fullySpecified: false,
-    ...ctx.config.resolve
-  };
-  ctx.config.resolveLoader = {
-    modules: webpackModulesDir,
-    ...ctx.config.resolveLoader
-  };
+	const webpackModulesDir = ["node_modules"].concat(ctx.options.modulesDir);
+	ctx.config.resolve = {
+		extensions: [
+			".wasm",
+			".mjs",
+			".js",
+			".ts",
+			".json",
+			".vue",
+			".jsx",
+			".tsx"
+		],
+		alias: ctx.alias,
+		modules: webpackModulesDir,
+		fullySpecified: false,
+		...ctx.config.resolve
+	};
+	ctx.config.resolveLoader = {
+		modules: webpackModulesDir,
+		...ctx.config.resolveLoader
+	};
 }
 function baseTranspile(ctx) {
-  const transpile = [
-    /\.vue\.js/i,
-    // include SFCs in node_modules
-    /consola\/src/,
-    /vue-demi/,
-    /(^|\/)nuxt\/(src\/|dist\/)?(app|[^/]+\/runtime)($|\/)/
-  ];
-  for (let pattern of ctx.options.build.transpile) {
-    if (typeof pattern === "function") {
-      const result = pattern(ctx);
-      if (result) {
-        pattern = result;
-      }
-    }
-    if (typeof pattern === "string") {
-      transpile.push(new RegExp(escapeRegExp(normalize(pattern))));
-    } else if (pattern instanceof RegExp) {
-      transpile.push(pattern);
-    }
-  }
-  ctx.transpile = [...transpile, ...ctx.transpile];
+	const transpile = [
+		/\.vue\.js/i,
+		/consola\/src/,
+		/vue-demi/,
+		/(^|\/)nuxt\/(src\/|dist\/)?(app|[^/]+\/runtime)($|\/)/
+	];
+	for (let pattern of ctx.options.build.transpile) {
+		if (typeof pattern === "function") {
+			const result = pattern(ctx);
+			if (result) pattern = result;
+		}
+		if (typeof pattern === "string") transpile.push(new RegExp(escapeRegExp(normalize(pattern))));
+		else if (pattern instanceof RegExp) transpile.push(pattern);
+	}
+	ctx.transpile = [...transpile, ...ctx.transpile];
 }
 function getCache(ctx) {
-  if (!ctx.options.dev) {
-    return false;
-  }
+	if (!ctx.options.dev) return false;
 }
 function getOutput(ctx) {
-  return {
-    path: resolve(ctx.options.buildDir, "dist", ctx.isServer ? "server" : joinURL("client", ctx.options.app.buildAssetsDir)),
-    filename: fileName(ctx, "app"),
-    chunkFilename: fileName(ctx, "chunk"),
-    publicPath: joinURL(ctx.options.app.baseURL, ctx.options.app.buildAssetsDir)
-  };
+	return {
+		path: resolve(ctx.options.buildDir, "dist", ctx.isServer ? "server" : joinURL("client", ctx.options.app.buildAssetsDir)),
+		filename: fileName(ctx, "app"),
+		chunkFilename: fileName(ctx, "chunk"),
+		publicPath: joinURL(ctx.options.app.baseURL, ctx.options.app.buildAssetsDir)
+	};
 }
 function getWarningIgnoreFilter(ctx) {
-  const filters = [
-    // Hide warnings about plugins without a default export (#1179)
-    (warn) => warn.name === "ModuleDependencyWarning" && warn.message.includes("export 'default'") && warn.message.includes("nuxt_plugin_"),
-    ...ctx.userConfig.warningIgnoreFilters || []
-  ];
-  return (warn) => !filters.some((ignoreFilter) => ignoreFilter(warn));
+	const filters = [(warn) => warn.name === "ModuleDependencyWarning" && warn.message.includes("export 'default'") && warn.message.includes("nuxt_plugin_"), ...ctx.userConfig.warningIgnoreFilters || []];
+	return (warn) => !filters.some((ignoreFilter) => ignoreFilter(warn));
 }
 function getEnv(ctx) {
-  const _env = {
-    "process.env.NODE_ENV": JSON.stringify(ctx.config.mode),
-    "__NUXT_VERSION__": JSON.stringify(ctx.nuxt._version),
-    "__NUXT_ASYNC_CONTEXT__": ctx.options.experimental.asyncContext,
-    "process.env.VUE_ENV": JSON.stringify(ctx.name),
-    "process.dev": ctx.options.dev,
-    "process.test": isTest,
-    "process.browser": ctx.isClient,
-    "process.client": ctx.isClient,
-    "process.server": ctx.isServer,
-    "import.meta.dev": ctx.options.dev,
-    "import.meta.test": isTest,
-    "import.meta.browser": ctx.isClient,
-    "import.meta.client": ctx.isClient,
-    "import.meta.server": ctx.isServer
-  };
-  if (ctx.isClient) {
-    _env["process.prerender"] = false;
-    _env["process.nitro"] = false;
-    _env["import.meta.prerender"] = false;
-    _env["import.meta.nitro"] = false;
-  } else {
-    _env["process.prerender"] = "(()=>process.prerender)()";
-    _env["process.nitro"] = "(()=>process.nitro)()";
-    _env["import.meta.prerender"] = "(()=>import.meta.prerender)()";
-    _env["import.meta.nitro"] = "(()=>import.meta.nitro)()";
-  }
-  if (ctx.userConfig.aggressiveCodeRemoval) {
-    _env["typeof process"] = JSON.stringify(ctx.isServer ? "object" : "undefined");
-    _env["typeof window"] = _env["typeof document"] = JSON.stringify(!ctx.isServer ? "object" : "undefined");
-  }
-  return _env;
+	const _env = {
+		"process.env.NODE_ENV": JSON.stringify(ctx.config.mode),
+		"__NUXT_VERSION__": JSON.stringify(ctx.nuxt._version),
+		"__NUXT_ASYNC_CONTEXT__": ctx.options.experimental.asyncContext,
+		"process.env.VUE_ENV": JSON.stringify(ctx.name),
+		"process.dev": ctx.options.dev,
+		"process.test": isTest,
+		"process.browser": ctx.isClient,
+		"process.client": ctx.isClient,
+		"process.server": ctx.isServer,
+		"import.meta.dev": ctx.options.dev,
+		"import.meta.test": isTest,
+		"import.meta.browser": ctx.isClient,
+		"import.meta.client": ctx.isClient,
+		"import.meta.server": ctx.isServer
+	};
+	if (ctx.isClient) {
+		_env["process.prerender"] = false;
+		_env["process.nitro"] = false;
+		_env["import.meta.prerender"] = false;
+		_env["import.meta.nitro"] = false;
+	} else {
+		_env["process.prerender"] = "(()=>process.prerender)()";
+		_env["process.nitro"] = "(()=>process.nitro)()";
+		_env["import.meta.prerender"] = "(()=>import.meta.prerender)()";
+		_env["import.meta.nitro"] = "(()=>import.meta.nitro)()";
+	}
+	if (ctx.userConfig.aggressiveCodeRemoval) {
+		_env["typeof process"] = JSON.stringify(ctx.isServer ? "object" : "undefined");
+		_env["typeof window"] = _env["typeof document"] = JSON.stringify(!ctx.isServer ? "object" : "undefined");
+	}
+	return _env;
 }
 const statsMap = {
-  silent: "none",
-  info: "normal",
-  verbose: "verbose"
+	silent: "none",
+	info: "normal",
+	verbose: "verbose"
 };
 
+//#endregion
+//#region ../webpack/src/presets/esbuild.ts
 function esbuild(ctx) {
-  const target = ctx.isServer ? "es2020" : "chrome85";
-  ctx.config.optimization.minimizer.push(new EsbuildPlugin());
-  ctx.config.module.rules.push(
-    {
-      test: /\.m?[jt]s$/i,
-      loader: "esbuild-loader",
-      exclude: (file) => {
-        const lastSegment = file.split("node_modules", 2)[1];
-        if (!lastSegment) {
-          return false;
-        }
-        return !ctx.transpile.some((module) => module.test(lastSegment));
-      },
-      resolve: {
-        fullySpecified: false
-      },
-      options: {
-        target,
-        ...ctx.nuxt.options.webpack.loaders.esbuild,
-        loader: "ts"
-      }
-    },
-    {
-      test: /\.m?[jt]sx$/,
-      loader: "esbuild-loader",
-      options: {
-        target,
-        ...ctx.nuxt.options.webpack.loaders.esbuild,
-        loader: "tsx"
-      }
-    }
-  );
+	const target = ctx.isServer ? "es2020" : "chrome85";
+	ctx.config.optimization.minimizer.push(new EsbuildPlugin());
+	ctx.config.module.rules.push({
+		test: /\.m?[jt]s$/i,
+		loader: "esbuild-loader",
+		exclude: (file) => {
+			const lastSegment = file.split("node_modules", 2)[1];
+			if (!lastSegment) return false;
+			return !ctx.transpile.some((module) => module.test(lastSegment));
+		},
+		resolve: { fullySpecified: false },
+		options: {
+			target,
+			...ctx.nuxt.options.webpack.loaders.esbuild,
+			loader: "ts"
+		}
+	}, {
+		test: /\.m?[jt]sx$/,
+		loader: "esbuild-loader",
+		options: {
+			target,
+			...ctx.nuxt.options.webpack.loaders.esbuild,
+			loader: "tsx"
+		}
+	});
 }
 
+//#endregion
+//#region ../webpack/src/presets/pug.ts
 function pug(ctx) {
-  ctx.config.module.rules.push({
-    test: /\.pug$/i,
-    oneOf: [
-      {
-        resourceQuery: /^\?vue/i,
-        use: [{
-          loader: "pug-plain-loader",
-          options: ctx.userConfig.loaders.pugPlain
-        }]
-      },
-      {
-        use: [
-          "raw-loader",
-          {
-            loader: "pug-plain-loader",
-            options: ctx.userConfig.loaders.pugPlain
-          }
-        ]
-      }
-    ]
-  });
+	ctx.config.module.rules.push({
+		test: /\.pug$/i,
+		oneOf: [{
+			resourceQuery: /^\?vue/i,
+			use: [{
+				loader: "pug-plain-loader",
+				options: ctx.userConfig.loaders.pugPlain
+			}]
+		}, { use: ["raw-loader", {
+			loader: "pug-plain-loader",
+			options: ctx.userConfig.loaders.pugPlain
+		}] }]
+	});
 }
 
+//#endregion
+//#region ../webpack/src/utils/postcss.ts
 const isPureObject = (obj) => obj !== null && !Array.isArray(obj) && typeof obj === "object";
 function sortPlugins({ plugins, order }) {
-  const names = Object.keys(plugins);
-  return typeof order === "function" ? order(names) : order || names;
+	const names = Object.keys(plugins);
+	return typeof order === "function" ? order(names) : order || names;
 }
-async function getPostcssConfig(nuxt) {
-  if (!nuxt.options.webpack.postcss || !nuxt.options.postcss) {
-    return false;
-  }
-  const postcssOptions = defu({}, nuxt.options.postcss, {
-    plugins: {
-      /**
-       * https://github.com/postcss/postcss-import
-       */
-      "postcss-import": {
-        resolve: createResolver({
-          alias: { ...nuxt.options.alias },
-          modules: nuxt.options.modulesDir
-        })
-      },
-      /**
-       * https://github.com/postcss/postcss-url
-       */
-      "postcss-url": {}
-    },
-    sourceMap: nuxt.options.webpack.cssSourceMap
-  });
-  const jiti = createJiti(nuxt.options.rootDir, { alias: nuxt.options.alias });
-  if (!Array.isArray(postcssOptions.plugins) && isPureObject(postcssOptions.plugins)) {
-    const plugins = [];
-    for (const pluginName of sortPlugins(postcssOptions)) {
-      const pluginOptions = postcssOptions.plugins[pluginName];
-      if (!pluginOptions) {
-        continue;
-      }
-      let pluginFn;
-      for (const parentURL of nuxt.options.modulesDir) {
-        pluginFn = await jiti.import(pluginName, { parentURL: parentURL.replace(/\/node_modules\/?$/, ""), try: true, default: true });
-        if (typeof pluginFn === "function") {
-          plugins.push(pluginFn(pluginOptions));
-          break;
-        }
-      }
-      if (typeof pluginFn !== "function") {
-        console.warn(`[nuxt] could not import postcss plugin \`${pluginName}\`. Please report this as a bug.`);
-      }
-    }
-    postcssOptions.plugins = plugins;
-  }
-  return {
-    sourceMap: nuxt.options.webpack.cssSourceMap,
-    ...nuxt.options.webpack.postcss,
-    postcssOptions
-  };
+async function getPostcssConfig(nuxt$1) {
+	if (!nuxt$1.options.webpack.postcss || !nuxt$1.options.postcss) return false;
+	const postcssOptions = defu({}, nuxt$1.options.postcss, {
+		plugins: {
+			"postcss-import": { resolve: createResolver({
+				alias: { ...nuxt$1.options.alias },
+				modules: nuxt$1.options.modulesDir
+			}) },
+			"postcss-url": {}
+		},
+		sourceMap: nuxt$1.options.webpack.cssSourceMap
+	});
+	const jiti = createJiti(nuxt$1.options.rootDir, { alias: nuxt$1.options.alias });
+	if (!Array.isArray(postcssOptions.plugins) && isPureObject(postcssOptions.plugins)) {
+		const plugins = [];
+		for (const pluginName$1 of sortPlugins(postcssOptions)) {
+			const pluginOptions = postcssOptions.plugins[pluginName$1];
+			if (!pluginOptions) continue;
+			let pluginFn;
+			for (const parentURL of nuxt$1.options.modulesDir) {
+				pluginFn = await jiti.import(pluginName$1, {
+					parentURL: parentURL.replace(/\/node_modules\/?$/, ""),
+					try: true,
+					default: true
+				});
+				if (typeof pluginFn === "function") {
+					plugins.push(pluginFn(pluginOptions));
+					break;
+				}
+			}
+			if (typeof pluginFn !== "function") console.warn(`[nuxt] could not import postcss plugin \`${pluginName$1}\`. Please report this as a bug.`);
+		}
+		postcssOptions.plugins = plugins;
+	}
+	return {
+		sourceMap: nuxt$1.options.webpack.cssSourceMap,
+		...nuxt$1.options.webpack.postcss,
+		postcssOptions
+	};
 }
 
+//#endregion
+//#region ../webpack/src/presets/style.ts
 async function style(ctx) {
-  await applyPresets(ctx, [
-    loaders,
-    extractCSS,
-    minimizer
-  ]);
+	await applyPresets(ctx, [
+		loaders,
+		extractCSS,
+		minimizer
+	]);
 }
 function minimizer(ctx) {
-  if (ctx.userConfig.optimizeCSS && Array.isArray(ctx.config.optimization.minimizer)) {
-    ctx.config.optimization.minimizer.push(new CssMinimizerPlugin({
-      ...ctx.userConfig.optimizeCSS
-    }));
-  }
+	if (ctx.userConfig.optimizeCSS && Array.isArray(ctx.config.optimization.minimizer)) ctx.config.optimization.minimizer.push(new CssMinimizerPlugin({ ...ctx.userConfig.optimizeCSS }));
 }
 function extractCSS(ctx) {
-  const config = ctx.userConfig.extractCSS;
-  if (!config) {
-    return;
-  }
-  const filename = fileName(ctx, "css");
-  ctx.config.plugins.push(new MiniCssExtractPlugin({
-    filename,
-    chunkFilename: filename,
-    ...config === true ? {} : config
-  }));
+	const config = ctx.userConfig.extractCSS;
+	if (!config) return;
+	const filename = fileName(ctx, "css");
+	ctx.config.plugins.push(new MiniCssExtractPlugin({
+		filename,
+		chunkFilename: filename,
+		...config === true ? {} : config
+	}));
 }
 async function loaders(ctx) {
-  ctx.config.module.rules.push(await createdStyleRule("css", /\.css$/i, null, ctx));
-  ctx.config.module.rules.push(await createdStyleRule("postcss", /\.p(ost)?css$/i, null, ctx));
-  const lessLoader = { loader: "less-loader", options: ctx.userConfig.loaders.less };
-  ctx.config.module.rules.push(await createdStyleRule("less", /\.less$/i, lessLoader, ctx));
-  const sassLoader = { loader: "sass-loader", options: ctx.userConfig.loaders.sass };
-  ctx.config.module.rules.push(await createdStyleRule("sass", /\.sass$/i, sassLoader, ctx));
-  const scssLoader = { loader: "sass-loader", options: ctx.userConfig.loaders.scss };
-  ctx.config.module.rules.push(await createdStyleRule("scss", /\.scss$/i, scssLoader, ctx));
-  const stylusLoader = { loader: "stylus-loader", options: ctx.userConfig.loaders.stylus };
-  ctx.config.module.rules.push(await createdStyleRule("stylus", /\.styl(us)?$/i, stylusLoader, ctx));
+	ctx.config.module.rules.push(await createdStyleRule("css", /\.css$/i, null, ctx));
+	ctx.config.module.rules.push(await createdStyleRule("postcss", /\.p(ost)?css$/i, null, ctx));
+	const lessLoader = {
+		loader: "less-loader",
+		options: ctx.userConfig.loaders.less
+	};
+	ctx.config.module.rules.push(await createdStyleRule("less", /\.less$/i, lessLoader, ctx));
+	const sassLoader = {
+		loader: "sass-loader",
+		options: ctx.userConfig.loaders.sass
+	};
+	ctx.config.module.rules.push(await createdStyleRule("sass", /\.sass$/i, sassLoader, ctx));
+	const scssLoader = {
+		loader: "sass-loader",
+		options: ctx.userConfig.loaders.scss
+	};
+	ctx.config.module.rules.push(await createdStyleRule("scss", /\.scss$/i, scssLoader, ctx));
+	const stylusLoader = {
+		loader: "stylus-loader",
+		options: ctx.userConfig.loaders.stylus
+	};
+	ctx.config.module.rules.push(await createdStyleRule("stylus", /\.styl(us)?$/i, stylusLoader, ctx));
 }
 async function createdStyleRule(lang, test, processorLoader, ctx) {
-  const styleLoaders = [
-    await createPostcssLoadersRule(ctx),
-    processorLoader
-  ].filter(Boolean);
-  ctx.userConfig.loaders.css.importLoaders = ctx.userConfig.loaders.cssModules.importLoaders = styleLoaders.length;
-  const cssLoaders = createCssLoadersRule(ctx, ctx.userConfig.loaders.css);
-  const cssModuleLoaders = createCssLoadersRule(ctx, ctx.userConfig.loaders.cssModules);
-  return {
-    test,
-    oneOf: [
-      // This matches <style module>
-      {
-        resourceQuery: /module/,
-        use: cssModuleLoaders.concat(styleLoaders)
-      },
-      // This matches plain <style> or <style scoped>
-      {
-        use: cssLoaders.concat(styleLoaders)
-      }
-    ]
-  };
+	const styleLoaders = [await createPostcssLoadersRule(ctx), processorLoader].filter(Boolean);
+	ctx.userConfig.loaders.css.importLoaders = ctx.userConfig.loaders.cssModules.importLoaders = styleLoaders.length;
+	const cssLoaders = createCssLoadersRule(ctx, ctx.userConfig.loaders.css);
+	return {
+		test,
+		oneOf: [{
+			resourceQuery: /module/,
+			use: createCssLoadersRule(ctx, ctx.userConfig.loaders.cssModules).concat(styleLoaders)
+		}, { use: cssLoaders.concat(styleLoaders) }]
+	};
 }
 function createCssLoadersRule(ctx, cssLoaderOptions) {
-  const cssLoader = { loader: "css-loader", options: cssLoaderOptions };
-  if (ctx.userConfig.extractCSS) {
-    if (ctx.isServer) {
-      if (cssLoader.options.modules) {
-        cssLoader.options.modules.exportOnlyLocals ??= true;
-      }
-      return [cssLoader];
-    }
-    return [
-      {
-        loader: MiniCssExtractPlugin.loader
-      },
-      cssLoader
-    ];
-  }
-  return [
-    // https://github.com/vuejs/vue-style-loader/issues/56
-    // {
-    //   loader: 'vue-style-loader',
-    //   options: options.webpack.loaders.vueStyle
-    // },
-    cssLoader
-  ];
+	const cssLoader = {
+		loader: "css-loader",
+		options: cssLoaderOptions
+	};
+	if (ctx.userConfig.extractCSS) {
+		if (ctx.isServer) {
+			if (cssLoader.options.modules) cssLoader.options.modules.exportOnlyLocals ??= true;
+			return [cssLoader];
+		}
+		return [{ loader: MiniCssExtractPlugin.loader }, cssLoader];
+	}
+	return [cssLoader];
 }
 async function createPostcssLoadersRule(ctx) {
-  if (!ctx.options.postcss) {
-    return;
-  }
-  const config = await getPostcssConfig(ctx.nuxt);
-  if (!config) {
-    return;
-  }
-  return {
-    loader: "postcss-loader",
-    options: config
-  };
+	if (!ctx.options.postcss) return;
+	const config = await getPostcssConfig(ctx.nuxt);
+	if (!config) return;
+	return {
+		loader: "postcss-loader",
+		options: config
+	};
 }
 
-class VueSSRClientPlugin {
-  serverDist;
-  nuxt;
-  constructor(options) {
-    this.serverDist = resolve(options.nuxt.options.buildDir, "dist/server");
-    this.nuxt = options.nuxt;
-  }
-  apply(compiler) {
-    compiler.hooks.afterEmit.tap("VueSSRClientPlugin", async (compilation) => {
-      const stats = compilation.getStats().toJson();
-      const initialFiles = /* @__PURE__ */ new Set();
-      for (const { assets } of Object.values(stats.entrypoints)) {
-        if (!assets) {
-          continue;
-        }
-        for (const asset of assets) {
-          const file = asset.name;
-          if ((isJS(file) || isCSS(file)) && !isHotUpdate(file)) {
-            initialFiles.add(file);
-          }
-        }
-      }
-      const allFiles = /* @__PURE__ */ new Set();
-      const asyncFiles = /* @__PURE__ */ new Set();
-      const assetsMapping = {};
-      for (const { name: file, chunkNames = [] } of stats.assets) {
-        if (isHotUpdate(file)) {
-          continue;
-        }
-        allFiles.add(file);
-        const isFileJS = isJS(file);
-        if (!initialFiles.has(file) && (isFileJS || isCSS(file))) {
-          asyncFiles.add(file);
-        }
-        if (isFileJS) {
-          const componentHash = hash(chunkNames.join("|"));
-          const map = assetsMapping[componentHash] ||= [];
-          map.push(file);
-        }
-      }
-      const webpackManifest = {
-        publicPath: stats.publicPath,
-        all: [...allFiles],
-        initial: [...initialFiles],
-        async: [...asyncFiles],
-        modules: {
-          /* [identifier: string]: Array<index: number> */
-        },
-        assetsMapping
-      };
-      const { entrypoints = {}, namedChunkGroups = {} } = stats;
-      const fileToIndex = (file) => webpackManifest.all.indexOf(String(file));
-      for (const m of stats.modules) {
-        if (m.chunks?.length !== 1) {
-          continue;
-        }
-        const [cid] = m.chunks;
-        const chunk = stats.chunks.find((c) => c.id === cid);
-        if (!chunk || !chunk.files || !cid) {
-          continue;
-        }
-        const id = m.identifier.replace(/\s\w+$/, "");
-        const filesSet = /* @__PURE__ */ new Set();
-        for (const file of chunk.files) {
-          const index = fileToIndex(file);
-          if (index !== -1) {
-            filesSet.add(index);
-          }
-        }
-        for (const chunkName of chunk.names) {
-          if (!entrypoints[chunkName]) {
-            const chunkGroup = namedChunkGroups[chunkName];
-            if (chunkGroup) {
-              for (const asset of chunkGroup.assets) {
-                filesSet.add(fileToIndex(asset.name));
-              }
-            }
-          }
-        }
-        const files = Array.from(filesSet);
-        webpackManifest.modules[hash(id)] = files;
-        if (Array.isArray(m.modules)) {
-          for (const concatenatedModule of m.modules) {
-            const id2 = hash(concatenatedModule.identifier.replace(/\s\w+$/, ""));
-            webpackManifest.modules[id2] ||= files;
-          }
-        }
-        if (stats.modules) {
-          for (const m2 of stats.modules) {
-            if (m2.assets?.length && m2.chunks?.includes(cid)) {
-              files.push(...m2.assets.map(fileToIndex));
-            }
-          }
-        }
-      }
-      const manifest = normalizeWebpackManifest(webpackManifest);
-      await this.nuxt.callHook("build:manifest", manifest);
-      await mkdir(this.serverDist, { recursive: true });
-      const precomputed = precomputeDependencies(manifest);
-      await writeFile(join(this.serverDist, `client.manifest.json`), JSON.stringify(manifest, null, 2));
-      await writeFile(join(this.serverDist, "client.manifest.mjs"), "export default " + serialize(manifest), "utf8");
-      await writeFile(join(this.serverDist, "client.precomputed.mjs"), "export default " + serialize(precomputed), "utf8");
-    });
-  }
-}
+//#endregion
+//#region ../webpack/src/plugins/vue/client.ts
+/**
+* This file is based on Vue.js (MIT) webpack plugins
+* https://github.com/vuejs/vue/blob/dev/src/server/webpack-plugin/client.js
+*/
+var VueSSRClientPlugin = class {
+	serverDist;
+	nuxt;
+	constructor(options) {
+		this.serverDist = resolve(options.nuxt.options.buildDir, "dist/server");
+		this.nuxt = options.nuxt;
+	}
+	getRelativeModuleId(identifier, context) {
+		const id = identifier.replace(/\s\w+$/, "");
+		const resourceMatch = id.match(/([^!]*\.vue)(?:\?|$)/);
+		return resourceMatch && resourceMatch[1] ? normalize(relative(context, resourceMatch[1])).replace(/^\.\//, "").replace(/\\/g, "/") : id;
+	}
+	apply(compiler) {
+		compiler.hooks.afterEmit.tap("VueSSRClientPlugin", async (compilation) => {
+			const stats = compilation.getStats().toJson();
+			const context = this.nuxt.options.srcDir;
+			const initialFiles = /* @__PURE__ */ new Set();
+			for (const { assets: assets$1 } of Object.values(stats.entrypoints)) {
+				if (!assets$1) continue;
+				for (const asset of assets$1) {
+					const file = asset.name;
+					if ((isJS(file) || isCSS(file)) && !isHotUpdate(file)) initialFiles.add(file);
+				}
+			}
+			const allFiles = /* @__PURE__ */ new Set();
+			const asyncFiles = /* @__PURE__ */ new Set();
+			const assetsMapping = {};
+			for (const { name: file, chunkNames = [] } of stats.assets) {
+				if (isHotUpdate(file)) continue;
+				allFiles.add(file);
+				const isFileJS = isJS(file);
+				if (!initialFiles.has(file) && (isFileJS || isCSS(file))) asyncFiles.add(file);
+				if (isFileJS) {
+					const componentHash = hash(chunkNames.join("|"));
+					(assetsMapping[componentHash] ||= []).push(file);
+				}
+			}
+			const webpackManifest = {
+				publicPath: stats.publicPath,
+				all: [...allFiles],
+				initial: [...initialFiles],
+				async: [...asyncFiles],
+				modules: {},
+				assetsMapping
+			};
+			const { entrypoints = {}, namedChunkGroups = {} } = stats;
+			const fileToIndex = (file) => webpackManifest.all.indexOf(String(file));
+			for (const m of stats.modules) {
+				if (m.chunks?.length !== 1) continue;
+				const [cid] = m.chunks;
+				const chunk = stats.chunks.find((c) => c.id === cid);
+				if (!chunk || !chunk.files || !cid) continue;
+				const relativeId = this.getRelativeModuleId(m.identifier, context);
+				const filesSet = /* @__PURE__ */ new Set();
+				for (const file of chunk.files) {
+					const index = fileToIndex(file);
+					if (index !== -1) filesSet.add(index);
+				}
+				for (const chunkName of chunk.names) if (!entrypoints[chunkName]) {
+					const chunkGroup = namedChunkGroups[chunkName];
+					if (chunkGroup) for (const asset of chunkGroup.assets) filesSet.add(fileToIndex(asset.name));
+				}
+				const files = Array.from(filesSet);
+				webpackManifest.modules[relativeId] = files;
+				if (Array.isArray(m.modules)) for (const concatenatedModule of m.modules) {
+					const relativeId$1 = this.getRelativeModuleId(concatenatedModule.identifier, context);
+					webpackManifest.modules[relativeId$1] ||= files;
+				}
+				if (stats.modules) {
+					for (const m$1 of stats.modules) if (m$1.assets?.length && m$1.chunks?.includes(cid)) files.push(...m$1.assets.map(fileToIndex));
+				}
+			}
+			const manifest = normalizeWebpackManifest(webpackManifest);
+			await this.nuxt.callHook("build:manifest", manifest);
+			await mkdir(this.serverDist, { recursive: true });
+			const precomputed = precomputeDependencies(manifest);
+			await writeFile(join(this.serverDist, `client.manifest.json`), JSON.stringify(manifest, null, 2));
+			await writeFile(join(this.serverDist, "client.manifest.mjs"), "export default " + serialize(manifest), "utf8");
+			await writeFile(join(this.serverDist, "client.precomputed.mjs"), "export default " + serialize(precomputed), "utf8");
+		});
+	}
+};
 
+//#endregion
+//#region ../webpack/src/plugins/vue/server.ts
 const JS_MAP_RE = /\.js\.map$/;
-class VueSSRServerPlugin {
-  options;
-  constructor(options = {}) {
-    this.options = Object.assign({
-      filename: null
-    }, options);
-  }
-  apply(compiler) {
-    validate(compiler);
-    compiler.hooks.make.tap("VueSSRServerPlugin", (compilation) => {
-      compilation.hooks.processAssets.tapAsync({
-        name: "VueSSRServerPlugin",
-        stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
-      }, (assets, cb) => {
-        const stats = compilation.getStats().toJson();
-        const [entryName] = Object.keys(stats.entrypoints);
-        const entryInfo = stats.entrypoints[entryName];
-        if (!entryInfo) {
-          return cb();
-        }
-        const entryAssets = entryInfo.assets.filter((asset) => isJS(asset.name));
-        if (entryAssets.length > 1) {
-          throw new Error(
-            "Server-side bundle should have one single entry file. Avoid using CommonsChunkPlugin in the server config."
-          );
-        }
-        const [entry] = entryAssets;
-        if (!entry || typeof entry.name !== "string") {
-          throw new Error(
-            `Entry "${entryName}" not found. Did you specify the correct entry option?`
-          );
-        }
-        const bundle = {
-          entry: entry.name,
-          files: {},
-          maps: {}
-        };
-        for (const asset of stats.assets) {
-          if (isJS(asset.name)) {
-            const queryPart = extractQueryPartJS(asset.name);
-            if (queryPart !== void 0) {
-              bundle.files[asset.name] = asset.name.replace(queryPart, "");
-            } else {
-              bundle.files[asset.name] = asset.name;
-            }
-          } else if (JS_MAP_RE.test(asset.name)) {
-            bundle.maps[asset.name.replace(/\.map$/, "")] = asset.name;
-          } else {
-            delete assets[asset.name];
-          }
-        }
-        const src = JSON.stringify(bundle, null, 2);
-        assets[this.options.filename] = {
-          source: () => src,
-          size: () => src.length
-        };
-        const mjsSrc = "export default " + src;
-        assets[this.options.filename.replace(".json", ".mjs")] = {
-          source: () => mjsSrc,
-          map: () => null,
-          size: () => mjsSrc.length
-        };
-        cb();
-      });
-    });
-  }
-}
+var VueSSRServerPlugin = class {
+	options;
+	constructor(options = {}) {
+		this.options = Object.assign({ filename: null }, options);
+	}
+	apply(compiler) {
+		validate(compiler);
+		compiler.hooks.make.tap("VueSSRServerPlugin", (compilation) => {
+			compilation.hooks.processAssets.tapAsync({
+				name: "VueSSRServerPlugin",
+				stage: webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+			}, (assets$1, cb) => {
+				const stats = compilation.getStats().toJson();
+				const [entryName] = Object.keys(stats.entrypoints);
+				const entryInfo = stats.entrypoints[entryName];
+				if (!entryInfo) return cb();
+				const entryAssets = entryInfo.assets.filter((asset) => isJS(asset.name));
+				if (entryAssets.length > 1) throw new Error("Server-side bundle should have one single entry file. Avoid using CommonsChunkPlugin in the server config.");
+				const [entry] = entryAssets;
+				if (!entry || typeof entry.name !== "string") throw new Error(`Entry "${entryName}" not found. Did you specify the correct entry option?`);
+				const bundle$1 = {
+					entry: entry.name,
+					files: {},
+					maps: {}
+				};
+				for (const asset of stats.assets) if (isJS(asset.name)) {
+					const queryPart = extractQueryPartJS(asset.name);
+					if (queryPart !== void 0) bundle$1.files[asset.name] = asset.name.replace(queryPart, "");
+					else bundle$1.files[asset.name] = asset.name;
+				} else if (JS_MAP_RE.test(asset.name)) bundle$1.maps[asset.name.replace(/\.map$/, "")] = asset.name;
+				else delete assets$1[asset.name];
+				const src = JSON.stringify(bundle$1, null, 2);
+				assets$1[this.options.filename] = {
+					source: () => src,
+					size: () => src.length
+				};
+				const mjsSrc = "export default " + src;
+				assets$1[this.options.filename.replace(".json", ".mjs")] = {
+					source: () => mjsSrc,
+					map: () => null,
+					size: () => mjsSrc.length
+				};
+				cb();
+			});
+		});
+	}
+};
 
+//#endregion
+//#region ../webpack/src/presets/vue.ts
 function vue(ctx) {
-  ctx.config.plugins.push(new (VueLoaderPlugin.default || VueLoaderPlugin)());
-  ctx.config.module.rules.push({
-    test: /\.vue$/i,
-    loader: "vue-loader",
-    options: ctx.userConfig.loaders.vue
-  });
-  if (ctx.isClient) {
-    ctx.config.plugins.push(new VueSSRClientPlugin({ nuxt: ctx.nuxt }));
-  } else {
-    ctx.config.plugins.push(new VueSSRServerPlugin({
-      filename: `${ctx.name}.manifest.json`
-    }));
-  }
-  ctx.config.plugins.push(new webpack.DefinePlugin({
-    "__VUE_OPTIONS_API__": "true",
-    "__VUE_PROD_DEVTOOLS__": "false",
-    "__VUE_PROD_HYDRATION_MISMATCH_DETAILS__": ctx.nuxt.options.debug && ctx.nuxt.options.debug.hydration
-  }));
+	ctx.config.plugins.push(new (VueLoaderPlugin.default || VueLoaderPlugin)());
+	ctx.config.module.rules.push({
+		test: /\.vue$/i,
+		loader: "vue-loader",
+		options: {
+			...ctx.userConfig.loaders.vue,
+			isServerBuild: ctx.isServer
+		}
+	});
+	if (ctx.isClient) ctx.config.plugins.push(new VueSSRClientPlugin({ nuxt: ctx.nuxt }));
+	else {
+		ctx.config.plugins.push(new VueSSRServerPlugin({ filename: `${ctx.name}.manifest.json` }));
+		const loaderPath = resolveModulePath("#vue-module-identifier", { from: import.meta.url });
+		ctx.config.module.rules.push({
+			test: /\.vue$/i,
+			enforce: "post",
+			use: [{
+				loader: loaderPath,
+				options: { srcDir: ctx.nuxt.options.srcDir }
+			}]
+		});
+	}
+	ctx.config.plugins.push(new webpack.DefinePlugin({
+		"__VUE_OPTIONS_API__": "true",
+		"__VUE_PROD_DEVTOOLS__": "false",
+		"__VUE_PROD_HYDRATION_MISMATCH_DETAILS__": ctx.nuxt.options.debug && ctx.nuxt.options.debug.hydration
+	}));
 }
 
+//#endregion
+//#region ../webpack/src/presets/nuxt.ts
 async function nuxt(ctx) {
-  await applyPresets(ctx, [
-    base,
-    assets,
-    esbuild,
-    pug,
-    style,
-    vue
-  ]);
+	await applyPresets(ctx, [
+		base,
+		assets,
+		esbuild,
+		pug,
+		style,
+		vue
+	]);
 }
 
+//#endregion
+//#region ../webpack/src/configs/client.ts
 async function client(ctx) {
-  ctx.name = "client";
-  ctx.isClient = true;
-  await applyPresets(ctx, [
-    nuxt,
-    clientPlugins,
-    clientOptimization,
-    clientDevtool,
-    clientPerformance,
-    clientHMR,
-    clientNodeCompat
-  ]);
+	ctx.name = "client";
+	ctx.isClient = true;
+	await applyPresets(ctx, [
+		nuxt,
+		clientPlugins,
+		clientOptimization,
+		clientDevtool,
+		clientPerformance,
+		clientHMR,
+		clientNodeCompat
+	]);
 }
 function clientDevtool(ctx) {
-  if (!ctx.nuxt.options.sourcemap.client) {
-    ctx.config.devtool = false;
-    return;
-  }
-  const prefix = ctx.nuxt.options.sourcemap.client === "hidden" ? "hidden-" : "";
-  if (!ctx.isDev) {
-    ctx.config.devtool = prefix + "source-map";
-    return;
-  }
-  ctx.config.devtool = prefix + "eval-cheap-module-source-map";
+	if (!ctx.nuxt.options.sourcemap.client) {
+		ctx.config.devtool = false;
+		return;
+	}
+	const prefix = ctx.nuxt.options.sourcemap.client === "hidden" ? "hidden-" : "";
+	if (!ctx.isDev) {
+		ctx.config.devtool = prefix + "source-map";
+		return;
+	}
+	ctx.config.devtool = prefix + "eval-cheap-module-source-map";
 }
 function clientPerformance(ctx) {
-  ctx.config.performance = {
-    maxEntrypointSize: 1e3 * 1024,
-    hints: ctx.isDev ? false : "warning",
-    ...ctx.config.performance
-  };
+	ctx.config.performance = {
+		maxEntrypointSize: 1e3 * 1024,
+		hints: ctx.isDev ? false : "warning",
+		...ctx.config.performance
+	};
 }
 function clientNodeCompat(ctx) {
-  if (!ctx.nuxt.options.experimental.clientNodeCompat) {
-    return;
-  }
-  ctx.config.plugins.push(new webpack.DefinePlugin({ global: "globalThis" }));
-  ctx.config.resolve ||= {};
-  ctx.config.resolve.fallback = {
-    ...defineEnv({
-      nodeCompat: true,
-      resolve: true
-    }).env.alias,
-    ...ctx.config.resolve.fallback
-  };
-  ctx.config.plugins.unshift(new webpack.NormalModuleReplacementPlugin(/node:/, (resource) => {
-    resource.request = resource.request.replace(/^node:/, "");
-  }));
+	if (!ctx.nuxt.options.experimental.clientNodeCompat) return;
+	ctx.config.plugins.push(new webpack.DefinePlugin({ global: "globalThis" }));
+	ctx.config.resolve ||= {};
+	ctx.config.resolve.fallback = {
+		...defineEnv({
+			nodeCompat: true,
+			resolve: true
+		}).env.alias,
+		...ctx.config.resolve.fallback
+	};
+	ctx.config.plugins.unshift(new webpack.NormalModuleReplacementPlugin(/node:/, (resource) => {
+		resource.request = resource.request.replace(/^node:/, "");
+	}));
 }
 function clientHMR(ctx) {
-  if (!ctx.isDev) {
-    return;
-  }
-  const clientOptions = ctx.userConfig.hotMiddleware?.client || {};
-  const hotMiddlewareClientOptions = {
-    reload: true,
-    timeout: 3e4,
-    path: joinURL(ctx.options.app.baseURL, "__webpack_hmr", ctx.name),
-    ...clientOptions,
-    ansiColors: JSON.stringify(clientOptions.ansiColors || {}),
-    overlayStyles: JSON.stringify(clientOptions.overlayStyles || {}),
-    name: ctx.name
-  };
-  const hotMiddlewareClientOptionsStr = querystring.stringify(hotMiddlewareClientOptions);
-  const app = ctx.config.entry.app;
-  app.unshift(
-    // https://github.com/glenjamin/webpack-hot-middleware#config
-    `webpack-hot-middleware/client?${hotMiddlewareClientOptionsStr}`
-  );
-  ctx.config.plugins ||= [];
-  ctx.config.plugins.push(new webpack.HotModuleReplacementPlugin());
+	if (!ctx.isDev) return;
+	const clientOptions = ctx.userConfig.hotMiddleware?.client || {};
+	const hotMiddlewareClientOptions = {
+		reload: true,
+		timeout: 3e4,
+		path: joinURL(ctx.options.app.baseURL, "__webpack_hmr", ctx.name),
+		...clientOptions,
+		ansiColors: JSON.stringify(clientOptions.ansiColors || {}),
+		overlayStyles: JSON.stringify(clientOptions.overlayStyles || {}),
+		name: ctx.name
+	};
+	const hotMiddlewareClientOptionsStr = querystring.stringify(hotMiddlewareClientOptions);
+	ctx.config.entry.app.unshift(`webpack-hot-middleware/client?${hotMiddlewareClientOptionsStr}`);
+	ctx.config.plugins ||= [];
+	ctx.config.plugins.push(new webpack.HotModuleReplacementPlugin());
 }
-function clientOptimization(_ctx) {
+function clientOptimization(ctx) {
+	if (!ctx.nuxt.options.features.inlineStyles) return;
+	const globalCSSPaths = /* @__PURE__ */ new Set();
+	for (const css of ctx.options.css) if (typeof css === "string") {
+		const resolved = resolveAlias(css, ctx.options.alias);
+		globalCSSPaths.add(normalize(resolved));
+	}
+	if (globalCSSPaths.size > 0) {
+		ctx.config.optimization ||= {};
+		ctx.config.optimization.splitChunks ||= {};
+		ctx.config.optimization.splitChunks.cacheGroups ||= {};
+		ctx.config.optimization.splitChunks.cacheGroups.nuxtGlobalCSS = {
+			name: "nuxt-global-css",
+			chunks: "all",
+			enforce: true,
+			test: (module) => {
+				if (module.type !== "css/mini-extract") return false;
+				const identifier = normalize(module.identifier());
+				for (const globalPath of globalCSSPaths) if (identifier.includes(globalPath)) return true;
+				return false;
+			}
+		};
+	}
 }
 function clientPlugins(ctx) {
-  if (!ctx.isDev && !ctx.nuxt.options.test && ctx.name === "client" && ctx.userConfig.analyze && (ctx.userConfig.analyze === true || ctx.userConfig.analyze.enabled)) {
-    const statsDir = resolve(ctx.options.analyzeDir);
-    ctx.config.plugins.push(new BundleAnalyzerPlugin({
-      analyzerMode: "static",
-      defaultSizes: "gzip",
-      generateStatsFile: true,
-      openAnalyzer: true,
-      reportFilename: resolve(statsDir, `${ctx.name}.html`),
-      statsFilename: resolve(statsDir, `${ctx.name}.json`),
-      ...ctx.userConfig.analyze === true ? {} : ctx.userConfig.analyze
-    }));
-  }
-  if (!ctx.nuxt.options.ssr) {
-    if (!ctx.nuxt.options.test && (ctx.nuxt.options.typescript.typeCheck === true || ctx.nuxt.options.typescript.typeCheck === "build" && !ctx.nuxt.options.dev)) {
-      ctx.config.plugins.push(new TsCheckerPlugin({
-        logger
-      }));
-    }
-  }
+	if (!ctx.isDev && !ctx.nuxt.options.test && ctx.name === "client" && ctx.userConfig.analyze && (ctx.userConfig.analyze === true || ctx.userConfig.analyze.enabled)) {
+		const statsDir = resolve(ctx.options.analyzeDir);
+		ctx.config.plugins.push(new BundleAnalyzerPlugin({
+			analyzerMode: "static",
+			defaultSizes: "gzip",
+			generateStatsFile: true,
+			openAnalyzer: true,
+			reportFilename: resolve(statsDir, `${ctx.name}.html`),
+			statsFilename: resolve(statsDir, `${ctx.name}.json`),
+			...ctx.userConfig.analyze === true ? {} : ctx.userConfig.analyze
+		}));
+	}
+	if (!ctx.nuxt.options.ssr) {
+		if (!ctx.nuxt.options.test && (ctx.nuxt.options.typescript.typeCheck === true || ctx.nuxt.options.typescript.typeCheck === "build" && !ctx.nuxt.options.dev)) ctx.config.plugins.push(new TsCheckerPlugin({ logger }));
+	}
 }
 
+//#endregion
+//#region ../webpack/src/presets/node.ts
 function node(ctx) {
-  ctx.config.target = "node";
-  ctx.config.node = false;
-  ctx.config.experiments.outputModule = true;
-  ctx.config.output = {
-    ...ctx.config.output,
-    chunkFilename: "[name].mjs",
-    chunkFormat: "module",
-    chunkLoading: "import",
-    module: true,
-    environment: {
-      module: true,
-      arrowFunction: true,
-      bigIntLiteral: true,
-      const: true,
-      destructuring: true,
-      dynamicImport: true,
-      forOf: true
-    },
-    library: {
-      type: "module"
-    }
-  };
-  ctx.config.performance = {
-    ...ctx.config.performance,
-    hints: false,
-    maxEntrypointSize: Number.POSITIVE_INFINITY,
-    maxAssetSize: Number.POSITIVE_INFINITY
-  };
+	ctx.config.target = "node";
+	ctx.config.node = false;
+	ctx.config.experiments.outputModule = true;
+	ctx.config.output = {
+		...ctx.config.output,
+		chunkFilename: "[name].mjs",
+		chunkFormat: "module",
+		chunkLoading: "import",
+		module: true,
+		environment: {
+			module: true,
+			arrowFunction: true,
+			bigIntLiteral: true,
+			const: true,
+			destructuring: true,
+			dynamicImport: true,
+			forOf: true
+		},
+		library: { type: "module" }
+	};
+	ctx.config.performance = {
+		...ctx.config.performance,
+		hints: false,
+		maxEntrypointSize: Number.POSITIVE_INFINITY,
+		maxAssetSize: Number.POSITIVE_INFINITY
+	};
 }
 
+//#endregion
+//#region ../webpack/src/configs/server.ts
 const assetPattern = /\.(?:css|s[ca]ss|png|jpe?g|gif|svg|woff2?|eot|ttf|otf|webp|webm|mp4|ogv)(?:\?.*)?$/i;
+const VIRTUAL_RE = /^\0?virtual:(?:nuxt:)?/;
 async function server(ctx) {
-  ctx.name = "server";
-  ctx.isServer = true;
-  await applyPresets(ctx, [
-    nuxt,
-    node,
-    serverStandalone,
-    serverPreset,
-    serverPlugins
-  ]);
+	ctx.name = "server";
+	ctx.isServer = true;
+	await applyPresets(ctx, [
+		nuxt,
+		node,
+		serverStandalone,
+		serverPreset,
+		serverPlugins
+	]);
 }
 function serverPreset(ctx) {
-  ctx.config.output.filename = "server.mjs";
-  if (ctx.nuxt.options.sourcemap.server) {
-    const prefix = ctx.nuxt.options.sourcemap.server === "hidden" ? "hidden-" : "";
-    ctx.config.devtool = prefix + ctx.isDev ? "cheap-module-source-map" : "source-map";
-  } else {
-    ctx.config.devtool = false;
-  }
-  ctx.config.optimization = {
-    splitChunks: false,
-    minimize: false
-  };
+	ctx.config.output.filename = "server.mjs";
+	if (ctx.nuxt.options.sourcemap.server) {
+		const prefix = ctx.nuxt.options.sourcemap.server === "hidden" ? "hidden-" : "";
+		ctx.config.devtool = prefix + (ctx.isDev ? "cheap-module-source-map" : "source-map");
+	} else ctx.config.devtool = false;
+	ctx.config.optimization = {
+		splitChunks: false,
+		minimize: false
+	};
+	if (ctx.isDev) ctx.config.output.asyncChunks = false;
 }
 function serverStandalone(ctx) {
-  const inline = [
-    "src/",
-    "#app",
-    "nuxt",
-    "nuxt3",
-    "nuxt-nightly",
-    "!",
-    "-!",
-    "~",
-    "@/",
-    "#",
-    ...ctx.options.build.transpile
-  ];
-  const external = /* @__PURE__ */ new Set([
-    "#internal/nitro",
-    "#shared",
-    resolve(ctx.nuxt.options.rootDir, ctx.nuxt.options.dir.shared)
-  ]);
-  if (!ctx.nuxt.options.dev) {
-    external.add("#internal/nuxt/paths");
-    external.add("#app-manifest");
-  }
-  if (!Array.isArray(ctx.config.externals)) {
-    return;
-  }
-  ctx.config.externals.push(({ request }, cb) => {
-    if (!request) {
-      return cb(void 0, false);
-    }
-    if (external.has(request)) {
-      return cb(void 0, true);
-    }
-    if (request[0] === "." || isAbsolute(request) || inline.find((prefix) => typeof prefix === "string" && request.startsWith(prefix)) || assetPattern.test(request)) {
-      return cb(void 0, false);
-    }
-    return cb(void 0, true);
-  });
+	const inline = [
+		"src/",
+		"#app",
+		"nuxt",
+		"nuxt3",
+		"nuxt-nightly",
+		"!",
+		"-!",
+		"~",
+		"@/",
+		"#",
+		...ctx.options.build.transpile
+	];
+	const external = new Set([
+		"#internal/nitro",
+		"#shared",
+		resolve(ctx.nuxt.options.rootDir, ctx.nuxt.options.dir.shared),
+		...ctx.nuxt["~runtimeDependencies"] || []
+	]);
+	if (!ctx.nuxt.options.dev) {
+		external.add("#internal/nuxt/paths");
+		external.add("#app-manifest");
+	}
+	if (!Array.isArray(ctx.config.externals)) return;
+	const conditions = [
+		ctx.nuxt.options.dev ? "development" : "production",
+		"node",
+		"import",
+		"require"
+	];
+	ctx.config.externals.push(({ request, context }, cb) => {
+		if (!request) return cb(void 0, false);
+		if (external.has(request)) {
+			const resolved = resolveModulePath(request, {
+				from: context ? [context, ...ctx.nuxt.options.modulesDir].map((d) => directoryToURL(d)) : ctx.nuxt.options.modulesDir.map((d) => directoryToURL(d)),
+				suffixes: ["", "index"],
+				conditions,
+				try: true
+			});
+			if (resolved && isAbsolute(resolved)) return cb(void 0, resolved);
+			return cb(void 0, true);
+		}
+		if (request[0] === "." || isAbsolute(request) || inline.find((prefix) => typeof prefix === "string" && request.startsWith(prefix)) || assetPattern.test(request)) return cb(void 0, false);
+		if (context && request && !request.startsWith("node:") && (isAbsolute(context) || VIRTUAL_RE.test(context))) try {
+			const resolved = resolveModulePath(resolveAlias(normalize(request), ctx.nuxt.options.alias), {
+				from: [parseNodeModulePath(context).dir || ctx.nuxt.options.rootDir, ...ctx.nuxt.options.modulesDir].map((d) => directoryToURL(d)),
+				suffixes: ["", "index"],
+				conditions,
+				try: true
+			});
+			if (resolved && isAbsolute(resolved)) return cb(void 0, false);
+		} catch {}
+		return cb(void 0, true);
+	});
 }
 function serverPlugins(ctx) {
-  ctx.config.plugins ||= [];
-  if (ctx.userConfig.serverURLPolyfill) {
-    ctx.config.plugins.push(new webpack.ProvidePlugin({
-      URL: [ctx.userConfig.serverURLPolyfill, "URL"],
-      URLSearchParams: [ctx.userConfig.serverURLPolyfill, "URLSearchParams"]
-    }));
-  }
-  if (!ctx.nuxt.options.test && (ctx.nuxt.options.typescript.typeCheck === true || ctx.nuxt.options.typescript.typeCheck === "build" && !ctx.nuxt.options.dev)) {
-    ctx.config.plugins.push(new TsCheckerPlugin({
-      logger
-    }));
-  }
+	ctx.config.plugins ||= [];
+	if (ctx.userConfig.serverURLPolyfill) ctx.config.plugins.push(new webpack.ProvidePlugin({
+		URL: [ctx.userConfig.serverURLPolyfill, "URL"],
+		URLSearchParams: [ctx.userConfig.serverURLPolyfill, "URLSearchParams"]
+	}));
+	if (!ctx.nuxt.options.test && (ctx.nuxt.options.typescript.typeCheck === true || ctx.nuxt.options.typescript.typeCheck === "build" && !ctx.nuxt.options.dev)) ctx.config.plugins.push(new TsCheckerPlugin({ logger }));
 }
 
-const bundle = async (nuxt) => {
-  const webpackConfigs = await Promise.all([client, ...nuxt.options.ssr ? [server] : []].map(async (preset) => {
-    const ctx = createWebpackConfigContext(nuxt);
-    ctx.userConfig = defu(nuxt.options.webpack[`$${preset.name}`], ctx.userConfig);
-    await applyPresets(ctx, preset);
-    return ctx.config;
-  }));
-  if (!nuxt.options.dev) {
-    const nitro = useNitro();
-    nitro.hooks.hook("rollup:before", (_nitro, config) => {
-      const plugins = config.plugins;
-      const existingPlugin = plugins.findIndex((i) => i && "name" in i && i.name === "dynamic-require");
-      if (existingPlugin >= 0) {
-        plugins.splice(existingPlugin, 1);
-      }
-    });
-  }
-  await nuxt.callHook(`${builder}:config`, webpackConfigs);
-  const mfs = nuxt.options.dev ? createMFS() : null;
-  for (const config of webpackConfigs) {
-    config.plugins.push(DynamicBasePlugin.webpack({
-      sourcemap: !!nuxt.options.sourcemap[config.name]
-    }));
-    if (config.name === "client" && nuxt.options.experimental.emitRouteChunkError && nuxt.options.builder !== "@nuxt/rspack-builder") {
-      config.plugins.push(new ChunkErrorPlugin());
-    }
-  }
-  await nuxt.callHook(`${builder}:configResolved`, webpackConfigs);
-  const compilers = webpackConfigs.map((config) => {
-    const compiler = webpack(config);
-    if (nuxt.options.dev && compiler) {
-      compiler.outputFileSystem = mfs;
-    }
-    return compiler;
-  });
-  nuxt.hook("close", async () => {
-    for (const compiler of compilers) {
-      await new Promise((resolve) => compiler?.close(resolve));
-    }
-  });
-  if (nuxt.options.dev) {
-    await Promise.all(compilers.map((c) => c && compile(c)));
-    return;
-  }
-  for (const c of compilers) {
-    if (c) {
-      await compile(c);
-    }
-  }
+//#endregion
+//#region ../webpack/src/webpack.ts
+const bundle = async (nuxt$1) => {
+	const webpackConfigs = await Promise.all([client, ...nuxt$1.options.ssr ? [server] : []].map(async (preset) => {
+		const ctx = createWebpackConfigContext(nuxt$1);
+		ctx.userConfig = defu(nuxt$1.options.webpack[`$${preset.name}`], ctx.userConfig);
+		await applyPresets(ctx, preset);
+		return ctx.config;
+	}));
+	/** Remove Nitro rollup plugin for handling dynamic imports from webpack chunks */
+	if (!nuxt$1.options.dev) useNitro().hooks.hook("rollup:before", (_nitro, config) => {
+		const plugins = config.plugins;
+		const existingPlugin = plugins.findIndex((i) => i && "name" in i && i.name === "dynamic-require");
+		if (existingPlugin >= 0) plugins.splice(existingPlugin, 1);
+	});
+	await nuxt$1.callHook(`${builder}:config`, webpackConfigs);
+	const mfs = nuxt$1.options.dev ? createMFS() : null;
+	const ssrStylesPlugin = nuxt$1.options.ssr && !nuxt$1.options.dev && nuxt$1.options.features.inlineStyles ? new SSRStylesPlugin(nuxt$1) : null;
+	for (const config of webpackConfigs) {
+		config.plugins.push(DynamicBasePlugin.webpack({ sourcemap: !!nuxt$1.options.sourcemap[config.name] }));
+		if (config.name === "client" && nuxt$1.options.experimental.emitRouteChunkError && nuxt$1.options.builder !== "@nuxt/rspack-builder") config.plugins.push(new ChunkErrorPlugin());
+		if (ssrStylesPlugin) config.plugins.push(ssrStylesPlugin);
+	}
+	await nuxt$1.callHook(`${builder}:configResolved`, webpackConfigs);
+	const compilers = webpackConfigs.map((config) => {
+		const compiler = webpack(config);
+		if (nuxt$1.options.dev && compiler) compiler.outputFileSystem = mfs;
+		return compiler;
+	});
+	nuxt$1.hook("close", async () => {
+		for (const compiler of compilers) await new Promise((resolve$1) => compiler.close(resolve$1));
+	});
+	if (nuxt$1.options.dev) {
+		await Promise.all(compilers.map((c) => compile(c)));
+		return;
+	}
+	for (const c of compilers) await compile(c);
 };
 async function createDevMiddleware(compiler) {
-  const nuxt = useNuxt();
-  logger.debug("Creating webpack middleware...");
-  const devMiddleware = webpackDevMiddleware(compiler, {
-    publicPath: joinURL(nuxt.options.app.baseURL, nuxt.options.app.buildAssetsDir),
-    outputFileSystem: compiler.outputFileSystem,
-    stats: "none",
-    ...nuxt.options.webpack.devMiddleware
-  });
-  nuxt.hook("close", () => pify(devMiddleware.close.bind(devMiddleware))());
-  const { client: _client, ...hotMiddlewareOptions } = nuxt.options.webpack.hotMiddleware || {};
-  const hotMiddleware = webpackHotMiddleware(compiler, {
-    log: false,
-    heartbeat: 1e4,
-    path: joinURL(nuxt.options.app.baseURL, "__webpack_hmr", compiler.options.name),
-    ...hotMiddlewareOptions
-  });
-  const devHandler = wdmToH3Handler(devMiddleware, nuxt.options.devServer.cors);
-  const hotHandler = fromNodeMiddleware(hotMiddleware);
-  await nuxt.callHook("server:devHandler", defineEventHandler(async (event) => {
-    const body = await devHandler(event);
-    if (body !== void 0) {
-      return body;
-    }
-    await hotHandler(event);
-  }));
-  return devMiddleware;
+	const nuxt$1 = useNuxt();
+	logger.debug("Creating webpack middleware...");
+	const devMiddleware = webpackDevMiddleware(compiler, {
+		publicPath: joinURL(nuxt$1.options.app.baseURL, nuxt$1.options.app.buildAssetsDir),
+		outputFileSystem: compiler.outputFileSystem,
+		stats: "none",
+		...nuxt$1.options.webpack.devMiddleware
+	});
+	nuxt$1.hook("close", () => pify(devMiddleware.close.bind(devMiddleware))());
+	const { client: _client, ...hotMiddlewareOptions } = nuxt$1.options.webpack.hotMiddleware || {};
+	const hotMiddleware = webpackHotMiddleware(compiler, {
+		log: false,
+		heartbeat: 1e4,
+		path: joinURL(nuxt$1.options.app.baseURL, "__webpack_hmr", compiler.options.name),
+		...hotMiddlewareOptions
+	});
+	const devHandler = wdmToH3Handler(devMiddleware);
+	await nuxt$1.callHook("server:devHandler", defineEventHandler(async (event) => {
+		const body = await devHandler(event);
+		if (body !== void 0) return body;
+		const { req, res } = "runtime" in event ? event.runtime.node : event.node;
+		await new Promise((resolve$1, reject) => hotMiddleware(req, res, (err) => err ? reject(err) : resolve$1()));
+	}), { cors: () => true });
+	return devMiddleware;
 }
-function wdmToH3Handler(devMiddleware, corsOptions) {
-  return defineEventHandler(async (event) => {
-    const isPreflight = handleCors(event, corsOptions);
-    if (isPreflight) {
-      return null;
-    }
-    if (getRequestHeader(event, "sec-fetch-mode") === "no-cors" && getRequestHeader(event, "sec-fetch-site") === "cross-site") {
-      throw createError({ statusCode: 403 });
-    }
-    setHeader(event, "Vary", "Origin");
-    event.context.webpack = {
-      ...event.context.webpack,
-      devMiddleware: devMiddleware.context
-    };
-    const { req, res } = event.node;
-    const body = await new Promise((resolve, reject) => {
-      res.stream = (stream) => {
-        resolve(stream);
-      };
-      res.send = (data) => {
-        resolve(data);
-      };
-      res.finish = (data) => {
-        resolve(data);
-      };
-      devMiddleware(req, res, (err) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(void 0);
-        }
-      });
-    });
-    return body;
-  });
+function wdmToH3Handler(devMiddleware) {
+	return defineEventHandler(async (event) => {
+		const { req, res } = "runtime" in event ? event.runtime.node : event.node;
+		if (req.headers["sec-fetch-mode"] === "no-cors" && req.headers["sec-fetch-site"] === "cross-site") throw { status: 403 };
+		event.context.webpack = {
+			...event.context.webpack,
+			devMiddleware: devMiddleware.context
+		};
+		return await new Promise((resolve$1, reject) => {
+			res.stream = (stream) => {
+				resolve$1(stream);
+			};
+			res.send = (data) => {
+				resolve$1(data);
+			};
+			res.finish = (data) => {
+				resolve$1(data);
+			};
+			devMiddleware(req, res, (err) => {
+				if (err) reject(err);
+				else resolve$1(void 0);
+			});
+		});
+	});
 }
 async function compile(compiler) {
-  const nuxt = useNuxt();
-  await nuxt.callHook(`${builder}:compile`, { name: compiler.options.name, compiler });
-  compiler.hooks.done.tap("load-resources", async (stats2) => {
-    await nuxt.callHook(`${builder}:compiled`, { name: compiler.options.name, compiler, stats: stats2 });
-  });
-  if (nuxt.options.dev) {
-    const compilersWatching = [];
-    nuxt.hook("close", async () => {
-      await Promise.all(compilersWatching.map((watching) => watching && pify(watching.close.bind(watching))()));
-    });
-    if (compiler.options.name === "client") {
-      return new Promise((resolve, reject) => {
-        compiler.hooks.done.tap("nuxt-dev", () => {
-          resolve(null);
-        });
-        compiler.hooks.failed.tap("nuxt-errorlog", (err) => {
-          reject(err);
-        });
-        createDevMiddleware(compiler).then((devMiddleware) => {
-          if (devMiddleware.context.watching) {
-            compilersWatching.push(devMiddleware.context.watching);
-          }
-        });
-      });
-    }
-    return new Promise((resolve, reject) => {
-      const watching = compiler.watch(nuxt.options.watchers.webpack, (err) => {
-        if (err) {
-          return reject(err);
-        }
-        resolve(null);
-      });
-      compilersWatching.push(watching);
-    });
-  }
-  const stats = await new Promise((resolve, reject) => compiler.run((err, stats2) => err ? reject(err) : resolve(stats2)));
-  if (stats.hasErrors()) {
-    const error = new Error("Nuxt build error");
-    error.stack = stats.toString("errors-only");
-    throw error;
-  }
+	const nuxt$1 = useNuxt();
+	await nuxt$1.callHook(`${builder}:compile`, {
+		name: compiler.options.name,
+		compiler
+	});
+	compiler.hooks.done.tap("load-resources", async (stats$1) => {
+		await nuxt$1.callHook(`${builder}:compiled`, {
+			name: compiler.options.name,
+			compiler,
+			stats: stats$1
+		});
+	});
+	if (nuxt$1.options.dev) {
+		const compilersWatching = [];
+		nuxt$1.hook("close", async () => {
+			await Promise.all(compilersWatching.map((watching) => watching && pify(watching.close.bind(watching))()));
+		});
+		if (compiler.options.name === "client") return new Promise((resolve$1, reject) => {
+			compiler.hooks.done.tap("nuxt-dev", () => {
+				resolve$1(null);
+			});
+			compiler.hooks.failed.tap("nuxt-errorlog", (err) => {
+				reject(err);
+			});
+			createDevMiddleware(compiler).then((devMiddleware) => {
+				if (devMiddleware.context.watching) compilersWatching.push(devMiddleware.context.watching);
+			});
+		});
+		return new Promise((resolve$1, reject) => {
+			const watching = compiler.watch(nuxt$1.options.watchers.webpack, (err) => {
+				if (err) return reject(err);
+				resolve$1(null);
+			});
+			compilersWatching.push(watching);
+		});
+	}
+	const stats = await new Promise((resolve$1, reject) => compiler.run((err, stats$1) => err ? reject(err) : resolve$1(stats$1)));
+	if (stats.hasErrors()) {
+		const error = /* @__PURE__ */ new Error("Nuxt build error");
+		error.stack = stats.toString("errors-only");
+		throw error;
+	}
+}
+function defineEventHandler(handler) {
+	return Object.assign(handler, { __is_handler__: true });
 }
 
-export { bundle };
+//#endregion
+export { bundle };