@stencil/core 5.0.0-alpha.16 → 5.0.0-alpha.17

package/dist/{compiler-ip-l8MSx.mjs → compiler-CXWiPNlE.mjs}

@@ -1,8 +1,8 @@
 import { n as __require } from "./chunk-z9aeyW2b.mjs";
-import { O as HYDRATED_CSS, f as scopeCss } from "./client-DI9mAOBd.mjs";
+import { O as HYDRATED_CSS, f as scopeCss } from "./client-CgXNkftm.mjs";
 import { $ as VALID_CONFIG_OUTPUT_TARGETS, C as ASSETS, D as COLLECTION_MANIFEST_FILE_NAME, E as COLLECTION_APP_DATA_FILE_NAME, F as DOCS_README, J as STANDALONE, L as EVENT_FLAGS, O as COPY, P as DOCS_JSON, Q as TYPES, R as GENERATED_DTS, T as COLLECTION, U as LOADER_BUNDLE, X as STYLE_EXT, Y as STATS, _ as sortBy, a as fromEntries, b as toTitleCase, d as isNumber$1, et as WATCH_FLAGS, f as isObject, h as noop, i as flatOne, j as DIST_LAZY, l as isFunction, m as mergeIntoWith, n as dashToPascalCase, o as isBoolean$1, p as isString$1, u as isIterable, x as unique, y as toDashCase, z as GLOBAL_STYLE } from "./regular-expression-CFVJOTUh.mjs";
 import { $ as loadTypeScriptDiagnostics, A as isOutputTargetCollection, B as isOutputTargetGlobalStyle, Ct as formatComponentRuntimeMeta, E as getComponentsDtsSrcFilePath, Et as byteSize, F as isOutputTargetDocsCustom, G as isOutputTargetStats, H as isOutputTargetSsr, I as isOutputTargetDocsCustomElementsManifest, J as isValidConfigOutputTarget, K as isOutputTargetTypes, L as isOutputTargetDocsJson, M as isOutputTargetCustom, N as isOutputTargetDistLazy, O as getComponentsFromModules, P as isOutputTargetDocs, Q as loadTypeScriptDiagnostic, R as isOutputTargetDocsReadme, S as ok, St as isGlob, T as filterExcludedComponents, Tt as stringifyRuntimeData, U as isOutputTargetSsrWasm, V as isOutputTargetLoaderBundle, W as isOutputTargetStandalone, Y as relativeImport, Z as augmentDiagnosticWithNode, _ as getSourceMappingUrlForEndOfFile, _t as catchError, a as getTextDocs, at as relative$1, b as err, ct as isRolldownError, d as isTsxFile, dt as normalizeDiagnostics, et as join$2, f as parsePackageJson, ft as splitLineBreaks, g as getInlineSourceMappingUrlLinker, gt as buildWarn, h as isRemoteUrl, ht as buildJsonFileError, i as generatePreamble, it as normalizePath, j as isOutputTargetCopy, k as isOutputTargetAssets, lt as loadRolldownDiagnostics, m as readPackageJson, mt as buildError, n as addDocBlock, nt as normalizeFsPath, o as hasDependency, ot as resolve$2, p as readOnlyArrayHasStringMember, q as isOutputTargetWww, r as createJsVarName, rt as normalizeFsPathQuery, s as isDtsFile, st as createOnWarnFn, t as validateComponentTag, u as isTsFile, vt as hasError, w as filterActiveTargets, x as map, xt as isRootPath, y as rolldownToStencilSourceMap, yt as hasWarning, z as isOutputTargetDocsVscode } from "./validation-ByxKj8bC.mjs";
