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

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

@@ -1,8 +1,8 @@
 import { n as __require } from "./chunk-CjcI7cDX.mjs";
-import { C as HYDRATED_CSS, h as scopeCss } from "./client-DucyoZT4.mjs";
-import { C as toDashCase, D as CMP_FLAGS, F as DIST_GLOBAL_STYLES, G as EVENT_FLAGS, H as DOCS_JSON, I as DIST_HYDRATE_SCRIPT, K as GENERATED_DTS, L as DIST_LAZY, N as DIST_COLLECTION, O as COLLECTION_MANIFEST_FILE_NAME, P as DIST_CUSTOM_ELEMENTS, R as DIST_LAZY_LOADER, T as unique, U as DOCS_README, _ as isString$1, b as pluck, c as flatOne, g as isObject, h as isNumber$1, it as VALID_CONFIG_OUTPUT_TARGETS, k as COPY, l as fromEntries, m as isIterable, o as dashToPascalCase, ot as WATCH_FLAGS, p as isFunction, tt as STATS, u as isBoolean$1, v as mergeIntoWith, w as toTitleCase, x as sortBy, y as noop, z as DIST_TYPES } from "./serialize-o-Sj1lvg.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, ct as escapeHtml, 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 loadRollupDiagnostics, 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 rollupToStencilSourceMap, yt as isRootPath, z as isOutputTargetDocsCustom } from "./validation-BR7tMYEv.mjs";
-import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-BWBQAh8C.mjs";
+import { m as scopeCss, w as HYDRATED_CSS } from "./client-CSm3x5ke.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 ts, { default as ts$1 } from "typescript";
 import { readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
@@ -13,25 +13,22 @@ import { cloneDocument, createDocument, serializeNodeToHtml } from "@stencil/moc
 import postcss from "postcss";
 import postcssSafeParser from "postcss-safe-parser";
 import postcssSelectorParser from "postcss-selector-parser";
-import rollupCommonjsPlugin from "@rollup/plugin-commonjs";
-import rollupJsonPlugin from "@rollup/plugin-json";
-import rollupNodeResolvePlugin from "@rollup/plugin-node-resolve";
-import rollupReplacePlugin from "@rollup/plugin-replace";
-import { rollup } from "rollup";
+import { rolldown } from "rolldown";
 import MagicString from "magic-string";
 import resolve from "resolve";
-import sourceMapMerge from "merge-source-map";
 import { minify } from "terser";
 import { SelectorType, parse, stringify } from "css-what";
 import * as os from "os";
 import { execSync } from "child_process";
 import { createHash } from "crypto";
+import browserslist from "browserslist";
+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.2-dev.1775073529.e56fbc8";
-const buildId = "1775073529";
-const vermoji = "🍻";
+const version = "5.0.0-alpha.3-dev.1775606156.754db56";
+const buildId = "1775606156";
+const vermoji = "🍹";
 /**
 * Get the installed version of a tool/dependency.
 * Handles packages with exports maps that point to subdirectories.
@@ -67,8 +64,8 @@ const versions = {
 	get typescript() {
 		return getToolVersion("typescript");
 	},
-	get rollup() {
-		return getToolVersion("rollup");
+	get rolldown() {
+		return getToolVersion("rolldown");
 	},
 	get terser() {
 		return getToolVersion("terser");
@@ -106,10 +103,10 @@ var CompilerContext = class {
 	moduleMap = /* @__PURE__ */ new Map();
 	nodeMap = /* @__PURE__ */ new WeakMap();
 	resolvedCollections = /* @__PURE__ */ new Set();
-	rollupCache = /* @__PURE__ */ new Map();
-	rollupCacheHydrate = null;
-	rollupCacheLazy = null;
-	rollupCacheNative = null;
+	rolldownCache = /* @__PURE__ */ new Map();
+	rolldownCacheHydrate = null;
+	rolldownCacheLazy = null;
+	rolldownCacheNative = null;
 	cachedGlobalStyle;
 	styleModeNames = /* @__PURE__ */ new Set();
 	worker = null;
@@ -120,9 +117,9 @@ var CompilerContext = class {
 		this.collections.length = 0;
 		this.compilerOptions = null;
 		this.hasSuccessfulBuild = false;
-		this.rollupCacheHydrate = null;
-		this.rollupCacheLazy = null;
-		this.rollupCacheNative = null;
+		this.rolldownCacheHydrate = null;
+		this.rolldownCacheLazy = null;
+		this.rolldownCacheNative = null;
 		this.moduleMap.clear();
 		this.resolvedCollections.clear();
 		if (this.fs != null) this.fs.clearCache();
@@ -240,15 +237,18 @@ const resetModuleLegacy = (moduleFile) => {
 * @returns an object containing TypeScript compiler options
 */
 const getTsOptionsToExtend = (config) => {
+	const cacheDir = config.cacheDir || config.sys.tmpDirSync();
 	return {
 		experimentalDecorators: true,
 		declaration: config.outputTargets.some(isOutputTargetDistTypes),
 		module: config.tsCompilerOptions?.module || ts.ModuleKind.ESNext,
 		moduleResolution: config.tsCompilerOptions?.moduleResolution === ts.ModuleResolutionKind.Bundler ? ts.ModuleResolutionKind.Bundler : ts.ModuleResolutionKind.NodeJs,
 		noEmitOnError: config.tsCompilerOptions?.noEmitOnError || false,
-		outDir: config.cacheDir || config.sys.tmpDirSync(),
+		outDir: cacheDir,
 		sourceMap: config.sourceMap,
-		inlineSources: config.sourceMap
+		inlineSources: config.sourceMap,
+		incremental: config.enableCache !== false,
+		tsBuildInfoFile: config.enableCache !== false ? join$1(cacheDir, ".tsbuildinfo") : void 0
 	};
 };
 //#endregion
@@ -956,7 +956,7 @@ function getSymbolForType(type) {
 * - For CommonJS, the component class is left as is
 * - For ESM, the component class is re-written as a variable statement
 *
-* @param transformOpts the options provided to TypeScript + Rollup for transforming the AST node
+* @param transformOpts the options provided to TypeScript + Rolldown for transforming the AST node
 * @param classNode the node in the AST pertaining to the Stencil component class to transform
 * @param heritageClauses a collection of heritage clauses associated with the provided class node
 * @param members a collection of members attached to the provided class node
@@ -983,7 +983,7 @@ const updateComponentClass = (transformOpts, classNode, heritageClauses, members
 * ```ts
 * const MyComponent = class {}
 * ```
-* @param transformOpts the options provided to TypeScript + Rollup for transforming the AST node
+* @param transformOpts the options provided to TypeScript + Rolldown for transforming the AST node
 * @param classNode the node in the AST pertaining to the Stencil component class to transform
 * @param heritageClauses a collection of heritage clauses associated with the provided class node
 * @param members a collection of members attached to the provided class node
@@ -2010,20 +2010,27 @@ const serializeCollectionDependencies = (compilerCtx) => {
 //#endregion
 //#region src/compiler/output-targets/dist-lazy/lazy-component-plugin.ts
 const lazyComponentPlugin = (buildCtx) => {
-	const entrys = /* @__PURE__ */ new Map();
+	const entryModuleMap = new Map(buildCtx.entryModules.map((em) => [em.entryKey, em]));
+	const exportCache = /* @__PURE__ */ new Map();
 	return {
 		name: "lazyComponentPlugin",
-		resolveId(importee) {
-			const entryModule = buildCtx.entryModules.find((em) => em.entryKey === importee);
-			if (entryModule) {
-				entrys.set(importee, entryModule);
-				return importee;
+		resolveId: {
+			filter: { id: /\.entry$/ },
+			handler(importee) {
+				if (entryModuleMap.has(importee)) return importee;
+				return null;
 			}
-			return null;
 		},
 		load(id) {
-			const entryModule = entrys.get(id);
-			if (entryModule) return entryModule.cmps.map(createComponentExport).join("\n");
+			const entryModule = entryModuleMap.get(id);
+			if (entryModule) {
+				let exports = exportCache.get(id);
+				if (!exports) {
+					exports = entryModule.cmps.map(createComponentExport).join("\n");
+					exportCache.set(id, exports);
+				}
+				return exports;
+			}
 			return null;
 		}
 	};
@@ -2072,26 +2079,29 @@ const USER_INDEX_ENTRY_ID = "@user-index-entrypoint";
 //#endregion
 //#region src/compiler/bundle/app-data-plugin.ts
 /**
-* A Rollup plugin which bundles application data.
+* A Rolldown plugin which bundles application data.
 *
 * @param config the Stencil configuration for a particular project
 * @param compilerCtx the current compiler context
 * @param buildCtx the current build context
 * @param buildConditionals the set build conditionals for the build
 * @param platform the platform that is being built
-* @returns a Rollup plugin which carries out the necessary work
+* @returns a Rolldown plugin which carries out the necessary work
 */
 const appDataPlugin = (config, compilerCtx, buildCtx, buildConditionals, platform) => {
 	if (!platform) return { name: "appDataPlugin" };
 	const globalScripts = getGlobalScriptData(config, compilerCtx);
 	return {
 		name: "appDataPlugin",
-		resolveId(id, importer) {
-			if (id === "@stencil/core/runtime/app-data" || id === "@stencil/core/runtime/app-globals") {
-				if (platform === "worker") this.error("@stencil/core packages cannot be imported from a worker.");
-				return id;
+		resolveId: {
+			filter: { id: /^@stencil\/core\/runtime\/app-(data|globals)$/ },
+			handler(id, importer) {
+				if (id === "@stencil/core/runtime/app-data" || id === "@stencil/core/runtime/app-globals") {
+					if (platform === "worker") this.error("@stencil/core packages cannot be imported from a worker.");
+					return id;
+				}
+				return null;
 			}
-			return null;
 		},
 		async load(id) {
 			if (id === "@stencil/core/runtime/app-globals") {
@@ -2397,76 +2407,79 @@ const coreResolvePlugin = (config, compilerCtx, platform, externalRuntime, lazyL
 	const compilerExe = config.sys.getCompilerExecutingPath();
 	const internalClient = getStencilInternalModule(config, compilerExe, "client/index.js");
 	const internalHydrate = getStencilInternalModule(config, compilerExe, "server/index.mjs");
+	const transformedCodeCache = /* @__PURE__ */ new Map();
+	const hydratedFlag = config.hydratedFlag;
+	const hydratedFlagHead = hydratedFlag ? getHydratedFlagHead(hydratedFlag) : null;
+	const hydratedReplacements = hydratedFlag && hydratedFlagHead !== "{visibility:hidden}.hydrated{visibility:inherit}" ? buildHydratedReplacements(hydratedFlag, hydratedFlagHead) : null;
+	const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 	return {
 		name: "coreResolvePlugin",
-		resolveId(id) {
-			if (id === "@stencil/core" || id === "@stencil/core/runtime") {
-				if (platform === "client") {
-					if (externalRuntime) return {
-						id: STENCIL_INTERNAL_CLIENT_PLATFORM_ID,
-						external: true
-					};
-					if (lazyLoad) return internalClient + APP_DATA_CONDITIONAL;
-					return internalClient;
+		resolveId: {
+			filter: { id: /^@stencil\/core/ },
+			handler(id) {
+				if (id === "@stencil/core" || id === "@stencil/core/runtime") {
+					if (platform === "client") {
+						if (externalRuntime) return {
+							id: STENCIL_INTERNAL_CLIENT_PLATFORM_ID,
+							external: true
+						};
+						if (lazyLoad) return internalClient + APP_DATA_CONDITIONAL;
+						return internalClient;
+					}
+					if (platform === "hydrate") return internalHydrate;
 				}
-				if (platform === "hydrate") return internalHydrate;
-			}
-			if (id === "@stencil/core/runtime/client") {
-				if (externalRuntime) return {
-					id: STENCIL_INTERNAL_CLIENT_PLATFORM_ID,
-					external: true
-				};
-				return internalClient;
-			}
-			if (id === "@stencil/core/runtime/server") return internalHydrate;
-			if (id === "@stencil/core/jsx-runtime" || id === "@stencil/core/jsx-dev-runtime") {
-				if (platform === "client") {
+				if (id === "@stencil/core/runtime/client") {
 					if (externalRuntime) return {
 						id: STENCIL_INTERNAL_CLIENT_PLATFORM_ID,
 						external: true
 					};
-					if (lazyLoad) return internalClient + APP_DATA_CONDITIONAL;
 					return internalClient;
 				}
-				if (platform === "hydrate") return internalHydrate;
+				if (id === "@stencil/core/runtime/server") return internalHydrate;
+				if (id === "@stencil/core/jsx-runtime" || id === "@stencil/core/jsx-dev-runtime") {
+					if (platform === "client") {
+						if (externalRuntime) return {
+							id: STENCIL_INTERNAL_CLIENT_PLATFORM_ID,
+							external: true
+						};
+						if (lazyLoad) return internalClient + APP_DATA_CONDITIONAL;
+						return internalClient;
+					}
+					if (platform === "hydrate") return internalHydrate;
+				}
+				return null;
 			}
-			return null;
 		},
-		async load(filePath) {
-			if (filePath && !filePath.startsWith("\0")) {
-				filePath = normalizeFsPath(filePath);
-				if (filePath === internalClient || filePath === internalHydrate) {
-					if (platform === "worker") return `
+		load: {
+			filter: { id: new RegExp(`^(${escapeRegex(internalClient)}|${escapeRegex(internalHydrate)})(\\?.*)?$`) },
+			async handler(filePath) {
+				if (filePath && !filePath.startsWith("\0")) {
+					filePath = normalizeFsPath(filePath);
+					if (filePath === internalClient || filePath === internalHydrate) {
+						if (platform === "worker") return `
 export const Build = {
   isDev: ${config.devMode},
   isBrowser: true,
   isServer: false,
   isTesting: false,
 };`;
-					let code = await compilerCtx.fs.readFile(filePath);
-					if (typeof code !== "string" && isRemoteUrl(compilerExe)) {
-						const url = getStencilModuleUrl(compilerExe, filePath);
-						code = await fetchModuleAsync(config.sys, compilerCtx.fs, packageVersions, url, filePath);
-					}
-					if (typeof code === "string") {
-						const hydratedFlag = config.hydratedFlag;
-						if (hydratedFlag) {
-							const hydratedFlagHead = getHydratedFlagHead(hydratedFlag);
-							if ("{visibility:hidden}.hydrated{visibility:inherit}" !== hydratedFlagHead) {
-								code = code.replace(HYDRATED_CSS, hydratedFlagHead);
-								if (hydratedFlag.name !== "hydrated") {
-									code = code.replace(`.classList.add("hydrated")`, `.classList.add("${hydratedFlag.name}")`);
-									code = code.replace(`.classList.add('hydrated')`, `.classList.add('${hydratedFlag.name}')`);
-									code = code.replace(`.setAttribute("hydrated",`, `.setAttribute("${hydratedFlag.name}",`);
-									code = code.replace(`.setAttribute('hydrated',`, `.setAttribute('${hydratedFlag.name}',`);
-								}
-							}
-						} else code = code.replace(HYDRATED_CSS, "{}");
+						const cached = transformedCodeCache.get(filePath);
+						if (cached) return cached;
+						let code = await compilerCtx.fs.readFile(filePath);
+						if (typeof code !== "string" && isRemoteUrl(compilerExe)) {
+							const url = getStencilModuleUrl(compilerExe, filePath);
+							code = await fetchModuleAsync(config.sys, compilerCtx.fs, packageVersions, url, filePath);
+						}
+						if (typeof code === "string") {
+							if (hydratedReplacements) for (const [search, replace] of hydratedReplacements) code = code.replace(search, replace);
+							else if (!hydratedFlag) code = code.replace(HYDRATED_CSS, "{}");
+							transformedCodeCache.set(filePath, code);
+						}
+						return code;
 					}
-					return code;
 				}
+				return null;
 			}
-			return null;
 		}
 	};
 };
@@ -2488,6 +2501,18 @@ const getHydratedFlagHead = (h) => {
 	else hydrated = `${selector}{${h.property}:${h.hydratedValue}}`;
 	return initial + hydrated;
 };
+/**
+* Pre-build all hydrated flag string replacements to avoid repeated computation.
+* Returns an array of [search, replace] tuples to apply in sequence.
+* @param hydratedFlag the hydrated flag configuration
+* @param hydratedFlagHead the pre-computed CSS string for the hydrated flag
+* @returns an array of [search, replace] tuples for string replacement
+*/
+const buildHydratedReplacements = (hydratedFlag, hydratedFlagHead) => {
+	const replacements = [[HYDRATED_CSS, hydratedFlagHead]];
+	if (hydratedFlag.name !== "hydrated") replacements.push([`.classList.add("hydrated")`, `.classList.add("${hydratedFlag.name}")`], [`.classList.add('hydrated')`, `.classList.add('${hydratedFlag.name}')`], [`.setAttribute("hydrated",`, `.setAttribute("${hydratedFlag.name}",`], [`.setAttribute('hydrated',`, `.setAttribute('${hydratedFlag.name}',`]);
+	return replacements;
+};
 //#endregion
 //#region src/compiler/bundle/constants.ts
 const DEV_MODULE_DIR = `~dev-module`;
@@ -3185,13 +3210,13 @@ const parseImportPath = (importPath) => {
 //#region src/compiler/bundle/ext-transforms-plugin.ts
 const allCmpStyles = /* @__PURE__ */ new Map();
 /**
-* A Rollup plugin which bundles up some transformation of CSS imports as well
+* A Rolldown plugin which bundles up some transformation of CSS imports as well
 * as writing some files to disk for the `DIST_COLLECTION` output target.
 *
 * @param config a user-supplied configuration
 * @param compilerCtx the current compiler context
 * @param buildCtx the current build context
-* @returns a Rollup plugin which carries out the necessary work
+* @returns a Rolldown plugin which carries out the necessary work
 */
 const extTransformsPlugin = (config, compilerCtx, buildCtx) => {
 	return {
@@ -3302,49 +3327,40 @@ const fileLoadPlugin = (fs) => {
 };
 //#endregion
 //#region src/compiler/bundle/loader-plugin.ts
+const escapeRegex$1 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 /**
-* Rollup plugin that aids in resolving the entry points (1 or more files) for a Stencil project. For example, a project
+* Rolldown plugin that aids in resolving the entry points (1 or more files) for a Stencil project. For example, a project
 * using the `dist-custom-elements` output target may have a single 'entry point' for each file containing a component.
-* Each of those files will be independently resolved and loaded by this plugin for further processing by Rollup later
+* Each of those files will be independently resolved and loaded by this plugin for further processing by Rolldown later
 * in the bundling process.
 *
 * @param entries the Stencil project files to process. It should be noted that the keys in this object may not
-* necessarily be an absolute or relative path to a file, but may be a Rollup Virtual Module (which begin with \0).
-* @returns the rollup plugin that loads and process a Stencil project's entry points
+* necessarily be an absolute or relative path to a file, but may be a Rolldown Virtual Module (which begin with \0).
+* @returns the rolldown plugin that loads and process a Stencil project's entry points
 */
 const loaderPlugin = (entries = {}) => {
+	const entryKeys = Object.keys(entries);
+	const entryFilter = entryKeys.length > 0 ? new RegExp(`^(${entryKeys.map(escapeRegex$1).join("|")})$`) : /^$/;
 	return {
 		name: "stencilLoaderPlugin",
-		resolveId(id) {
-			if (id in entries) return { id };
-			return null;
+		resolveId: {
+			filter: { id: entryFilter },
+			handler(id) {
+				if (id in entries) return { id };
+				return null;
+			}
 		},
-		load(id) {
-			if (id in entries) return entries[id];
-			return null;
+		load: {
+			filter: { id: entryFilter },
+			handler(id) {
+				if (id in entries) return entries[id];
+				return null;
+			}
 		}
 	};
 };
 //#endregion
 //#region src/compiler/bundle/plugin-helper.ts
-const pluginHelper = (config, builtCtx, platform) => {
-	return {
-		name: "pluginHelper",
-		resolveId(importee, importer) {
-			if (/\0/.test(importee)) return null;
-			if (importee.endsWith("/")) importee = importee.slice(0, -1);
-			if (builtIns.has(importee)) {
-				let fromMsg = "";
-				if (importer) fromMsg = ` from ${relative$1(config.rootDir, importer)}`;
-				const diagnostic = buildError(builtCtx.diagnostics);
-				diagnostic.header = `Node Polyfills Required`;
-				diagnostic.messageText = `For the import "${importee}" to be bundled${fromMsg}, ensure the "rollup-plugin-node-polyfills" plugin is installed and added to the stencil config plugins (${platform}). Please see the bundling docs for more information.
-        Further information: https://stenciljs.com/docs/module-bundling`;
-			}
-			return null;
-		}
-	};
-};
 const builtIns = new Set([
 	"child_process",
 	"cluster",
@@ -3387,8 +3403,30 @@ const builtIns = new Set([
 	"vm",
 	"zlib"
 ]);
+const BUILT_INS_FILTER = new RegExp(`^(${[...builtIns].join("|")})$`);
+const pluginHelper = (config, builtCtx, platform) => {
+	return {
+		name: "pluginHelper",
+		resolveId: {
+			filter: { id: BUILT_INS_FILTER },
+			handler(importee, importer) {
+				if (importee.endsWith("/")) importee = importee.slice(0, -1);
+				if (builtIns.has(importee)) {
+					let fromMsg = "";
+					if (importer) fromMsg = ` from ${relative$1(config.rootDir, importer)}`;
+					const diagnostic = buildError(builtCtx.diagnostics);
+					diagnostic.header = `Node Polyfills Required`;
+					diagnostic.messageText = `For the import "${importee}" to be bundled${fromMsg}, ensure the "rolldown-plugin-node-polyfills" plugin is installed and added to the stencil config plugins (${platform}). Please see the bundling docs for more information.
+        Further information: https://stenciljs.com/docs/module-bundling`;
+				}
+				return null;
+			}
+		}
+	};
+};
 //#endregion
 //#region src/compiler/bundle/server-plugin.ts
+const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const serverPlugin = (config, platform) => {
 	const isHydrateBundle = platform === "hydrate";
 	const serverVarid = `@removed-server-code`;
@@ -3400,205 +3438,38 @@ const serverPlugin = (config, platform) => {
 		return false;
 	};
 	const externals = isHydrateBundle ? config.outputTargets.filter(isOutputTargetHydrate).flatMap((o) => o.external) : [];
+	const filterPatterns = [escapeRegex(serverVarid), "\\.server"];
+	if (externals.length > 0) filterPatterns.push(...externals.map(escapeRegex));
 	return {
 		name: "serverPlugin",
-		resolveId(id, importer) {
-			if (id === serverVarid) return id;
-			if (isHydrateBundle) {
-				if (externals.includes(id)) return {
-					id,
-					external: true
-				};
-				if (isServerOnlyModule(importer) && !id.startsWith(".") && !isAbsolute(id)) return {
-					id,
-					external: true
-				};
-			} else if (isServerOnlyModule(id)) return serverVarid;
-			return null;
+		resolveId: {
+			filter: { id: new RegExp(`(${filterPatterns.join("|")})`) },
+			handler(id, importer) {
+				if (id === serverVarid) return id;
+				if (isHydrateBundle) {
+					if (externals.includes(id)) return {
+						id,
+						external: true
+					};
+					if (isServerOnlyModule(importer) && !id.startsWith(".") && !isAbsolute(id)) return {
+						id,
+						external: true
+					};
+				} else if (isServerOnlyModule(id)) return serverVarid;
+				return null;
+			}
 		},
-		load(id) {
-			if (id === serverVarid) return {
-				code: "export default {};",
-				syntheticNamedExports: true
-			};
-			return null;
-		}
-	};
-};
-const IS_CASE_SENSITIVE_FILE_NAMES = !(process.platform === "win32");
-//#endregion
-//#region src/compiler/sys/typescript/typescript-sys.ts
-const patchTsSystemFileSystem = (config, compilerSys, inMemoryFs, tsSys) => {
-	const realpath = (path) => {
-		const rp = compilerSys.realpathSync(path);
-		if (isString$1(rp)) return rp;
-		return path;
-	};
-	const getAccessibleFileSystemEntries = (path) => {
-		try {
-			const entries = compilerSys.readDirSync(path || ".").sort();
-			const files = [];
-			const directories = [];
-			for (const absPath of entries) {
-				const stat = inMemoryFs.statSync(absPath);
-				if (!stat) continue;
-				const entry = basename$1(absPath);
-				if (stat.isFile) files.push(entry);
-				else if (stat.isDirectory) directories.push(entry);
+		load: {
+			filter: { id: /^@removed-server-code$/ },
+			handler(id) {
+				if (id === serverVarid) return {
+					code: "export default {};",
+					syntheticNamedExports: true
+				};
+				return null;
 			}
-			return {
-				files,
-				directories
-			};
-		} catch {
-			return {
-				files: [],
-				directories: []
-			};
-		}
-	};
-	tsSys.createDirectory = (p) => {
-		compilerSys.createDirSync(p, { recursive: true });
-	};
-	tsSys.directoryExists = (p) => {
-		if (inMemoryFs) return inMemoryFs.statSync(p).isDirectory;
-		else return compilerSys.statSync(p).isDirectory;
-	};
-	tsSys.exit = compilerSys.exit;
-	tsSys.fileExists = (p) => {
-		let filePath = p;
-		if (isRemoteUrl(p)) filePath = getTypescriptPathFromUrl(config, tsSys.getExecutingFilePath(), p);
-		if (inMemoryFs) {
-			const s = inMemoryFs.statSync(filePath);
-			return !!(s && s.isFile);
-		} else {
-			const s = compilerSys.statSync(filePath);
-			return !!(s && s.isFile);
 		}
 	};
-	tsSys.getCurrentDirectory = compilerSys.getCurrentDirectory;
-	tsSys.getExecutingFilePath = () => {
-		try {
-			return __require.resolve("typescript");
-		} catch {
-			return compilerSys.getCompilerExecutingPath();
-		}
-	};
-	tsSys.getDirectories = (p) => {
-		return compilerSys.readDirSync(p).filter((itemPath) => {
-			if (inMemoryFs) {
-				const s = inMemoryFs.statSync(itemPath);
-				return !!(s && s.exists && s.isDirectory);
-			} else {
-				const s = compilerSys.statSync(itemPath);
-				return !!(s && s.isDirectory);
-			}
-		});
-	};
-	tsSys.readDirectory = (path, extensions, exclude, include, depth) => {
-		const cwd = compilerSys.getCurrentDirectory();
-		return ts.matchFiles(path, extensions, exclude, include, IS_CASE_SENSITIVE_FILE_NAMES, cwd, depth, getAccessibleFileSystemEntries, realpath);
-	};
-	tsSys.readFile = (filePath) => {
-		return inMemoryFs ? inMemoryFs.readFileSync(filePath, { useCache: false }) : compilerSys.readFileSync(filePath);
-	};
-	tsSys.writeFile = (p, data) => inMemoryFs ? inMemoryFs.writeFile(p, data) : compilerSys.writeFile(p, data);
-	return tsSys;
-};
-const patchTsSystemWatch = (compilerSystem, tsSys) => {
-	tsSys.watchDirectory = (p, cb, recursive) => {
-		const watcher = compilerSystem.watchDirectory(p, (filePath) => {
-			cb(filePath);
-		}, recursive);
-		return { close() {
-			watcher.close();
-		} };
-	};
-	tsSys.watchFile = (p, cb) => {
-		const watcher = compilerSystem.watchFile(p, (filePath, eventKind) => {
-			if (eventKind === "fileAdd") cb(filePath, ts.FileWatcherEventKind.Created);
-			else if (eventKind === "fileUpdate") cb(filePath, ts.FileWatcherEventKind.Changed);
-			else if (eventKind === "fileDelete") cb(filePath, ts.FileWatcherEventKind.Deleted);
-		});
-		return { close() {
-			watcher.close();
-		} };
-	};
-};
-const patchTypescript = (config, inMemoryFs) => {
-	if (!ts.__patched) {
-		patchTsSystemFileSystem(config, config.sys, inMemoryFs, ts.sys);
-		patchTsSystemWatch(config.sys, ts.sys);
-		ts.__patched = true;
-	}
-};
-const patchTypeScriptSysMinimum = () => {
-	if (!ts.sys) ts.sys = {
-		args: [],
-		createDirectory: noop,
-		directoryExists: () => false,
-		exit: noop,
-		fileExists: () => false,
-		getCurrentDirectory: process.cwd,
-		getDirectories: () => [],
-		getExecutingFilePath: () => "./",
-		readDirectory: () => [],
-		readFile: noop,
-		newLine: "\n",
-		resolvePath: resolve$1,
-		useCaseSensitiveFileNames: false,
-		write: noop,
-		writeFile: noop
-	};
-};
-patchTypeScriptSysMinimum();
-const getTypescriptPathFromUrl = (config, tsExecutingUrl, url) => {
-	const tsBaseUrl = new URL("..", tsExecutingUrl).href;
-	if (url.startsWith(tsBaseUrl)) {
-		const tsFilePath = url.replace(tsBaseUrl, "/");
-		return normalizePath(config.sys.getLocalModulePath({
-			rootDir: config.rootDir,
-			moduleId: "@stencil/core",
-			path: tsFilePath
-		}));
-	}
-	return url;
-};
-//#endregion
-//#region src/compiler/sys/typescript/typescript-resolve-module.ts
-const tsResolveModuleName = (config, compilerCtx, moduleName, containingFile) => {
-	const resolveModuleName = ts.__resolveModuleName || ts.resolveModuleName;
-	if (moduleName && resolveModuleName && config.tsCompilerOptions) {
-		const host = patchTsSystemFileSystem(config, config.sys, compilerCtx.fs, ts.sys);
-		const compilerOptions = { ...config.tsCompilerOptions };
-		compilerOptions.resolveJsonModule = true;
-		return resolveModuleName(moduleName, containingFile, compilerOptions, host);
-	}
-	return null;
-};
-const tsGetSourceFile = (config, module) => {
-	if (!module || !module.resolvedModule) return null;
-	const compilerOptions = { ...config.tsCompilerOptions };
-	const host = ts.createCompilerHost(compilerOptions);
-	return ts.createProgram([module.resolvedModule.resolvedFileName], compilerOptions, host).getSourceFile(module.resolvedModule.resolvedFileName);
-};
-const tsResolveModuleNamePackageJsonPath = (config, compilerCtx, moduleName, containingFile) => {
-	try {
-		const resolvedModule = tsResolveModuleName(config, compilerCtx, moduleName, containingFile);
-		if (resolvedModule && resolvedModule.resolvedModule && resolvedModule.resolvedModule.resolvedFileName) {
-			const rootDir = resolve$1("/");
-			let resolvedFileName = resolvedModule.resolvedModule.resolvedFileName;
-			for (let i = 0; i < 30; i++) {
-				if (rootDir === resolvedFileName) return null;
-				resolvedFileName = dirname$1(resolvedFileName);
-				const pkgJsonPath = join$1(resolvedFileName, "package.json");
-				if (config.sys.accessSync(pkgJsonPath)) return normalizePath(pkgJsonPath);
-			}
-		}
-	} catch (e) {
-		config.logger.error(e);
-	}
-	return null;
 };
 //#endregion
 //#region src/compiler/transpile/transpiled-module.ts
@@ -3660,11 +3531,11 @@ const createModule = (staticSourceFile, staticSourceFileText, emitFilepath) => (
 //#endregion
 //#region src/compiler/bundle/typescript-plugin.ts
 /**
-* Rollup plugin that aids in resolving the TypeScript files and performing the transpilation step.
+* Rolldown plugin that aids in resolving the TypeScript files and performing the transpilation step.
 * @param compilerCtx the current compiler context
-* @param bundleOpts Rollup bundling options to apply during TypeScript compilation
+* @param bundleOpts Rolldown bundling options to apply during TypeScript compilation
 * @param config the Stencil configuration for the project
-* @returns the rollup plugin for handling TypeScript files.
+* @returns the rolldown plugin for handling TypeScript files.
 */
 const typescriptPlugin = (compilerCtx, bundleOpts, config) => {
 	return {
@@ -3707,36 +3578,28 @@ const typescriptPlugin = (compilerCtx, bundleOpts, config) => {
 		}
 	};
 };
-const resolveIdWithTypeScript = (config, compilerCtx) => {
-	return {
-		name: `resolveIdWithTypeScript`,
-		async resolveId(importee, importer) {
-			if (/\0/.test(importee) || !isString$1(importer)) return null;
-			const tsResolved = tsResolveModuleName(config, compilerCtx, importee, importer);
-			if (tsResolved && tsResolved.resolvedModule) {
-				const tsResolvedPath = tsResolved.resolvedModule.resolvedFileName;
-				if (isString$1(tsResolvedPath) && !isDtsFile(tsResolvedPath)) return tsResolvedPath;
-			}
-			return null;
-		}
-	};
-};
-//#endregion
-//#region src/compiler/bundle/user-index-plugin.ts
-const userIndexPlugin = (config, compilerCtx) => {
+//#endregion
+//#region src/compiler/bundle/user-index-plugin.ts
+const userIndexPlugin = (config, compilerCtx) => {
 	return {
 		name: "userIndexPlugin",
-		async resolveId(importee) {
-			if (importee === "@user-index-entrypoint") {
-				const usersIndexJsPath = join$1(config.srcDir, "index.ts");
-				if (await compilerCtx.fs.access(usersIndexJsPath)) return usersIndexJsPath;
-				return importee;
+		resolveId: {
+			filter: { id: /^@user-index-entrypoint$/ },
+			async handler(importee) {
+				if (importee === "@user-index-entrypoint") {
+					const usersIndexJsPath = join$1(config.srcDir, "index.ts");
+					if (await compilerCtx.fs.access(usersIndexJsPath)) return usersIndexJsPath;
+					return importee;
+				}
+				return null;
 			}
-			return null;
 		},
-		async load(id) {
-			if (id === "@user-index-entrypoint") return `//! Autogenerated index`;
-			return null;
+		load: {
+			filter: { id: /^@user-index-entrypoint$/ },
+			handler(id) {
+				if (id === "@user-index-entrypoint") return `//! Autogenerated index`;
+				return null;
+			}
 		}
 	};
 };
@@ -3867,7 +3730,7 @@ const MINIFY_CHAR_BREAK = new Set([
 * @returns the minified JavaScript result
 */
 const optimizeModule = async (config, compilerCtx, opts) => {
-	if (!opts.minify && opts.sourceTarget !== "es5" || opts.input === "") return {
+	if (!opts.minify || opts.input === "") return {
 		output: opts.input,
 		diagnostics: [],
 		sourceMap: opts.sourceMap
@@ -3883,35 +3746,30 @@ const optimizeModule = async (config, compilerCtx, opts) => {
 			sourceMap: cachedMap ? JSON.parse(cachedMap) : null
 		};
 	}
-	let minifyOpts;
-	let code = opts.input;
-	if (opts.isCore) code = code.replace(/\/\* IS_ESM_BUILD \*\//g, "&& false /* IS_SYSTEM_JS_BUILD */");
-	if (opts.sourceTarget === "es5" || opts.minify) {
-		minifyOpts = getTerserOptions(config, opts.sourceTarget, isDebug);
-		if (config.sourceMap) minifyOpts.sourceMap = { content: opts.sourceMap != null ? {
-			...opts.sourceMap,
-			version: 3
-		} : void 0 };
-		const compressOpts = minifyOpts.compress;
-		const mangleOptions = minifyOpts.mangle;
-		if (opts.sourceTarget !== "es5" && opts.isCore) {
-			if (!isDebug) {
-				compressOpts.passes = 2;
-				compressOpts.global_defs = { supportsListenerOptions: true };
-				compressOpts.pure_funcs = compressOpts.pure_funcs || [];
-				compressOpts.pure_funcs = ["getHostRef", ...compressOpts.pure_funcs];
-			}
-			mangleOptions.properties = {
-				debug: isDebug,
-				...getTerserManglePropertiesConfig()
-			};
-			compressOpts.inline = 1;
-			compressOpts.unsafe = true;
-			compressOpts.unsafe_undefined = true;
-		}
+	const minifyOpts = getTerserOptions(config, opts.sourceTarget, isDebug);
+	const code = opts.input;
+	if (config.sourceMap) minifyOpts.sourceMap = { content: opts.sourceMap != null ? {
+		...opts.sourceMap,
+		version: 3
+	} : void 0 };
+	const compressOpts = minifyOpts.compress;
+	const mangleOptions = minifyOpts.mangle;
+	if (opts.isCore) {
+		if (!isDebug) {
+			compressOpts.passes = 2;
+			compressOpts.global_defs = { supportsListenerOptions: true };
+			compressOpts.pure_funcs = compressOpts.pure_funcs || [];
+			compressOpts.pure_funcs = ["getHostRef", ...compressOpts.pure_funcs];
+		}
+		mangleOptions.properties = {
+			debug: isDebug,
+			...getTerserManglePropertiesConfig()
+		};
+		compressOpts.inline = 1;
+		compressOpts.unsafe = true;
+		compressOpts.unsafe_undefined = true;
 	}
-	const shouldTranspile = opts.sourceTarget === "es5";
-	const results = await compilerCtx.worker.prepareModule(code, minifyOpts, shouldTranspile, !!opts.inlineHelpers);
+	const results = await compilerCtx.worker.prepareModule(code, minifyOpts);
 	if (results != null && typeof results.output === "string" && results.diagnostics.length === 0 && compilerCtx != null) {
 		if (opts.isCore) results.output = results.output.replace(/disconnectedCallback\(\)\{\},/g, "");
 		await compilerCtx.cache.put(cacheKey, results.output);
@@ -3933,25 +3791,19 @@ const getTerserOptions = (config, sourceTarget, prettyOutput) => {
 		format: {},
 		sourceMap: config.sourceMap
 	};
-	if (sourceTarget === "es5") {
-		opts.ecma = opts.format.ecma = 5;
-		opts.compress = false;
-		opts.mangle = { properties: getTerserManglePropertiesConfig() };
-	} else {
-		opts.mangle = { properties: getTerserManglePropertiesConfig() };
-		opts.compress = {
-			pure_getters: true,
-			keep_fargs: false,
-			passes: 2
-		};
-		opts.ecma = opts.format.ecma = opts.compress.ecma = 2018;
-		opts.toplevel = true;
-		opts.module = true;
-		opts.mangle.toplevel = true;
-		opts.compress.arrows = true;
-		opts.compress.module = true;
-		opts.compress.toplevel = true;
-	}
+	opts.mangle = { properties: getTerserManglePropertiesConfig() };
+	opts.compress = {
+		pure_getters: true,
+		keep_fargs: false,
+		passes: 2
+	};
+	opts.ecma = opts.format.ecma = opts.compress.ecma = 2018;
+	opts.toplevel = true;
+	opts.module = true;
+	opts.mangle.toplevel = true;
+	opts.compress.arrows = true;
+	opts.compress.module = true;
+	opts.compress.toplevel = true;
 	if (prettyOutput) {
 		opts.mangle = {
 			keep_fnames: true,
@@ -3983,54 +3835,28 @@ function getTerserManglePropertiesConfig() {
 * This method is likely to be called by a worker on the compiler context, rather than directly.
 * @param input the source code to minify
 * @param minifyOpts options to be used by the minifier
-* @param transpileToEs5 if true, use the TypeScript compiler to transpile the input to ES5 prior to minification
-* @param inlineHelpers when true, emits less terse JavaScript by allowing global helpers created by the TypeScript
-* compiler to be added directly to the transpiled source. Used only if `transpileToEs5` is true.
 * @returns minified input, as JavaScript
 */
-const prepareModule = async (input, minifyOpts, transpileToEs5, inlineHelpers) => {
-	const results = {
+const prepareModule = async (input, minifyOpts) => {
+	if (minifyOpts) return minifyJs(input, minifyOpts);
+	return {
 		output: input,
 		diagnostics: [],
 		sourceMap: null
 	};
-	if (transpileToEs5) {
-		const tsResults = ts.transpileModule(input, {
-			fileName: "module.ts",
-			compilerOptions: {
-				sourceMap: !!minifyOpts.sourceMap,
-				allowJs: true,
-				target: ts.ScriptTarget.ES5,
-				module: ts.ModuleKind.ESNext,
-				removeComments: false,
-				isolatedModules: true,
-				skipLibCheck: true,
-				noEmitHelpers: !inlineHelpers,
-				importHelpers: !inlineHelpers
-			},
-			reportDiagnostics: false
-		});
-		results.output = tsResults.outputText;
-		if (tsResults.sourceMapText) {
-			const mergeMap = sourceMapMerge(minifyOpts.sourceMap?.content, JSON.parse(tsResults.sourceMapText));
-			if (mergeMap != null) minifyOpts.sourceMap = { content: {
-				...mergeMap,
-				sources: mergeMap.sources ?? [],
-				version: 3
-			} };
-		}
-	}
-	if (minifyOpts) return minifyJs(results.output, minifyOpts);
-	return results;
 };
 //#endregion
 //#region src/compiler/bundle/worker-plugin.ts
+const WORKER_FILTER = /(\?worker(-inline)?|\.worker(\.tsx?|\/index\.tsx?))$/;
 const workerPlugin = (config, compilerCtx, buildCtx, platform, inlineWorkers) => {
 	if (platform === "worker" || platform === "hydrate") return {
 		name: "workerPlugin",
-		transform(_, id) {
-			if (id.endsWith("?worker") || id.endsWith("?worker-inline")) return getMockedWorkerMain();
-			return null;
+		transform: {
+			filter: { id: /\?worker(-inline)?$/ },
+			handler(_, id) {
+				if (id.endsWith("?worker") || id.endsWith("?worker-inline")) return getMockedWorkerMain();
+				return null;
+			}
 		}
 	};
 	const workersMap = /* @__PURE__ */ new Map();
@@ -4039,61 +3865,70 @@ const workerPlugin = (config, compilerCtx, buildCtx, platform, inlineWorkers) =>
 		buildStart() {
 			workersMap.clear();
 		},
-		resolveId(id) {
-			if (id === WORKER_HELPER_ID) return {
-				id,
-				moduleSideEffects: false
-			};
-			return null;
-		},
-		load(id) {
-			if (id === WORKER_HELPER_ID) return WORKER_HELPERS;
-			return null;
-		},
-		async transform(_, id) {
-			if (/\0/.test(id)) return null;
-			if (id.endsWith("?worker")) {
-				const workerEntryPath = normalizeFsPath(id);
-				const workerName = getWorkerName(workerEntryPath);
-				const { code, dependencies, workerMsgId } = await getWorker(config, compilerCtx, buildCtx, this, workersMap, workerEntryPath);
-				const referenceId = this.emitFile({
-					type: "asset",
-					source: code,
-					name: workerName + ".js"
-				});
-				dependencies.forEach((dep) => this.addWatchFile(dep));
-				return {
-					code: getWorkerMain(referenceId, workerName, workerMsgId),
-					moduleSideEffects: false
-				};
-			} else if (id.endsWith("?worker-inline")) {
-				const workerEntryPath = normalizeFsPath(id);
-				const workerName = getWorkerName(workerEntryPath);
-				const { code, dependencies, workerMsgId } = await getWorker(config, compilerCtx, buildCtx, this, workersMap, workerEntryPath);
-				const referenceId = this.emitFile({
-					type: "asset",
-					source: code,
-					name: workerName + ".js"
-				});
-				dependencies.forEach((dep) => this.addWatchFile(dep));
-				return {
-					code: getInlineWorker(referenceId, workerName, workerMsgId),
+		resolveId: {
+			filter: { id: /^@worker-helper$/ },
+			handler(id) {
+				if (id === WORKER_HELPER_ID) return {
+					id,
 					moduleSideEffects: false
 				};
+				return null;
 			}
-			const workerEntryPath = getWorkerEntryPath(id);
-			if (workerEntryPath != null) {
-				const worker = await getWorker(config, compilerCtx, buildCtx, this, workersMap, workerEntryPath);
-				if (worker) if (inlineWorkers) return {
-					code: getInlineWorkerProxy(workerEntryPath, worker.workerMsgId, worker.exports),
-					moduleSideEffects: false
-				};
-				else return {
-					code: getWorkerProxy(workerEntryPath, worker.exports),
-					moduleSideEffects: false
-				};
+		},
+		load: {
+			filter: { id: /^@worker-helper$/ },
+			handler(id) {
+				if (id === WORKER_HELPER_ID) return WORKER_HELPERS;
+				return null;
+			}
+		},
+		transform: {
+			filter: { id: WORKER_FILTER },
+			async handler(_, id) {
+				if (/\0/.test(id)) return null;
+				if (id.endsWith("?worker")) {
+					const workerEntryPath = normalizeFsPath(id);
+					const workerName = getWorkerName(workerEntryPath);
+					const { code, dependencies, workerMsgId } = await getWorker(config, compilerCtx, buildCtx, this, workersMap, workerEntryPath);
+					const referenceId = this.emitFile({
+						type: "asset",
+						source: code,
+						name: workerName + ".js"
+					});
+					dependencies.forEach((dep) => this.addWatchFile(dep));
+					return {
+						code: getWorkerMain(referenceId, workerName, workerMsgId),
+						moduleSideEffects: false
+					};
+				} else if (id.endsWith("?worker-inline")) {
+					const workerEntryPath = normalizeFsPath(id);
+					const workerName = getWorkerName(workerEntryPath);
+					const { code, dependencies, workerMsgId } = await getWorker(config, compilerCtx, buildCtx, this, workersMap, workerEntryPath);
+					const referenceId = this.emitFile({
+						type: "asset",
+						source: code,
+						name: workerName + ".js"
+					});
+					dependencies.forEach((dep) => this.addWatchFile(dep));
+					return {
+						code: getInlineWorker(referenceId, workerName, workerMsgId),
+						moduleSideEffects: false
+					};
+				}
+				const workerEntryPath = getWorkerEntryPath(id);
+				if (workerEntryPath != null) {
+					const worker = await getWorker(config, compilerCtx, buildCtx, this, workersMap, workerEntryPath);
+					if (worker) if (inlineWorkers) return {
+						code: getInlineWorkerProxy(workerEntryPath, worker.workerMsgId, worker.exports),
+						moduleSideEffects: false
+					};
+					else return {
+						code: getWorkerProxy(workerEntryPath, worker.exports),
+						moduleSideEffects: false
+					};
+				}
+				return null;
 			}
-			return null;
 		}
 	};
 };
@@ -4121,7 +3956,7 @@ const buildWorker = async (config, compilerCtx, buildCtx, ctx, workerEntryPath)
 		platform: "worker",
 		id: workerName,
 		inputs: { [workerName]: workerEntryPath },
-		inlineDynamicImports: true
+		codeSplitting: false
 	});
 	if (build) {
 		const entryPoint = (await build.generate({
@@ -4136,7 +3971,7 @@ const buildWorker = async (config, compilerCtx, buildCtx, ctx, workerEntryPath)
 		let code = entryPoint.code;
 		const results = await optimizeModule(config, compilerCtx, {
 			input: code,
-			sourceTarget: config.buildEs5 ? "es5" : "es2017",
+			sourceTarget: "es2017",
 			isCore: false,
 			minify: config.minifyJs,
 			inlineHelpers: true
@@ -4336,7 +4171,7 @@ const getWorkerMain = (referenceId, workerName, workerMsgId) => {
 import { createWorker } from '${WORKER_HELPER_ID}';
 export const workerName = '${workerName}';
 export const workerMsgId = '${workerMsgId}';
-export const workerPath = /*@__PURE__*/import.meta.ROLLUP_FILE_URL_${referenceId};
+export const workerPath = /*@__PURE__*/import.meta.ROLLDOWN_FILE_URL_${referenceId};
 export const worker = /*@__PURE__*/createWorker(workerPath, workerName, workerMsgId);
 `;
 };
@@ -4345,7 +4180,7 @@ const getInlineWorker = (referenceId, workerName, workerMsgId) => {
 import { createWorker } from '${WORKER_HELPER_ID}';
 export const workerName = '${workerName}';
 export const workerMsgId = '${workerMsgId}';
-export const workerPath = /*@__PURE__*/import.meta.ROLLUP_FILE_URL_${referenceId};
+export const workerPath = /*@__PURE__*/import.meta.ROLLDOWN_FILE_URL_${referenceId};
 export let worker;
 try {
   // first try directly starting the worker with the URL
@@ -4389,91 +4224,34 @@ ${exportedMethods.map((exportedMethod) => {
 //#region src/compiler/bundle/bundle-output.ts
 const bundleOutput = async (config, compilerCtx, buildCtx, bundleOpts) => {
 	try {
-		const rollupBuild = await rollup(getRollupOptions(config, compilerCtx, buildCtx, bundleOpts));
-		compilerCtx.rollupCache.set(bundleOpts.id, rollupBuild.cache);
-		return rollupBuild;
+		return await rolldown(getRolldownOptions(config, compilerCtx, buildCtx, bundleOpts));
 	} catch (e) {
-		if (!buildCtx.hasError) loadRollupDiagnostics(config, compilerCtx, buildCtx, e);
+		if (!buildCtx.hasError) loadRolldownDiagnostics(config, compilerCtx, buildCtx, e);
 	}
 };
 /**
-* Build the rollup options that will be used to transpile, minify, and otherwise transform a Stencil project
+* Build the rolldown options that will be used to transpile, minify, and otherwise transform a Stencil project
 * @param config the Stencil configuration for the project
 * @param compilerCtx the current compiler context
 * @param buildCtx a context object containing information about the current build
-* @param bundleOpts Rollup bundling options to apply to the base configuration setup by this function
-* @returns the rollup options to be used
-*/
-const getRollupOptions = (config, compilerCtx, buildCtx, bundleOpts) => {
-	const nodeResolvePlugin = rollupNodeResolvePlugin({
-		mainFields: [
-			"collection:main",
-			"jsnext:main",
-			"es2017",
-			"es2015",
-			"module",
-			"main"
-		],
-		browser: bundleOpts.platform !== "hydrate",
-		rootDir: config.rootDir,
-		exportConditions: [
-			"default",
-			"module",
-			"import",
-			"require"
-		],
-		extensions: [
-			".tsx",
-			".ts",
-			".mts",
-			".cts",
-			".js",
-			".mjs",
-			".cjs",
-			".json",
-			".d.ts",
-			".d.mts",
-			".d.cts"
-		],
-		...config.nodeResolve
-	});
-	nodeResolvePlugin.resolve = async function() {};
-	nodeResolvePlugin.warn = (log) => {
-		const onWarn = createOnWarnFn(buildCtx.diagnostics);
-		if (typeof log === "string") onWarn({ message: log });
-		else if (typeof log === "function") {
-			const result = log();
-			if (typeof result === "string") onWarn({ message: result });
-			else onWarn(result);
-		} else onWarn(log);
-	};
-	assertIsObjectHook(nodeResolvePlugin.resolveId);
-	nodeResolvePlugin.resolveId.order = null;
-	const orgNodeResolveId = nodeResolvePlugin.resolveId.handler;
-	const orgNodeResolveId2 = nodeResolvePlugin.resolveId.handler = async function(importee, importer) {
-		const [realImportee, query] = importee.split("?");
-		const resolved = await orgNodeResolveId.call(nodeResolvePlugin, realImportee, importer, {
-			attributes: {},
-			isEntry: true
-		});
-		if (resolved) {
-			if (isString$1(resolved)) return query ? resolved + "?" + query : resolved;
-			return {
-				...resolved,
-				id: query ? resolved.id + "?" + query : resolved.id
-			};
+* @param bundleOpts Rolldown bundling options to apply to the base configuration setup by this function
+* @returns the rolldown options to be used
+*/
+const getRolldownOptions = (config, compilerCtx, buildCtx, bundleOpts) => {
+	const beforePlugins = config.rolldownPlugins.before || [];
+	const afterPlugins = config.rolldownPlugins.after || [];
+	const devModulePlugin = config.devServer?.experimentalDevModules ? {
+		name: "stencil-dev-module-resolve",
+		async resolveId(importee, importer) {
+			const resolved = await this.resolve(importee, importer, { skipSelf: true });
+			if (resolved) return devNodeModuleResolveId(config, compilerCtx.fs, resolved, importee);
+			return null;
 		}
-		return resolved;
-	};
-	if (config.devServer?.experimentalDevModules) nodeResolvePlugin.resolveId = async function(importee, importer) {
-		const resolvedId = await orgNodeResolveId2.call(nodeResolvePlugin, importee, importer);
-		return devNodeModuleResolveId(config, compilerCtx.fs, resolvedId, importee);
-	};
-	const beforePlugins = config.rollupPlugins.before || [];
-	const afterPlugins = config.rollupPlugins.after || [];
+	} : null;
 	return {
 		input: bundleOpts.inputs,
-		output: { inlineDynamicImports: bundleOpts.inlineDynamicImports ?? false },
+		platform: bundleOpts.platform === "hydrate" ? "node" : "browser",
+		tsconfig: config.tsconfig,
 		plugins: [
 			coreResolvePlugin(config, compilerCtx, bundleOpts.platform, !!bundleOpts.externalRuntime, bundleOpts.conditionals?.lazyLoad ?? false),
 			appDataPlugin(config, compilerCtx, buildCtx, bundleOpts.conditionals, bundleOpts.platform),
@@ -4486,44 +4264,82 @@ const getRollupOptions = (config, compilerCtx, buildCtx, bundleOpts) => {
 			workerPlugin(config, compilerCtx, buildCtx, bundleOpts.platform, !!bundleOpts.inlineWorkers),
 			serverPlugin(config, bundleOpts.platform),
 			...beforePlugins,
-			nodeResolvePlugin,
-			resolveIdWithTypeScript(config, compilerCtx),
-			rollupCommonjsPlugin({
-				include: /node_modules/,
-				sourceMap: config.sourceMap,
-				transformMixedEsModules: false,
-				...config.commonjs
-			}),
+			devModulePlugin,
 			...afterPlugins,
 			pluginHelper(config, buildCtx, bundleOpts.platform),
-			rollupJsonPlugin({ preferConst: true }),
-			rollupReplacePlugin({
-				"process.env.NODE_ENV": config.devMode ? "\"development\"" : "\"production\"",
-				preventAssignment: true
-			}),
 			fileLoadPlugin(compilerCtx.fs)
-		],
+		].filter(Boolean),
+		resolve: {
+			mainFields: [
+				"collection:main",
+				"jsnext:main",
+				"es2017",
+				"es2015",
+				"module",
+				"main"
+			],
+			conditionNames: bundleOpts.platform === "hydrate" ? [
+				"node",
+				"import",
+				"require",
+				"default"
+			] : [
+				"browser",
+				"default",
+				"import",
+				"module",
+				"require"
+			],
+			extensions: [
+				".tsx",
+				".ts",
+				".mts",
+				".cts",
+				".js",
+				".mjs",
+				".cjs",
+				".json",
+				".d.ts",
+				".d.mts",
+				".d.cts"
+			],
+			...config.nodeResolve
+		},
+		transform: { define: { "process.env.NODE_ENV": config.devMode ? "\"development\"" : "\"production\"" } },
+		checks: {
+			preferBuiltinFeature: false,
+			pluginTimings: config.devMode
+		},
+		moduleTypes: {
+			".css": "js",
+			".scss": "js",
+			".sass": "js",
+			".less": "js",
+			".styl": "js",
+			".stylus": "js",
+			".pcss": "js",
+			".txt": "js",
+			".frag": "js",
+			".vert": "js",
+			".svg": "js"
+		},
 		treeshake: getTreeshakeOption(config, bundleOpts),
 		preserveEntrySignatures: bundleOpts.preserveEntrySignatures ?? "strict",
-		onwarn: createOnWarnFn(buildCtx.diagnostics),
-		cache: compilerCtx.rollupCache.get(bundleOpts.id),
-		external: config.rollupConfig.inputOptions.external,
-		maxParallelFileOps: config.rollupConfig.inputOptions.maxParallelFileOps
+		external: config.rolldownConfig.inputOptions.external,
+		onwarn: createOnWarnFn(buildCtx.diagnostics)
 	};
 };
 const getTreeshakeOption = (config, bundleOpts) => {
 	if (bundleOpts.platform === "hydrate") return {
-		propertyReadSideEffects: false,
-		tryCatchDeoptimization: false
+		moduleSideEffects: false,
+		propertyReadSideEffects: false
+	};
+	if (config.devMode || config.rolldownConfig.inputOptions.treeshake === false) return false;
+	return {
+		moduleSideEffects: false,
+		propertyReadSideEffects: false
 	};
-	return !config.devMode && config.rollupConfig.inputOptions.treeshake !== false ? {
-		propertyReadSideEffects: false,
-		tryCatchDeoptimization: false
-	} : false;
 };
-function assertIsObjectHook(hook) {
-	if (typeof hook !== "object") throw new Error(`expected the rollup plugin hook ${hook} to be an object`);
-}
 //#endregion
 //#region src/compiler/transformers/add-tag-transform.ts
 /**
@@ -5374,7 +5190,7 @@ const createStyleIdentifier = (cmp, style) => {
 	const externalStyles = getExternalStyles(style);
 	/**
 	* Set a styleIdentifier which will be propagated to the component and
-	* later picked up by rollup when it injects the parsed CSS directly into
+	* later picked up by rolldown when it injects the parsed CSS directly into
 	* the component, see `compilerCtx.worker.transformCssToEsm` in
 	* `src/compiler/bundle/ext-transforms-plugin.ts`
 	*/
@@ -5788,6 +5604,7 @@ const KEEP_IMPORTS = new Set([
 	"writeTask",
 	"readTask",
 	"getElement",
+	"getShadowRoot",
 	"forceUpdate",
 	"getRenderingRef",
 	"forceModeUpdate",
@@ -5823,7 +5640,6 @@ const getBuildFeatures = (cmps) => {
 		hostListenerTargetWindow: cmps.some((c) => c.hasListenerTargetWindow),
 		hostListenerTargetDocument: cmps.some((c) => c.hasListenerTargetDocument),
 		hostListenerTargetBody: cmps.some((c) => c.hasListenerTargetBody),
-		hostListenerTargetParent: cmps.some((c) => c.hasListenerTargetParent),
 		hostListenerTarget: cmps.some((c) => c.hasListenerTarget),
 		member: cmps.some((c) => c.hasMember),
 		method: cmps.some((c) => c.hasMethod),
@@ -5840,6 +5656,7 @@ const getBuildFeatures = (cmps) => {
 		serializer: cmps.some((c) => c.hasSerializer),
 		shadowDom,
 		shadowDelegatesFocus: shadowDom && cmps.some((c) => c.shadowDelegatesFocus),
+		shadowModeClosed: shadowDom && cmps.some((c) => c.shadowMode === "closed"),
 		shadowSlotAssignmentManual: shadowDom && cmps.some((c) => c.slotAssignment === "manual"),
 		slot,
 		slotRelocation,
@@ -5858,7 +5675,11 @@ const getBuildFeatures = (cmps) => {
 		vdomRender: cmps.some((c) => c.hasVdomRender),
 		vdomStyle: cmps.some((c) => c.hasVdomStyle),
 		vdomText: cmps.some((c) => c.hasVdomText),
-		taskQueue: true
+		taskQueue: true,
+		patchAll: cmps.some((c) => c.hasPatchAll),
+		patchChildren: cmps.some((c) => c.hasPatchChildren),
+		patchClone: cmps.some((c) => c.hasPatchClone),
+		patchInsert: cmps.some((c) => c.hasPatchInsert)
 	};
 	f.vdomAttribute = f.vdomAttribute || f.reflect;
 	f.vdomPropOrAttr = f.vdomPropOrAttr || f.reflect;
@@ -5972,7 +5793,7 @@ const getCustomElementsBuildConditionals = (config, cmps) => {
 //#endregion
 //#region src/compiler/output-targets/dist-custom-elements/generate-loader-module.ts
 /**
-* Generate the auto-loader module content that will be bundled via Rollup.
+* Generate the auto-loader module content that will be bundled via Rolldown.
 * This loader uses MutationObserver to lazily load and define custom elements
 * as they appear in the DOM.
 *
@@ -6169,7 +5990,7 @@ ${autoStart ? "\n// Auto-start the loader\nstart();" : ""}
 /**
 * Main output target function for `dist-custom-elements`. This function just
 * does some organizational work to call the other functions in this module,
-* which do actual work of generating the rollup configuration, creating an
+* which do actual work of generating the rolldown configuration, creating an
 * entry chunk, running, the build, etc.
 *
 * @param config the validated compiler configuration we're using
@@ -6188,13 +6009,13 @@ const outputCustomElements = async (config, compilerCtx, buildCtx) => {
 };
 /**
 * Get bundle options for our current build and compiler context which we'll use
-* to generate a Rollup build and so on.
+* to generate a Rolldown build and so on.
 *
 * @param config a validated Stencil configuration object
 * @param buildCtx the current build context
 * @param compilerCtx the current compiler context
 * @param outputTarget the outputTarget we're currently dealing with
-* @returns bundle options suitable for generating a rollup configuration
+* @returns bundle options suitable for generating a rolldown configuration
 */
 const getBundleOptions = (config, buildCtx, compilerCtx, outputTarget) => ({
 	id: "customElements",
@@ -6208,7 +6029,7 @@ const getBundleOptions = (config, buildCtx, compilerCtx, outputTarget) => ({
 	preserveEntrySignatures: "allow-extension"
 });
 /**
-* Get bundle options for rollup, run the rollup build, optionally minify the
+* Get bundle options for rolldown, run the rolldown build, optionally minify the
 * output, and write files to disk.
 *
 * @param config the validated Stencil configuration we're using
@@ -6223,7 +6044,7 @@ const bundleCustomElements = async (config, compilerCtx, buildCtx, outputTarget)
 		addCustomElementInputs(buildCtx, bundleOpts, outputTarget);
 		const build = await bundleOutput(config, compilerCtx, buildCtx, bundleOpts);
 		if (build) {
-			const rollupOutput = await build.generate({
+			const rolldownOutput = await build.generate({
 				banner: generatePreamble(config),
 				format: "esm",
 				sourcemap: config.sourceMap,
@@ -6242,10 +6063,10 @@ const bundleCustomElements = async (config, compilerCtx, buildCtx, outputTarget)
 				return;
 			}
 			const minify = isBoolean$1(outputTarget.minify) ? outputTarget.minify : config.minifyJs;
-			const files = rollupOutput.output.map(async (bundle) => {
+			const files = rolldownOutput.output.map(async (bundle) => {
 				if (bundle.type === "chunk") {
 					let code = bundle.code;
-					let sourceMap = bundle.map ? rollupToStencilSourceMap(bundle.map) : void 0;
+					let sourceMap = bundle.map ? rolldownToStencilSourceMap(bundle.map) : void 0;
 					const optimizeResults = await optimizeModule(config, compilerCtx, {
 						input: code,
 						isCore: bundle.isEntry,
@@ -6487,14 +6308,14 @@ const getHydrateBuildConditionals = (config, cmps) => {
 //#endregion
 //#region src/compiler/output-targets/dist-hydrate-script/bundle-hydrate-factory.ts
 /**
-* Marshall some Rollup options for the hydrate factory and then pass it to our
+* Marshall some Rolldown options for the hydrate factory and then pass it to our
 * {@link bundleOutput} helper
 *
 * @param config a validated Stencil configuration
 * @param compilerCtx the current compiler context
 * @param buildCtx the current build context
 * @param appFactoryEntryCode an entry code for the app factory
-* @returns a promise wrapping a rollup build object
+* @returns a promise wrapping a rolldown build object
 */
 const bundleHydrateFactory = async (config, compilerCtx, buildCtx, appFactoryEntryCode) => {
 	try {
@@ -6503,12 +6324,12 @@ const bundleHydrateFactory = async (config, compilerCtx, buildCtx, appFactoryEnt
 			platform: "hydrate",
 			conditionals: getHydrateBuildConditionals(config, buildCtx.components),
 			customBeforeTransformers: getCustomBeforeTransformers$1(config, compilerCtx, buildCtx),
-			inlineDynamicImports: true,
+			codeSplitting: false,
 			inputs: { "@stencil/core/runtime/server/hydrate-factory": "@stencil/core/runtime/server/hydrate-factory" },
 			loader: { "@stencil/core/runtime/server/hydrate-factory": appFactoryEntryCode }
 		});
 	} catch (e) {
-		if (!buildCtx.hasError) loadRollupDiagnostics(config, compilerCtx, buildCtx, e);
+		if (!buildCtx.hasError) loadRolldownDiagnostics(config, compilerCtx, buildCtx, e);
 	}
 };
 /**
@@ -6549,7 +6370,7 @@ const MODE_RESOLUTION_CHAIN_DECLARATION = `modeResolutionChain = [];`;
 * one module resolution chain across hydrate and core runtime.
 */
 const HYDRATE_FACTORY_INTRO = `
-// let ${MODE_RESOLUTION_CHAIN_DECLARATION}
+//! let ${MODE_RESOLUTION_CHAIN_DECLARATION}
 
 // Capture native setTimeout/clearTimeout at module scope (before globalThis can be shadowed inside the factory).
 // Used for the hydrate timeout timer to avoid being affected by constrainTimeouts.
@@ -6729,34 +6550,24 @@ const relocateHydrateContextConst = (config, compilerCtx, code) => {
 };
 //#endregion
 //#region src/compiler/output-targets/dist-hydrate-script/write-hydrate-outputs.ts
-const writeHydrateOutputs = (config, compilerCtx, buildCtx, outputTargets, rollupOutput) => {
+const writeHydrateOutputs = (config, compilerCtx, buildCtx, outputTargets, rolldownOutput) => {
 	return Promise.all(outputTargets.map((outputTarget) => {
-		return writeHydrateOutput(config, compilerCtx, buildCtx, outputTarget, rollupOutput);
+		return writeHydrateOutput(config, compilerCtx, buildCtx, outputTarget, rolldownOutput);
 	}));
 };
-const writeHydrateOutput = async (config, compilerCtx, buildCtx, outputTarget, rollupOutput) => {
-	const hydratePackageName = await getHydratePackageName(config, compilerCtx);
+const writeHydrateOutput = async (config, compilerCtx, buildCtx, outputTarget, rolldownOutput) => {
 	const hydrateAppDirPath = outputTarget.dir;
 	if (!hydrateAppDirPath) throw new Error(`outputTarget config missing the "dir" property`);
-	const hydrateCoreIndexPath = join$1(hydrateAppDirPath, "index.js");
-	const hydrateCoreIndexPathESM = join$1(hydrateAppDirPath, "index.mjs");
-	const hydrateCoreIndexDtsFilePath = join$1(hydrateAppDirPath, "index.d.ts");
-	const writeOperations = [copyHydrateRunnerDts(config, compilerCtx, hydrateAppDirPath)];
-	if (outputTarget.generatePackageJson) {
-		const pkgJsonPath = join$1(hydrateAppDirPath, "package.json");
-		const pkgJsonCode = getHydratePackageJson(config, hydrateCoreIndexPath, hydrateCoreIndexPathESM, hydrateCoreIndexDtsFilePath, hydratePackageName);
-		writeOperations.push(compilerCtx.fs.writeFile(pkgJsonPath, pkgJsonCode));
-	}
-	await Promise.all(writeOperations);
-	buildCtx.hydrateAppFilePath = hydrateCoreIndexPath;
+	await copyHydrateRunnerDts(config, compilerCtx, hydrateAppDirPath);
+	buildCtx.hydrateAppFilePath = join$1(hydrateAppDirPath, "index.js");
 	const minify = outputTarget.minify === true;
-	await Promise.all(rollupOutput.output.map(async (output) => {
+	await Promise.all(rolldownOutput.output.map(async (output) => {
 		if (output.type === "chunk") {
 			let code = relocateHydrateContextConst(config, compilerCtx, output.code);
 			/**
 			* Enable the line where we define `modeResolutionChain` for the hydrate module.
 			*/
-			code = code.replace(`// let ${MODE_RESOLUTION_CHAIN_DECLARATION}`, `let ${MODE_RESOLUTION_CHAIN_DECLARATION}`);
+			code = code.replace(`//! let ${MODE_RESOLUTION_CHAIN_DECLARATION}`, `let ${MODE_RESOLUTION_CHAIN_DECLARATION}`);
 			if (code.match(/function (setTagTransformer|transformTag)\(/)) {
 				const injectCode = `\n// Tag transform state object for factory closure\nvar $stencilTagTransform = { setTagTransformer: setTagTransformer, transformTag: transformTag };\n`;
 				const lastTransformTagIndex = code.lastIndexOf("function transformTag(");
@@ -6793,28 +6604,6 @@ const writeHydrateOutput = async (config, compilerCtx, buildCtx, outputTarget, r
 		}
 	}));
 };
-const getHydratePackageJson = (config, hydrateAppFilePathCJS, hydrateAppFilePathESM, hydrateDtsFilePath, hydratePackageName) => {
-	const pkg = {
-		name: hydratePackageName,
-		description: `${config.namespace} component hydration app.`,
-		main: basename$1(hydrateAppFilePathCJS),
-		types: basename$1(hydrateDtsFilePath),
-		exports: { ".": {
-			require: `./${basename$1(hydrateAppFilePathCJS)}`,
-			import: `./${basename$1(hydrateAppFilePathESM)}`
-		} }
-	};
-	return JSON.stringify(pkg, null, 2);
-};
-const getHydratePackageName = async (config, compilerCtx) => {
-	const directoryName = basename$1(config.rootDir);
-	try {
-		const rootPkgFilePath = join$1(config.rootDir, "package.json");
-		const pkgStr = await compilerCtx.fs.readFile(rootPkgFilePath);
-		return `${JSON.parse(pkgStr).name || directoryName}/hydrate`;
-	} catch {}
-	return `${config.fsNamespace || directoryName}/hydrate`;
-};
 const copyHydrateRunnerDts = async (config, compilerCtx, hydrateAppDirPath) => {
 	const srcHydrateDir = join$1(join$1(config.sys.getCompilerExecutingPath(), "..", ".."), "runtime", "server", "runner.d.mts");
 	const runnerDtsDestPath = join$1(hydrateAppDirPath, "index.d.ts");
@@ -6822,9 +6611,9 @@ const copyHydrateRunnerDts = async (config, compilerCtx, hydrateAppDirPath) => {
 };
 //#endregion
 //#region src/compiler/output-targets/dist-hydrate-script/generate-hydrate-app.ts
-const buildHydrateAppFor = async (format, rollupBuild, config, compilerCtx, buildCtx, outputTargets) => {
-	const file = format === "esm" ? "index.mjs" : "index.js";
-	await writeHydrateOutputs(config, compilerCtx, buildCtx, outputTargets, await rollupBuild.generate({
+const buildHydrateAppFor = async (format, rolldownBuild, config, compilerCtx, buildCtx, outputTargets) => {
+	const file = format === "esm" ? "index.js" : "index.cjs";
+	await writeHydrateOutputs(config, compilerCtx, buildCtx, outputTargets, await rolldownBuild.generate({
 		banner: generatePreamble(config),
 		format,
 		file
@@ -6843,52 +6632,62 @@ const generateHydrateApp = async (config, compilerCtx, buildCtx, outputTargets)
 		const packageDir = join$1(config.sys.getCompilerExecutingPath(), "..", "..");
 		const input = join$1(packageDir, "runtime", "server", "runner.mjs");
 		const appData = join$1(packageDir, "runtime", "app-data", "index.js");
-		const rollupAppBuild = await rollup({
-			...config.rollupConfig.inputOptions,
+		const rolldownAppBuild = await rolldown({
+			...config.rolldownConfig.inputOptions,
 			external: ["node:stream"],
 			input,
 			plugins: [{
 				name: "hydrateAppPlugin",
-				resolveId(id) {
-					if (id === "@stencil/core/runtime/server/hydrate-factory") return STENCIL_HYDRATE_FACTORY_ID;
-					if (id === "@stencil/core/runtime/app-data") return appData;
-					return null;
+				resolveId: {
+					filter: { id: /^@stencil\/core\/runtime\/(server\/hydrate-factory|app-data)$/ },
+					handler(id) {
+						if (id === "@stencil/core/runtime/server/hydrate-factory") return STENCIL_HYDRATE_FACTORY_ID;
+						if (id === "@stencil/core/runtime/app-data") return appData;
+						return null;
+					}
 				},
-				load(id) {
-					if (id === "@stencil/core/runtime/server/hydrate-factory") return generateHydrateFactory(config, compilerCtx, buildCtx);
-					return null;
+				load: {
+					filter: { id: /^@stencil\/core\/runtime\/server\/hydrate-factory$/ },
+					handler(id) {
+						if (id === "@stencil/core/runtime/server/hydrate-factory") return generateHydrateFactory(config, compilerCtx, buildCtx);
+						return null;
+					}
 				},
-				transform(code) {
+				transform(code, _id) {
 					/**
 					* Remove the modeResolutionChain variable from the generated code.
 					* This variable is redefined in `HYDRATE_FACTORY_INTRO` to ensure we can
 					* use it within the hydrate and global runtime.
 					*/
 					const searchPattern = `const ${MODE_RESOLUTION_CHAIN_DECLARATION}`;
+					if (!code.includes(searchPattern)) return null;
 					return code.replaceAll(searchPattern, "");
 				}
 			}],
 			treeshake: false,
-			onwarn: createOnWarnFn(buildCtx.diagnostics)
+			onwarn: createOnWarnFn(buildCtx.diagnostics),
+			checks: { pluginTimings: config.devMode }
 		});
-		await Promise.all([buildHydrateAppFor("cjs", rollupAppBuild, config, compilerCtx, buildCtx, outputTargets), buildHydrateAppFor("esm", rollupAppBuild, config, compilerCtx, buildCtx, outputTargets)]);
+		const buildPromises = [buildHydrateAppFor("esm", rolldownAppBuild, config, compilerCtx, buildCtx, outputTargets)];
+		if (outputTargets.some((o) => o.cjs)) buildPromises.push(buildHydrateAppFor("cjs", rolldownAppBuild, config, compilerCtx, buildCtx, outputTargets));
+		await Promise.all(buildPromises);
 	} catch (e) {
-		if (!buildCtx.hasError) loadRollupDiagnostics(config, compilerCtx, buildCtx, e);
+		if (!buildCtx.hasError) loadRolldownDiagnostics(config, compilerCtx, buildCtx, e);
 	}
 };
 const generateHydrateFactory = async (config, compilerCtx, buildCtx) => {
 	if (!buildCtx.hasError) try {
-		const rollupFactoryBuild = await bundleHydrateFactory(config, compilerCtx, buildCtx, await generateHydrateFactoryEntry(buildCtx));
-		if (rollupFactoryBuild != null) {
-			const rollupOutput = await rollupFactoryBuild.generate({
+		const rolldownFactoryBuild = await bundleHydrateFactory(config, compilerCtx, buildCtx, await generateHydrateFactoryEntry(buildCtx));
+		if (rolldownFactoryBuild != null) {
+			const rolldownOutput = await rolldownFactoryBuild.generate({
 				format: "cjs",
 				esModule: false,
 				strict: false,
 				intro: HYDRATE_FACTORY_INTRO,
 				outro: HYDRATE_FACTORY_OUTRO,
-				inlineDynamicImports: true
+				codeSplitting: false
 			});
-			if (!buildCtx.hasError && rollupOutput != null && Array.isArray(rollupOutput.output)) return rollupOutput.output[0].code;
+			if (!buildCtx.hasError && rolldownOutput != null && Array.isArray(rolldownOutput.output)) return rolldownOutput.output[0].code;
 		}
 	} catch (e) {
 		catchError(buildCtx.diagnostics, e);
@@ -7136,7 +6935,7 @@ const generateModuleGraph = (cmps, bundleModules) => {
 	const cmpMap = /* @__PURE__ */ new Map();
 	cmps.forEach((cmp) => {
 		const bundle = bundleModules.find((b) => b.cmps.includes(cmp));
-		if (bundle) cmpMap.set(getScopeId(cmp.tagName), bundle.rollupResult.imports);
+		if (bundle) cmpMap.set(getScopeId(cmp.tagName), bundle.rolldownResult.imports);
 	});
 	return cmpMap;
 };
@@ -7228,16 +7027,16 @@ const lazyComponentTransform = (compilerCtx, transformOpts, buildCtx) => {
 //#endregion
 //#region src/compiler/app-core/bundle-app-core.ts
 /**
-* Generate rollup output based on a rollup build and a series of options.
+* Generate rolldown output based on a rolldown build and a series of options.
 *
-* @param build a rollup build
-* @param options output options for rollup
+* @param build a rolldown build
+* @param options output options for rolldown
 * @param config a user-supplied configuration object
 * @param entryModules a list of entry modules, for checking which chunks
 * contain components
 * @returns a Promise wrapping either build results or `null`
 */
-const generateRollupOutput = async (build, options, config, entryModules) => {
+const generateRolldownOutput = async (build, options, config, entryModules) => {
 	if (build == null) return null;
 	const { output } = await build.generate(options);
 	return output.map((chunk) => {
@@ -7269,8 +7068,8 @@ const generateRollupOutput = async (build, options, config, entryModules) => {
 };
 //#endregion
 //#region src/compiler/output-targets/dist-lazy/write-lazy-entry-module.ts
-const writeLazyModule = async (compilerCtx, outputTargetType, destinations, code, sourceMap, rollupResult) => {
-	const fileName = rollupResult.fileName;
+const writeLazyModule = async (compilerCtx, outputTargetType, destinations, code, sourceMap, rolldownResult) => {
+	const fileName = rolldownResult.fileName;
 	const bundleId = fileName.replace(".entry.js", "");
 	if (sourceMap) code = code + getSourceMappingUrlForEndOfFile(fileName);
 	await Promise.all(destinations.map((dst) => {
@@ -7291,20 +7090,20 @@ const writeLazyModule = async (compilerCtx, outputTargetType, destinations, code
 const generateLazyModules = async (config, compilerCtx, buildCtx, outputTargetType, destinations, results, sourceTarget, isBrowserBuild) => {
 	if (!Array.isArray(destinations) || destinations.length === 0) return [];
 	const shouldMinify = !!(config.minifyJs && isBrowserBuild);
-	const rollupResults = results.filter((r) => r.type === "chunk");
-	const entryComponentsResults = rollupResults.filter((rollupResult) => rollupResult.isComponent);
-	const chunkResults = rollupResults.filter((rollupResult) => !rollupResult.isComponent && !rollupResult.isEntry);
-	const bundleModules = await Promise.all(entryComponentsResults.map((rollupResult) => {
-		return generateLazyEntryModule(config, compilerCtx, buildCtx, rollupResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild);
+	const rolldownResults = results.filter((r) => r.type === "chunk");
+	const entryComponentsResults = rolldownResults.filter((rolldownResult) => rolldownResult.isComponent);
+	const chunkResults = rolldownResults.filter((rolldownResult) => !rolldownResult.isComponent && !rolldownResult.isEntry);
+	const bundleModules = await Promise.all(entryComponentsResults.map((rolldownResult) => {
+		return generateLazyEntryModule(config, compilerCtx, buildCtx, rolldownResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild);
 	}));
-	if ((!!config.extras.experimentalImportInjection || !!config.extras.enableImportInjection) && !isBrowserBuild) addStaticImports(rollupResults, bundleModules);
-	await Promise.all(chunkResults.map((rollupResult) => {
-		return writeLazyChunk(config, compilerCtx, buildCtx, rollupResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild);
+	if (config.extras.enableImportInjection && !isBrowserBuild) addStaticImports(rolldownResults, bundleModules);
+	await Promise.all(chunkResults.map((rolldownResult) => {
+		return writeLazyChunk(config, compilerCtx, buildCtx, rolldownResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild);
 	}));
 	const lazyRuntimeData = formatLazyBundlesRuntimeMeta(bundleModules);
-	const entryResults = rollupResults.filter((rollupResult) => !rollupResult.isComponent && rollupResult.isEntry);
-	await Promise.all(entryResults.map((rollupResult) => {
-		return writeLazyEntry(config, compilerCtx, buildCtx, rollupResult, outputTargetType, destinations, lazyRuntimeData, sourceTarget, shouldMinify, isBrowserBuild);
+	const entryResults = rolldownResults.filter((rolldownResult) => !rolldownResult.isComponent && rolldownResult.isEntry);
+	await Promise.all(entryResults.map((rolldownResult) => {
+		return writeLazyEntry(config, compilerCtx, buildCtx, rolldownResult, outputTargetType, destinations, lazyRuntimeData, sourceTarget, shouldMinify, isBrowserBuild);
 	}));
 	await Promise.all(results.filter((r) => r.type === "asset").map((r) => {
 		return Promise.all(destinations.map((dest) => {
@@ -7314,14 +7113,14 @@ const generateLazyModules = async (config, compilerCtx, buildCtx, outputTargetTy
 	return bundleModules;
 };
 /**
-* Add imports for each bundle to Stencil's lazy loader. Some bundlers that are built atop of Rollup strictly impose
-* the limitations that are laid out in https://github.com/rollup/plugins/tree/master/packages/dynamic-import-vars#limitations.
+* Add imports for each bundle to Stencil's lazy loader. Some bundlers that are built atop of Rolldown strictly impose
+* the limitations that are laid out in https://github.com/rolldown/plugins/tree/master/packages/dynamic-import-vars#limitations.
 * This function injects an explicit import statement for each bundle that can be lazily loaded.
-* @param rollupChunkResults the results of running Rollup across a Stencil project
+* @param rolldownChunkResults the results of running Rolldown across a Stencil project
 * @param bundleModules lazy-loadable modules that can be resolved at runtime
 */
-const addStaticImports = (rollupChunkResults, bundleModules) => {
-	rollupChunkResults.filter(isStencilCoreResult).forEach((index) => {
+const addStaticImports = (rolldownChunkResults, bundleModules) => {
+	rolldownChunkResults.filter(isStencilCoreResult).forEach((index) => {
 		const generateCjs = isCjsFormat(index) ? generateCaseClauseCjs : generateCaseClause;
 		index.code = index.code.replace("/*!__STENCIL_STATIC_IMPORT_SWITCH__*/", `
         if (!hmrVersionId || !BUILD.hotModuleReplacement) {
@@ -7336,20 +7135,20 @@ const addStaticImports = (rollupChunkResults, bundleModules) => {
 	});
 };
 /**
-* Determine if a Rollup output chunk contains Stencil runtime code
-* @param rollupChunkResult the rollup chunk output to test
+* Determine if a Rolldown output chunk contains Stencil runtime code
+* @param rolldownChunkResult the rolldown chunk output to test
 * @returns true if the output chunk contains Stencil runtime code, false otherwise
 */
-const isStencilCoreResult = (rollupChunkResult) => {
-	return rollupChunkResult.isCore && rollupChunkResult.entryKey === "index" && (rollupChunkResult.moduleFormat === "es" || rollupChunkResult.moduleFormat === "esm" || isCjsFormat(rollupChunkResult));
+const isStencilCoreResult = (rolldownChunkResult) => {
+	return rolldownChunkResult.isCore && !rolldownChunkResult.isComponent && (rolldownChunkResult.moduleFormat === "es" || rolldownChunkResult.moduleFormat === "esm" || isCjsFormat(rolldownChunkResult));
 };
 /**
-* Helper function to determine if a Rollup chunk has a commonjs module format
-* @param rollupChunkResult the Rollup result to test
-* @returns true if the Rollup chunk has a commonjs module format, false otherwise
+* Helper function to determine if a Rolldown chunk has a commonjs module format
+* @param rolldownChunkResult the Rolldown result to test
+* @returns true if the Rolldown chunk has a commonjs module format, false otherwise
 */
-const isCjsFormat = (rollupChunkResult) => {
-	return rollupChunkResult.moduleFormat === "cjs" || rollupChunkResult.moduleFormat === "commonjs";
+const isCjsFormat = (rolldownChunkResult) => {
+	return rolldownChunkResult.moduleFormat === "cjs" || rolldownChunkResult.moduleFormat === "commonjs";
 };
 /**
 * Generate a 'case' clause to be used within a `switch` statement. The case clause generated will key-off the provided
@@ -7377,40 +7176,40 @@ const generateCaseClauseCjs = (bundleId) => {
                         /* webpackMode: "lazy" */
                         './${bundleId}.entry.js')); }).then(processMod, consoleError);`;
 };
-const generateLazyEntryModule = async (config, compilerCtx, buildCtx, rollupResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild) => {
-	const entryModule = buildCtx.entryModules.find((em) => em.entryKey === rollupResult.entryKey);
-	const { code, sourceMap } = await convertChunk(config, compilerCtx, buildCtx, sourceTarget, shouldMinify, false, isBrowserBuild, rollupResult.code, rollupResult.map);
-	const output = await writeLazyModule(compilerCtx, outputTargetType, destinations, code, sourceMap, rollupResult);
+const generateLazyEntryModule = async (config, compilerCtx, buildCtx, rolldownResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild) => {
+	const entryModule = buildCtx.entryModules.find((em) => em.entryKey === rolldownResult.entryKey);
+	const { code, sourceMap } = await convertChunk(config, compilerCtx, buildCtx, sourceTarget, shouldMinify, false, isBrowserBuild, rolldownResult.code, rolldownResult.map);
+	const output = await writeLazyModule(compilerCtx, outputTargetType, destinations, code, sourceMap, rolldownResult);
 	return {
-		rollupResult,
-		entryKey: rollupResult.entryKey,
+		rolldownResult,
+		entryKey: rolldownResult.entryKey,
 		cmps: entryModule.cmps,
 		output
 	};
 };
-const writeLazyChunk = async (config, compilerCtx, buildCtx, rollupResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild) => {
-	const { code, sourceMap } = await convertChunk(config, compilerCtx, buildCtx, sourceTarget, shouldMinify, rollupResult.isCore, isBrowserBuild, rollupResult.code, rollupResult.map);
+const writeLazyChunk = async (config, compilerCtx, buildCtx, rolldownResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild) => {
+	const { code, sourceMap } = await convertChunk(config, compilerCtx, buildCtx, sourceTarget, shouldMinify, rolldownResult.isCore, isBrowserBuild, rolldownResult.code, rolldownResult.map);
 	await Promise.all(destinations.map((dst) => {
-		const filePath = join$1(dst, rollupResult.fileName);
+		const filePath = join$1(dst, rolldownResult.fileName);
 		let fileCode = code;
 		const writes = [];
 		if (sourceMap) {
-			fileCode = code + getSourceMappingUrlForEndOfFile(rollupResult.fileName);
+			fileCode = code + getSourceMappingUrlForEndOfFile(rolldownResult.fileName);
 			writes.push(compilerCtx.fs.writeFile(filePath + ".map", JSON.stringify(sourceMap), { outputTargetType }));
 		}
 		writes.push(compilerCtx.fs.writeFile(filePath, fileCode, { outputTargetType }));
 		return Promise.all(writes);
 	}));
 };
-const writeLazyEntry = async (config, compilerCtx, buildCtx, rollupResult, outputTargetType, destinations, lazyRuntimeData, sourceTarget, shouldMinify, isBrowserBuild) => {
-	if (isBrowserBuild && ["loader"].includes(rollupResult.entryKey)) return;
-	const { code, sourceMap } = await convertChunk(config, compilerCtx, buildCtx, sourceTarget, shouldMinify, false, isBrowserBuild, rollupResult.code.replace(`[/*!__STENCIL_LAZY_DATA__*/]`, `${lazyRuntimeData}`), rollupResult.map);
+const writeLazyEntry = async (config, compilerCtx, buildCtx, rolldownResult, outputTargetType, destinations, lazyRuntimeData, sourceTarget, shouldMinify, isBrowserBuild) => {
+	if (isBrowserBuild && ["loader"].includes(rolldownResult.entryKey)) return;
+	const { code, sourceMap } = await convertChunk(config, compilerCtx, buildCtx, sourceTarget, shouldMinify, false, isBrowserBuild, rolldownResult.code.replace(`["__STENCIL_LAZY_DATA__"]`, `${lazyRuntimeData}`), rolldownResult.map);
 	await Promise.all(destinations.map((dst) => {
-		const filePath = join$1(dst, rollupResult.fileName);
+		const filePath = join$1(dst, rolldownResult.fileName);
 		let fileCode = code;
 		const writes = [];
 		if (sourceMap) {
-			fileCode = code + getSourceMappingUrlForEndOfFile(rollupResult.fileName);
+			fileCode = code + getSourceMappingUrlForEndOfFile(rolldownResult.fileName);
 			writes.push(compilerCtx.fs.writeFile(filePath + ".map", JSON.stringify(sourceMap), { outputTargetType }));
 		}
 		writes.push(compilerCtx.fs.writeFile(filePath, fileCode, { outputTargetType }));
@@ -7420,7 +7219,7 @@ const writeLazyEntry = async (config, compilerCtx, buildCtx, rollupResult, outpu
 /**
 * Sorts, formats, and stringifies the bundles for a lazy build of a Stencil project.
 *
-* @param bundleModules The modules for the Stencil lazy build emitted from Rollup.
+* @param bundleModules The modules for the Stencil lazy build emitted from Rolldown.
 * @returns A stringified representation of the lazy bundles.
 */
 const formatLazyBundlesRuntimeMeta = (bundleModules) => {
@@ -7500,8 +7299,8 @@ const sortBundleComponents = (a, b) => {
 	if (a.tagName > b.tagName) return 1;
 	return 0;
 };
-const convertChunk = async (config, compilerCtx, buildCtx, sourceTarget, shouldMinify, isCore, isBrowserBuild, code, rollupSrcMap) => {
-	let sourceMap = rollupToStencilSourceMap(rollupSrcMap);
+const convertChunk = async (config, compilerCtx, buildCtx, sourceTarget, shouldMinify, isCore, isBrowserBuild, code, rolldownSrcMap) => {
+	let sourceMap = rolldownToStencilSourceMap(rolldownSrcMap);
 	const inlineHelpers = isBrowserBuild || !hasDependency(buildCtx, "tslib");
 	const optimizeResults = await optimizeModule(config, compilerCtx, {
 		input: code,
@@ -7522,13 +7321,13 @@ const convertChunk = async (config, compilerCtx, buildCtx, sourceTarget, shouldM
 //#endregion
 //#region src/compiler/output-targets/dist-lazy/lazy-bundleid-plugin.ts
 /**
-* A Rollup plugin to generate unique bundle IDs for lazy-loaded modules.
+* A Rolldown plugin to generate unique bundle IDs for lazy-loaded modules.
 * @param buildCtx The build context
 * @param config The validated configuration
 * @param shouldHash Whether to hash the bundle ID
 * @param suffix The suffix to append to the bundle ID
 * @param isBrowserBuild Whether this is a browser build
-* @returns A Rollup plugin
+* @returns A Rolldown plugin
 */
 const lazyBundleIdPlugin = (buildCtx, config, shouldHash, suffix, isBrowserBuild) => {
 	const getBundleId = async (entryKey, code, fileSuffix) => {
@@ -7584,7 +7383,7 @@ const lazyBundleIdPlugin = (buildCtx, config, shouldHash, suffix, isBrowserBuild
 };
 //#endregion
 //#region src/compiler/output-targets/dist-lazy/generate-cjs.ts
-const generateCjs = async (config, compilerCtx, buildCtx, rollupBuild, outputTargets) => {
+const generateCjs = async (config, compilerCtx, buildCtx, rolldownBuild, outputTargets) => {
 	const cjsOutputs = outputTargets.filter((o) => !!o.cjsDir);
 	if (cjsOutputs.length > 0) {
 		const outputTargetType = cjsOutputs[0].type;
@@ -7596,11 +7395,8 @@ const generateCjs = async (config, compilerCtx, buildCtx, rollupBuild, outputTar
 			sourcemap: config.sourceMap,
 			plugins: [lazyBundleIdPlugin(buildCtx, config, false, ".cjs")]
 		};
-		if (!!config.extras.experimentalImportInjection || !!config.extras.enableImportInjection) {
-			esmOpts.interop = "auto";
-			esmOpts.dynamicImportInCjs = false;
-		}
-		const results = await generateRollupOutput(rollupBuild, esmOpts, config, buildCtx.entryModules);
+		if (config.extras.enableImportInjection) esmOpts.dynamicImportInCjs = false;
+		const results = await generateRolldownOutput(rolldownBuild, esmOpts, config, buildCtx.entryModules);
 		if (results != null) {
 			buildCtx.commonJsComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargetType, cjsOutputs.map((o) => o.cjsDir).filter((cjsDir) => typeof cjsDir === "string"), results, "es2017", false);
 			await generateShortcuts$1(compilerCtx, results, cjsOutputs);
@@ -7611,8 +7407,8 @@ const generateCjs = async (config, compilerCtx, buildCtx, rollupBuild, outputTar
 		buildCtx
 	};
 };
-const generateShortcuts$1 = (compilerCtx, rollupResult, outputTargets) => {
-	const indexFilename = rollupResult.find((r) => r.type === "chunk" && r.isIndex).fileName;
+const generateShortcuts$1 = (compilerCtx, rolldownResult, outputTargets) => {
+	const indexFilename = rolldownResult.find((r) => r.type === "chunk" && r.isIndex).fileName;
 	return Promise.all(outputTargets.map(async (o) => {
 		if (o.cjsIndexFile) {
 			const entryPointPath = join$1(o.cjsDir, indexFilename);
@@ -7623,10 +7419,9 @@ const generateShortcuts$1 = (compilerCtx, rollupResult, outputTargets) => {
 };
 //#endregion
 //#region src/compiler/output-targets/dist-lazy/generate-esm.ts
-const generateEsm = async (config, compilerCtx, buildCtx, rollupBuild, outputTargets) => {
-	const esmEs5Outputs = config.buildEs5 ? outputTargets.filter((o) => !!o.esmEs5Dir && !o.isBrowserBuild) : [];
+const generateEsm = async (config, compilerCtx, buildCtx, rolldownBuild, outputTargets) => {
 	const esmOutputs = outputTargets.filter((o) => !!o.esmDir && !o.isBrowserBuild);
-	if (esmOutputs.length + esmEs5Outputs.length > 0) {
+	if (esmOutputs.length > 0) {
 		const esmOpts = {
 			banner: generatePreamble(config),
 			format: "es",
@@ -7636,11 +7431,9 @@ const generateEsm = async (config, compilerCtx, buildCtx, rollupBuild, outputTar
 			plugins: [lazyBundleIdPlugin(buildCtx, config, false, "")]
 		};
 		const outputTargetType = esmOutputs[0].type;
-		const output = await generateRollupOutput(rollupBuild, esmOpts, config, buildCtx.entryModules);
+		const output = await generateRolldownOutput(rolldownBuild, esmOpts, config, buildCtx.entryModules);
 		if (output != null) {
 			buildCtx.esmComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargetType, esmOutputs.map((o) => o.esmDir).filter((esmDir) => typeof esmDir === "string"), output, "es2017", false);
-			buildCtx.es5ComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargetType, esmEs5Outputs.map((o) => o.esmEs5Dir).filter((esmEs5Dir) => typeof esmEs5Dir === "string"), output, "es5", false);
-			if (config.buildEs5) await copyPolyfills(config, compilerCtx, esmOutputs);
 			await generateShortcuts(config, compilerCtx, outputTargets, output);
 		}
 	}
@@ -7649,31 +7442,11 @@ const generateEsm = async (config, compilerCtx, buildCtx, rollupBuild, outputTar
 		buildCtx
 	};
 };
-/**
-* Copy polyfills from `$INSTALL_DIR/internal/client/polyfills` to the lazy
-* loader output directory where $INSTALL_DIR is the directory in which the
-* `@stencil/core` package is installed.
-*
-* @param config a validated Stencil configuration
-* @param compilerCtx the current compiler context
-* @param outputTargets dist-lazy output targets
-*/
-const copyPolyfills = async (config, compilerCtx, outputTargets) => {
-	const destinations = outputTargets.filter((o) => o.polyfills).map((o) => o.esmDir).filter((esmDir) => typeof esmDir === "string");
-	if (destinations.length === 0) return;
-	const src = join$1(config.sys.getCompilerExecutingPath(), "..", "..", "internal", "client", "polyfills");
-	const files = await compilerCtx.fs.readdir(src);
-	await Promise.all(destinations.map((dest) => {
-		return Promise.all(files.map((f) => {
-			return compilerCtx.fs.copyFile(f.absPath, join$1(dest, "polyfills", f.relPath));
-		}));
-	}));
-};
-const generateShortcuts = (config, compilerCtx, outputTargets, rollupResult) => {
-	const indexFilename = rollupResult.find((r) => r.type === "chunk" && r.isIndex).fileName;
+const generateShortcuts = (_config, compilerCtx, outputTargets, rolldownResult) => {
+	const indexFilename = rolldownResult.find((r) => r.type === "chunk" && r.isIndex).fileName;
 	return Promise.all(outputTargets.map(async (o) => {
 		if (o.esmDir && o.esmIndexFile) {
-			const entryPointPath = config.buildEs5 && o.esmEs5Dir ? join$1(o.esmEs5Dir, indexFilename) : join$1(o.esmDir, indexFilename);
+			const entryPointPath = join$1(o.esmDir, indexFilename);
 			const shortcutContent = `export * from '${relativeImport(o.esmIndexFile, entryPointPath)}';`;
 			await compilerCtx.fs.writeFile(o.esmIndexFile, shortcutContent, { outputTargetType: o.type });
 		}
@@ -7681,11 +7454,11 @@ const generateShortcuts = (config, compilerCtx, outputTargets, rollupResult) =>
 };
 //#endregion
 //#region src/compiler/output-targets/dist-lazy/generate-esm-browser.ts
-const generateEsmBrowser = async (config, compilerCtx, buildCtx, rollupBuild, outputTargets) => {
+const generateEsmBrowser = async (config, compilerCtx, buildCtx, rolldownBuild, outputTargets) => {
 	const esmOutputs = outputTargets.filter((o) => !!o.esmDir && !!o.isBrowserBuild);
 	if (esmOutputs.length) {
 		const outputTargetType = esmOutputs[0].type;
-		const output = await generateRollupOutput(rollupBuild, {
+		const output = await generateRolldownOutput(rolldownBuild, {
 			banner: generatePreamble(config),
 			format: "es",
 			entryFileNames: "[name].esm.js",
@@ -7702,96 +7475,11 @@ const generateEsmBrowser = async (config, compilerCtx, buildCtx, rollupBuild, ou
 	};
 };
 //#endregion
-//#region src/compiler/app-core/app-polyfills.ts
-const getClientPolyfill = async (config, compilerCtx, polyfillFile) => {
-	const polyfillFilePath = join$1(config.sys.getCompilerExecutingPath(), "..", "..", "internal", "client", "polyfills", polyfillFile);
-	return compilerCtx.fs.readFile(polyfillFilePath);
-};
-const getAppBrowserCorePolyfills = async (config, compilerCtx) => {
-	const polyfills = INLINE_POLYFILLS.slice();
-	return (await Promise.all(polyfills.map((polyfillFile) => getClientPolyfill(config, compilerCtx, polyfillFile)))).join("\n").trim();
-};
-const INLINE_POLYFILLS = [
-	"core-js.js",
-	"dom.js",
-	"es5-html-element.js",
-	"system.js"
-];
-//#endregion
-//#region src/compiler/output-targets/dist-lazy/generate-system.ts
-const generateSystem = async (config, compilerCtx, buildCtx, rollupBuild, outputTargets) => {
-	const systemOutputs = outputTargets.filter((o) => !!o.systemDir);
-	if (systemOutputs.length > 0) {
-		const results = await generateRollupOutput(rollupBuild, {
-			banner: generatePreamble(config),
-			format: "system",
-			entryFileNames: config.hashFileNames ? "p-[hash].system.js" : "[name].system.js",
-			chunkFileNames: config.hashFileNames ? "p-[hash].system.js" : "[name]-[hash].system.js",
-			assetFileNames: config.hashFileNames ? "p-[hash][extname]" : "[name]-[hash][extname]",
-			sourcemap: config.sourceMap,
-			plugins: [lazyBundleIdPlugin(buildCtx, config, config.hashFileNames, ".system", true)]
-		}, config, buildCtx.entryModules);
-		if (results != null) {
-			const destinations = systemOutputs.map((o) => o.esmDir).filter((esmDir) => typeof esmDir === "string");
-			buildCtx.systemComponentBundle = await generateLazyModules(config, compilerCtx, buildCtx, outputTargets[0].type, destinations, results, "es5", true);
-			await generateSystemLoaders(config, compilerCtx, results, systemOutputs);
-		}
-	}
-	return {
-		name: "system",
-		buildCtx
-	};
-};
-const generateSystemLoaders = (config, compilerCtx, rollupResult, systemOutputs) => {
-	const loaderFilename = rollupResult.find((r) => r.type === "chunk" && r.isBrowserLoader).fileName;
-	return Promise.all(systemOutputs.map((o) => writeSystemLoader(config, compilerCtx, loaderFilename, o)));
-};
-const writeSystemLoader = async (config, compilerCtx, loaderFilename, outputTarget) => {
-	if (outputTarget.systemLoaderFile) {
-		const entryPointPath = join$1(outputTarget.systemDir, loaderFilename);
-		const loaderContent = await getSystemLoader(config, compilerCtx, relativeImport(outputTarget.systemLoaderFile, entryPointPath), !!outputTarget.polyfills);
-		await compilerCtx.fs.writeFile(outputTarget.systemLoaderFile, loaderContent, { outputTargetType: outputTarget.type });
-	}
-};
-const getSystemLoader = async (config, compilerCtx, corePath, includePolyfills) => {
-	return `
-'use strict';
-(function () {
-  var currentScript = document.currentScript;
-
-  // Safari 10 support type="module" but still download and executes the nomodule script
-  if (!currentScript || !currentScript.hasAttribute('nomodule') || !('onbeforeload' in currentScript)) {
-
-    ${includePolyfills ? await getAppBrowserCorePolyfills(config, compilerCtx) : "/* polyfills excluded */"}
-
-    // Figure out currentScript (for IE11, since it does not support currentScript)
-    var regex = /\\/${config.fsNamespace}(\\.esm)?\\.js($|\\?|#)/;
-    var scriptElm = currentScript || Array.from(document.querySelectorAll('script')).find(function(s) {
-      return regex.test(s.src) || s.getAttribute('data-stencil-namespace') === "${config.fsNamespace}";
-    });
-
-    var resourcesUrl = scriptElm ? scriptElm.getAttribute('data-resources-url') || scriptElm.src : '';
-    var start = function() {
-      // if src is not present then origin is "null", and new URL() throws TypeError: Failed to construct 'URL': Invalid base URL
-      var url = new URL('${corePath}', new URL(resourcesUrl, window.location.origin !== 'null' ? window.location.origin : undefined));
-      System.import(url.href);
-    };
-
-    start();
-
-    // Note: using .call(window) here because the self-executing function needs
-    // to be scoped to the window object for the ES6Promise polyfill to work
-  }
-}).call(window);
-`;
-};
-//#endregion
 //#region src/compiler/output-targets/dist-lazy/lazy-build-conditionals.ts
 const getLazyBuildConditionals = (config, cmps) => {
 	const build = getBuildFeatures(cmps);
 	build.lazyLoad = true;
 	build.hydrateServerSide = false;
-	build.transformTagName = config.extras.tagNameTransform;
 	build.asyncQueue = config.taskQueue === "congestionAsync";
 	build.taskQueue = config.taskQueue !== "immediate";
 	build.initializeNextTick = config.extras.initializeNextTick;
@@ -7827,20 +7515,16 @@ const outputLazy = async (config, compilerCtx, buildCtx) => {
 		buildCtx.entryModules.forEach((entryModule) => {
 			bundleOpts.inputs[entryModule.entryKey] = entryModule.entryKey;
 		});
-		const rollupBuild = await bundleOutput(config, compilerCtx, buildCtx, bundleOpts);
-		if (rollupBuild != null) {
+		const rolldownBuild = await bundleOutput(config, compilerCtx, buildCtx, bundleOpts);
+		if (rolldownBuild != null) {
 			(await Promise.all([
-				generateEsmBrowser(config, compilerCtx, buildCtx, rollupBuild, outputTargets),
-				generateEsm(config, compilerCtx, buildCtx, rollupBuild, outputTargets),
-				generateSystem(config, compilerCtx, buildCtx, rollupBuild, outputTargets),
-				generateCjs(config, compilerCtx, buildCtx, rollupBuild, outputTargets)
+				generateEsmBrowser(config, compilerCtx, buildCtx, rolldownBuild, outputTargets),
+				generateEsm(config, compilerCtx, buildCtx, rolldownBuild, outputTargets),
+				generateCjs(config, compilerCtx, buildCtx, rolldownBuild, outputTargets)
 			])).forEach((result) => {
 				if (result.name === "cjs") buildCtx.commonJsComponentBundle = result.buildCtx.commonJsComponentBundle;
-				else if (result.name === "system") buildCtx.systemComponentBundle = result.buildCtx.systemComponentBundle;
-				else if (result.name === "esm") {
-					buildCtx.esmComponentBundle = result.buildCtx.esmComponentBundle;
-					buildCtx.es5ComponentBundle = result.buildCtx.es5ComponentBundle;
-				} else if (result.name === "esm-browser") {
+				else if (result.name === "esm") buildCtx.esmComponentBundle = result.buildCtx.esmComponentBundle;
+				else if (result.name === "esm-browser") {
 					buildCtx.esmBrowserComponentBundle = result.buildCtx.esmBrowserComponentBundle;
 					buildCtx.buildResults = result.buildCtx.buildResults;
 					buildCtx.components = result.buildCtx.components;
@@ -7919,14 +7603,14 @@ const getLazyEntry = (isBrowser) => {
 		s.append(`import { globalScripts } from '${STENCIL_APP_GLOBALS_ID}';\n`);
 		s.append(`(async () => {\n`);
 		s.append(`  await globalScripts();\n`);
-		s.append(`  bootstrapLazy([/*!__STENCIL_LAZY_DATA__*/]);\n`);
+		s.append(`  bootstrapLazy(["__STENCIL_LAZY_DATA__"]);\n`);
 		s.append(`})();\n`);
 	} else {
 		s.append(`import { globalScripts } from '${STENCIL_APP_GLOBALS_ID}';\n`);
 		s.append(`export const defineCustomElements = async (win, options) => {\n`);
 		s.append(`  if (typeof window === 'undefined') return undefined;\n`);
 		s.append(`  await globalScripts();\n`);
-		s.append(`  return bootstrapLazy([/*!__STENCIL_LAZY_DATA__*/], options);\n`);
+		s.append(`  return bootstrapLazy(["__STENCIL_LAZY_DATA__"], options);\n`);
 		s.append(`};\n`);
 	}
 	return s.toString();
@@ -8106,10 +7790,6 @@ const validateDist = (config, userOutputs) => {
 		outputs.push({
 			type: DIST_LAZY,
 			esmDir: lazyDir,
-			systemDir: config.buildEs5 ? lazyDir : void 0,
-			systemLoaderFile: config.buildEs5 ? join$1(lazyDir, namespace + ".js") : void 0,
-			legacyLoaderFile: join$1(distOutputTarget.buildDir, namespace + ".js"),
-			polyfills: outputTarget.polyfills !== void 0 ? !!distOutputTarget.polyfills : true,
 			isBrowserBuild: true,
 			empty: distOutputTarget.empty
 		});
@@ -8149,23 +7829,19 @@ const validateDist = (config, userOutputs) => {
 				});
 			}
 			const esmDir = join$1(distOutputTarget.dir, "esm");
-			const esmEs5Dir = config.buildEs5 ? join$1(distOutputTarget.dir, "esm-es5") : void 0;
-			const cjsDir = join$1(distOutputTarget.dir, "cjs");
+			const cjsDir = distOutputTarget.cjs ? join$1(distOutputTarget.dir, "cjs") : void 0;
 			outputs.push({
 				type: DIST_LAZY,
 				esmDir,
-				esmEs5Dir,
 				cjsDir,
-				cjsIndexFile: join$1(distOutputTarget.dir, "index.cjs.js"),
+				cjsIndexFile: distOutputTarget.cjs ? join$1(distOutputTarget.dir, "index.cjs.js") : void 0,
 				esmIndexFile: join$1(distOutputTarget.dir, "index.js"),
-				polyfills: true,
 				empty: distOutputTarget.empty
 			});
 			outputs.push({
 				type: DIST_LAZY_LOADER,
 				dir: distOutputTarget.esmLoaderPath,
 				esmDir,
-				esmEs5Dir,
 				cjsDir,
 				componentDts: getComponentsDtsTypesFilePath(distOutputTarget),
 				empty: distOutputTarget.empty
@@ -8194,10 +7870,10 @@ const validateOutputTargetDist = (config, o) => {
 		typesDir: o.typesDir || DEFAULT_TYPES_DIR,
 		esmLoaderPath: o.esmLoaderPath || DEFAULT_ESM_LOADER_DIR,
 		copy: validateCopy(o.copy ?? [], []),
-		polyfills: isBoolean$1(o.polyfills) ? o.polyfills : false,
 		empty: isBoolean$1(o.empty) ? o.empty : true,
 		transformAliasedImportPathsInCollection: isBoolean$1(o.transformAliasedImportPathsInCollection) ? o.transformAliasedImportPathsInCollection : true,
-		isPrimaryPackageOutputTarget: o.isPrimaryPackageOutputTarget ?? false
+		isPrimaryPackageOutputTarget: o.isPrimaryPackageOutputTarget ?? false,
+		cjs: isBoolean$1(o.cjs) ? o.cjs : false
 	};
 	if (!isAbsolute(outputTarget.buildDir)) outputTarget.buildDir = join$1(outputTarget.dir, outputTarget.buildDir);
 	if (outputTarget.collectionDir && !isAbsolute(outputTarget.collectionDir)) outputTarget.collectionDir = join$1(outputTarget.dir, outputTarget.collectionDir);
@@ -8305,7 +7981,7 @@ const validateHydrateScript = (config, userOutputs) => {
 		if (!isAbsolute(outputTarget.dir)) outputTarget.dir = join$1(config.rootDir, outputTarget.dir);
 		if (!isBoolean$1(outputTarget.empty)) outputTarget.empty = true;
 		if (!isBoolean$1(outputTarget.minify)) outputTarget.minify = false;
-		if (!isBoolean$1(outputTarget.generatePackageJson)) outputTarget.generatePackageJson = true;
+		if (!isBoolean$1(outputTarget.cjs)) outputTarget.cjs = false;
 		outputTarget.external = outputTarget.external || [];
 		outputTarget.external.push("fs");
 		outputTarget.external.push("path");
@@ -8318,13 +7994,9 @@ const validateHydrateScript = (config, userOutputs) => {
 //#region src/compiler/config/outputs/validate-lazy.ts
 const validateLazy = (config, userOutputs) => {
 	return userOutputs.filter(isOutputTargetDistLazy).map((o) => {
-		const dir = getAbsolutePath(config, o.dir || join$1("dist", config.fsNamespace));
 		return {
 			type: DIST_LAZY,
-			esmDir: dir,
-			systemDir: config.buildEs5 ? dir : void 0,
-			systemLoaderFile: config.buildEs5 ? join$1(dir, `${config.fsNamespace}.js`) : void 0,
-			polyfills: !!o.polyfills,
+			esmDir: getAbsolutePath(config, o.dir || join$1("dist", config.fsNamespace)),
 			isBrowserBuild: true,
 			empty: isBoolean$1(o.empty) ? o.empty : true
 		};
@@ -8437,9 +8109,8 @@ const DEFAULT_FILENAME = "sw.js";
 //#region src/compiler/config/outputs/validate-www.ts
 const validateWww = (config, diagnostics, userOutputs) => {
 	const hasOutputTargets = userOutputs.length > 0;
-	const hasE2eTests = !!config.e2eTests;
 	const userWwwOutputs = userOutputs.filter(isOutputTargetWww);
-	if (!hasOutputTargets || hasE2eTests && !userOutputs.some(isOutputTargetWww) && !userOutputs.some(isOutputTargetDist)) userWwwOutputs.push({ type: "www" });
+	if (!hasOutputTargets) userWwwOutputs.push({ type: "www" });
 	if (config.prerender && userWwwOutputs.length === 0) {
 		const err = buildError(diagnostics);
 		err.messageText = `You need at least one "www" output target configured in your stencil.config.ts, when the "--prerender" flag is used`;
@@ -8452,9 +8123,6 @@ const validateWww = (config, diagnostics, userOutputs) => {
 			type: DIST_LAZY,
 			dir: buildDir,
 			esmDir: buildDir,
-			systemDir: config.buildEs5 ? buildDir : void 0,
-			systemLoaderFile: config.buildEs5 ? join$1(buildDir, `${config.fsNamespace}.js`) : void 0,
-			polyfills: outputTarget.polyfills,
 			isBrowserBuild: true
 		});
 		outputs.push({
@@ -8494,8 +8162,6 @@ const validateWwwOutputTarget = (config, outputTarget, diagnostics) => {
 	if (!isBoolean$1(outputTarget.empty)) outputTarget.empty = true;
 	validatePrerender(config, diagnostics, outputTarget);
 	validateServiceWorker(config, outputTarget);
-	if (outputTarget.polyfills === void 0) outputTarget.polyfills = true;
-	outputTarget.polyfills = !!outputTarget.polyfills;
 	return outputTarget;
 };
 //#endregion
@@ -8603,7 +8269,7 @@ const validateDevServer = (config, diagnostics) => {
 			err.messageText = `dev server excludeHmr must be an array of glob strings`;
 		}
 	} else devServer.excludeHmr = [];
-	if (!config.devMode || config.buildEs5) devServer.experimentalDevModules = false;
+	if (!config.devMode) devServer.experimentalDevModules = false;
 	else devServer.experimentalDevModules = !!devServer.experimentalDevModules;
 	return devServer;
 };
@@ -8873,34 +8539,34 @@ const DEFAULT_SRC_DIR = "src";
 //#region src/compiler/config/validate-plugins.ts
 const validatePlugins = (config, diagnostics) => {
 	const userPlugins = config.plugins;
-	if (!config.rollupPlugins) config.rollupPlugins = {};
+	if (!config.rolldownPlugins) config.rolldownPlugins = {};
 	if (!Array.isArray(userPlugins)) {
 		config.plugins = [];
 		return;
 	}
-	const rollupPlugins = userPlugins.filter((plugin) => {
+	const rolldownPlugins = userPlugins.filter((plugin) => {
 		return !!(plugin && typeof plugin === "object" && !plugin.pluginType);
 	});
-	const hasResolveNode = rollupPlugins.some((p) => p.name === "node-resolve");
-	if (rollupPlugins.some((p) => p.name === "commonjs")) {
+	const hasResolveNode = rolldownPlugins.some((p) => p.name === "node-resolve");
+	if (rolldownPlugins.some((p) => p.name === "commonjs")) {
 		const warn = buildWarn(diagnostics);
-		warn.messageText = `Stencil already uses "@rollup/plugin-commonjs", please remove it from your "stencil.config.ts" plugins.
+		warn.messageText = `Stencil already uses "@rolldown/plugin-commonjs", please remove it from your "stencil.config.ts" plugins.
     You can configure the commonjs settings using the "commonjs" property in "stencil.config.ts`;
 	}
 	if (hasResolveNode) {
 		const warn = buildWarn(diagnostics);
-		warn.messageText = `Stencil already uses "@rollup/plugin-commonjs", please remove it from your "stencil.config.ts" plugins.
+		warn.messageText = `Stencil already uses "@rolldown/plugin-commonjs", please remove it from your "stencil.config.ts" plugins.
     You can configure the commonjs settings using the "commonjs" property in "stencil.config.ts`;
 	}
-	config.rollupPlugins.before = [...config.rollupPlugins.before || [], ...rollupPlugins.filter(({ name }) => name !== "node-resolve" && name !== "commonjs")];
+	config.rolldownPlugins.before = [...config.rolldownPlugins.before || [], ...rolldownPlugins.filter(({ name }) => name !== "node-resolve" && name !== "commonjs")];
 	config.plugins = userPlugins.filter((plugin) => {
 		return !!(plugin && typeof plugin === "object" && plugin.pluginType);
 	});
 };
 //#endregion
-//#region src/compiler/config/validate-rollup-config.ts
+//#region src/compiler/config/validate-rolldown-config.ts
 /**
-* Ensure that a valid baseline rollup configuration is set on the validated
+* Ensure that a valid baseline rolldown configuration is set on the validated
 * config.
 *
 * If a config is present this will return a new config based on the user
@@ -8909,15 +8575,15 @@ const validatePlugins = (config, diagnostics) => {
 * If no config is present, this will return a default config.
 *
 * @param config a validated user-supplied configuration object
-* @returns a validated rollup configuration
-*/
-const validateRollupConfig = (config) => {
-	let cleanRollupConfig = { ...DEFAULT_ROLLUP_CONFIG };
-	const rollupConfig = config.rollupConfig;
-	if (!rollupConfig || !isObject(rollupConfig)) return cleanRollupConfig;
-	if (rollupConfig.inputOptions && isObject(rollupConfig.inputOptions)) cleanRollupConfig = {
-		...cleanRollupConfig,
-		inputOptions: pluck(rollupConfig.inputOptions, [
+* @returns a validated rolldown configuration
+*/
+const validateRolldownConfig = (config) => {
+	let cleanRolldownConfig = { ...DEFAULT_ROLLDOWN_CONFIG };
+	const rolldownConfig = config.rolldownConfig;
+	if (!rolldownConfig || !isObject(rolldownConfig)) return cleanRolldownConfig;
+	if (rolldownConfig.inputOptions && isObject(rolldownConfig.inputOptions)) cleanRolldownConfig = {
+		...cleanRolldownConfig,
+		inputOptions: pluck(rolldownConfig.inputOptions, [
 			"context",
 			"moduleContext",
 			"treeshake",
@@ -8925,13 +8591,13 @@ const validateRollupConfig = (config) => {
 			"maxParallelFileOps"
 		])
 	};
-	if (rollupConfig.outputOptions && isObject(rollupConfig.outputOptions)) cleanRollupConfig = {
-		...cleanRollupConfig,
-		outputOptions: pluck(rollupConfig.outputOptions, ["globals"])
+	if (rolldownConfig.outputOptions && isObject(rolldownConfig.outputOptions)) cleanRolldownConfig = {
+		...cleanRolldownConfig,
+		outputOptions: pluck(rolldownConfig.outputOptions, ["globals"])
 	};
-	return cleanRollupConfig;
+	return cleanRolldownConfig;
 };
-const DEFAULT_ROLLUP_CONFIG = {
+const DEFAULT_ROLLDOWN_CONFIG = {
 	inputOptions: {},
 	outputOptions: {}
 };
@@ -8983,7 +8649,6 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 	const validatedConfig = {
 		devServer: {},
 		...config,
-		buildEs5: config.buildEs5 === true || !devMode && config.buildEs5 === "prod",
 		devMode,
 		extras: config.extras || {},
 		generateExportMaps: isBoolean$1(config.generateExportMaps) ? config.generateExportMaps : false,
@@ -8995,10 +8660,9 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 		minifyCss: config.minifyCss ?? !devMode,
 		minifyJs: config.minifyJs ?? !devMode,
 		outputTargets: config.outputTargets ?? [],
-		rollupConfig: validateRollupConfig(config),
+		rolldownConfig: validateRolldownConfig(config),
 		sourceMap: config.sourceMap === true || devMode && (config.sourceMap === "dev" || typeof config.sourceMap === "undefined"),
 		sys: config.sys ?? bootstrapConfig.sys ?? createNodeSys({ logger }),
-		testing: config.testing ?? {},
 		docs: validateDocs(config, logger),
 		transformAliasedImportPaths: isBoolean$1(userConfig.transformAliasedImportPaths) ? userConfig.transformAliasedImportPaths : true,
 		validatePrimaryPackageOutputTarget: userConfig.validatePrimaryPackageOutputTarget ?? false,
@@ -9008,7 +8672,6 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 	if (validatedConfig.buildLogFilePath) logger.setLogFilePath(validatedConfig.buildLogFilePath);
 	validatedConfig.extras.lifecycleDOMEvents = !!validatedConfig.extras.lifecycleDOMEvents;
 	validatedConfig.extras.initializeNextTick = !!validatedConfig.extras.initializeNextTick;
-	validatedConfig.extras.tagNameTransform = !!validatedConfig.extras.tagNameTransform;
 	validatedConfig.extras.additionalTagTransformers = validatedConfig.extras.additionalTagTransformers === true || !devMode && validatedConfig.extras.additionalTagTransformers === "prod";
 	validatedConfig.extras.addGlobalStyleToComponents = isBoolean$1(validatedConfig.extras.addGlobalStyleToComponents) ? validatedConfig.extras.addGlobalStyleToComponents : "client";
 	if (validatedConfig.extras.experimentalSlotFixes === true) {
@@ -9041,11 +8704,11 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 	}
 	setBooleanConfig(validatedConfig, "watch", false);
 	setBooleanConfig(validatedConfig, "buildDocs", !validatedConfig.devMode);
-	setBooleanConfig(validatedConfig, "buildDist", !validatedConfig.devMode || !!validatedConfig.buildEs5);
+	setBooleanConfig(validatedConfig, "buildDist", !validatedConfig.devMode);
 	setBooleanConfig(validatedConfig, "profile", validatedConfig.devMode);
 	setBooleanConfig(validatedConfig, "writeLog", false);
 	setBooleanConfig(validatedConfig, "buildAppCore", true);
-	setBooleanConfig(validatedConfig, "autoprefixCss", validatedConfig.buildEs5);
+	setBooleanConfig(validatedConfig, "autoprefixCss", false);
 	setBooleanConfig(validatedConfig, "validateTypes", !validatedConfig._isTesting);
 	setBooleanConfig(validatedConfig, "allowInlineScripts", true);
 	setBooleanConfig(validatedConfig, "suppressReservedPublicNameWarnings", false);
@@ -9076,10 +8739,6 @@ const validateConfig = (userConfig = {}, bootstrapConfig) => {
 		if (reg instanceof RegExp) arr.push(reg);
 		return arr;
 	}, []);
-	if (validatedConfig.nodeResolve?.customResolveOptions) {
-		const warn = buildWarn(diagnostics);
-		warn.messageText = `nodeResolve.customResolveOptions is a deprecated option in a Stencil Configuration file. If you need this option, please open a new issue in the Stencil repository (https://github.com/stenciljs/core/issues/new/choose)`;
-	}
 	CACHED_VALIDATED_CONFIG = validatedConfig;
 	return {
 		config: validatedConfig,
@@ -9107,8 +8766,6 @@ var BuildContext = class {
 	buildStats = void 0;
 	esmBrowserComponentBundle;
 	esmComponentBundle;
-	es5ComponentBundle;
-	systemComponentBundle;
 	commonJsComponentBundle;
 	diagnostics = [];
 	dirsAdded = [];
@@ -10444,39 +10101,19 @@ const outputLazyLoader = async (config, compilerCtx) => {
 };
 const generateLoader = async (config, compilerCtx, outputTarget) => {
 	const loaderPath = outputTarget.dir;
-	const es2017Dir = outputTarget.esmDir;
-	const es5Dir = outputTarget.esmEs5Dir || es2017Dir;
+	const esmDir = outputTarget.esmDir;
 	const cjsDir = outputTarget.cjsDir;
-	if (!loaderPath || !es2017Dir || !cjsDir) return;
-	const es5HtmlElement = await getClientPolyfill(config, compilerCtx, "es5-html-element.js");
-	const polyfillsExport = `export * from '${relative$1(loaderPath, join$1(es2017Dir, "polyfills/index.js"))}';`;
-	const es5EntryPoint = join$1(es5Dir, "loader.js");
-	const indexContent = filterAndJoin([
-		generatePreamble(config),
-		es5HtmlElement,
-		config.buildEs5 ? polyfillsExport : null,
-		`export * from '${relative$1(loaderPath, es5EntryPoint)}';`
-	]);
-	const es2017EntryPoint = join$1(es2017Dir, "loader.js");
-	const indexES2017Content = filterAndJoin([
-		generatePreamble(config),
-		config.buildEs5 ? polyfillsExport : null,
-		`export * from '${relative$1(loaderPath, es2017EntryPoint)}';`
-	]);
-	const cjsEntryPoint = join$1(cjsDir, "loader.cjs.js");
-	const indexCjsContent = filterAndJoin([
-		generatePreamble(config),
-		`module.exports = require('${relative$1(loaderPath, cjsEntryPoint)}');`,
-		config.buildEs5 ? `module.exports.applyPolyfills = function() { return Promise.resolve() };` : null
-	]);
+	if (!loaderPath || !esmDir) return;
+	const esmEntryPoint = join$1(esmDir, "loader.js");
+	const indexContent = filterAndJoin([generatePreamble(config), `export * from '${relative$1(loaderPath, esmEntryPoint)}';`]);
 	const indexDtsPath = join$1(loaderPath, "index.d.ts");
-	await Promise.all([
-		compilerCtx.fs.writeFile(join$1(loaderPath, "index.d.ts"), generateIndexDts(indexDtsPath, outputTarget.componentDts)),
-		compilerCtx.fs.writeFile(join$1(loaderPath, "index.js"), indexContent),
-		compilerCtx.fs.writeFile(join$1(loaderPath, "index.cjs.js"), indexCjsContent),
-		compilerCtx.fs.writeFile(join$1(loaderPath, "cdn.js"), indexCjsContent),
-		compilerCtx.fs.writeFile(join$1(loaderPath, "index.es2017.js"), indexES2017Content)
-	]);
+	const writes = [compilerCtx.fs.writeFile(join$1(loaderPath, "index.d.ts"), generateIndexDts(indexDtsPath, outputTarget.componentDts)), compilerCtx.fs.writeFile(join$1(loaderPath, "index.js"), indexContent)];
+	if (cjsDir) {
+		const cjsEntryPoint = join$1(cjsDir, "loader.cjs.js");
+		const indexCjsContent = filterAndJoin([generatePreamble(config), `module.exports = require('${relative$1(loaderPath, cjsEntryPoint)}');`]);
+		writes.push(compilerCtx.fs.writeFile(join$1(loaderPath, "index.cjs.js"), indexCjsContent), compilerCtx.fs.writeFile(join$1(loaderPath, "cdn.js"), indexCjsContent));
+	}
+	await Promise.all(writes);
 };
 const generateIndexDts = (indexDtsPath, componentsDtsPath) => {
 	return `export * from '${relativeImport(indexDtsPath, componentsDtsPath, ".d.ts")}';
@@ -10489,10 +10126,6 @@ export interface CustomElementsDefineOptions {
   rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
 }
 export declare function defineCustomElements(win?: Window, opts?: CustomElementsDefineOptions): void;
-/**
- * @deprecated
- */
-export declare function applyPolyfills(): Promise<void>;
 
 /**
  * Used to specify a nonce value that corresponds with an application's CSP.
@@ -11525,142 +11158,6 @@ const outputTypes = async (config, compilerCtx, buildCtx) => {
 	timespan.finish(`generate types finished`);
 };
 //#endregion
-//#region src/compiler/app-core/app-es5-disabled.ts
-const generateEs5DisabledMessage = async (config, compilerCtx, outputTarget) => {
-	const fileName = `${config.fsNamespace}.js`;
-	const filePath = join$1(outputTarget.buildDir, fileName);
-	await compilerCtx.fs.writeFile(filePath, getDisabledMessageScript(config));
-	return fileName;
-};
-const getDisabledMessageScript = (config) => {
-	const style = `
-<style>
-body {
-  display: block !important;
-  font-family: sans-serif;
-  padding: 20px;
-  line-height:22px;
-}
-h1 {
-  font-size: 18px;
-}
-h2 {
-  font-size: 14px;
-  margin-top: 40px;
-}
-</style>
-`;
-	const htmlLegacy = `
-  ${style}
-
-  <h1>This Stencil app is disabled for this browser.</h1>
-
-  <h2>Developers:</h2>
-  <ul>
-    <li>ES5 builds are disabled <strong>during development</strong> to take advantage of 2x faster build times.</li>
-    <li>Please see the example below or our <a href="https://stenciljs.com/docs/stencil-config" target="_blank" rel="noopener noreferrer">config docs</a> if you would like to develop on a browser that does not fully support ES2017 and custom elements.</li>
-    <li>Note that as of Stencil v2, ES5 builds and polyfills are <strong>disabled</strong> during production builds. You can enable these <a href="https://stenciljs.com/docs/config#buildes5" target="_blank" rel="noopener noreferrer">in your stencil.config.ts file</a>.</li>
-    <li>When testing browsers it is recommended to always test in production mode, and ES5 builds should always be enabled during production builds.</li>
-    <li><em>This is only an experiment and if it slows down app development then we will revert this and enable ES5 builds during dev.</em></li>
-  </ul>
-
-
-  <h2>Enabling ES5 builds during development:</h2>
-  <pre>
-    <code>npm run dev --es5</code>
-  </pre>
-  <p>For stencil-component-starter, use:</p>
-  <pre>
-    <code>npm start --es5</code>
-  </pre>
-
-
-  <h2>Enabling full production builds during development:</h2>
-  <pre>
-    <code>npm run dev --prod</code>
-  </pre>
-  <p>For stencil-component-starter, use:</p>
-  <pre>
-    <code>npm start --prod</code>
-  </pre>
-
-  <h2>Current Browser's Support:</h2>
-  <ul>
-    <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import">ES Module Imports</a>: <span id="es-modules-test"></span></li>
-    <li><a href="http://2ality.com/2017/01/import-operator.html">ES Dynamic Imports</a>: <span id="es-dynamic-modules-test"></span></li>
-    <li><a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/customElements">Custom Elements</a>: <span id="custom-elements-test"></span></li>
-    <li><a href="https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_shadow_DOM">Shadow DOM</a>: <span id="shadow-dom-test"></span></li>
-    <li><a href="https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API">fetch</a>: <span id="fetch-test"></span></li>
-    <li><a href="https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_variables">CSS Variables</a>: <span id="css-variables-test"></span></li>
-  </ul>
-
-  <h2>Current Browser:</h2>
-  <pre>
-    <code id="current-browser-output"></code>
-  </pre>
-  `;
-	const htmlUpdate = `
-  ${style}
-
-  <h1>Update src/index.html</h1>
-
-  <p>Stencil recently changed how scripts are loaded in order to improve performance.</p>
-
-  <h2>BEFORE:</h2>
-  <p>Previously, a single script was included that handled loading the correct JavaScript based on browser support.</p>
-  <pre>
-    <code>${escapeHtml(`<script src="/build/${config.fsNamespace}.js"><\/script>
-`)}</code>
-  </pre>
-
-  <h2 style="margin-top:0">AFTER:</h2>
-  <p>The index.html should now include two scripts using the modern ES Module script pattern.
-  Note that only one file will actually be requested and loaded based on the browser's native support for ES Modules.
-  For more info, please see <a href="https://developers.google.com/web/fundamentals/primers/modules#browser" target="_blank" rel="noopener noreferrer">Using JavaScript modules on the web</a>.
-  </p>
-  <pre>
-  <code>${escapeHtml(`<script`)} <span style="background:yellow">type="module"</span> src="/build/${config.fsNamespace}<span style="background:yellow">.esm</span>.js"${escapeHtml(`><\/script>`)}
-  ${escapeHtml(`<script`)} <span style="background:yellow">nomodule</span> ${escapeHtml(`src="/build/${config.fsNamespace}.js"><\/script>`)}</code>
-    </pre>
-  `;
-	return `${generatePreamble(config)}
-(function() {
-  function checkSupport() {
-    if (!document.body) {
-      setTimeout(checkSupport);
-      return;
-    }
-    function supportsDynamicImports() {
-      try {
-        new Function('import("")');
-        return true;
-      } catch {}
-      return false;
-    }
-    var supportsEsModules = !!('noModule' in document.createElement('script'));
-
-    if (!supportsEsModules) {
-      document.body.innerHTML = '${inlineHTML(htmlLegacy)}';
-
-      document.getElementById('current-browser-output').textContent = window.navigator.userAgent;
-      document.getElementById('es-modules-test').textContent = supportsEsModules;
-      document.getElementById('es-dynamic-modules-test').textContent = supportsDynamicImports();
-      document.getElementById('shadow-dom-test').textContent = !!(document.head.attachShadow);
-      document.getElementById('custom-elements-test').textContent = !!(window.customElements);
-      document.getElementById('css-variables-test').textContent = !!(window.CSS && window.CSS.supports && window.CSS.supports('color', 'var(--c)'));
-      document.getElementById('fetch-test').textContent = !!(window.fetch);
-    } else {
-      document.body.innerHTML = '${inlineHTML(htmlUpdate)}';
-    }
-  }
-
-  setTimeout(checkSupport);
-})();`;
-};
-const inlineHTML = (html) => {
-	return html.replace(/\n/g, "\\n").replace(/'/g, `\\'`).trim();
-};
-//#endregion
 //#region src/compiler/html/html-utils.ts
 /**
 * Get the path to the build directory where files written for the `www` output
@@ -12067,7 +11564,6 @@ const getCriticalPath = (buildCtx) => {
 * @param outputTarget the www output target of interest
 */
 const generateWww = async (config, compilerCtx, buildCtx, criticalPath, outputTarget) => {
-	if (!config.buildEs5) await generateEs5DisabledMessage(config, compilerCtx, outputTarget);
 	if (buildCtx.indexDoc && outputTarget.indexHtml) await generateIndexHtml(config, compilerCtx, buildCtx, criticalPath, outputTarget);
 	await generateHostConfig(compilerCtx, outputTarget);
 };
@@ -12130,7 +11626,7 @@ const generateOutputTargets = async (config, compilerCtx, buildCtx) => {
 	const timeSpan = buildCtx.createTimeSpan("generate outputs started", true);
 	const changedModuleFiles = Array.from(compilerCtx.changedModules).map((filename) => compilerCtx.moduleMap.get(filename)).filter((mod) => mod && !mod.isCollectionDependency);
 	compilerCtx.changedModules.clear();
-	invalidateRollupCaches(compilerCtx);
+	invalidateRolldownCaches(compilerCtx);
 	await Promise.all([
 		outputCollection(config, compilerCtx, buildCtx, changedModuleFiles),
 		outputCustomElements(config, compilerCtx, buildCtx),
@@ -12147,11 +11643,11 @@ const generateOutputTargets = async (config, compilerCtx, buildCtx) => {
 	]);
 	timeSpan.finish("generate outputs finished");
 };
-const invalidateRollupCaches = (compilerCtx) => {
+const invalidateRolldownCaches = (compilerCtx) => {
 	const invalidatedIds = compilerCtx.changedFiles;
-	compilerCtx.rollupCache.forEach((cache) => {
-		cache.modules.forEach((mod) => {
-			if (mod.transformDependencies.some((id) => invalidatedIds.has(id))) mod.originalCode = null;
+	compilerCtx.rolldownCache.forEach((cache) => {
+		if (cache?.modules) cache.modules.forEach((mod) => {
+			if (mod?.transformDependencies?.some((id) => invalidatedIds.has(id))) mod.originalCode = null;
 		});
 	});
 };
@@ -12278,51 +11774,439 @@ const hasChangedImportContent = async (config, compilerCtx, buildCtx, filePath,
 	return (await Promise.all(promises)).includes(true);
 };
 //#endregion
-//#region src/compiler/entries/resolve-component-dependencies.ts
-/**
-* For each entry in the provided collection of compiler metadata, generate several lists:
-* - dependencies that the component has (both directly and indirectly/transitively)
-* - dependencies that the component has (only directly)
-* - components that are dependent on a particular component (both directly and indirectly/transitively)
-* - components that are dependent on a particular component (only directly)
-*
-* This information is stored directly on each entry in the provided collection
-*
-* @param cmps the compiler metadata of the components whose dependencies and dependents ought to be calculated
-*/
-function resolveComponentDependencies(cmps) {
-	computeDependencies(cmps);
-	computeDependents(cmps);
-}
-/**
-* Compute the direct and transitive dependencies for each entry in the provided collection of component metadata.
-*
-* This function mutates each entry in the provided collection.
-*
-* @param cmps the metadata for the components whose dependencies ought to be calculated.
-*/
-function computeDependencies(cmps) {
-	const visited = /* @__PURE__ */ new Set();
-	cmps.forEach((cmp) => {
-		resolveTransitiveDependencies(cmp, cmps, visited);
-		cmp.dependencies = unique(cmp.dependencies).sort();
-	});
-}
+//#region src/compiler/transformers/decorators-to-static/decorator-utils.ts
+const getDecoratorParameters = (decorator, typeChecker, diagnostics) => {
+	if (!ts.isCallExpression(decorator.expression)) return [];
+	return decorator.expression.arguments.map((arg) => getDecoratorParameter(arg, typeChecker, diagnostics, decorator.expression));
+};
+const getDecoratorParameter = (arg, typeChecker, diagnostics, errorNode) => {
+	if (ts.isCallExpression(arg)) {
+		const expression = arg.expression;
+		if (ts.isIdentifier(expression) && expression.text === "resolveVar" || ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.name) && expression.name.text === "resolveVar") {
+			if (arg.arguments.length !== 1) {
+				const err = buildError(diagnostics);
+				err.messageText = "resolveVar() expects exactly one argument.";
+				if (errorNode) augmentDiagnosticWithNode(err, errorNode);
+				throw new Error(err.messageText);
+			}
+			const resolveArg = arg.arguments[0];
+			return resolveVariableValue(resolveArg, typeChecker, diagnostics, resolveArg);
+		}
+	}
+	if (ts.isObjectLiteralExpression(arg)) return objectLiteralToObjectMap(arg, typeChecker, diagnostics, errorNode);
+	else if (ts.isStringLiteral(arg)) return arg.text;
+	else if (ts.isPropertyAccessExpression(arg) || ts.isIdentifier(arg)) {
+		const type = typeChecker.getTypeAtLocation(arg);
+		if (type !== void 0 && type.isLiteral())
+ /**
+		* Using enums or variables require us to resolve the value for
+		* the computed property/identifier via the TS type checker. As long
+		* as the type resolves to a literal, we can grab its value to be used
+		* as the `@Watch()` decorator argument.
+		*/
+		return type.value;
+	}
+	throw new Error(`invalid decorator argument: ${arg.getText()}`);
+};
 /**
-* Compute the direct and transitive dependents for each entry in the provided collection of component metadata.
-*
-* @param cmps the component metadata whose entries will have their dependents calculated
+* Resolves a variable or object property to its string literal value at compile time.
+* Supports const variables and object properties with string literal values.
+* @param node - the expression to resolve
+* @param typeChecker - the TypeScript type checker
+* @param diagnostics - optional diagnostics array for error reporting
+* @param errorNode - optional node for error location
+* @returns the resolved string value
 */
-function computeDependents(cmps) {
-	cmps.forEach((cmp) => {
-		resolveTransitiveDependents(cmp, cmps);
-	});
-}
-/**
-* Calculate the direct and transitive dependencies of a particular component.
-*
-* For example, given a component `foo-bar` whose `render` function references another web component `baz-buzz`:
-* ```tsx
+const resolveVariableValue = (node, typeChecker, diagnostics, errorNode) => {
+	if (ts.isIdentifier(node)) {
+		const symbol = typeChecker.getSymbolAtLocation(node);
+		if (!symbol || !symbol.valueDeclaration) {
+			const err = buildError(diagnostics);
+			err.messageText = `resolveVar() cannot resolve the value of "${node.text}" at compile time. Only const variables and object properties with string literal values are supported.`;
+			if (errorNode) augmentDiagnosticWithNode(err, errorNode);
+			throw new Error(err.messageText);
+		}
+		const declaration = symbol.valueDeclaration;
+		if (ts.isVariableDeclaration(declaration)) {
+			const type = typeChecker.getTypeAtLocation(node);
+			if (type && type.isLiteral() && typeof type.value === "string") return type.value;
+			if (declaration.initializer) {
+				const initializerValue = extractStringFromExpression(declaration.initializer, typeChecker);
+				if (initializerValue !== null) return initializerValue;
+			}
+		}
+		const err = buildError(diagnostics);
+		err.messageText = `resolveVar() cannot resolve the value of "${node.text}" at compile time. Only const variables and object properties with string literal values are supported.`;
+		if (errorNode) augmentDiagnosticWithNode(err, errorNode);
+		throw new Error(err.messageText);
+	}
+	if (ts.isPropertyAccessExpression(node)) {
+		const objectType = typeChecker.getTypeAtLocation(node.expression);
+		if (!objectType) {
+			const err = buildError(diagnostics);
+			err.messageText = `resolveVar() cannot resolve the object type for "${node.getText()}" at compile time.`;
+			if (errorNode) augmentDiagnosticWithNode(err, errorNode);
+			throw new Error(err.messageText);
+		}
+		const propertyName = node.name.text;
+		const property = typeChecker.getPropertyOfType(objectType, propertyName);
+		if (!property) {
+			const err = buildError(diagnostics);
+			err.messageText = `resolveVar() cannot find property "${propertyName}" on object "${node.expression.getText()}" at compile time.`;
+			if (errorNode) augmentDiagnosticWithNode(err, errorNode);
+			throw new Error(err.messageText);
+		}
+		const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, node);
+		if (propertyType && propertyType.isLiteral() && typeof propertyType.value === "string") return propertyType.value;
+		if (property.valueDeclaration) {
+			if (ts.isPropertyDeclaration(property.valueDeclaration)) {
+				const initializer = property.valueDeclaration.initializer;
+				if (initializer) {
+					const value = extractStringFromExpression(initializer, typeChecker);
+					if (value !== null) return value;
+				}
+			} else if (ts.isPropertySignature(property.valueDeclaration)) {} else if (ts.isVariableDeclaration(property.valueDeclaration)) {
+				const initializer = property.valueDeclaration.initializer;
+				if (initializer) {
+					const value = extractStringFromExpression(initializer, typeChecker);
+					if (value !== null) return value;
+				}
+			}
+		}
+		const err = buildError(diagnostics);
+		err.messageText = `resolveVar() cannot resolve the value of "${node.getText()}" at compile time. Only const variables and object properties with string literal values are supported.`;
+		if (errorNode) augmentDiagnosticWithNode(err, errorNode);
+		throw new Error(err.messageText);
+	}
+	const err = buildError(diagnostics);
+	err.messageText = `resolveVar() can only be used with const variables or object properties. "${node.getText()}" is not supported.`;
+	if (errorNode) augmentDiagnosticWithNode(err, errorNode);
+	throw new Error(err.messageText);
+};
+/**
+* Extracts a string value from a TypeScript expression.
+* Returns null if the expression doesn't represent a string literal.
+* @param expr - the expression to extract from
+* @param typeChecker - the TypeScript type checker
+* @returns the extracted string value or null
+*/
+const extractStringFromExpression = (expr, typeChecker) => {
+	if (ts.isStringLiteral(expr)) return expr.text;
+	if (ts.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
+	const type = typeChecker.getTypeAtLocation(expr);
+	if (type && type.isLiteral() && typeof type.value === "string") return type.value;
+	return null;
+};
+/**
+* Returns a function that checks if a decorator:
+* - is a call expression. these are decorators that are immediately followed by open/close parenthesis with optional
+*   arg(s), e.g. `@Prop()`
+* - the name of the decorator matches the provided `propName`
+*
+* @param propName the name of the decorator to match against
+* @returns true if the conditions above are both true, false otherwise
+*/
+const isDecoratorNamed = (propName) => {
+	return (dec) => {
+		return ts.isCallExpression(dec.expression) && dec.expression.expression.getText() === propName;
+	};
+};
+//#endregion
+//#region src/compiler/transformers/decorators-to-static/style-to-static.ts
+const styleToStatic = (newMembers, componentOptions) => {
+	const defaultModeStyles = [];
+	if (componentOptions.styleUrls) if (Array.isArray(componentOptions.styleUrls)) defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrls));
+	else defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrls["$"]));
+	if (componentOptions.styleUrl) defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrl));
+	let styleUrls = {};
+	if (componentOptions.styleUrls && !Array.isArray(componentOptions.styleUrls)) styleUrls = normalizeStyleUrls(componentOptions.styleUrls);
+	if (defaultModeStyles.length > 0) styleUrls["$"] = defaultModeStyles;
+	if (Object.keys(styleUrls).length > 0) {
+		const originalStyleUrls = convertValueToLiteral(styleUrls);
+		newMembers.push(createStaticGetter("originalStyleUrls", originalStyleUrls));
+		const normalizedStyleExp = convertValueToLiteral(normalizeExtension(styleUrls));
+		newMembers.push(createStaticGetter("styleUrls", normalizedStyleExp));
+	}
+	if (typeof componentOptions.styles === "string") {
+		const styles = componentOptions.styles.trim();
+		if (styles.length > 0) newMembers.push(createStaticGetter("styles", ts.factory.createStringLiteral(styles)));
+	} else if (componentOptions.styles) {
+		const convertIdentifier = componentOptions.styles;
+		if (convertIdentifier.__identifier) {
+			const stylesIdentifier = convertIdentifier.__escapedText;
+			newMembers.push(createStaticGetter("styles", ts.factory.createIdentifier(stylesIdentifier)));
+		} else if (typeof convertIdentifier === "object") {
+			if (Object.keys(convertIdentifier).length > 0) newMembers.push(createStaticGetter("styles", convertValueToLiteral(convertIdentifier)));
+		}
+	}
+};
+const normalizeExtension = (styleUrls) => {
+	const compilerStyleUrls = {};
+	Object.keys(styleUrls).forEach((key) => {
+		compilerStyleUrls[key] = styleUrls[key].map((s) => useCss(s));
+	});
+	return compilerStyleUrls;
+};
+const useCss = (stylePath) => {
+	return join$1(dirname$1(stylePath), basename$1(stylePath, extname(stylePath)) + ".css");
+};
+const normalizeStyleUrls = (styleUrls) => {
+	const compilerStyleUrls = {};
+	Object.keys(styleUrls).forEach((key) => {
+		compilerStyleUrls[key] = normalizeStyleUrl(styleUrls[key]);
+	});
+	return compilerStyleUrls;
+};
+const normalizeStyleUrl = (style) => {
+	if (Array.isArray(style)) return style;
+	if (style) return [style];
+	return [];
+};
+//#endregion
+//#region src/compiler/transformers/decorators-to-static/component-decorator.ts
+let hasShownDeprecatedApiError = false;
+/**
+* Reset the deprecated API error flag. Call this at the start of each build.
+*/
+const resetDeprecatedApiWarning = () => {
+	hasShownDeprecatedApiError = false;
+};
+/**
+* Perform code generation to create new class members for a Stencil component
+* which will drive the runtime functionality specified by various options
+* passed to the `@Component` decorator.
+*
+* Inputs are validated (@see {@link validateComponent}) before code generation
+* is performed.
+*
+* **Note**: in this function and in functions that it calls the `newMembers`
+* parameter is treated as an out parameter and mutated, with new class members
+* added to it.
+*
+* @param config a user-supplied config
+* @param typeChecker a TypeScript type checker instance
+* @param diagnostics an array of diagnostics for surfacing errors and warnings
+* @param cmpNode a TypeScript class declaration node corresponding to a
+* Stencil component
+* @param newMembers an out param to hold newly generated class members
+* @param componentDecorator the TypeScript decorator node for the `@Component`
+* decorator
+*/
+const componentDecoratorToStatic = (config, typeChecker, diagnostics, cmpNode, newMembers, componentDecorator) => {
+	const [componentOptions] = getDecoratorParameters(componentDecorator, typeChecker, diagnostics);
+	if (!componentOptions) return;
+	if (!checkForDeprecatedApi(diagnostics, componentOptions, componentDecorator)) return;
+	if (!validateComponent(config, diagnostics, typeChecker, componentOptions, cmpNode, componentDecorator)) return;
+	newMembers.push(createStaticGetter("is", convertValueToLiteral(componentOptions.tag.trim())));
+	if (componentOptions.encapsulation) {
+		const enc = componentOptions.encapsulation;
+		if (enc.type === "shadow") {
+			newMembers.push(createStaticGetter("encapsulation", convertValueToLiteral("shadow")));
+			if (enc.mode === "closed") newMembers.push(createStaticGetter("shadowMode", convertValueToLiteral("closed")));
+			if (enc.delegatesFocus === true) newMembers.push(createStaticGetter("delegatesFocus", convertValueToLiteral(true)));
+			if (enc.slotAssignment === "manual") newMembers.push(createStaticGetter("slotAssignment", convertValueToLiteral("manual")));
+		} else if (enc.type === "scoped") {
+			newMembers.push(createStaticGetter("encapsulation", convertValueToLiteral("scoped")));
+			if (enc.patches && enc.patches.length > 0) newMembers.push(createStaticGetter("patches", convertValueToLiteral(enc.patches)));
+		} else if (enc.type === "none") {
+			if (enc.patches && enc.patches.length > 0) newMembers.push(createStaticGetter("patches", convertValueToLiteral(enc.patches)));
+		}
+	}
+	styleToStatic(newMembers, componentOptions);
+	const assetsDirs = componentOptions.assetsDirs || [];
+	if (assetsDirs.length > 0) newMembers.push(createStaticGetter("assetsDirs", convertValueToLiteral(assetsDirs)));
+};
+/**
+* Check for usage of deprecated API properties and emit helpful error messages.
+* Returns false if deprecated API is detected (halts compilation).
+* Only shows detailed error once per build to avoid flooding the console.
+*
+* @param diagnostics an array of diagnostics for surfacing errors
+* @param componentOptions the options passed to the `@Component` decorator
+* @param componentDecorator the TypeScript decorator node
+* @returns whether the component uses only the new API (true = valid)
+*/
+const checkForDeprecatedApi = (diagnostics, componentOptions, componentDecorator) => {
+	const deprecatedProps = [];
+	if (componentOptions.shadow !== void 0) deprecatedProps.push("shadow");
+	if (componentOptions.scoped !== void 0) deprecatedProps.push("scoped");
+	if (componentOptions.formAssociated !== void 0) deprecatedProps.push("formAssociated");
+	if (deprecatedProps.length > 0) {
+		if (!hasShownDeprecatedApiError) {
+			hasShownDeprecatedApiError = true;
+			const err = buildError(diagnostics);
+			err.messageText = `@Component() uses deprecated API removed in Stencil v5.
+
+The "shadow", "scoped", and "formAssociated" properties have been replaced:
+  • shadow: true → encapsulation: { type: "shadow" }
+  • scoped: true → encapsulation: { type: "scoped" }
+  • formAssociated: true → Use @AttachInternals() decorator
+
+Run 'npx stencil migrate --dry-run' to see all affected files.
+Run 'npx stencil migrate' to automatically update your components.`;
+			augmentDiagnosticWithNode(err, findTagNode(deprecatedProps[0], componentDecorator));
+		}
+		return false;
+	}
+	return true;
+};
+/**
+* Perform validation on a Stencil component in preparation for some
+* component-level code generation, checking that the class declaration node
+* itself doesn't have any problems and that the options passed to the
+* `@Component` decorator are valid.
+*
+* @param config a user-supplied config
+* @param diagnostics an array of diagnostics for surfacing errors and warnings
+* @param typeChecker a TypeScript type checker instance
+* @param componentOptions the options passed to the `@Component` director
+* @param cmpNode a TypeScript class declaration node corresponding to a
+* Stencil component
+* @param componentDecorator the TypeScript decorator node for the `@Component`
+* decorator
+* @returns whether or not the component is valid
+*/
+const validateComponent = (config, diagnostics, typeChecker, componentOptions, cmpNode, componentDecorator) => {
+	if (componentOptions.encapsulation) {
+		const enc = componentOptions.encapsulation;
+		if (enc.type === "shadow") {
+			if (enc.slotAssignment && enc.slotAssignment !== "manual" && enc.slotAssignment !== "named") {
+				const err = buildError(diagnostics);
+				err.messageText = `The "slotAssignment" option must be either "manual" or "named".`;
+				augmentDiagnosticWithNode(err, findTagNode("slotAssignment", componentDecorator));
+				return false;
+			}
+			if (enc.mode && enc.mode !== "open" && enc.mode !== "closed") {
+				const err = buildError(diagnostics);
+				err.messageText = `The "mode" option must be either "open" or "closed".`;
+				augmentDiagnosticWithNode(err, findTagNode("mode", componentDecorator));
+				return false;
+			}
+		}
+		if ((enc.type === "none" || enc.type === "scoped") && enc.patches) {
+			const validPatches = [
+				"all",
+				"children",
+				"clone",
+				"insert"
+			];
+			for (const patch of enc.patches) if (!validPatches.includes(patch)) {
+				const err = buildError(diagnostics);
+				err.messageText = `Invalid patch "${patch}". Valid patches are: ${validPatches.join(", ")}.`;
+				augmentDiagnosticWithNode(err, findTagNode("patches", componentDecorator));
+				return false;
+			}
+		}
+	}
+	const constructor = cmpNode.members.find(ts.isConstructorDeclaration);
+	if (constructor && constructor.parameters.length > 0) {
+		const err = buildError(diagnostics);
+		err.messageText = `Classes decorated with @Component can not have a "constructor" that takes arguments.
+    All data required by a component must be passed by using class properties decorated with @Prop()`;
+		augmentDiagnosticWithNode(err, constructor.parameters[0]);
+		return false;
+	}
+	const otherDecorator = retrieveTsDecorators(cmpNode)?.find((d) => d !== componentDecorator);
+	if (otherDecorator) {
+		const err = buildError(diagnostics);
+		err.messageText = `Classes decorated with @Component can not be decorated with more decorators.
+    Stencil performs extensive static analysis on top of your components in order to generate the necessary metadata, runtime decorators at the components level make this task very hard.`;
+		augmentDiagnosticWithNode(err, otherDecorator);
+		return false;
+	}
+	const tag = componentOptions.tag;
+	if (typeof tag !== "string" || tag.trim().length === 0) {
+		const err = buildError(diagnostics);
+		err.messageText = `tag missing in component decorator`;
+		augmentDiagnosticWithNode(err, componentDecorator);
+		return false;
+	}
+	const tagError = validateComponentTag(tag);
+	if (tagError) {
+		const err = buildError(diagnostics);
+		err.messageText = `${tagError}. Please refer to https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name for more info.`;
+		augmentDiagnosticWithNode(err, findTagNode("tag", componentDecorator));
+		return false;
+	}
+	if (!config._isTesting) {
+		const nonTypeExports = typeChecker.getExportsOfModule(typeChecker.getSymbolAtLocation(cmpNode.getSourceFile())).filter((symbol) => (symbol.flags & (ts.SymbolFlags.Interface | ts.SymbolFlags.TypeAlias | ts.SymbolFlags.Enum)) === 0).filter((symbol) => symbol.name !== cmpNode.name.text);
+		nonTypeExports.forEach((symbol) => {
+			const err = buildError(diagnostics);
+			err.messageText = `To allow efficient bundling, modules using @Component() can only have a single export which is the component class itself.
+      Any other exports should be moved to a separate file.
+      For further information check out: https://stenciljs.com/docs/module-bundling`;
+			augmentDiagnosticWithNode(err, symbol.valueDeclaration ? symbol.valueDeclaration : symbol.declarations[0]);
+		});
+		if (nonTypeExports.length > 0) return false;
+	}
+	return true;
+};
+/**
+* Given a TypeScript Decorator node, try to find a property with a given name
+* on an object possibly passed to it as an argument. If found, return the node
+* to initialize the value, and if no such property is found return the
+* decorator instead.
+*
+* @param propName the name of the argument to search for
+* @param node the decorator node to search within
+* @returns the initializer for the property (if found) or the decorator
+*/
+const findTagNode = (propName, node) => {
+	let out = node;
+	if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
+		const arg = node.expression.arguments[0];
+		if (ts.isObjectLiteralExpression(arg)) arg.properties.forEach((prop) => {
+			if (ts.isPropertyAssignment(prop) && prop.name.getText() === propName) out = prop.initializer;
+		});
+	}
+	return out;
+};
+//#endregion
+//#region src/compiler/entries/resolve-component-dependencies.ts
+/**
+* For each entry in the provided collection of compiler metadata, generate several lists:
+* - dependencies that the component has (both directly and indirectly/transitively)
+* - dependencies that the component has (only directly)
+* - components that are dependent on a particular component (both directly and indirectly/transitively)
+* - components that are dependent on a particular component (only directly)
+*
+* This information is stored directly on each entry in the provided collection
+*
+* @param cmps the compiler metadata of the components whose dependencies and dependents ought to be calculated
+*/
+function resolveComponentDependencies(cmps) {
+	computeDependencies(cmps);
+	computeDependents(cmps);
+}
+/**
+* Compute the direct and transitive dependencies for each entry in the provided collection of component metadata.
+*
+* This function mutates each entry in the provided collection.
+*
+* @param cmps the metadata for the components whose dependencies ought to be calculated.
+*/
+function computeDependencies(cmps) {
+	const visited = /* @__PURE__ */ new Set();
+	cmps.forEach((cmp) => {
+		resolveTransitiveDependencies(cmp, cmps, visited);
+		cmp.dependencies = unique(cmp.dependencies).sort();
+	});
+}
+/**
+* Compute the direct and transitive dependents for each entry in the provided collection of component metadata.
+*
+* @param cmps the component metadata whose entries will have their dependents calculated
+*/
+function computeDependents(cmps) {
+	cmps.forEach((cmp) => {
+		resolveTransitiveDependents(cmp, cmps);
+	});
+}
+/**
+* Calculate the direct and transitive dependencies of a particular component.
+*
+* For example, given a component `foo-bar` whose `render` function references another web component `baz-buzz`:
+* ```tsx
 * // foo-bar.ts
 * render() {
 *  return <baz-buzz></baz-buzz>;
@@ -12513,186 +12397,48 @@ function isJSXElWithAttrs(node) {
 }
 /**
 * Given a JSX syntax tree node update it to include a unique key attribute.
-* This will respect any attributes already set on the node, including a
-* pre-existing, user-defined `key` attribute.
-*
-* @param jsxElement a typescript JSX syntax tree node
-* @returns an updated JSX element, with a key added.
-*/
-function addKeyAttr(jsxElement) {
-	if (jsxElement.attributes.properties.some(isKeyAttr)) return jsxElement;
-	const updatedAttributes = ts.factory.createJsxAttributes([ts.factory.createJsxAttribute(ts.factory.createIdentifier("key"), ts.factory.createStringLiteral(deriveJSXKey(jsxElement))), ...jsxElement.attributes.properties]);
-	if (ts.isJsxOpeningElement(jsxElement)) return ts.factory.updateJsxOpeningElement(jsxElement, jsxElement.tagName, jsxElement.typeArguments, updatedAttributes);
-	else return ts.factory.updateJsxSelfClosingElement(jsxElement, jsxElement.tagName, jsxElement.typeArguments, updatedAttributes);
-}
-/**
-* Check whether or not a JSX attribute node (well, technically a
-* {@link ts.JsxAttributeLike} node) has the name `"key"` or not
-*
-* @param attr the JSX attribute node to check
-* @returns whether or not this node has the name 'key'
-*/
-function isKeyAttr(attr) {
-	return !!attr.name && attrNameToString(attr) === "key";
-}
-/**
-* Given a JSX attribute get its name as a string
-*
-* @param attr the attribute of interest
-* @returns the attribute's name, formatted as a string
-*/
-function attrNameToString(attr) {
-	switch (attr.name?.kind) {
-		case ts.SyntaxKind.Identifier:
-		case ts.SyntaxKind.PrivateIdentifier:
-		case ts.SyntaxKind.StringLiteral:
-		case ts.SyntaxKind.NumericLiteral: return attr.name.text;
-		case ts.SyntaxKind.JsxNamespacedName: return attr.name.getText();
-		case ts.SyntaxKind.ComputedPropertyName:
-			const expression = attr.name.expression;
-			if (ts.isStringLiteral(expression) || ts.isNumericLiteral(expression)) return expression.text;
-			return "";
-		default: return "";
-	}
-}
-//#endregion
-//#region src/compiler/transformers/decorators-to-static/decorator-utils.ts
-const getDecoratorParameters = (decorator, typeChecker, diagnostics) => {
-	if (!ts.isCallExpression(decorator.expression)) return [];
-	return decorator.expression.arguments.map((arg) => getDecoratorParameter(arg, typeChecker, diagnostics, decorator.expression));
-};
-const getDecoratorParameter = (arg, typeChecker, diagnostics, errorNode) => {
-	if (ts.isCallExpression(arg)) {
-		const expression = arg.expression;
-		if (ts.isIdentifier(expression) && expression.text === "resolveVar" || ts.isPropertyAccessExpression(expression) && ts.isIdentifier(expression.name) && expression.name.text === "resolveVar") {
-			if (arg.arguments.length !== 1) {
-				const err = buildError(diagnostics);
-				err.messageText = "resolveVar() expects exactly one argument.";
-				if (errorNode) augmentDiagnosticWithNode(err, errorNode);
-				throw new Error(err.messageText);
-			}
-			const resolveArg = arg.arguments[0];
-			return resolveVariableValue(resolveArg, typeChecker, diagnostics, resolveArg);
-		}
-	}
-	if (ts.isObjectLiteralExpression(arg)) return objectLiteralToObjectMap(arg, typeChecker, diagnostics, errorNode);
-	else if (ts.isStringLiteral(arg)) return arg.text;
-	else if (ts.isPropertyAccessExpression(arg) || ts.isIdentifier(arg)) {
-		const type = typeChecker.getTypeAtLocation(arg);
-		if (type !== void 0 && type.isLiteral())
- /**
-		* Using enums or variables require us to resolve the value for
-		* the computed property/identifier via the TS type checker. As long
-		* as the type resolves to a literal, we can grab its value to be used
-		* as the `@Watch()` decorator argument.
-		*/
-		return type.value;
-	}
-	throw new Error(`invalid decorator argument: ${arg.getText()}`);
-};
-/**
-* Resolves a variable or object property to its string literal value at compile time.
-* Supports const variables and object properties with string literal values.
-* @param node - the expression to resolve
-* @param typeChecker - the TypeScript type checker
-* @param diagnostics - optional diagnostics array for error reporting
-* @param errorNode - optional node for error location
-* @returns the resolved string value
-*/
-const resolveVariableValue = (node, typeChecker, diagnostics, errorNode) => {
-	if (ts.isIdentifier(node)) {
-		const symbol = typeChecker.getSymbolAtLocation(node);
-		if (!symbol || !symbol.valueDeclaration) {
-			const err = buildError(diagnostics);
-			err.messageText = `resolveVar() cannot resolve the value of "${node.text}" at compile time. Only const variables and object properties with string literal values are supported.`;
-			if (errorNode) augmentDiagnosticWithNode(err, errorNode);
-			throw new Error(err.messageText);
-		}
-		const declaration = symbol.valueDeclaration;
-		if (ts.isVariableDeclaration(declaration)) {
-			const type = typeChecker.getTypeAtLocation(node);
-			if (type && type.isLiteral() && typeof type.value === "string") return type.value;
-			if (declaration.initializer) {
-				const initializerValue = extractStringFromExpression(declaration.initializer, typeChecker);
-				if (initializerValue !== null) return initializerValue;
-			}
-		}
-		const err = buildError(diagnostics);
-		err.messageText = `resolveVar() cannot resolve the value of "${node.text}" at compile time. Only const variables and object properties with string literal values are supported.`;
-		if (errorNode) augmentDiagnosticWithNode(err, errorNode);
-		throw new Error(err.messageText);
-	}
-	if (ts.isPropertyAccessExpression(node)) {
-		const objectType = typeChecker.getTypeAtLocation(node.expression);
-		if (!objectType) {
-			const err = buildError(diagnostics);
-			err.messageText = `resolveVar() cannot resolve the object type for "${node.getText()}" at compile time.`;
-			if (errorNode) augmentDiagnosticWithNode(err, errorNode);
-			throw new Error(err.messageText);
-		}
-		const propertyName = node.name.text;
-		const property = typeChecker.getPropertyOfType(objectType, propertyName);
-		if (!property) {
-			const err = buildError(diagnostics);
-			err.messageText = `resolveVar() cannot find property "${propertyName}" on object "${node.expression.getText()}" at compile time.`;
-			if (errorNode) augmentDiagnosticWithNode(err, errorNode);
-			throw new Error(err.messageText);
-		}
-		const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, node);
-		if (propertyType && propertyType.isLiteral() && typeof propertyType.value === "string") return propertyType.value;
-		if (property.valueDeclaration) {
-			if (ts.isPropertyDeclaration(property.valueDeclaration)) {
-				const initializer = property.valueDeclaration.initializer;
-				if (initializer) {
-					const value = extractStringFromExpression(initializer, typeChecker);
-					if (value !== null) return value;
-				}
-			} else if (ts.isPropertySignature(property.valueDeclaration)) {} else if (ts.isVariableDeclaration(property.valueDeclaration)) {
-				const initializer = property.valueDeclaration.initializer;
-				if (initializer) {
-					const value = extractStringFromExpression(initializer, typeChecker);
-					if (value !== null) return value;
-				}
-			}
-		}
-		const err = buildError(diagnostics);
-		err.messageText = `resolveVar() cannot resolve the value of "${node.getText()}" at compile time. Only const variables and object properties with string literal values are supported.`;
-		if (errorNode) augmentDiagnosticWithNode(err, errorNode);
-		throw new Error(err.messageText);
-	}
-	const err = buildError(diagnostics);
-	err.messageText = `resolveVar() can only be used with const variables or object properties. "${node.getText()}" is not supported.`;
-	if (errorNode) augmentDiagnosticWithNode(err, errorNode);
-	throw new Error(err.messageText);
-};
+* This will respect any attributes already set on the node, including a
+* pre-existing, user-defined `key` attribute.
+*
+* @param jsxElement a typescript JSX syntax tree node
+* @returns an updated JSX element, with a key added.
+*/
+function addKeyAttr(jsxElement) {
+	if (jsxElement.attributes.properties.some(isKeyAttr)) return jsxElement;
+	const updatedAttributes = ts.factory.createJsxAttributes([ts.factory.createJsxAttribute(ts.factory.createIdentifier("key"), ts.factory.createStringLiteral(deriveJSXKey(jsxElement))), ...jsxElement.attributes.properties]);
+	if (ts.isJsxOpeningElement(jsxElement)) return ts.factory.updateJsxOpeningElement(jsxElement, jsxElement.tagName, jsxElement.typeArguments, updatedAttributes);
+	else return ts.factory.updateJsxSelfClosingElement(jsxElement, jsxElement.tagName, jsxElement.typeArguments, updatedAttributes);
+}
 /**
-* Extracts a string value from a TypeScript expression.
-* Returns null if the expression doesn't represent a string literal.
-* @param expr - the expression to extract from
-* @param typeChecker - the TypeScript type checker
-* @returns the extracted string value or null
+* Check whether or not a JSX attribute node (well, technically a
+* {@link ts.JsxAttributeLike} node) has the name `"key"` or not
+*
+* @param attr the JSX attribute node to check
+* @returns whether or not this node has the name 'key'
 */
-const extractStringFromExpression = (expr, typeChecker) => {
-	if (ts.isStringLiteral(expr)) return expr.text;
-	if (ts.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
-	const type = typeChecker.getTypeAtLocation(expr);
-	if (type && type.isLiteral() && typeof type.value === "string") return type.value;
-	return null;
-};
+function isKeyAttr(attr) {
+	return !!attr.name && attrNameToString(attr) === "key";
+}
 /**
-* Returns a function that checks if a decorator:
-* - is a call expression. these are decorators that are immediately followed by open/close parenthesis with optional
-*   arg(s), e.g. `@Prop()`
-* - the name of the decorator matches the provided `propName`
+* Given a JSX attribute get its name as a string
 *
-* @param propName the name of the decorator to match against
-* @returns true if the conditions above are both true, false otherwise
+* @param attr the attribute of interest
+* @returns the attribute's name, formatted as a string
 */
-const isDecoratorNamed = (propName) => {
-	return (dec) => {
-		return ts.isCallExpression(dec.expression) && dec.expression.expression.getText() === propName;
-	};
-};
+function attrNameToString(attr) {
+	switch (attr.name?.kind) {
+		case ts.SyntaxKind.Identifier:
+		case ts.SyntaxKind.PrivateIdentifier:
+		case ts.SyntaxKind.StringLiteral:
+		case ts.SyntaxKind.NumericLiteral: return attr.name.text;
+		case ts.SyntaxKind.JsxNamespacedName: return attr.name.getText();
+		case ts.SyntaxKind.ComputedPropertyName:
+			const expression = attr.name.expression;
+			if (ts.isStringLiteral(expression) || ts.isNumericLiteral(expression)) return expression.text;
+			return "";
+		default: return "";
+	}
+}
 //#endregion
 //#region src/compiler/transformers/decorators-to-static/attach-internals.ts
 /**
@@ -12734,236 +12480,69 @@ const attachInternalsDecoratorsToStatic = (diagnostics, decoratedMembers, newMem
 	const { staticName: name } = tsPropDeclName(decoratedProp, typeChecker);
 	const decorator = retrieveTsDecorators(decoratedProp)?.find(isDecoratorNamed(decoratorName));
 	const customStates = parseCustomStatesFromDecorator(decorator, typeChecker);
+	const formAssociated = parseFormAssociatedFromDecorator(decorator);
 	newMembers.push(createStaticGetter("attachInternalsMemberName", convertValueToLiteral(name)));
 	if (customStates.length > 0) newMembers.push(createStaticGetter("attachInternalsCustomStates", convertValueToLiteral(customStates)));
+	if (formAssociated) newMembers.push(createStaticGetter("formAssociated", convertValueToLiteral(true)));
 };
 /**
-* Parse custom states from the decorator AST, including JSDoc comments.
-*
-* Supports JSDoc comments on state properties:
-* ```ts
-* @AttachInternals({
-*   states: {
-*     hovered: false,
-*     /&#42;&#42; Whether is currently active &#42;/
-*     active: true
-*   }
-* })
-* ```
+* Parse the formAssociated option from the decorator.
+* Returns true (form-associated) unless explicitly set to false.
 *
 * @param decorator the decorator node to parse
-* @param typeChecker a TypeScript typechecker for resolving symbols
-* @returns array of custom state metadata with docs
+* @returns whether the component should be form-associated
 */
-function parseCustomStatesFromDecorator(decorator, typeChecker) {
-	if (!decorator || !ts.isCallExpression(decorator.expression)) return [];
+function parseFormAssociatedFromDecorator(decorator) {
+	if (!decorator || !ts.isCallExpression(decorator.expression)) return true;
 	const [firstArg] = decorator.expression.arguments;
-	if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) return [];
-	const statesProp = firstArg.properties.find((prop) => ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "states");
-	if (!statesProp || !ts.isObjectLiteralExpression(statesProp.initializer)) return [];
-	const customStates = [];
-	for (const prop of statesProp.initializer.properties) {
-		if (!ts.isPropertyAssignment(prop)) continue;
-		const stateName = ts.isIdentifier(prop.name) ? prop.name.text : ts.isStringLiteral(prop.name) ? prop.name.text : null;
-		if (!stateName) continue;
-		let initialValue = false;
-		if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) initialValue = true;
-		else if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword) initialValue = false;
-		const symbol = typeChecker.getSymbolAtLocation(prop.name);
-		const docs = symbol ? ts.displayPartsToString(symbol.getDocumentationComment(typeChecker)) : "";
-		customStates.push({
-			name: stateName,
-			initialValue,
-			docs
-		});
-	}
-	return customStates;
+	if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) return true;
+	const formAssociatedProp = firstArg.properties.find((prop) => ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "formAssociated");
+	if (!formAssociatedProp) return true;
+	if (formAssociatedProp.initializer.kind === ts.SyntaxKind.FalseKeyword) return false;
+	return true;
 }
-//#endregion
-//#region src/compiler/transformers/decorators-to-static/style-to-static.ts
-const styleToStatic = (newMembers, componentOptions) => {
-	const defaultModeStyles = [];
-	if (componentOptions.styleUrls) if (Array.isArray(componentOptions.styleUrls)) defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrls));
-	else defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrls["$"]));
-	if (componentOptions.styleUrl) defaultModeStyles.push(...normalizeStyleUrl(componentOptions.styleUrl));
-	let styleUrls = {};
-	if (componentOptions.styleUrls && !Array.isArray(componentOptions.styleUrls)) styleUrls = normalizeStyleUrls(componentOptions.styleUrls);
-	if (defaultModeStyles.length > 0) styleUrls["$"] = defaultModeStyles;
-	if (Object.keys(styleUrls).length > 0) {
-		const originalStyleUrls = convertValueToLiteral(styleUrls);
-		newMembers.push(createStaticGetter("originalStyleUrls", originalStyleUrls));
-		const normalizedStyleExp = convertValueToLiteral(normalizeExtension(styleUrls));
-		newMembers.push(createStaticGetter("styleUrls", normalizedStyleExp));
-	}
-	if (typeof componentOptions.styles === "string") {
-		const styles = componentOptions.styles.trim();
-		if (styles.length > 0) newMembers.push(createStaticGetter("styles", ts.factory.createStringLiteral(styles)));
-	} else if (componentOptions.styles) {
-		const convertIdentifier = componentOptions.styles;
-		if (convertIdentifier.__identifier) {
-			const stylesIdentifier = convertIdentifier.__escapedText;
-			newMembers.push(createStaticGetter("styles", ts.factory.createIdentifier(stylesIdentifier)));
-		} else if (typeof convertIdentifier === "object") {
-			if (Object.keys(convertIdentifier).length > 0) newMembers.push(createStaticGetter("styles", convertValueToLiteral(convertIdentifier)));
-		}
-	}
-};
-const normalizeExtension = (styleUrls) => {
-	const compilerStyleUrls = {};
-	Object.keys(styleUrls).forEach((key) => {
-		compilerStyleUrls[key] = styleUrls[key].map((s) => useCss(s));
-	});
-	return compilerStyleUrls;
-};
-const useCss = (stylePath) => {
-	return join$1(dirname$1(stylePath), basename$1(stylePath, extname(stylePath)) + ".css");
-};
-const normalizeStyleUrls = (styleUrls) => {
-	const compilerStyleUrls = {};
-	Object.keys(styleUrls).forEach((key) => {
-		compilerStyleUrls[key] = normalizeStyleUrl(styleUrls[key]);
-	});
-	return compilerStyleUrls;
-};
-const normalizeStyleUrl = (style) => {
-	if (Array.isArray(style)) return style;
-	if (style) return [style];
-	return [];
-};
-//#endregion
-//#region src/compiler/transformers/decorators-to-static/component-decorator.ts
-/**
-* Perform code generation to create new class members for a Stencil component
-* which will drive the runtime functionality specified by various options
-* passed to the `@Component` decorator.
-*
-* Inputs are validated (@see {@link validateComponent}) before code generation
-* is performed.
-*
-* **Note**: in this function and in functions that it calls the `newMembers`
-* parameter is treated as an out parameter and mutated, with new class members
-* added to it.
-*
-* @param config a user-supplied config
-* @param typeChecker a TypeScript type checker instance
-* @param diagnostics an array of diagnostics for surfacing errors and warnings
-* @param cmpNode a TypeScript class declaration node corresponding to a
-* Stencil component
-* @param newMembers an out param to hold newly generated class members
-* @param componentDecorator the TypeScript decorator node for the `@Component`
-* decorator
-*/
-const componentDecoratorToStatic = (config, typeChecker, diagnostics, cmpNode, newMembers, componentDecorator) => {
-	const [componentOptions] = getDecoratorParameters(componentDecorator, typeChecker, diagnostics);
-	if (!componentOptions) return;
-	if (!validateComponent(config, diagnostics, typeChecker, componentOptions, cmpNode, componentDecorator)) return;
-	newMembers.push(createStaticGetter("is", convertValueToLiteral(componentOptions.tag.trim())));
-	if (componentOptions.shadow) {
-		newMembers.push(createStaticGetter("encapsulation", convertValueToLiteral("shadow")));
-		if (typeof componentOptions.shadow !== "boolean") {
-			if (componentOptions.shadow.delegatesFocus === true) newMembers.push(createStaticGetter("delegatesFocus", convertValueToLiteral(true)));
-			if (componentOptions.shadow.slotAssignment === "manual") newMembers.push(createStaticGetter("slotAssignment", convertValueToLiteral("manual")));
-		}
-	} else if (componentOptions.scoped) newMembers.push(createStaticGetter("encapsulation", convertValueToLiteral("scoped")));
-	if (componentOptions.formAssociated === true) newMembers.push(createStaticGetter("formAssociated", convertValueToLiteral(true)));
-	styleToStatic(newMembers, componentOptions);
-	const assetsDirs = componentOptions.assetsDirs || [];
-	if (assetsDirs.length > 0) newMembers.push(createStaticGetter("assetsDirs", convertValueToLiteral(assetsDirs)));
-};
 /**
-* Perform validation on a Stencil component in preparation for some
-* component-level code generation, checking that the class declaration node
-* itself doesn't have any problems and that the options passed to the
-* `@Component` decorator are valid.
+* Parse custom states from the decorator AST, including JSDoc comments.
 *
-* @param config a user-supplied config
-* @param diagnostics an array of diagnostics for surfacing errors and warnings
-* @param typeChecker a TypeScript type checker instance
-* @param componentOptions the options passed to the `@Component` director
-* @param cmpNode a TypeScript class declaration node corresponding to a
-* Stencil component
-* @param componentDecorator the TypeScript decorator node for the `@Component`
-* decorator
-* @returns whether or not the component is valid
-*/
-const validateComponent = (config, diagnostics, typeChecker, componentOptions, cmpNode, componentDecorator) => {
-	if (componentOptions.shadow && componentOptions.scoped) {
-		const err = buildError(diagnostics);
-		err.messageText = `Components cannot be "scoped" and "shadow" at the same time, they are mutually exclusive configurations.`;
-		augmentDiagnosticWithNode(err, findTagNode("scoped", componentDecorator));
-		return false;
-	}
-	if (typeof componentOptions.shadow === "object" && componentOptions.shadow.slotAssignment) {
-		if (componentOptions.shadow.slotAssignment !== "manual" && componentOptions.shadow.slotAssignment !== "named") {
-			const err = buildError(diagnostics);
-			err.messageText = `The "slotAssignment" option must be either "manual" or "named".`;
-			augmentDiagnosticWithNode(err, findTagNode("slotAssignment", componentDecorator));
-			return false;
-		}
-	}
-	const constructor = cmpNode.members.find(ts.isConstructorDeclaration);
-	if (constructor && constructor.parameters.length > 0) {
-		const err = buildError(diagnostics);
-		err.messageText = `Classes decorated with @Component can not have a "constructor" that takes arguments.
-    All data required by a component must be passed by using class properties decorated with @Prop()`;
-		augmentDiagnosticWithNode(err, constructor.parameters[0]);
-		return false;
-	}
-	const otherDecorator = retrieveTsDecorators(cmpNode)?.find((d) => d !== componentDecorator);
-	if (otherDecorator) {
-		const err = buildError(diagnostics);
-		err.messageText = `Classes decorated with @Component can not be decorated with more decorators.
-    Stencil performs extensive static analysis on top of your components in order to generate the necessary metadata, runtime decorators at the components level make this task very hard.`;
-		augmentDiagnosticWithNode(err, otherDecorator);
-		return false;
-	}
-	const tag = componentOptions.tag;
-	if (typeof tag !== "string" || tag.trim().length === 0) {
-		const err = buildError(diagnostics);
-		err.messageText = `tag missing in component decorator`;
-		augmentDiagnosticWithNode(err, componentDecorator);
-		return false;
-	}
-	const tagError = validateComponentTag(tag);
-	if (tagError) {
-		const err = buildError(diagnostics);
-		err.messageText = `${tagError}. Please refer to https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name for more info.`;
-		augmentDiagnosticWithNode(err, findTagNode("tag", componentDecorator));
-		return false;
-	}
-	if (!config._isTesting) {
-		const nonTypeExports = typeChecker.getExportsOfModule(typeChecker.getSymbolAtLocation(cmpNode.getSourceFile())).filter((symbol) => (symbol.flags & (ts.SymbolFlags.Interface | ts.SymbolFlags.TypeAlias | ts.SymbolFlags.Enum)) === 0).filter((symbol) => symbol.name !== cmpNode.name.text);
-		nonTypeExports.forEach((symbol) => {
-			const err = buildError(diagnostics);
-			err.messageText = `To allow efficient bundling, modules using @Component() can only have a single export which is the component class itself.
-      Any other exports should be moved to a separate file.
-      For further information check out: https://stenciljs.com/docs/module-bundling`;
-			augmentDiagnosticWithNode(err, symbol.valueDeclaration ? symbol.valueDeclaration : symbol.declarations[0]);
-		});
-		if (nonTypeExports.length > 0) return false;
-	}
-	return true;
-};
-/**
-* Given a TypeScript Decorator node, try to find a property with a given name
-* on an object possibly passed to it as an argument. If found, return the node
-* to initialize the value, and if no such property is found return the
-* decorator instead.
+* Supports JSDoc comments on state properties:
+* ```ts
+* @AttachInternals({
+*   states: {
+*     hovered: false,
+*     /&#42;&#42; Whether is currently active &#42;/
+*     active: true
+*   }
+* })
+* ```
 *
-* @param propName the name of the argument to search for
-* @param node the decorator node to search within
-* @returns the initializer for the property (if found) or the decorator
+* @param decorator the decorator node to parse
+* @param typeChecker a TypeScript typechecker for resolving symbols
+* @returns array of custom state metadata with docs
 */
-const findTagNode = (propName, node) => {
-	let out = node;
-	if (ts.isDecorator(node) && ts.isCallExpression(node.expression)) {
-		const arg = node.expression.arguments[0];
-		if (ts.isObjectLiteralExpression(arg)) arg.properties.forEach((prop) => {
-			if (ts.isPropertyAssignment(prop) && prop.name.getText() === propName) out = prop.initializer;
+function parseCustomStatesFromDecorator(decorator, typeChecker) {
+	if (!decorator || !ts.isCallExpression(decorator.expression)) return [];
+	const [firstArg] = decorator.expression.arguments;
+	if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) return [];
+	const statesProp = firstArg.properties.find((prop) => ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "states");
+	if (!statesProp || !ts.isObjectLiteralExpression(statesProp.initializer)) return [];
+	const customStates = [];
+	for (const prop of statesProp.initializer.properties) {
+		if (!ts.isPropertyAssignment(prop)) continue;
+		const stateName = ts.isIdentifier(prop.name) ? prop.name.text : ts.isStringLiteral(prop.name) ? prop.name.text : null;
+		if (!stateName) continue;
+		let initialValue = false;
+		if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword) initialValue = true;
+		else if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword) initialValue = false;
+		const symbol = typeChecker.getSymbolAtLocation(prop.name);
+		const docs = symbol ? ts.displayPartsToString(symbol.getDocumentationComment(typeChecker)) : "";
+		customStates.push({
+			name: stateName,
+			initialValue,
+			docs
 		});
 	}
-	return out;
-};
+	return customStates;
+}
 //#endregion
 //#region src/compiler/transformers/decorators-to-static/decorators-constants.ts
 /**
@@ -14448,7 +14027,6 @@ const setComponentBuildConditionals = (cmpMeta) => {
 		cmpMeta.hasListenerTargetWindow = cmpMeta.listeners.some((l) => l.target === "window");
 		cmpMeta.hasListenerTargetDocument = cmpMeta.listeners.some((l) => l.target === "document");
 		cmpMeta.hasListenerTargetBody = cmpMeta.listeners.some((l) => l.target === "body");
-		cmpMeta.hasListenerTargetParent = cmpMeta.listeners.some((l) => l.target === "parent");
 		cmpMeta.hasListenerTarget = cmpMeta.listeners.some((l) => !!l.target);
 	}
 	cmpMeta.hasMember = cmpMeta.hasProp || cmpMeta.hasState || cmpMeta.hasElement || cmpMeta.hasMethod || cmpMeta.formAssociated;
@@ -14459,6 +14037,12 @@ const setComponentBuildConditionals = (cmpMeta) => {
 	}
 	cmpMeta.hasLifecycle = cmpMeta.hasComponentWillLoadFn || cmpMeta.hasComponentDidLoadFn || cmpMeta.hasComponentShouldUpdateFn || cmpMeta.hasComponentWillUpdateFn || cmpMeta.hasComponentDidUpdateFn || cmpMeta.hasComponentWillRenderFn || cmpMeta.hasComponentDidRenderFn;
 	cmpMeta.isPlain = !cmpMeta.hasMember && !cmpMeta.hasStyle && !cmpMeta.hasLifecycle && !cmpMeta.hasListener && !cmpMeta.hasVdomRender;
+	if (cmpMeta.patches) {
+		cmpMeta.hasPatchAll = !!cmpMeta.patches.all;
+		cmpMeta.hasPatchChildren = !!cmpMeta.patches.children;
+		cmpMeta.hasPatchClone = !!cmpMeta.patches.clone;
+		cmpMeta.hasPatchInsert = !!cmpMeta.patches.insert;
+	}
 };
 //#endregion
 //#region src/compiler/transformers/detect-modern-prop-decls.ts
@@ -14533,6 +14117,181 @@ const parseAttachInternalsCustomStates = (staticMembers) => {
 	}));
 	return [];
 };
+const IS_CASE_SENSITIVE_FILE_NAMES = !(process.platform === "win32");
+//#endregion
+//#region src/compiler/sys/typescript/typescript-sys.ts
+const patchTsSystemFileSystem = (config, compilerSys, inMemoryFs, tsSys) => {
+	const realpath = (path) => {
+		const rp = compilerSys.realpathSync(path);
+		if (isString$1(rp)) return rp;
+		return path;
+	};
+	const getAccessibleFileSystemEntries = (path) => {
+		try {
+			const entries = compilerSys.readDirSync(path || ".").sort();
+			const files = [];
+			const directories = [];
+			for (const absPath of entries) {
+				const stat = inMemoryFs.statSync(absPath);
+				if (!stat) continue;
+				const entry = basename$1(absPath);
+				if (stat.isFile) files.push(entry);
+				else if (stat.isDirectory) directories.push(entry);
+			}
+			return {
+				files,
+				directories
+			};
+		} catch {
+			return {
+				files: [],
+				directories: []
+			};
+		}
+	};
+	tsSys.createDirectory = (p) => {
+		compilerSys.createDirSync(p, { recursive: true });
+	};
+	tsSys.directoryExists = (p) => {
+		if (inMemoryFs) return inMemoryFs.statSync(p).isDirectory;
+		else return compilerSys.statSync(p).isDirectory;
+	};
+	tsSys.exit = compilerSys.exit;
+	tsSys.fileExists = (p) => {
+		let filePath = p;
+		if (isRemoteUrl(p)) filePath = getTypescriptPathFromUrl(config, tsSys.getExecutingFilePath(), p);
+		if (inMemoryFs) {
+			const s = inMemoryFs.statSync(filePath);
+			return !!(s && s.isFile);
+		} else {
+			const s = compilerSys.statSync(filePath);
+			return !!(s && s.isFile);
+		}
+	};
+	tsSys.getCurrentDirectory = compilerSys.getCurrentDirectory;
+	tsSys.getExecutingFilePath = () => {
+		try {
+			return __require.resolve("typescript");
+		} catch {
+			return compilerSys.getCompilerExecutingPath();
+		}
+	};
+	tsSys.getDirectories = (p) => {
+		return compilerSys.readDirSync(p).filter((itemPath) => {
+			if (inMemoryFs) {
+				const s = inMemoryFs.statSync(itemPath);
+				return !!(s && s.exists && s.isDirectory);
+			} else {
+				const s = compilerSys.statSync(itemPath);
+				return !!(s && s.isDirectory);
+			}
+		});
+	};
+	tsSys.readDirectory = (path, extensions, exclude, include, depth) => {
+		const cwd = compilerSys.getCurrentDirectory();
+		return ts.matchFiles(path, extensions, exclude, include, IS_CASE_SENSITIVE_FILE_NAMES, cwd, depth, getAccessibleFileSystemEntries, realpath);
+	};
+	tsSys.readFile = (filePath) => {
+		return inMemoryFs ? inMemoryFs.readFileSync(filePath, { useCache: false }) : compilerSys.readFileSync(filePath);
+	};
+	tsSys.writeFile = (p, data) => inMemoryFs ? inMemoryFs.writeFile(p, data) : compilerSys.writeFile(p, data);
+	return tsSys;
+};
+const patchTsSystemWatch = (compilerSystem, tsSys) => {
+	tsSys.watchDirectory = (p, cb, recursive) => {
+		const watcher = compilerSystem.watchDirectory(p, (filePath) => {
+			cb(filePath);
+		}, recursive);
+		return { close() {
+			watcher.close();
+		} };
+	};
+	tsSys.watchFile = (p, cb) => {
+		const watcher = compilerSystem.watchFile(p, (filePath, eventKind) => {
+			if (eventKind === "fileAdd") cb(filePath, ts.FileWatcherEventKind.Created);
+			else if (eventKind === "fileUpdate") cb(filePath, ts.FileWatcherEventKind.Changed);
+			else if (eventKind === "fileDelete") cb(filePath, ts.FileWatcherEventKind.Deleted);
+		});
+		return { close() {
+			watcher.close();
+		} };
+	};
+};
+const patchTypescript = (config, inMemoryFs) => {
+	if (!ts.__patched) {
+		patchTsSystemFileSystem(config, config.sys, inMemoryFs, ts.sys);
+		patchTsSystemWatch(config.sys, ts.sys);
+		ts.__patched = true;
+	}
+};
+const patchTypeScriptSysMinimum = () => {
+	if (!ts.sys) ts.sys = {
+		args: [],
+		createDirectory: noop,
+		directoryExists: () => false,
+		exit: noop,
+		fileExists: () => false,
+		getCurrentDirectory: process.cwd,
+		getDirectories: () => [],
+		getExecutingFilePath: () => "./",
+		readDirectory: () => [],
+		readFile: noop,
+		newLine: "\n",
+		resolvePath: resolve$1,
+		useCaseSensitiveFileNames: false,
+		write: noop,
+		writeFile: noop
+	};
+};
+patchTypeScriptSysMinimum();
+const getTypescriptPathFromUrl = (config, tsExecutingUrl, url) => {
+	const tsBaseUrl = new URL("..", tsExecutingUrl).href;
+	if (url.startsWith(tsBaseUrl)) {
+		const tsFilePath = url.replace(tsBaseUrl, "/");
+		return normalizePath(config.sys.getLocalModulePath({
+			rootDir: config.rootDir,
+			moduleId: "@stencil/core",
+			path: tsFilePath
+		}));
+	}
+	return url;
+};
+//#endregion
+//#region src/compiler/sys/typescript/typescript-resolve-module.ts
+const tsResolveModuleName = (config, compilerCtx, moduleName, containingFile) => {
+	const resolveModuleName = ts.__resolveModuleName || ts.resolveModuleName;
+	if (moduleName && resolveModuleName && config.tsCompilerOptions) {
+		const host = patchTsSystemFileSystem(config, config.sys, compilerCtx.fs, ts.sys);
+		const compilerOptions = { ...config.tsCompilerOptions };
+		compilerOptions.resolveJsonModule = true;
+		return resolveModuleName(moduleName, containingFile, compilerOptions, host);
+	}
+	return null;
+};
+const tsGetSourceFile = (config, module) => {
+	if (!module || !module.resolvedModule) return null;
+	const compilerOptions = { ...config.tsCompilerOptions };
+	const host = ts.createCompilerHost(compilerOptions);
+	return ts.createProgram([module.resolvedModule.resolvedFileName], compilerOptions, host).getSourceFile(module.resolvedModule.resolvedFileName);
+};
+const tsResolveModuleNamePackageJsonPath = (config, compilerCtx, moduleName, containingFile) => {
+	try {
+		const resolvedModule = tsResolveModuleName(config, compilerCtx, moduleName, containingFile);
+		if (resolvedModule && resolvedModule.resolvedModule && resolvedModule.resolvedModule.resolvedFileName) {
+			const rootDir = resolve$1("/");
+			let resolvedFileName = resolvedModule.resolvedModule.resolvedFileName;
+			for (let i = 0; i < 30; i++) {
+				if (rootDir === resolvedFileName) return null;
+				resolvedFileName = dirname$1(resolvedFileName);
+				const pkgJsonPath = join$1(resolvedFileName, "package.json");
+				if (config.sys.accessSync(pkgJsonPath)) return normalizePath(pkgJsonPath);
+			}
+		}
+	} catch (e) {
+		config.logger.error(e);
+	}
+	return null;
+};
 //#endregion
 //#region src/compiler/transformers/static-to-meta/events.ts
 const parseStaticEvents = (staticMembers) => {
@@ -15038,6 +14797,45 @@ const parseStaticSlotAssignment = (encapsulation, staticMembers) => {
 	if (encapsulation === "shadow") return getStaticValue(staticMembers, "slotAssignment") === "manual" ? "manual" : null;
 	return null;
 };
+/**
+* Find and return the shadow DOM mode for a component.
+*
+* @param encapsulation the encapsulation mode to use for a component
+* @param staticMembers a collection of static getters to search
+* @returns 'open' (default), 'closed' if explicitly set, or null if not shadow encapsulation
+*/
+const parseStaticShadowMode = (encapsulation, staticMembers) => {
+	if (encapsulation === "shadow") return getStaticValue(staticMembers, "shadowMode") === "closed" ? "closed" : "open";
+	return null;
+};
+/**
+* Find and return the per-component patches for slot handling.
+*
+* @param encapsulation the encapsulation mode to use for a component
+* @param staticMembers a collection of static getters to search
+* @returns ComponentPatches object or null if no patches defined
+*/
+const parseStaticPatches = (encapsulation, staticMembers) => {
+	if (encapsulation === "shadow") return null;
+	const patches = getStaticValue(staticMembers, "patches");
+	if (!Array.isArray(patches) || patches.length === 0) return null;
+	const result = {};
+	for (const patch of patches) switch (patch) {
+		case "all":
+			result.all = true;
+			break;
+		case "children":
+			result.children = true;
+			break;
+		case "clone":
+			result.clone = true;
+			break;
+		case "insert":
+			result.insert = true;
+			break;
+	}
+	return Object.keys(result).length > 0 ? result : null;
+};
 //#endregion
 //#region src/compiler/transformers/static-to-meta/form-associated.ts
 /**
@@ -15194,7 +14992,9 @@ const parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile,
 		elementRef: parseStaticElementRef(staticMembers),
 		encapsulation,
 		shadowDelegatesFocus: !!parseStaticShadowDelegatesFocus(encapsulation, staticMembers),
+		shadowMode: parseStaticShadowMode(encapsulation, staticMembers),
 		slotAssignment: parseStaticSlotAssignment(encapsulation, staticMembers),
+		patches: parseStaticPatches(encapsulation, staticMembers),
 		properties,
 		virtualProperties: parseVirtualProps(docs),
 		states,
@@ -15232,7 +15032,6 @@ const parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile,
 		hasListenerTargetWindow: false,
 		hasListenerTargetDocument: false,
 		hasListenerTargetBody: false,
-		hasListenerTargetParent: false,
 		hasMember: false,
 		hasMethod: false,
 		hasMode: false,
@@ -15270,7 +15069,11 @@ const parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile,
 		dependents: [],
 		dependencies: [],
 		directDependents: [],
-		directDependencies: []
+		directDependencies: [],
+		hasPatchAll: false,
+		hasPatchChildren: false,
+		hasPatchClone: false,
+		hasPatchInsert: false
 	};
 	const visitComponentChildNode = (node, ctx) => {
 		validateComponentMembers(node, ctx);
@@ -15997,21 +15800,18 @@ function generateBuildStats(config, buildCtx) {
 				minifyJs: !!config.minifyJs,
 				minifyCss: !!config.minifyCss,
 				hashFileNames: !!config.hashFileNames,
-				hashedFileNameLength: config.hashedFileNameLength,
-				buildEs5: !!config.buildEs5
+				hashedFileNameLength: config.hashedFileNameLength
 			},
 			formats: {
 				esmBrowser: sanitizeBundlesForStats(buildCtx.esmBrowserComponentBundle),
 				esm: sanitizeBundlesForStats(buildCtx.esmComponentBundle),
-				es5: sanitizeBundlesForStats(buildCtx.es5ComponentBundle),
-				system: sanitizeBundlesForStats(buildCtx.systemComponentBundle),
 				commonjs: sanitizeBundlesForStats(buildCtx.commonJsComponentBundle)
 			},
 			components: getComponentsFileMap(config, buildCtx),
 			entries: buildCtx.entryModules,
 			componentGraph: buildResults.componentGraph ?? {},
 			sourceGraph: getSourceGraph(config, buildCtx),
-			rollupResults: buildCtx.rollupResults ?? { modules: [] },
+			rolldownResults: buildCtx.rolldownResults ?? { modules: [] },
 			collections: getCollections(config, buildCtx)
 		});
 	} catch (e) {
@@ -16047,8 +15847,8 @@ function sanitizeBundlesForStats(bundleArray) {
 			components: bundle.cmps.map((c) => c.tagName),
 			bundleId: bundle.output.bundleId,
 			fileName: bundle.output.fileName,
-			imports: bundle.rollupResult.imports,
-			originalByteSize: byteSize(bundle.rollupResult.code)
+			imports: bundle.rolldownResult.imports,
+			originalByteSize: byteSize(bundle.rolldownResult.code)
 		};
 	});
 }
@@ -16641,6 +16441,7 @@ const writeBuild = async (config, compilerCtx, buildCtx) => {
 const build = async (config, compilerCtx, buildCtx, tsBuilder) => {
 	try {
 		process.chdir(config.rootDir);
+		resetDeprecatedApiWarning();
 		await emptyOutputTargets(config, compilerCtx, buildCtx);
 		if (buildCtx.hasError) return buildAbort(buildCtx);
 		if (config.srcIndexHtml) {
@@ -16775,12 +16576,12 @@ const compilerRequest = async (config, compilerCtx, data) => {
 const bundleDevModule = async (config, compilerCtx, parsedUrl, results) => {
 	const buildCtx = new BuildContext(config, compilerCtx);
 	try {
-		const inputOpts = getRollupOptions(config, compilerCtx, buildCtx, {
+		const inputOpts = getRolldownOptions(config, compilerCtx, buildCtx, {
 			id: parsedUrl.nodeModuleId,
 			platform: "client",
 			inputs: { index: parsedUrl.nodeResolvedPath }
 		});
-		const rollupBuild = await rollup(inputOpts);
+		const rolldownBuild = await rolldown(inputOpts);
 		const outputOpts = {
 			banner: generatePreamble(config),
 			format: "es"
@@ -16790,7 +16591,7 @@ const bundleDevModule = async (config, compilerCtx, parsedUrl, results) => {
 			outputOpts.intro = `/**\n * Dev Node Module: ${parsedUrl.nodeModuleId}, v${parsedUrl.nodeModuleVersion}\n * Entry: ${commentPath}\n * DEVELOPMENT PURPOSES ONLY!!\n */`;
 			inputOpts.input = parsedUrl.nodeResolvedPath;
 		}
-		const r = await rollupBuild.generate(outputOpts);
+		const r = await rolldownBuild.generate(outputOpts);
 		if (buildCtx.hasError) {
 			results.status = 500;
 			results.content = `console.error(${JSON.stringify(buildCtx.diagnostics)})`;
@@ -16983,6 +16784,7 @@ const isWatchIgnorePath = (config, path) => {
 * - No conflict with @parcel/watcher (no dual file watching)
 * - Explicit cache invalidation when files change
 * - Simpler control flow without setTimeout debouncing
+* - Persistent .tsbuildinfo file for faster cold builds
 *
 * The builder program is passed to runTsProgram which handles emit with
 * custom transformers.
@@ -17045,7 +16847,7 @@ function createCachingCompilerHost(options) {
 	});
 }
 /**
-* Incremental TypeScript compiler for watch mode.
+* Incremental TypeScript compiler for watch mode and cold builds.
 *
 * Usage:
 * 1. Create once at start: const compiler = new IncrementalCompiler(config)
@@ -17053,12 +16855,15 @@ function createCachingCompilerHost(options) {
 * 3. On file change:
 *    - compiler.invalidateFiles([changedPaths])
 *    - compiler.rebuild() // returns builder program with only changed files marked for emit
+*
+* On cold builds, reads existing .tsbuildinfo from disk to restore incremental state.
 */
 var IncrementalCompiler = class {
 	builderProgram;
 	host;
 	rootNames;
 	options;
+	hasRestoredFromDisk = false;
 	constructor(config) {
 		const optionsToExtend = getTsOptionsToExtend(config);
 		const configFile = ts.readConfigFile(config.tsconfig, ts.sys.readFile);
@@ -17079,11 +16884,21 @@ var IncrementalCompiler = class {
 	* Rebuild the TypeScript program incrementally.
 	* Returns the builder program which can be passed to runTsProgram for emit.
 	*
-	* TypeScript detects which source files have changed (via sf.version property)
-	* and only re-emits those when emit() is called.
+	* On first call (cold build), attempts to read existing .tsbuildinfo from disk
+	* to restore incremental state. TypeScript will then only re-check and re-emit
+	* files that have actually changed since the last build.
+	*
 	* @returns the builder program
 	*/
 	rebuild() {
+		if (!this.hasRestoredFromDisk && !this.builderProgram && this.options.incremental) {
+			this.hasRestoredFromDisk = true;
+			const oldProgram = ts.readBuilderProgram(this.options, this.host);
+			if (oldProgram) {
+				this.builderProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram(this.rootNames, this.options, this.host, oldProgram);
+				return this.builderProgram;
+			}
+		}
 		this.builderProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram(this.rootNames, this.options, this.host, this.builderProgram);
 		return this.builderProgram;
 	}
@@ -17102,11 +16917,12 @@ var IncrementalCompiler = class {
 		return this.builderProgram?.getProgram();
 	}
 	/**
-	* Force a full rebuild by invalidating all caches
+	* Force a full rebuild by invalidating all caches (including disk cache)
 	*/
 	invalidateAll() {
 		this.host.invalidateAll();
 		this.builderProgram = void 0;
+		this.hasRestoredFromDisk = false;
 	}
 };
 //#endregion
@@ -18433,17 +18249,16 @@ const createWorkerMainContext = (workerCtrl) => ({
 });
 //#endregion
 //#region src/compiler/optimize/autoprefixer.ts
-let cssProcessor;
 /**
-* Autoprefix a CSS string, adding vendor prefixes to make sure that what
-* is written in the CSS will render correctly in our range of supported browsers.
-* This function uses PostCSS in combination with the Autoprefix plugin to
-* automatically add vendor prefixes based on a list of browsers which we want
-* to support.
+* 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
+* query.
 *
-* @param cssText the text to be prefixed
-* @param opts an optional param with options for Autoprefixer
-* @returns a Promise wrapping some prefixed CSS as well as diagnostics
+* @param cssText the CSS text to be prefixed
+* @param opts options controlling which browsers to target, or `null` to use
+* the default browser targets
+* @returns a Promise wrapping the prefixed CSS and any diagnostics
 */
 const autoprefixCss = async (cssText, opts) => {
 	const output = {
@@ -18451,94 +18266,42 @@ const autoprefixCss = async (cssText, opts) => {
 		diagnostics: []
 	};
 	try {
-		const result = await (await getProcessor(opts != null && typeof opts === "object" ? opts : DEFAULT_AUTOPREFIX_OPTIONS)).process(cssText, { map: null });
-		result.warnings().forEach((warning) => {
-			output.diagnostics.push({
-				header: `Autoprefix CSS: ${warning.plugin}`,
-				messageText: warning.text,
-				level: "warn",
-				type: "css",
-				lines: []
-			});
-		});
-		output.output = result.css;
+		const targets = browserslistToTargets(browserslist(opts != null && typeof opts === "object" && Array.isArray(opts.targets) ? opts.targets : DEFAULT_BROWSER_TARGETS));
+		output.output = transform({
+			filename: "style.css",
+			code: Buffer.from(cssText),
+			targets,
+			minify: false
+		}).code.toString();
 	} catch (e) {
 		const diagnostic = {
 			header: `Autoprefix CSS`,
-			messageText: `CSS Error` + e,
+			messageText: `CSS Error: ${e}`,
 			level: `error`,
 			type: `css`,
 			lines: []
 		};
 		if (typeof e.name === "string") diagnostic.header = e.name;
-		if (typeof e.reason === "string") diagnostic.messageText = e.reason;
-		if (typeof e.source === "string" && typeof e.line === "number") {
-			const lines = e.source.replace(/\r/g, "\n").split("\n");
-			if (lines.length > 0) {
-				const addLine = (lineNumber) => {
-					const line = lines[lineNumber];
-					if (typeof line === "string") {
-						const printLine = {
-							lineIndex: -1,
-							lineNumber: -1,
-							text: line,
-							errorCharStart: -1,
-							errorLength: -1
-						};
-						diagnostic.lines = diagnostic.lines || [];
-						diagnostic.lines.push(printLine);
-					}
-				};
-				addLine(e.line - 3);
-				addLine(e.line - 2);
-				addLine(e.line - 1);
-				addLine(e.line);
-				addLine(e.line + 1);
-				addLine(e.line + 2);
-				addLine(e.line + 3);
-			}
-		}
+		if (typeof e.message === "string") diagnostic.messageText = e.message;
 		output.diagnostics.push(diagnostic);
 	}
 	return output;
 };
 /**
-* Get the processor for PostCSS and the Autoprefixer plugin
-*
-* @param autoprefixerOpts Options for Autoprefixer
-* @returns postCSS with the Autoprefixer plugin applied
-*/
-const getProcessor = async (autoprefixerOpts) => {
-	if (!cssProcessor) {
-		const [{ default: postcss }, { default: autoprefixer }] = await Promise.all([import("postcss"), import("autoprefixer")]);
-		cssProcessor = postcss([autoprefixer(autoprefixerOpts)]);
-	}
-	return cssProcessor;
-};
-/**
-* Default options for the Autoprefixer PostCSS plugin. See the documentation:
-* https://github.com/postcss/autoprefixer#options for a complete list.
-*
-* This default option set will:
-*
-* - override the default browser list (`overrideBrowserslist`)
-* - turn off the visual cascade (`cascade`)
-* - disable auto-removing outdated prefixes (`remove`)
-* - set `flexbox` to `"no-2009"`, which limits prefixing for flexbox to the
-*   final and IE 10 versions of the specification
+* Default browserslist targets used when autoprefixing CSS in v5.
+* Targets modern browsers — IE11, old Edge, and very old mobile browsers
+* are no longer included since Stencil v5 targets ES2017+ only.
 */
-const DEFAULT_AUTOPREFIX_OPTIONS = {
-	overrideBrowserslist: [
-		"last 2 versions",
-		"iOS >= 9",
-		"Android >= 4.4",
-		"Explorer >= 11",
-		"ExplorerMobile >= 11"
-	],
-	cascade: false,
-	remove: false,
-	flexbox: "no-2009"
-};
+const DEFAULT_BROWSER_TARGETS = [
+	"last 2 Chrome versions",
+	"last 2 Firefox versions",
+	"last 2 Safari versions",
+	"last 2 Edge versions",
+	"iOS >= 14",
+	"Android >= 6",
+	"> 0.5%",
+	"not dead"
+];
 //#endregion
 //#region src/compiler/style/css-parser/css-parse-declarations.ts
 let CssNodeType = /* @__PURE__ */ function(CssNodeType) {
@@ -19550,8 +19313,7 @@ const optimizeJs = async (inputOpts) => {
 		sourceMap: null
 	};
 	try {
-		const prettyOutput = !!inputOpts.pretty;
-		const minifyOpts = getTerserOptions({}, inputOpts.target === "es5" ? "es5" : "latest", prettyOutput);
+		const minifyOpts = getTerserOptions({}, "latest", !!inputOpts.pretty);
 		const minifyResults = await minifyJs(inputOpts.input, minifyOpts);
 		if (minifyResults.diagnostics.length > 0) result.diagnostics.push(...minifyResults.diagnostics);
 		else {
@@ -19598,13 +19360,11 @@ const minifyScriptElements = async (doc, addMinifiedAttr) => {
 	await Promise.all(scriptElms.map(async (scriptElm) => {
 		const content = scriptElm.innerHTML.trim();
 		if (content.length > 0) {
-			const opts = {
+			const optimizeResults = await optimizeJs({
 				input: content,
 				sourceMap: false,
 				target: "latest"
-			};
-			if (scriptElm.getAttribute("type") !== "module") opts.target = "es5";
-			const optimizeResults = await optimizeJs(opts);
+			});
 			if (optimizeResults.diagnostics.length === 0) scriptElm.innerHTML = optimizeResults.output;
 			if (addMinifiedAttr) scriptElm.setAttribute(dataMinifiedAttr, "");
 		}
@@ -20326,7 +20086,7 @@ const validateTsConfig = async (config, sys, init) => {
 				if (results.watchOptions) tsconfig.watchOptions = results.watchOptions;
 				if (results.options) {
 					tsconfig.compilerOptions = results.options;
-					const target = tsconfig.compilerOptions.target ?? ts.ScriptTarget.ES5;
+					const target = tsconfig.compilerOptions.target ?? ts.ScriptTarget.ES2017;
 					if ([
 						ts.ScriptTarget.ES3,
 						ts.ScriptTarget.ES5,
@@ -20334,7 +20094,7 @@ const validateTsConfig = async (config, sys, init) => {
 						ts.ScriptTarget.ES2016
 					].includes(target)) {
 						const warn = buildWarn(tsconfig.diagnostics);
-						warn.messageText = `To improve bundling, it is always recommended to set the tsconfig.json “target” setting to "es2017". Note that the compiler will automatically handle transpilation for ES5-only browsers.`;
+						warn.messageText = `Stencil requires the tsconfig.json "target" setting to be "es2017" or higher. ES5 build output is no longer supported.`;
 					}
 					if (tsconfig.compilerOptions.module !== ts.ModuleKind.ESNext && !config._isTesting) {
 						const warn = buildWarn(tsconfig.diagnostics);
@@ -21538,8 +21298,7 @@ const VALID_TARGET = new Set([
 	"es2018",
 	"es2017",
 	"es2016",
-	"es2015",
-	"es5"
+	"es2015"
 ]);
 //#endregion
 //#region src/compiler/transformers/static-to-meta/visitor.ts