@stencil/core 5.0.0-alpha.3 → 5.0.0-alpha.4

package/dist/{compiler-D6iP7Bzb.mjs → compiler-BYRrEeD-.mjs}

@@ -1,8 +1,8 @@
 import { n as __require } from "./chunk-CjcI7cDX.mjs";
-import { m as scopeCss, w as HYDRATED_CSS } from "./client-CSm3x5ke.mjs";
+import { m as scopeCss, w as HYDRATED_CSS } from "./client-Dti6fFpE.mjs";
 import { A as DIST_CUSTOM_ELEMENTS, C as CMP_FLAGS, F as DIST_TYPES, H as GENERATED_DTS, J as STATS, M as DIST_HYDRATE_SCRIPT, N as DIST_LAZY, P as DIST_LAZY_LOADER, R as DOCS_JSON, T as COPY, V as EVENT_FLAGS, X as VALID_CONFIG_OUTPUT_TARGETS, Z as WATCH_FLAGS, _ as sortBy, a as fromEntries, b as toTitleCase, d as isNumber$1, f as isObject, g as pluck, h as noop, i as flatOne, j as DIST_GLOBAL_STYLES, k as DIST_COLLECTION, l as isFunction, m as mergeIntoWith, n as dashToPascalCase, o as isBoolean$1, p as isString$1, u as isIterable, w as COLLECTION_MANIFEST_FILE_NAME, x as unique, y as toDashCase, z as DOCS_README } from "./regular-expression-D5pGVpCu.mjs";
 import { $ as join$1, A as isOutputTargetCustom, B as isOutputTargetDocsCustomElementsManifest, Ct as stringifyRuntimeData, D as getComponentsFromModules, E as getComponentsDtsTypesFilePath, F as isOutputTargetDistLazy, G as isOutputTargetStats, H as isOutputTargetDocsReadme, I as isOutputTargetDistLazyLoader, J as relativeImport, K as isOutputTargetWww, L as isOutputTargetDistTypes, M as isOutputTargetDistCollection, N as isOutputTargetDistCustomElements, O as isEligiblePrimaryPackageOutputTarget, P as isOutputTargetDistGlobalStyles, Q as loadTypeScriptDiagnostics, R as isOutputTargetDocs, S as ok, T as getComponentsDtsSrcFilePath, U as isOutputTargetDocsVscode, V as isOutputTargetDocsJson, W as isOutputTargetHydrate, X as augmentDiagnosticWithNode, Z as loadTypeScriptDiagnostic, _ as getSourceMappingUrlForEndOfFile, _t as hasWarning, a as getTextDocs, at as resolve$1, b as err, bt as isGlob, d as isTsxFile, f as parsePackageJson, ft as buildError, g as getInlineSourceMappingUrlLinker, gt as hasError, h as isRemoteUrl, ht as catchError, i as generatePreamble, it as relative$1, j as isOutputTargetDist, k as isOutputTargetCopy, lt as normalizeDiagnostics, m as readPackageJson, mt as buildWarn, n as addDocBlock, nt as normalizeFsPathQuery, o as hasDependency, ot as createOnWarnFn, p as readOnlyArrayHasStringMember, pt as buildJsonFileError, q as isValidConfigOutputTarget, r as createJsVarName, rt as normalizePath, s as isDtsFile, st as loadRolldownDiagnostics, t as validateComponentTag, tt as normalizeFsPath, u as isTsFile, ut as splitLineBreaks, w as filterExcludedComponents, wt as byteSize, x as map, xt as formatComponentRuntimeMeta, y as rolldownToStencilSourceMap, yt as isRootPath, z as isOutputTargetDocsCustom } from "./validation-Byxie0Uk.mjs";