-import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-BdyxhldJ.mjs";
+import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-jFf98r0u.mjs";
 import ts, { default as ts$1 } from "typescript";
 import { readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
@@ -28,9 +28,9 @@ import { createJiti } from "jiti";
 import * as process$1 from "process";
 import { dataToEsm } from "@rollup/pluginutils";
 //#region src/version.ts
-const version = "5.0.0-alpha.16";
-const buildId = "1782306279";
-const vermoji = "🐹";
+const version = "5.0.0-alpha.17";
+const buildId = "1783170414";
+const vermoji = "🎨";
 /**
 * Get the installed version of a tool/dependency.
 * Handles packages with exports maps that point to subdirectories.
@@ -1738,16 +1738,6 @@ const isInternal = (jsDocs) => {
 	return !!(jsDocs && jsDocs.tags.some((s) => s.name === "internal"));
 };
 /**
-* Check if a class element is a method with a specific name.
-*
-* @param member - the class element to check
-* @param methodName - the method name to match
-* @returns true if the member is a method with the specified name
-*/
-const isMethod = (member, methodName) => {
-	return ts.isMethodDeclaration(member) && member.name && member.name.escapedText === methodName;
-};
-/**
 * Create an ESM import statement.
 *
 * @param importFnNames - the names to import
@@ -3094,6 +3084,7 @@ const removeCollectionImports = (compilerCtx) => {
 //#region src/compiler/bundle/entry-alias-ids.ts
 const STENCIL_CORE_ID = "@stencil/core";
 const STENCIL_INTERNAL_ID = "@stencil/core/runtime";
+const STENCIL_APP_DATA_ID = "@stencil/core/app-data";
 const STENCIL_APP_GLOBALS_ID = "@stencil/core/app-globals";
 const STENCIL_SSR_FACTORY_ID = "@stencil/core/runtime/server/ssr-factory";
 const STENCIL_INTERNAL_STANDALONE_CLIENT_PLATFORM_ID = "@stencil/core/runtime/client/standalone";
@@ -7194,6 +7185,51 @@ const getDocsCustomStates = (cmpMeta) => {
 		docs: state.docs || ""
 	})), (state) => state.name);
 };
+/**
+* Convert a single {@link d.ComponentCompilerMeta} to a {@link d.JsonDocsComponent}
+* without reading any files from disk (readme/usage are left empty).
+*
+* Useful for single-file transpilation contexts (e.g. `transpileSync`) when a
+* full build context is not available.
+* @param cmp the component metadata to convert
+* @param filePath absolute path to the component source file
+* @param rootDir project root used to make `filePath` relative (defaults to `process.cwd()`)
+* @returns a {@link d.JsonDocsComponent} with empty readme/usage
+*/
+const cmpMetaToDocsComponent = (cmp, filePath, rootDir = process.cwd()) => {
+	const normalizedFilePath = normalizePath(filePath);
+	const dirPath = normalizePath(dirname$1(normalizedFilePath));
+	const docs = cmp.docs ?? {
+		text: "",
+		tags: []
+	};
+	return {
+		dirPath,
+		filePath: normalizePath(relative$1(rootDir, normalizedFilePath), false),
+		fileName: basename$1(normalizedFilePath),
+		readmePath: normalizePath(join$2(dirPath, "readme.md")),
+		usagesDir: normalizePath(join$2(dirPath, "usage")),
+		tag: cmp.tagName,
+		readme: "",
+		overview: docs.text,
+		usage: {},
+		docs: docs.text,
+		docsTags: docs.tags,
+		encapsulation: getDocsEncapsulation(cmp),
+		dependents: cmp.directDependents ?? [],
+		dependencies: cmp.directDependencies ?? [],
+		dependencyGraph: {},
+		deprecation: getDocsDeprecationText(docs.tags),
+		props: getDocsProperties(cmp),
+		methods: getDocsMethods(cmp.methods ?? []),
+		events: getDocsEvents(cmp.events ?? []),
+		styles: getDocsStyles(cmp),
+		slots: getDocsSlots(docs.tags),
+		parts: getDocsParts(cmp.htmlParts ?? [], docs.tags),
+		customStates: getDocsCustomStates(cmp),
+		listeners: getDocsListeners(cmp.listeners ?? [])
+	};
+};
 const getNameText = (name, tags) => {
 	return tags.filter((tag) => tag.name === name && tag.text).map(({ text }) => {
 		const [namePart, ...rest] = (" " + text).split(" - ");
@@ -7367,6 +7403,19 @@ const convertTypeReferences = (references) => {
 	}));
 };
 /**
+* Converts Stencil docsTags to CEM Tag objects, skipping `@deprecated` which
+* is already conveyed by the dedicated `deprecated` CEM field.
+* @param docsTags the Stencil docsTags array
+* @returns CEM Tag array or undefined if no tags remain
+*/
+const toTags = (docsTags) => {
+	const tags = docsTags.filter((t) => t.name !== "deprecated").map((t) => ({
+		name: t.name,
+		...t.text && { text: t.text }
+	}));
+	return tags.length > 0 ? tags : void 0;
+};
+/**
 * Create a CEM Type object from a type string and optional references
 * @param text the type string
 * @param references Stencil's type references map
@@ -7392,7 +7441,8 @@ const componentToDeclaration = (component) => {
 		...prop.type && { type: createType(prop.type, prop.complexType?.references) },
 		...prop.default !== void 0 && { default: prop.default },
 		fieldName: prop.name,
-		...prop.deprecation !== void 0 && { deprecated: prop.deprecation || true }
+		...prop.deprecation !== void 0 && { deprecated: prop.deprecation || true },
+		...toTags(prop.docsTags) && { tags: toTags(prop.docsTags) }
 	}));
 	const members = [...component.props.map((prop) => ({
 		kind: "field",
@@ -7403,7 +7453,8 @@ const componentToDeclaration = (component) => {
 		...prop.deprecation !== void 0 && { deprecated: prop.deprecation || true },
 		...!prop.mutable && { readonly: true },
 		...prop.attr && { attribute: prop.attr },
-		...prop.reflectToAttr && { reflects: true }
+		...prop.reflectToAttr && { reflects: true },
+		...toTags(prop.docsTags) && { tags: toTags(prop.docsTags) }
 	})), ...component.methods.map((method) => ({
 		kind: "method",
 		name: method.name,
@@ -7417,13 +7468,15 @@ const componentToDeclaration = (component) => {
 		...method.returns && { return: {
 			...method.returns.type && { type: createType(method.returns.type, method.complexType?.references) },
 			...method.returns.docs && { description: method.returns.docs }
-		} }
+		} },
+		...toTags(method.docsTags) && { tags: toTags(method.docsTags) }
 	}))];
 	const events = component.events.map((event) => ({
 		name: event.event,
 		...event.docs && { description: event.docs },
 		type: createType(event.detail ? `CustomEvent<${event.detail}>` : "CustomEvent", event.complexType?.references),
-		...event.deprecation !== void 0 && { deprecated: event.deprecation || true }
+		...event.deprecation !== void 0 && { deprecated: event.deprecation || true },
+		...toTags(event.docsTags) && { tags: toTags(event.docsTags) }
 	}));
 	const slots = component.slots.map((slot) => ({
 		name: slot.name,
@@ -7448,13 +7501,14 @@ const componentToDeclaration = (component) => {
 		name: className,
 		...component.docs && { description: component.docs },
 		...component.deprecation !== void 0 && { deprecated: component.deprecation || true },
+		...toTags(component.docsTags) && { tags: toTags(component.docsTags) },
 		...attributes.length > 0 && { attributes },
 		...members.length > 0 && { members },
 		...events.length > 0 && { events },
 		...slots.length > 0 && { slots },
 		...cssParts.length > 0 && { cssParts },
 		...cssProperties.length > 0 && { cssProperties },
-		...component.customStates.length > 0 && { customStates: component.customStates.map((state) => ({
+		...component.customStates.length > 0 && { cssStates: component.customStates.map((state) => ({
 			name: state.name,
 			initialValue: state.initialValue,
 			...state.docs && { description: state.docs }
@@ -11198,17 +11252,24 @@ const updateNativeComponentClass = (transformOpts, classNode, moduleFile, cmp, b
 	return updateComponentClass(transformOpts, withHeritageClauses, withHeritageClauses.heritageClauses, members);
 };
 /**
-* Updates classes that are extended by Stencil components:
-* - extend `HTMLElement` if necessary
-* - ensure the constructor has a `super()` call
-* - remove static metadata properties
+* Transforms a Stencil superclass (a base class that Stencil components extend)
+* in the **full build** path, where `compilerCtx.moduleMap` is populated and the
+* module is flagged with `isExtended = true`.
+*
+* For the stateless transpile / unplugin path, use {@link updateNativeBaseClass}
+* instead — it preserves the `ClassDeclaration` form so derived components can
+* still import the base class by name.
+*
+* - Adds `extends HTMLElement` if necessary
+* - Ensures the constructor has a `super()` call
+* - Removes static metadata properties
 *
 * @param node the class node to update
 * @param moduleFile the module file containing the class
 * @param transformOpts transformation options
 * @returns the updated class node
 */
-const updateNativeExtendedClass = (node, moduleFile, transformOpts) => {
+const updateNativeSuperClass = (node, moduleFile, transformOpts) => {
 	let withHeritageClauses = updateNativeHostComponentHeritageClauses(node, moduleFile);
 	const ctor = withHeritageClauses.members.find(ts.isConstructorDeclaration);
 	if (!foundSuper(ctor?.body?.statements)) {
@@ -11232,6 +11293,26 @@ const updateNativeHostComponentHeritageClauses = (classNode, moduleFile) => {
 	return ts.factory.updateClassDeclaration(classNode, classNode.modifiers, classNode.name, classNode.typeParameters, [heritageClause], classNode.members);
 };
 /**
+* Transforms a Stencil superclass (a base class that Stencil components extend)
+* in the **stateless transpile / unplugin** path, where `compilerCtx.moduleMap`
+* is not populated.
+*
+* For the full build path, use {@link updateNativeSuperClass} instead.
+*
+* Unlike `updateNativeSuperClass` this function keeps the class as a
+* `ClassDeclaration` so the `export` modifier is preserved — derived
+* components still need to import the base class by name.
+*
+* @param node the base class declaration
+* @param moduleFile the module file (used to register the HTMLElement import)
+* @returns the updated class declaration
+*/
+const updateNativeBaseClass = (node, moduleFile) => {
+	const withHeritageClauses = updateNativeHostComponentHeritageClauses(node, moduleFile);
+	const membersWithCtor = updateConstructor(withHeritageClauses, removeStaticMetaProperties(withHeritageClauses), [], void 0, false);
+	return ts.factory.updateClassDeclaration(withHeritageClauses, withHeritageClauses.modifiers, withHeritageClauses.name, withHeritageClauses.typeParameters, withHeritageClauses.heritageClauses, membersWithCtor);
+};
+/**
 * Perform various modifications to the class members of a Stencil component
 * which are necessary for it to be a 'native' web component.
 *
@@ -11261,6 +11342,15 @@ const updateNativeHostComponentMembers = (transformOpts, classNode, moduleFile,
 };
 //#endregion
 //#region src/compiler/transformers/component-native/tranform-to-native-component.ts
+const STENCIL_META_GETTER_NAMES = [
+	"properties",
+	"states",
+	"events",
+	"listeners",
+	"watchers",
+	"methods"
+];
+const isStencilBaseClass = (node) => node.members.some((m) => isStaticGetter(m) && ts.isGetAccessorDeclaration(m) && ts.isIdentifier(m.name) && STENCIL_META_GETTER_NAMES.includes(m.name.text));
 /**
 * A function that returns a transformation factory. The returned factory
 * performs a series of transformations on Stencil components, in order to
@@ -11292,7 +11382,8 @@ const nativeComponentTransform = (compilerCtx, transformOpts, buildCtx) => {
 				if (ts.isClassDeclaration(node)) {
 					const cmp = getComponentMeta(compilerCtx, tsSourceFile, node);
 					if (cmp != null) return updateNativeComponentClass(transformOpts, node, moduleFile, cmp, buildCtx);
-					else if (compilerCtx.moduleMap.get(tsSourceFile.fileName)?.isExtended) return updateNativeExtendedClass(node, moduleFile, transformOpts);
+					else if (compilerCtx.moduleMap.get(tsSourceFile.fileName)?.isExtended) return updateNativeSuperClass(node, moduleFile, transformOpts);
+					else if (moduleFile && (isStencilBaseClass(node) || transformOpts.transformAsBaseClass)) return updateNativeBaseClass(node, moduleFile);
 				}
 				return ts.visitEachChild(node, visitNode, transformCtx);
 			};
@@ -14594,8 +14685,7 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 				if (keepLooking) buildExtendsTree(compilerCtx, foundClassDeclaration, dependentClasses, typeChecker, buildCtx, ogModule);
 				return;
 			}
-			const importStatements = currentSource.statements.filter(ts.isImportDeclaration);
-			importStatements.forEach((statement) => {
+			currentSource.statements.filter(ts.isImportDeclaration).forEach((statement) => {
 				if (statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause?.namedBindings)) statement.importClause?.namedBindings.elements.forEach((element) => {
 					if (element.name.getText() === extendee.getText()) {
 						const className = element.propertyName?.getText() || element.name.getText();
@@ -14603,11 +14693,6 @@ function buildExtendsTree(compilerCtx, classDeclaration, dependentClasses, typeC
 					}
 				});
 			});
-			if (!importStatements.length) currentSource.statements.filter(ts.isVariableStatement).forEach((statement) => {
-				statement.declarationList.declarations.forEach((declaration) => {
-					if (declaration.initializer && ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.initializer.expression) && declaration.initializer.expression.escapedText === "require" && declaration.initializer.arguments.length === 1 && ts.isStringLiteral(declaration.initializer.arguments[0])) resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, declaration.initializer.arguments[0].text.replaceAll(/['"]/g, ""), extendee.getText(), dependentClasses, typeChecker, ogModule, targetScriptTarget);
-				});
-			});
 		}
 	});
 	return dependentClasses;
@@ -14635,7 +14720,7 @@ function mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, sta
 	let listeners = parseStaticListeners(staticMembers);
 	let events = parseStaticEvents(staticMembers);
 	let watchers = parseStaticWatchers(staticMembers);
-	let classMethods = cmpNode.members.filter(ts.isMethodDeclaration);
+	let classMethods = cmpNode.members.filter(ts.isMethodDeclaration).map((m) => ts.isIdentifier(m.name) ? m.name.text : "").filter(Boolean);
 	let serializers = parseStaticSerializers(staticMembers, "serializers");
 	let deserializers = parseStaticSerializers(staticMembers, "deserializers");
 	tree.forEach((extendedClass) => {
@@ -14668,7 +14753,7 @@ function mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, sta
 		watchers = [...deDupeMembers(parseStaticWatchers(extendedStaticMembers) ?? [], watchers), ...watchers];
 		serializers = [...deDupeMembers(parseStaticSerializers(extendedStaticMembers, "serializers") ?? [], serializers), ...serializers];
 		deserializers = [...deDupeMembers(parseStaticSerializers(extendedStaticMembers, "deserializers") ?? [], deserializers), ...deserializers];
-		classMethods = [...classMethods, ...extendedClass.classNode.members.filter(ts.isMethodDeclaration) ?? []];
+		classMethods = [...classMethods, ...extendedClass.classNode.members.filter(ts.isMethodDeclaration).map((m) => ts.isIdentifier(m.name) ? m.name.text : "").filter(Boolean)];
 		if (isMixin) hasMixin = true;
 	});
 	return {
@@ -14685,23 +14770,274 @@ function mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, sta
 		deserializers
 	};
 }
+const EMPTY_DOCS = {
+	text: "",
+	tags: []
+};
+const EMPTY_PROP_COMPLEX_TYPE = {
+	original: "any",
+	resolved: "any",
+	references: {}
+};
+const EMPTY_EVENT_COMPLEX_TYPE = {
+	original: "any",
+	resolved: "any",
+	references: {}
+};
+const EMPTY_METHOD_COMPLEX_TYPE = {
+	signature: "() => void",
+	parameters: [],
+	references: {},
+	return: "void"
+};
+function extractDecoratorOptions(node) {
+	if (!node || !ts.isObjectLiteralExpression(node)) return {};
+	const result = {};
+	for (const prop of node.properties) {
+		if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+		const key = prop.name.text;
+		const val = prop.initializer;
+		if (ts.isStringLiteral(val)) result[key] = val.text;
+		else if (val.kind === ts.SyntaxKind.TrueKeyword) result[key] = true;
+		else if (val.kind === ts.SyntaxKind.FalseKeyword) result[key] = false;
+		else if (ts.isNumericLiteral(val)) result[key] = Number(val.text);
+	}
+	return result;
+}
+/**
+* Extract Stencil member metadata from source text using parse-only TypeScript
+* (no Program, no TypeChecker). Handles both decorator syntax (.tsx source files)
+* and compiled static getter syntax (.js collection files).
+*
+* @param code source text to parse
+* @param className name of the class to extract metadata from
+* @param fileName virtual filename used to determine script kind
+* @returns extracted metadata, or null if the named class is not found
+*/
+function extractInheritedMeta(code, className, fileName = "__stencil_parent__.tsx") {
+	const scriptKind = fileName.endsWith(".tsx") || fileName.endsWith(".ts") ? ts.ScriptKind.TSX : ts.ScriptKind.JS;
+	const classDecl = ts.createSourceFile(fileName, code, ts.ScriptTarget.ESNext, true, scriptKind).statements.filter(ts.isClassDeclaration).find((c) => c.name?.text === className);
+	if (!classDecl) return null;
+	const methodNames = classDecl.members.filter(ts.isMethodDeclaration).map((m) => ts.isIdentifier(m.name) ? m.name.text : "").filter(Boolean);
+	const staticMembers = classDecl.members.filter(isStaticGetter);
+	if (staticMembers.some((m) => ts.isGetAccessorDeclaration(m) && ts.isIdentifier(m.name) && [
+		"properties",
+		"states",
+		"events",
+		"listeners",
+		"watchers",
+		"methods"
+	].includes(m.name.text))) return {
+		properties: parseStaticProps(staticMembers),
+		states: parseStaticStates(staticMembers),
+		methods: parseStaticMethods(staticMembers),
+		events: parseStaticEvents(staticMembers),
+		listeners: parseStaticListeners(staticMembers),
+		watchers: parseStaticWatchers(staticMembers),
+		methodNames
+	};
+	const properties = [];
+	const states = [];
+	const methods = [];
+	const events = [];
+	const listeners = [];
+	const watchers = [];
+	for (const member of classDecl.members) {
+		if (!ts.isPropertyDeclaration(member) && !ts.isMethodDeclaration(member)) continue;
+		if (!ts.isIdentifier(member.name)) continue;
+		const memberName = member.name.text;
+		const decorators = ts.getDecorators?.(member) ?? [];
+		for (const dec of decorators) {
+			if (!ts.isCallExpression(dec.expression) || !ts.isIdentifier(dec.expression.expression)) continue;
+			const decName = dec.expression.expression.text;
+			const args = dec.expression.arguments;
+			if (decName === "Prop" && ts.isPropertyDeclaration(member)) {
+				const opts = extractDecoratorOptions(args[0]);
+				properties.push({
+					name: memberName,
+					attribute: typeof opts.attribute === "string" ? opts.attribute.toLowerCase() : toDashCase(memberName),
+					reflect: !!opts.reflect,
+					mutable: !!opts.mutable,
+					required: false,
+					optional: !!member.questionToken,
+					type: "any",
+					complexType: EMPTY_PROP_COMPLEX_TYPE,
+					docs: EMPTY_DOCS,
+					internal: false,
+					getter: false,
+					setter: false
+				});
+			} else if (decName === "State" && ts.isPropertyDeclaration(member)) states.push({ name: memberName });
+			else if (decName === "Event" && ts.isPropertyDeclaration(member)) {
+				const opts = extractDecoratorOptions(args[0]);
+				events.push({
+					name: typeof opts.eventName === "string" ? opts.eventName : memberName,
+					method: memberName,
+					bubbles: opts.bubbles !== false,
+					cancelable: opts.cancelable !== false,
+					composed: !!opts.composed,
+					docs: EMPTY_DOCS,
+					complexType: EMPTY_EVENT_COMPLEX_TYPE,
+					internal: false
+				});
+			} else if (decName === "Method" && ts.isMethodDeclaration(member)) methods.push({
+				name: memberName,
+				docs: EMPTY_DOCS,
+				complexType: EMPTY_METHOD_COMPLEX_TYPE,
+				internal: false
+			});
+			else if (decName === "Watch" && ts.isMethodDeclaration(member)) {
+				const propName = ts.isStringLiteral(args[0]) ? args[0].text : null;
+				if (propName) watchers.push({
+					propName,
+					methodName: memberName
+				});
+			} else if (decName === "Listen" && ts.isMethodDeclaration(member)) {
+				const eventName = ts.isStringLiteral(args[0]) ? args[0].text : null;
+				if (eventName) {
+					const listenOpts = extractDecoratorOptions(args[1]);
+					listeners.push({
+						name: eventName,
+						method: memberName,
+						capture: !!listenOpts.capture,
+						passive: !!listenOpts.passive,
+						target: typeof listenOpts.target === "string" ? listenOpts.target : void 0
+					});
+				}
+			}
+		}
+	}
+	return {
+		properties,
+		states,
+		methods,
+		events,
+		listeners,
+		watchers,
+		methodNames
+	};
+}
+function getExtendsClassName(node) {
+	const heritage = node.heritageClauses?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword);
+	if (!heritage?.types.length) return null;
+	const expr = heritage.types[0].expression;
+	return ts.isIdentifier(expr) ? expr.text : null;
+}
+function findImportSpecifier(sf, localName) {
+	for (const stmt of sf.statements) {
+		if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier)) continue;
+		const clause = stmt.importClause;
+		if (!clause) continue;
+		if (clause.name?.text === localName) return stmt.moduleSpecifier.text;
+		const bindings = clause.namedBindings;
+		if (bindings && ts.isNamedImports(bindings)) {
+			for (const el of bindings.elements) if (el.name.text === localName) return stmt.moduleSpecifier.text;
+		}
+	}
+	return null;
+}
+/**
+* Resolves the inheritance chain for a component using a caller-supplied
+* `resolveImport` callback instead of the full compiler infrastructure.
+* Safe to call from `transpileSync`/`transpileAsync` (no TypeChecker needed).
+*
+* @param cmpNode the component's class declaration
+* @param staticMembers static getter members already parsed from the component
+* @param sourceFile the source file containing the component (for import resolution)
+* @param resolveImport callback that resolves an import specifier to source code
+* @returns merged metadata including all inherited members
+*/
+function mergeExtendedClassMetaWithResolveImport(cmpNode, staticMembers, sourceFile, resolveImport) {
+	let doesExtend = false;
+	let properties = parseStaticProps(staticMembers);
+	let states = parseStaticStates(staticMembers);
+	let methods = parseStaticMethods(staticMembers);
+	let listeners = parseStaticListeners(staticMembers);
+	let events = parseStaticEvents(staticMembers);
+	let watchers = parseStaticWatchers(staticMembers);
+	let classMethods = cmpNode.members.filter(ts.isMethodDeclaration).map((m) => ts.isIdentifier(m.name) ? m.name.text : "").filter(Boolean);
+	const serializers = [];
+	const deserializers = [];
+	let currentNode = cmpNode;
+	let currentSf = sourceFile;
+	let currentPath = sourceFile.fileName;
+	const visited = /* @__PURE__ */ new Set();
+	while (true) {
+		const parentClassName = getExtendsClassName(currentNode);
+		if (!parentClassName) break;
+		const specifier = findImportSpecifier(currentSf, parentClassName);
+		if (!specifier) break;
+		const resolved = resolveImport(specifier, currentPath);
+		if (!resolved) break;
+		const { code, path: resolvedPath } = resolved;
+		if (visited.has(resolvedPath)) break;
+		visited.add(resolvedPath);
+		const isTs = resolvedPath.endsWith(".tsx") || resolvedPath.endsWith(".ts");
+		const parentSf = ts.createSourceFile(resolvedPath, code, ts.ScriptTarget.ESNext, true, isTs ? ts.ScriptKind.TSX : ts.ScriptKind.JS);
+		const parentClass = parentSf.statements.filter(ts.isClassDeclaration).find((c) => c.name?.text === parentClassName);
+		if (!parentClass) break;
+		const parentStaticMembers = parentClass.members.filter(isStaticGetter);
+		const parentMeta = parentStaticMembers.some((m) => ts.isGetAccessorDeclaration(m) && ts.isIdentifier(m.name) && [
+			"properties",
+			"states",
+			"events",
+			"listeners",
+			"watchers",
+			"methods"
+		].includes(m.name.text)) ? {
+			properties: parseStaticProps(parentStaticMembers),
+			states: parseStaticStates(parentStaticMembers),
+			methods: parseStaticMethods(parentStaticMembers),
+			events: parseStaticEvents(parentStaticMembers),
+			listeners: parseStaticListeners(parentStaticMembers),
+			watchers: parseStaticWatchers(parentStaticMembers),
+			methodNames: parentClass.members.filter(ts.isMethodDeclaration).map((m) => ts.isIdentifier(m.name) ? m.name.text : "").filter(Boolean)
+		} : extractInheritedMeta(code, parentClassName, resolvedPath);
+		if (!parentMeta) break;
+		doesExtend = true;
+		const mixinPropsExcludingStates = parentMeta.properties.filter((mp) => !states.some((s) => s.name === mp.name));
+		const mixinStatesExcludingProps = parentMeta.states.filter((ms) => !properties.some((p) => p.name === ms.name));
+		properties = [...deDupeMembers(mixinPropsExcludingStates, properties), ...properties];
+		states = [...deDupeMembers(mixinStatesExcludingProps, states), ...states];
+		methods = [...deDupeMembers(parentMeta.methods, methods), ...methods];
+		events = [...deDupeMembers(parentMeta.events, events), ...events];
+		listeners = [...deDupeMembers(parentMeta.listeners, listeners), ...listeners];
+		watchers = [...deDupeMembers(parentMeta.watchers, watchers), ...watchers];
+		classMethods = [...classMethods, ...parentMeta.methodNames];
+		currentNode = parentClass;
+		currentSf = parentSf;
+		currentPath = resolvedPath;
+	}
+	return {
+		doesExtend,
+		properties,
+		states,
+		methods,
+		listeners,
+		events,
+		watchers,
+		classMethods,
+		serializers,
+		deserializers
+	};
+}
 //#endregion
 //#region src/compiler/transformers/static-to-meta/class-methods.ts
 const parseClassMethods = (classMethods, cmpMeta) => {
 	if (!classMethods?.length) return;
-	const hasHostData = classMethods.some((m) => isMethod(m, "hostData"));
-	cmpMeta.hasAttributeChangedCallbackFn = classMethods.some((m) => isMethod(m, "attributeChangedCallback"));
-	cmpMeta.hasConnectedCallbackFn = classMethods.some((m) => isMethod(m, "connectedCallback"));
-	cmpMeta.hasDisconnectedCallbackFn = classMethods.some((m) => isMethod(m, "disconnectedCallback"));
-	cmpMeta.hasComponentWillLoadFn = classMethods.some((m) => isMethod(m, "componentWillLoad"));
-	cmpMeta.hasComponentWillUpdateFn = classMethods.some((m) => isMethod(m, "componentWillUpdate"));
-	cmpMeta.hasComponentWillRenderFn = classMethods.some((m) => isMethod(m, "componentWillRender"));
-	cmpMeta.hasComponentDidRenderFn = classMethods.some((m) => isMethod(m, "componentDidRender"));
-	cmpMeta.hasComponentDidLoadFn = classMethods.some((m) => isMethod(m, "componentDidLoad"));
-	cmpMeta.hasComponentShouldUpdateFn = classMethods.some((m) => isMethod(m, "componentShouldUpdate"));
-	cmpMeta.hasComponentDidUpdateFn = classMethods.some((m) => isMethod(m, "componentDidUpdate"));
+	const hasHostData = classMethods.includes("hostData");
+	cmpMeta.hasAttributeChangedCallbackFn = classMethods.includes("attributeChangedCallback");
+	cmpMeta.hasConnectedCallbackFn = classMethods.includes("connectedCallback");
+	cmpMeta.hasDisconnectedCallbackFn = classMethods.includes("disconnectedCallback");
+	cmpMeta.hasComponentWillLoadFn = classMethods.includes("componentWillLoad");
+	cmpMeta.hasComponentWillUpdateFn = classMethods.includes("componentWillUpdate");
+	cmpMeta.hasComponentWillRenderFn = classMethods.includes("componentWillRender");
+	cmpMeta.hasComponentDidRenderFn = classMethods.includes("componentDidRender");
+	cmpMeta.hasComponentDidLoadFn = classMethods.includes("componentDidLoad");
+	cmpMeta.hasComponentShouldUpdateFn = classMethods.includes("componentShouldUpdate");
+	cmpMeta.hasComponentDidUpdateFn = classMethods.includes("componentDidUpdate");
 	cmpMeta.hasLifecycle = cmpMeta.hasComponentWillLoadFn || cmpMeta.hasComponentDidLoadFn || cmpMeta.hasComponentWillUpdateFn || cmpMeta.hasComponentDidUpdateFn;
-	cmpMeta.hasRenderFn = classMethods.some((m) => isMethod(m, "render")) || hasHostData;
+	cmpMeta.hasRenderFn = classMethods.includes("render") || hasHostData;
 	cmpMeta.hasVdomRender = cmpMeta.hasVdomRender || hasHostData;
 };
 //#endregion
@@ -14955,7 +15291,7 @@ const parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile,
 	const staticMembers = cmpNode.members.filter(isStaticGetter);
 	const tagName = getComponentTagName(staticMembers);
 	if (tagName == null) return cmpNode;
-	const { doesExtend, properties, states, methods, listeners, events, watchers, classMethods, serializers, deserializers } = mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, staticMembers, moduleFile);
+	const { doesExtend, properties, states, methods, listeners, events, watchers, classMethods, serializers, deserializers } = transformOpts?.resolveImport ? mergeExtendedClassMetaWithResolveImport(cmpNode, staticMembers, moduleFile.staticSourceFile, transformOpts.resolveImport) : mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, staticMembers, moduleFile);
 	const docs = serializeSymbol(typeChecker, typeChecker ? typeChecker.getSymbolAtLocation(cmpNode.name) : void 0);
 	const isCollectionDependency = moduleFile.isCollectionDependency;
 	const encapsulation = parseStaticEncapsulation(staticMembers);