-import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-Bg-mO5dw.mjs";
+import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-BF2jSfWg.mjs";
 import ts, { default as ts$1 } from "typescript";
 import { readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
@@ -26,9 +26,9 @@ import { browserslistToTargets, transform } from "lightningcss";
 import * as process$1 from "process";
 import { dataToEsm } from "@rollup/pluginutils";
 //#region src/version.ts
-const version = "5.0.0-alpha.3-dev.1775606156.754db56";
-const buildId = "1775606156";
-const vermoji = "🍹";
+const version = "5.0.0-alpha.4";
+const buildId = "1775838541";
+const vermoji = "❓";
 /**
 * Get the installed version of a tool/dependency.
 * Handles packages with exports maps that point to subdirectories.
@@ -107,6 +107,7 @@ var CompilerContext = class {
 	rolldownCacheHydrate = null;
 	rolldownCacheLazy = null;
 	rolldownCacheNative = null;
+	cssTransformCache = /* @__PURE__ */ new Map();
 	cachedGlobalStyle;
 	styleModeNames = /* @__PURE__ */ new Set();
 	worker = null;
@@ -3219,8 +3220,19 @@ const allCmpStyles = /* @__PURE__ */ new Map();
 * @returns a Rolldown plugin which carries out the necessary work
 */
 const extTransformsPlugin = (config, compilerCtx, buildCtx) => {
+	let transformCount = 0;
+	let cacheHits = 0;
+	let firstTransformStart = null;
+	let lastTransformEnd = 0;
 	return {
 		name: "extTransformsPlugin",
+		buildEnd() {
+			if (config.logLevel === "debug" && firstTransformStart !== null) {
+				const totalElapsed = lastTransformEnd - firstTransformStart;
+				const computed = transformCount - cacheHits;
+				buildCtx.debug(`extTransformsPlugin: ${transformCount} stylesheets in ${totalElapsed.toFixed(1)}ms wall-clock` + (cacheHits > 0 ? ` (${computed} computed, ${cacheHits} from cache)` : ""));
+			}
+		},
 		async transform(_, id) {
 			if (/\0/.test(id)) return null;
 			/**
@@ -3230,24 +3242,53 @@ const extTransformsPlugin = (config, compilerCtx, buildCtx) => {
 			if (!compilerCtx.worker) return null;
 			const { data } = parseImportPath(id);
 			if (data != null) {
-				let cmpStyles = void 0;
-				let cmp = void 0;
 				const filePath = normalizeFsPath(id);
-				const code = await compilerCtx.fs.readFile(filePath);
-				if (typeof code !== "string") return null;
+				const wasCached = compilerCtx.cssTransformCache.has(id);
+				if (!wasCached) {
+					const code = await compilerCtx.fs.readFile(filePath);
+					if (typeof code !== "string") compilerCtx.cssTransformCache.set(id, null);
+					else {
+						const pluginTransforms = await runPluginTransformsEsmImports(config, compilerCtx, buildCtx, code, filePath);
+						const cssTransformResults = await compilerCtx.worker.transformCssToEsm({
+							file: pluginTransforms.id,
+							input: pluginTransforms.code,
+							tag: data.tag,
+							tags: buildCtx.components.map((c) => c.tagName),
+							addTagTransformers: !!buildCtx.config.extras.additionalTagTransformers,
+							encapsulation: data.encapsulation,
+							mode: data.mode,
+							sourceMap: config.sourceMap,
+							minify: config.minifyCss,
+							autoprefixer: config.autoprefixCss,
+							docs: config.buildDocs
+						});
+						compilerCtx.cssTransformCache.set(id, {
+							pluginTransformId: pluginTransforms.id,
+							pluginTransformCode: pluginTransforms.code,
+							pluginTransformDependencies: pluginTransforms.dependencies,
+							pluginTransformDiagnostics: pluginTransforms.diagnostics,
+							cssTransformOutput: cssTransformResults
+						});
+					}
+				}
+				const cacheEntry = compilerCtx.cssTransformCache.get(id);
+				if (wasCached) cacheHits++;
+				if (cacheEntry == null) return null;
 				/**
 				* add file to watch list if it is outside of the `srcDir` config path
 				*/
 				if (config.watch && (id.startsWith("/") || id.startsWith(".")) && !id.startsWith(config.srcDir)) compilerCtx.addWatchFile(id.split("?")[0]);
-				const pluginTransforms = await runPluginTransformsEsmImports(config, compilerCtx, buildCtx, code, filePath);
+				if (firstTransformStart === null) firstTransformStart = performance.now();
+				let cmpStyles = void 0;
+				let cmp = void 0;
 				if (data.tag) {
 					cmp = buildCtx.components.find((c) => c.tagName === data.tag);
 					if (cmp && !cmp.isCollectionDependency && compilerCtx.moduleMap.get(cmp.sourceFilePath)) {
 						const collectionDirs = config.outputTargets.filter(isOutputTargetDistCollection);
-						const relPath = relative$1(config.srcDir, pluginTransforms.id);
+						const relPath = relative$1(config.srcDir, cacheEntry.pluginTransformId);
 						await Promise.all(collectionDirs.map(async (outputTarget) => {
 							const collectionPath = join$1(outputTarget.collectionDir, relPath);
-							await compilerCtx.fs.writeFile(collectionPath, pluginTransforms.code);
+							await compilerCtx.fs.writeFile(collectionPath, cacheEntry.pluginTransformCode);
 						}));
 					}
 					/**
@@ -3257,46 +3298,35 @@ const extTransformsPlugin = (config, compilerCtx, buildCtx) => {
 					if (!allCmpStyles.has(scopeId)) allCmpStyles.set(scopeId, /* @__PURE__ */ new Map());
 					cmpStyles = allCmpStyles.get(scopeId);
 				}
-				const cssTransformResults = await compilerCtx.worker.transformCssToEsm({
-					file: pluginTransforms.id,
-					input: pluginTransforms.code,
-					tag: data.tag,
-					tags: buildCtx.components.map((c) => c.tagName),
-					addTagTransformers: !!buildCtx.config.extras.additionalTagTransformers,
-					encapsulation: data.encapsulation,
-					mode: data.mode,
-					sourceMap: config.sourceMap,
-					minify: config.minifyCss,
-					autoprefixer: config.autoprefixCss,
-					docs: config.buildDocs
-				});
+				transformCount++;
+				lastTransformEnd = performance.now();
 				/**
 				* persist component styles for transformed stylesheet
 				*/
-				if (cmpStyles) cmpStyles.set(filePath, cssTransformResults.styleText);
+				if (cmpStyles) cmpStyles.set(filePath, cacheEntry.cssTransformOutput.styleText);
 				if (cmp) {
 					cmp.styleDocs ||= [];
-					mergeIntoWith(cmp.styleDocs, cssTransformResults.styleDocs, (docs) => `${docs.name},${docs.mode}`);
+					mergeIntoWith(cmp.styleDocs, cacheEntry.cssTransformOutput.styleDocs, (docs) => `${docs.name},${docs.mode}`);
 				}
-				for (const dep of pluginTransforms.dependencies) {
+				for (const dep of cacheEntry.pluginTransformDependencies) {
 					this.addWatchFile(dep);
 					compilerCtx.addWatchFile(dep);
 				}
-				buildCtx.diagnostics.push(...pluginTransforms.diagnostics);
-				buildCtx.diagnostics.push(...cssTransformResults.diagnostics);
-				if (hasError(cssTransformResults.diagnostics) || hasError(pluginTransforms.diagnostics)) this.error("Plugin CSS transform error");
+				buildCtx.diagnostics.push(...cacheEntry.pluginTransformDiagnostics);
+				buildCtx.diagnostics.push(...cacheEntry.cssTransformOutput.diagnostics);
+				if (hasError(cacheEntry.cssTransformOutput.diagnostics) || hasError(cacheEntry.pluginTransformDiagnostics)) this.error("Plugin CSS transform error");
 				/**
 				* if the style has updated, compose all styles for the component
 				*/
 				if (!buildCtx.stylesUpdated.some((s) => {
-					return s.styleTag === data.tag && s.styleMode === data.mode && s.styleText === cssTransformResults.styleText;
+					return s.styleTag === data.tag && s.styleMode === data.mode && s.styleText === cacheEntry.cssTransformOutput.styleText;
 				}) && data.tag && data.mode) {
 					const externalStyles = cmp?.styles?.[0]?.externalStyles;
 					/**
 					* if component has external styles, use a list to keep the order to which
 					* styles are applied.
 					*/
-					const styleText = cmpStyles ? externalStyles ? externalStyles.map((es) => cmpStyles.get(es.originalComponentPath) || cmpStyles.get(es.absolutePath)).join("\n") : [...cmpStyles.values()].join("\n") : cssTransformResults.styleText;
+					const styleText = cmpStyles ? externalStyles ? externalStyles.map((es) => cmpStyles.get(es.originalComponentPath) || cmpStyles.get(es.absolutePath)).join("\n") : [...cmpStyles.values()].join("\n") : cacheEntry.cssTransformOutput.styleText;
 					buildCtx.stylesUpdated.push({
 						styleTag: data.tag,
 						styleMode: data.mode,
@@ -3304,8 +3334,8 @@ const extTransformsPlugin = (config, compilerCtx, buildCtx) => {
 					});
 				}
 				return {
-					code: cssTransformResults.output,
-					map: cssTransformResults.map,
+					code: cacheEntry.cssTransformOutput.output,
+					map: cacheEntry.cssTransformOutput.map,
 					moduleSideEffects: false
 				};
 			}
@@ -3538,8 +3568,25 @@ const createModule = (staticSourceFile, staticSourceFileText, emitFilepath) => (
 * @returns the rolldown plugin for handling TypeScript files.
 */
 const typescriptPlugin = (compilerCtx, bundleOpts, config) => {
+	/**
+	* Cache the result of `ts.transpileModule` for a given file, keyed by the
+	* normalized file path. Rolldown re-runs the `transform` hook for every
+	* `.generate()` call on the same build object (once per output format:
+	* esm-browser, esm, cjs), so without this cache a 220-component project
+	* would call `ts.transpileModule` 660 times; with it, only 220.
+	*
+	* The cache is intentionally scoped to this plugin instance (one per
+	* `bundleOutput` call) so it is automatically discarded when the Rolldown
+	* build object is garbage-collected — no manual invalidation required.
+	*/
+	const transformCache = /* @__PURE__ */ new Map();
+	let cacheHits = 0;
+	let cacheMisses = 0;
 	return {
 		name: `${bundleOpts.id}TypescriptPlugin`,
+		buildEnd() {
+			if (config.logLevel === "debug" && cacheMisses > 0) config.logger.debug(`${bundleOpts.id}TypescriptPlugin: ${cacheMisses} transforms computed` + (cacheHits > 0 ? `, ${cacheHits} from cache` : ""));
+		},
 		load(id) {
 			if (isAbsolute(id)) {
 				const module = getModule(compilerCtx, normalizeFsPath(id));
@@ -3560,13 +3607,28 @@ const typescriptPlugin = (compilerCtx, bundleOpts, config) => {
 		},
 		transform(_code, id) {
 			if (isAbsolute(id)) {
-				const mod = getModule(compilerCtx, normalizeFsPath(id));
+				const fsFilePath = normalizeFsPath(id);
+				const mod = getModule(compilerCtx, fsFilePath);
 				if (mod?.cmps) {
+					const cached = transformCache.get(fsFilePath);
+					if (cached) {
+						cacheHits++;
+						const sourceMap = cached.sourceMapText ? JSON.parse(cached.sourceMapText) : null;
+						return {
+							code: cached.outputText,
+							map: sourceMap
+						};
+					}
+					cacheMisses++;
 					const tsResult = ts.transpileModule(mod.staticSourceFileText, {
 						compilerOptions: config.tsCompilerOptions,
 						fileName: mod.sourceFilePath,
 						transformers: { before: bundleOpts.customBeforeTransformers ?? [] }
 					});
+					transformCache.set(fsFilePath, {
+						outputText: tsResult.outputText,
+						sourceMapText: tsResult.sourceMapText ?? null
+					});
 					const sourceMap = tsResult.sourceMapText ? JSON.parse(tsResult.sourceMapText) : null;
 					return {
 						code: tsResult.outputText,
@@ -4308,7 +4370,7 @@ const getRolldownOptions = (config, compilerCtx, buildCtx, bundleOpts) => {
 		transform: { define: { "process.env.NODE_ENV": config.devMode ? "\"development\"" : "\"production\"" } },
 		checks: {
 			preferBuiltinFeature: false,
-			pluginTimings: config.devMode
+			pluginTimings: config.logLevel === "debug"
 		},
 		moduleTypes: {
 			".css": "js",
@@ -6666,7 +6728,7 @@ const generateHydrateApp = async (config, compilerCtx, buildCtx, outputTargets)
 			}],
 			treeshake: false,
 			onwarn: createOnWarnFn(buildCtx.diagnostics),
-			checks: { pluginTimings: config.devMode }
+			checks: { pluginTimings: config.logLevel === "debug" }
 		});
 		const buildPromises = [buildHydrateAppFor("esm", rolldownAppBuild, config, compilerCtx, buildCtx, outputTargets)];
 		if (outputTargets.some((o) => o.cjs)) buildPromises.push(buildHydrateAppFor("cjs", rolldownAppBuild, config, compilerCtx, buildCtx, outputTargets));
@@ -7511,10 +7573,12 @@ const outputLazy = async (config, compilerCtx, buildCtx) => {
 				[LAZY_BROWSER_ENTRY_ID]: getLazyEntry(true)
 			}
 		};
+		const entryGenStart = performance.now();
 		generateEntryModules(config, buildCtx);
 		buildCtx.entryModules.forEach((entryModule) => {
 			bundleOpts.inputs[entryModule.entryKey] = entryModule.entryKey;
 		});
+		buildCtx.debug(`lazy: generateEntryModules: ${(performance.now() - entryGenStart).toFixed(1)}ms`);
 		const rolldownBuild = await bundleOutput(config, compilerCtx, buildCtx, bundleOpts);
 		if (rolldownBuild != null) {
 			(await Promise.all([
@@ -14264,6 +14328,7 @@ const tsResolveModuleName = (config, compilerCtx, moduleName, containingFile) =>
 		const host = patchTsSystemFileSystem(config, config.sys, compilerCtx.fs, ts.sys);
 		const compilerOptions = { ...config.tsCompilerOptions };
 		compilerOptions.resolveJsonModule = true;
+		compilerOptions.noResolve = false;
 		return resolveModuleName(moduleName, containingFile, compilerOptions, host);
 	}
 	return null;
@@ -14429,6 +14494,41 @@ const deDupeMembers = (dedupeMembers, staticMembers) => {
 	}));
 };
 /**
+* When a parent-class source file is fetched directly from disk (via
+* {@link tsGetSourceFile}) rather than from the compiler's moduleMap cache, it
+* arrives with its original decorator syntax intact.  The static-meta parsers
+* (`parseStaticProps`, `parseStaticStates`, etc.) only understand the static-
+* getter form produced by {@link convertDecoratorsToStatic}.
+*
+* This helper creates a self-contained mini TypeScript program for the single
+* file and runs the decorator→static transformer on it, returning the
+* transformed source file.  Prop types may be under-resolved (external imports
+* are not available in the mini program) and will fall back to `any`, which is
+* acceptable for the purpose of walking the inheritance chain.
+*
+* @param sourceFile the raw (decorator-syntax) source file from disk
+* @param config the current Stencil validated config
+* @param target the script target to use when converting decorators to static (if needed)
+* @returns the source file with decorators converted to static getters
+*/
+function convertDiskSourceFileDecorators(sourceFile, config, target = ts.ScriptTarget.ESNext) {
+	const compilerOptions = {
+		...config.tsCompilerOptions,
+		experimentalDecorators: true,
+		noLib: true,
+		noResolve: true,
+		isolatedModules: false,
+		target
+	};
+	const host = ts.createCompilerHost(compilerOptions);
+	const program = ts.createProgram([sourceFile.fileName], compilerOptions, host);
+	const typeChecker = program.getTypeChecker();
+	const ownSourceFile = program.getSourceFile(sourceFile.fileName) ?? sourceFile;
+	const result = ts.transform(ownSourceFile, [convertDecoratorsToStatic(config, [], typeChecker, program)]);
+	const printed = ts.createPrinter({ removeComments: false }).printFile(result.transformed[0]);
+	return ts.createSourceFile(sourceFile.fileName, printed, target, true);
+}
+/**
 * Helper function to resolve and process an extended class from a module.
 * This handles:
 * 1. Resolving the module path
@@ -14443,12 +14543,13 @@ const deDupeMembers = (dedupeMembers, staticMembers) => {
 * @param moduleSpecifier - the module path to resolve
 * @param className - the name of the class to find in the resolved module
 * @param dependentClasses - the array to add found classes to
-* @param keepLooking - whether to continue recursively looking for more extended classes
 * @param typeChecker - the TypeScript type checker
 * @param ogModule - the original module file of the class declaration
+* @param targetScriptTarget - the script target to use when converting decorators to static (if needed)
 * @returns the found class declaration or undefined
 */
-function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, moduleSpecifier, className, dependentClasses, keepLooking, typeChecker, ogModule) {
+function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, moduleSpecifier, className, dependentClasses, typeChecker, ogModule, targetScriptTarget = ts.ScriptTarget.ESNext) {
+	let keepLooking = true;
 	const foundFile = tsResolveModuleName(buildCtx.config, compilerCtx, moduleSpecifier, currentSource.fileName);
 	if (!foundFile?.resolvedModule || !className) return;
 	let foundSource = compilerCtx.moduleMap.get(foundFile.resolvedModule.resolvedFileName)?.staticSourceFile;
@@ -14461,6 +14562,7 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 			if (!buildCtx.config._isTesting) augmentDiagnosticWithNode(err, classDeclaration);
 			return;
 		}
+		foundSource = convertDiskSourceFileDecorators(foundSource, buildCtx.config, targetScriptTarget);
 	}
 	const matchedStatement = foundSource.statements.find(matchesNamedDeclaration(className));
 	if (!matchedStatement) {
@@ -14556,6 +14658,7 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 	if (!hasHeritageClauses?.length) return dependentClasses;
 	const extendsClause = hasHeritageClauses.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword);
 	if (!extendsClause) return dependentClasses;
+	const targetScriptTarget = (ogModule?.staticSourceFile)?.languageVersion ?? ts.ScriptTarget.ESNext;
 	let classIdentifiers = [];
 	let foundClassDeclaration;
 	let keepLooking = true;
@@ -14641,13 +14744,13 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 				if (statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause?.namedBindings)) statement.importClause?.namedBindings.elements.forEach((element) => {
 					if (element.name.getText() === extendee.getText()) {
 						const className = element.propertyName?.getText() || element.name.getText();
-						resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, statement.moduleSpecifier.getText().replaceAll(/['"]/g, ""), className, dependentClasses, keepLooking, typeChecker, ogModule);
+						resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, statement.moduleSpecifier.getText().replaceAll(/['"]/g, ""), className, dependentClasses, typeChecker, ogModule, targetScriptTarget);
 					}
 				});
 			});
 			if (!importStatements.length) currentSource.statements.filter(ts.isVariableStatement).forEach((statement) => {
 				statement.declarationList.declarations.forEach((declaration) => {
-					if (declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.escapedText === "require" && declaration.initializer.arguments.length === 1 && ts.isStringLiteral(declaration.initializer.arguments[0])) resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, declaration.initializer.arguments[0].text.replaceAll(/['"]/g, ""), extendee.getText(), dependentClasses, keepLooking, typeChecker, ogModule);
+					if (declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.escapedText === "require" && declaration.initializer.arguments.length === 1 && ts.isStringLiteral(declaration.initializer.arguments[0])) resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, declaration.initializer.arguments[0].text.replaceAll(/['"]/g, ""), extendee.getText(), dependentClasses, typeChecker, ogModule, targetScriptTarget);
 				});
 			});
 		}
@@ -14688,9 +14791,10 @@ function mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, sta
 		const mixinEvents = parseStaticEvents(extendedStaticMembers) ?? [];
 		const isMixin = mixinProps.length > 0 || mixinStates.length > 0 || mixinMethods.length > 0 || mixinEvents.length > 0;
 		const module = compilerCtx.moduleMap.get(extendedClass.fileName);
-		if (!module) return;
-		module.isMixin = isMixin;
-		module.isExtended = true;
+		if (module) {
+			module.isMixin = isMixin;
+			module.isExtended = true;
+		}
 		doesExtend = true;
 		if ((mixinProps.length > 0 || mixinStates.length > 0) && !detectModernPropDeclarations(extendedClass.classNode, extendedClass.sourceFile)) {
 			const err = buildWarn(buildCtx.diagnostics);
@@ -17893,25 +17997,29 @@ const createInMemoryFs = (sys) => {
 	* modify the in-memory filesystem cache. Otherwise it will create directories
 	* in the real FS.
 	*
+	* All directories are created concurrently using `{ recursive: true }`, which
+	* lets the OS handle parent-before-child ordering without requiring the sorted
+	* sequential loop that was previously needed.
+	*
 	* @param dirsToEnsure directories we want to ensure exist
 	* @param inMemoryOnly whether directory creation should be confined to the
 	* in-memory cache
 	* @returns a Promise wrapping a list of directories created
 	*/
 	const commitEnsureDirs = async (dirsToEnsure, inMemoryOnly) => {
-		const dirsAdded = [];
-		for (const dirPath of dirsToEnsure) {
+		return (await Promise.all(dirsToEnsure.map(async (dirPath) => {
 			const item = getItem(dirPath);
-			if (item.exists === true && item.isDirectory === true) continue;
+			if (item.exists === true && item.isDirectory === true) return null;
 			try {
 				item.exists = true;
 				item.isDirectory = true;
 				item.isFile = false;
-				if (!inMemoryOnly) await sys.createDir(dirPath);
-				dirsAdded.push(dirPath);
-			} catch {}
-		}
-		return dirsAdded;
+				if (!inMemoryOnly) await sys.createDir(dirPath, { recursive: true });
+				return dirPath;
+			} catch {
+				return null;
+			}
+		}))).filter((d) => d !== null);
 	};
 	/**
 	* Commit copy file operations to disk
@@ -18250,6 +18358,26 @@ const createWorkerMainContext = (workerCtrl) => ({
 //#endregion
 //#region src/compiler/optimize/autoprefixer.ts
 /**
+* Cache for resolved browserslist targets to avoid re-parsing for every stylesheet.
+* The key is a JSON-stringified version of the browser targets array.
+*/
+let cachedTargets = null;
+let cachedTargetKey = null;
+/**
+* Get Lightning CSS targets from browser targets, using a cache to avoid
+* repeatedly parsing the same browserslist query for every stylesheet.
+*
+* @param browserTargets array of browserslist query strings
+* @returns Lightning CSS targets object
+*/
+const getTargets = (browserTargets) => {
+	const key = JSON.stringify(browserTargets);
+	if (cachedTargetKey === key && cachedTargets !== null) return cachedTargets;
+	cachedTargets = browserslistToTargets(browserslist(browserTargets));
+	cachedTargetKey = key;
+	return cachedTargets;
+};
+/**
 * Autoprefix a CSS string, adding vendor prefixes to ensure that what is
 * written in the CSS will render correctly across our range of supported
 * browsers. Uses Lightning CSS to add vendor prefixes based on a browserslist
@@ -18258,24 +18386,26 @@ const createWorkerMainContext = (workerCtrl) => ({
 * @param cssText the CSS text to be prefixed
 * @param opts options controlling which browsers to target, or `null` to use
 * the default browser targets
+* @param filePath optional file path for error reporting
+* @param minify whether to also minify the CSS (default: false)
 * @returns a Promise wrapping the prefixed CSS and any diagnostics
 */
-const autoprefixCss = async (cssText, opts) => {
+const autoprefixCss = async (cssText, opts, filePath, minify = false) => {
 	const output = {
 		output: cssText,
 		diagnostics: []
 	};
 	try {
-		const targets = browserslistToTargets(browserslist(opts != null && typeof opts === "object" && Array.isArray(opts.targets) ? opts.targets : DEFAULT_BROWSER_TARGETS));
+		const targets = getTargets(opts != null && typeof opts === "object" && Array.isArray(opts.targets) ? opts.targets : DEFAULT_BROWSER_TARGETS);
 		output.output = transform({
-			filename: "style.css",
+			filename: filePath ?? "style.css",
 			code: Buffer.from(cssText),
 			targets,
-			minify: false
+			minify
 		}).code.toString();
 	} catch (e) {
 		const diagnostic = {
-			header: `Autoprefix CSS`,
+			header: `CSS Error`,
 			messageText: `CSS Error: ${e}`,
 			level: `error`,
 			type: `css`,
@@ -18283,6 +18413,30 @@ const autoprefixCss = async (cssText, opts) => {
 		};
 		if (typeof e.name === "string") diagnostic.header = e.name;
 		if (typeof e.message === "string") diagnostic.messageText = e.message;
+		if (filePath) diagnostic.absFilePath = filePath;
+		else if (typeof e.fileName === "string" && e.fileName !== "style.css") diagnostic.absFilePath = e.fileName;
+		if (e.loc && typeof e.loc.line === "number") {
+			diagnostic.lineNumber = e.loc.line;
+			diagnostic.columnNumber = e.loc.column ?? 1;
+			const lines = (typeof e.source === "string" ? e.source : cssText).split("\n");
+			const errorLine = e.loc.line;
+			const errorColumn = e.loc.column ?? 1;
+			const startLine = Math.max(1, errorLine - 2);
+			const endLine = Math.min(lines.length, errorLine + 2);
+			const printLines = [];
+			for (let lineNum = startLine; lineNum <= endLine; lineNum++) {
+				const lineIndex = lineNum - 1;
+				const lineText = lines[lineIndex] ?? "";
+				printLines.push({
+					lineIndex,
+					lineNumber: lineNum,
+					text: lineText,
+					errorCharStart: lineNum === errorLine ? errorColumn - 1 : -1,
+					errorLength: lineNum === errorLine ? Math.max(1, lineText.length - (errorColumn - 1)) : 0
+				});
+			}
+			diagnostic.lines = printLines;
+		}
 		output.diagnostics.push(diagnostic);
 	}
 	return output;
@@ -19036,7 +19190,7 @@ const optimizeCss = async (inputOpts) => {
 		diagnostics: []
 	};
 	if (inputOpts.autoprefixer !== false && inputOpts.autoprefixer !== null) {
-		result = await autoprefixCss(inputOpts.input, inputOpts.autoprefixer ?? null);
+		result = await autoprefixCss(inputOpts.input, inputOpts.autoprefixer ?? null, inputOpts.filePath);
 		if (hasError(result.diagnostics)) return result;
 	}
 	if (inputOpts.minify !== false) result.output = await minifyCss({
@@ -21242,7 +21396,8 @@ const getTranspileConfig = (input) => {
 		file: compileOpts.file,
 		style: compileOpts.style,
 		styleImportData: compileOpts.styleImportData,
-		target: compileOpts.target
+		target: compileOpts.target,
+		extraFiles: input.extraFiles
 	};
 	return {
 		compileOpts,
@@ -21370,9 +21525,20 @@ const transpileModule = (config, input, transformOpts) => {
 	if (tsCompilerOptions.jsx != null && !isAutomaticRuntime && !isString$1(tsCompilerOptions.jsxFragmentFactory)) tsCompilerOptions.jsxFragmentFactory = "Fragment";
 	if (tsCompilerOptions.paths && !isString$1(tsCompilerOptions.baseUrl)) tsCompilerOptions.baseUrl = ".";
 	const sourceFile = ts.createSourceFile(sourceFilePath, input, tsCompilerOptions.target);
-	const program = ts.createProgram([sourceFilePath], tsCompilerOptions, {
+	const extraSourceFiles = /* @__PURE__ */ new Map();
+	if (transformOpts.extraFiles) {
+		const currentDir = normalizePath(transformOpts.currentDirectory || process.cwd());
+		for (const [filePath, text] of Object.entries(transformOpts.extraFiles)) {
+			const resolvedPath = normalizePath(filePath.startsWith("/") ? filePath : join$1(currentDir, filePath));
+			extraSourceFiles.set(resolvedPath, ts.createSourceFile(resolvedPath, text, tsCompilerOptions.target));
+		}
+		tsCompilerOptions.noResolve = false;
+	}
+	const compilerHost = {
 		getSourceFile: (fileName) => {
-			return normalizePath(fileName) === normalizePath(sourceFilePath) ? sourceFile : void 0;
+			const normalized = normalizePath(fileName);
+			if (normalized === normalizePath(sourceFilePath)) return sourceFile;
+			return extraSourceFiles.get(normalized);
 		},
 		writeFile: (name, text) => {
 			if (name.endsWith(".js.map") || name.endsWith(".mjs.map")) results.map = text;
@@ -21383,12 +21549,45 @@ const transpileModule = (config, input, transformOpts) => {
 		getCanonicalFileName: (fileName) => fileName,
 		getCurrentDirectory: () => transformOpts.currentDirectory || process.cwd(),
 		getNewLine: () => ts.sys.newLine || "\n",
-		fileExists: (fileName) => normalizePath(fileName) === normalizePath(sourceFilePath),
+		fileExists: (fileName) => {
+			const normalized = normalizePath(fileName);
+			return normalized === normalizePath(sourceFilePath) || extraSourceFiles.has(normalized);
+		},
 		readFile: () => "",
 		directoryExists: () => true,
 		getDirectories: () => []
-	});
+	};
+	const program = ts.createProgram([sourceFilePath, ...extraSourceFiles.keys()], tsCompilerOptions, compilerHost);
 	const typeChecker = program.getTypeChecker();
+	if (extraSourceFiles.size > 0) {
+		const miniCompilerHost = {
+			getSourceFile: (fileName) => extraSourceFiles.get(normalizePath(fileName)),
+			writeFile: () => {},
+			getDefaultLibFileName: () => "lib.d.ts",
+			useCaseSensitiveFileNames: () => false,
+			getCanonicalFileName: (f) => f,
+			getCurrentDirectory: () => transformOpts.currentDirectory || process.cwd(),
+			getNewLine: () => ts.sys.newLine || "\n",
+			fileExists: (f) => extraSourceFiles.has(normalizePath(f)),
+			readFile: () => "",
+			directoryExists: () => true,
+			getDirectories: () => []
+		};
+		const miniProgram = ts.createProgram([...extraSourceFiles.keys()], {
+			...tsCompilerOptions,
+			noResolve: true
+		}, miniCompilerHost);
+		const miniTypeChecker = miniProgram.getTypeChecker();
+		const decoratorConverter = convertDecoratorsToStatic(config, buildCtx.diagnostics, miniTypeChecker, miniProgram);
+		for (const [resolvedPath, rawSource] of extraSourceFiles) {
+			const transformResult = ts.transform(rawSource, [decoratorConverter], tsCompilerOptions);
+			const processedSource = transformResult.transformed[0];
+			transformResult.dispose();
+			const moduleFile = getModuleLegacy(compilerCtx, resolvedPath);
+			moduleFile.staticSourceFile = processedSource;
+			moduleFile.staticSourceFileText = processedSource.getFullText?.() ?? rawSource.text;
+		}
+	}
 	const transformers = {
 		before: [
 			convertDecoratorsToStatic(config, buildCtx.diagnostics, typeChecker, program),
@@ -21404,7 +21603,8 @@ const transpileModule = (config, input, transformOpts) => {
 	}
 	if (transformOpts.componentExport === "customelement" || transformOpts.componentExport === "module") transformers.after.push(nativeComponentTransform(compilerCtx, transformOpts, buildCtx));
 	else transformers.after.push(lazyComponentTransform(compilerCtx, transformOpts, buildCtx));
-	program.emit(void 0, void 0, void 0, false, transformers);
+	const emitTarget = extraSourceFiles.size > 0 ? program.getSourceFile(sourceFilePath) : void 0;
+	program.emit(emitTarget, void 0, void 0, false, transformers);
 	const tsDiagnostics = [...program.getSyntacticDiagnostics()];
 	if (config.validateTypes) tsDiagnostics.push(...program.getOptionsDiagnostics());
 	buildCtx.diagnostics.push(...loadTypeScriptDiagnostics(tsDiagnostics));