@@ -22792,7 +23128,9 @@ const getTranspileConfig = (input) => {
 		style: compileOpts.style,
 		styleImportData: compileOpts.styleImportData,
 		target: compileOpts.target,
-		extraFiles: input.extraFiles
+		resolveImport: input.resolveImport,
+		transformAsBaseClass: input.transformAsBaseClass,
+		buildOverrides: input.buildOverrides
 	};
 	return {
 		compileOpts,
@@ -22920,21 +23258,8 @@ const transpileModule = (config, input, transformOpts) => {
 	if (tsCompilerOptions.jsx != null && !isAutomaticRuntime && !isString$1(tsCompilerOptions.jsxFragmentFactory)) tsCompilerOptions.jsxFragmentFactory = "Fragment";
 	if (tsCompilerOptions.paths && !isString$1(tsCompilerOptions.baseUrl)) tsCompilerOptions.baseUrl = ".";
 	const sourceFile = ts.createSourceFile(sourceFilePath, input, tsCompilerOptions.target);
-	const extraSourceFiles = /* @__PURE__ */ new Map();
-	if (transformOpts.extraFiles) {
-		const currentDir = normalizePath(transformOpts.currentDirectory || process.cwd());
-		for (const [filePath, text] of Object.entries(transformOpts.extraFiles)) {
-			const resolvedPath = normalizePath(filePath.startsWith("/") ? filePath : join$2(currentDir, filePath));
-			extraSourceFiles.set(resolvedPath, ts.createSourceFile(resolvedPath, text, tsCompilerOptions.target));
-		}
-		tsCompilerOptions.noResolve = false;
-	}
-	const compilerHost = {
-		getSourceFile: (fileName) => {
-			const normalized = normalizePath(fileName);
-			if (normalized === normalizePath(sourceFilePath)) return sourceFile;
-			return extraSourceFiles.get(normalized);
-		},
+	const program = ts.createProgram([sourceFilePath], tsCompilerOptions, {
+		getSourceFile: (fileName) => normalizePath(fileName) === normalizePath(sourceFilePath) ? sourceFile : void 0,
 		writeFile: (name, text) => {
 			if (name.endsWith(".js.map") || name.endsWith(".mjs.map")) results.map = text;
 			else if (name.endsWith(".js") || name.endsWith(".mjs")) results.code = text;
@@ -22944,45 +23269,12 @@ const transpileModule = (config, input, transformOpts) => {
 		getCanonicalFileName: (fileName) => fileName,
 		getCurrentDirectory: () => transformOpts.currentDirectory || process.cwd(),
 		getNewLine: () => ts.sys.newLine || "\n",
-		fileExists: (fileName) => {
-			const normalized = normalizePath(fileName);
-			return normalized === normalizePath(sourceFilePath) || extraSourceFiles.has(normalized);
-		},
+		fileExists: (fileName) => normalizePath(fileName) === normalizePath(sourceFilePath),
 		readFile: () => "",
 		directoryExists: () => true,
 		getDirectories: () => []
-	};
-	const program = ts.createProgram([sourceFilePath, ...extraSourceFiles.keys()], tsCompilerOptions, compilerHost);
+	});
 	const typeChecker = program.getTypeChecker();
-	if (extraSourceFiles.size > 0) {
-		const miniCompilerHost = {
-			getSourceFile: (fileName) => extraSourceFiles.get(normalizePath(fileName)),
-			writeFile: () => {},
-			getDefaultLibFileName: () => "lib.d.ts",
-			useCaseSensitiveFileNames: () => false,
-			getCanonicalFileName: (f) => f,
-			getCurrentDirectory: () => transformOpts.currentDirectory || process.cwd(),
-			getNewLine: () => ts.sys.newLine || "\n",
-			fileExists: (f) => extraSourceFiles.has(normalizePath(f)),
-			readFile: () => "",
-			directoryExists: () => true,
-			getDirectories: () => []
-		};
-		const miniProgram = ts.createProgram([...extraSourceFiles.keys()], {
-			...tsCompilerOptions,
-			noResolve: true
-		}, miniCompilerHost);
-		const miniTypeChecker = miniProgram.getTypeChecker();
-		const decoratorConverter = convertDecoratorsToStatic(config, buildCtx.diagnostics, miniTypeChecker, miniProgram);
-		for (const [resolvedPath, rawSource] of extraSourceFiles) {
-			const transformResult = ts.transform(rawSource, [decoratorConverter], tsCompilerOptions);
-			const processedSource = transformResult.transformed[0];
-			transformResult.dispose();
-			const moduleFile = getModuleLegacy(compilerCtx, resolvedPath);
-			moduleFile.staticSourceFile = processedSource;
-			moduleFile.staticSourceFileText = processedSource.getFullText?.() ?? rawSource.text;
-		}
-	}
 	const transformers = {
 		before: [
 			convertDecoratorsToStatic(config, buildCtx.diagnostics, typeChecker, program),
@@ -22998,8 +23290,11 @@ const transpileModule = (config, input, transformOpts) => {
 	}
 	if (transformOpts.componentExport === "customelement" || transformOpts.componentExport === "module") transformers.after.push(nativeComponentTransform(compilerCtx, transformOpts, buildCtx));
 	else transformers.after.push(lazyComponentTransform(compilerCtx, transformOpts, buildCtx));
-	const emitTarget = extraSourceFiles.size > 0 ? program.getSourceFile(sourceFilePath) : void 0;
-	program.emit(emitTarget, void 0, void 0, false, transformers);
+	program.emit(void 0, void 0, void 0, false, transformers);
+	if (transformOpts.buildOverrides && results.code) {
+		const mutations = Object.entries(transformOpts.buildOverrides).filter(([, v]) => v !== void 0).map(([k, v]) => `__stencilBUILD.${k}=${v};`).join("");
+		if (mutations) results.code = `import{BUILD as __stencilBUILD}from"${STENCIL_APP_DATA_ID}";\n${mutations}\n` + results.code;
+	}
 	const tsDiagnostics = [...program.getSyntacticDiagnostics()];
 	if (config.validateTypes) tsDiagnostics.push(...program.getOptionsDiagnostics());
 	buildCtx.diagnostics.push(...loadTypeScriptDiagnostics(tsDiagnostics));
@@ -23097,7 +23392,11 @@ const transpileCode = (config, transpileOpts, transformOpts, results) => {
 	if (moduleFile) {
 		results.outputFilePath = moduleFile.jsFilePath;
 		moduleFile.cmps.forEach((cmp) => {
-			results.data.push(getPublicCompilerMeta(cmp));
+			results.data.push({
+				...getPublicCompilerMeta(cmp),
+				docs: cmp.docs,
+				styleDocs: cmp.styleDocs
+			});
 		});
 		moduleFile.originalImports.forEach((originalImport) => {
 			results.imports.push({ path: originalImport });
@@ -23134,4 +23433,4 @@ const shouldTranspileModule = (ext) => [
 	"js"
 ].includes(ext);
 //#endregion
-export { getBuildFeatures as _, createPrerenderer as a, version as b, createWorkerContext as c, nodeRequire as d, optimizeCss as f, BuildContext as g, Cache as h, createSystem as i, createWorkerMessageHandler as l, validateConfig as m, transpile as n, loadConfig as o, createInMemoryFs as p, transpileSync as r, createCompiler as s, ts$1 as t, optimizeJs as u, buildId as v, versions as x, vermoji as y };
+export { version as C, vermoji as S, cmpMetaToDocsComponent as _, createPrerenderer as a, getBuildFeatures as b, createWorkerContext as c, nodeRequire as d, optimizeCss as f, generateManifest as g, Cache as h, createSystem as i, createWorkerMessageHandler as l, validateConfig as m, transpile as n, loadConfig as o, createInMemoryFs as p, transpileSync as r, createCompiler as s, ts$1 as t, optimizeJs as u, BuildContext as v, versions as w, buildId as x, getScopeId as y };