@stencil/core 5.0.0-beta.26 → 5.0.0-beta.28

package/dist/{compiler-D7LTP5Hp.mjs → compiler-BQcDWWEp.mjs}

@@ -1,9 +1,9 @@
 import { n as __require } from "./rolldown-runtime-BhDjJH2R.mjs";
-import { E as SERVER_BUILD_FLAGS, T as HYDRATED_CSS, w as CLIENT_BUILD_FLAGS } from "./client-CVXS3JZ-.mjs";
+import { E as SERVER_BUILD_FLAGS, T as HYDRATED_CSS, w as CLIENT_BUILD_FLAGS } from "./client-BYvfR_Hx.mjs";
 import { $ as VALID_CONFIG_OUTPUT_TARGETS, A as DIST_LAZY, D as COPY, E as COLLECTION_MANIFEST_FILE_NAME, J as STANDALONE, L as EVENT_FLAGS, P as DOCS_JSON, Q as TYPES, R as GENERATED_DTS, S as ASSETS, T as COLLECTION_APP_DATA_FILE_NAME, U as LOADER_BUNDLE, X as STYLE_EXT, Y as STATS, a as isBoolean$1, b as unique, c as isFunction, d as isObject, et as WATCH_FLAGS, f as isString$1, g as sortBy, i as fromEntries, l as isIterable, m as noop, p as mergeIntoWith, r as flatOne, t as dashToPascalCase, u as isNumber$1, v as toDashCase, w as COLLECTION, y as toTitleCase, z as GLOBAL_STYLE } from "./helpers-Cpp3qc3u.mjs";
 import { E as escapeRegExpSpecialCharacters, S as formatComponentRuntimeMeta, T as byteSize, _ as loadRolldownDiagnostics, a as getSourceMappingUrlForEndOfFile, b as splitLineBreaks, c as err, f as augmentDiagnosticWithNode, g as isRolldownError, h as createOnWarnFn, i as getInlineSourceMappingUrlLinker, l as map, m as loadTypeScriptDiagnostics, n as validateComponentTag, p as loadTypeScriptDiagnostic, r as isRemoteUrl, s as rolldownToStencilSourceMap, t as validateComponentModes, u as ok, w as stringifyRuntimeData, x as isRootPath, y as normalizeDiagnostics } from "./validation-DAdGTrys.mjs";
 import { $ as catchError, A as isOutputTargetDocsVscode, B as relativeImport, C as isOutputTargetDistLazy, D as isOutputTargetDocsCustomElementsManifest, E as isOutputTargetDocsCustom, F as isOutputTargetStandalone, G as normalizeFsPathQuery, H as join$2, I as isOutputTargetStats, J as resolve$2, K as normalizePath, L as isOutputTargetTypes, M as isOutputTargetLoaderBundle, N as isOutputTargetSsr, O as isOutputTargetDocsJson, P as isOutputTargetSsrWasm, Q as buildWarn, R as isOutputTargetWww, S as isOutputTargetCustom, T as isOutputTargetDocsAgentSkill, V as shouldExcludeComponent, W as normalizeFsPath, X as buildError, Z as buildJsonFileError, a as hasDependency, b as isOutputTargetCollection, d as parsePackageJson, et as hasError, f as readOnlyArrayHasStringMember, g as getComponentsDtsSrcFilePath, h as filterExcludedComponents, i as getTextDocs, j as isOutputTargetGlobalStyle, k as isOutputTargetDocsReadme, l as isTsFile, m as filterActiveTargets, n as createJsVarName, o as isDtsFile, p as readPackageJson, q as relative$1, r as generatePreamble, rt as isGlob, t as addDocBlock, tt as hasWarning, u as isTsxFile, v as getComponentsFromModules, w as isOutputTargetDocs, x as isOutputTargetCopy, y as isOutputTargetAssets, z as isValidConfigOutputTarget } from "./util-IKfWWLJo.mjs";
-import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-Bz2SOK7_.mjs";
+import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-CvPPhnWO.mjs";
 import ts, { default as ts$1 } from "typescript";
 import { readFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
@@ -461,9 +461,9 @@ const scopeCss = (cssText, scopeId, commentOriginalSelector) => {
 };
 //#endregion
 //#region src/version.ts
-const version = "5.0.0-beta.26";
-const buildId = "1792014462";
-const vermoji = "🎁";
+const version = "5.0.0-beta.28";
+const buildId = "1793723538";
+const vermoji = "🐆";
 /**
 * Get the installed version of a tool/dependency.
 * Handles packages with exports maps that point to subdirectories.
@@ -665,6 +665,7 @@ const resetModuleLegacy = (moduleFile) => {
 	moduleFile.externalImports.length = 0;
 	moduleFile.isCollectionDependency = false;
 	moduleFile.localImports.length = 0;
+	moduleFile.functionalComponentDeps.length = 0;
 	moduleFile.originalCollectionComponentPath = null;
 	moduleFile.originalImports.length = 0;
 	moduleFile.hasVdomXlink = false;
@@ -1560,6 +1561,20 @@ const parsePropertyAtRuleDescriptors = (node) => {
 		initialValue
 	};
 };
+/** `--name: docs`, `--name - docs` (as `@attr`/`@slot` use) or `--name docs`. */
+const CUSTOM_PROPERTY_TAG_RE = /^(--[\w-]+)\s*(?::|-(?=\s))?(.*)$/;
+/**
+* @param text the text after a `@prop`/`@cssprop` tag
+* @returns the custom property name and description, or `undefined` if `text` doesn't start
+* with a custom property name
+*/
+const parseCustomPropertyTag = (text) => {
+	const match = text.trim().match(CUSTOM_PROPERTY_TAG_RE);
+	return match ? {
+		name: match[1],
+		docs: match[2].trim()
+	} : void 0;
+};
 //#endregion
 //#region src/compiler/css-components/parse-css-component.ts
 /**
@@ -1607,6 +1622,7 @@ const parseCssComponentFile = async (filePath, cssText) => {
 	}
 	const defs = /* @__PURE__ */ new Map();
 	const rawNodes = rawRoot.nodes;
+	const attributeRuleDocs = /* @__PURE__ */ new Map();
 	for (let i = 0; i < rawNodes.length; i++) {
 		const node = rawNodes[i];
 		if (node.type !== "comment" || !isJsDocComment(node.text)) continue;
@@ -1657,6 +1673,7 @@ const parseCssComponentFile = async (filePath, cssText) => {
 		defs.set(baseTag, def);
 		collectAutoDetectedCustomProperties(next, def);
 		collectAutoDetectedSlots(next, def);
+		collectAttributeRuleDocs(next, (selector) => selector.nonTagParts[0] === "nesting" ? def : void 0, attributeRuleDocs);
 	}
 	if (defs.size === 0) return {
 		defs: [],
@@ -1671,6 +1688,8 @@ const parseCssComponentFile = async (filePath, cssText) => {
 			collectAutoDetectedAttributes(selector, def);
 		}
 	}
+	collectAttributeRuleDocs(rawRoot, (selector) => defs.get(selector.tag ?? ""), attributeRuleDocs);
+	for (const [def, docsByName] of attributeRuleDocs) for (const attr of def.attributes) if (attr.source === "auto") attr.docs = docsByName.get(attr.name) ?? attr.docs;
 	for (const node of nodes) {
 		if (node.type !== "rule") continue;
 		for (const selector of parseSelectorList(node.selector)) {
@@ -1688,7 +1707,13 @@ const parseCssComponentFile = async (filePath, cssText) => {
 		const prev = nodes[i - 1];
 		const docs = prev && prev.type === "comment" && isJsDocComment(prev.text) ? normalizeJsDocText(prev.text) : "";
 		for (const def of defs.values()) {
-			if (def.properties.some((p) => p.name === propName)) continue;
+			const existing = def.properties.find((p) => p.name === propName);
+			if (existing) {
+				existing.docs ||= docs;
+				if (syntax) existing.syntax ??= syntax;
+				if (initialValue) existing.default ??= initialValue;
+				continue;
+			}
 			const prop = {
 				name: propName,
 				docs,
@@ -1820,6 +1845,34 @@ const collectAutoDetectedAttributes = (selector, def) => {
 		});
 	}
 };
+/**
+* Record the JSDoc comment directly above each of `container`'s child rules as the description
+* of the attributes in that rule's leading compound selector. The first documented rule for an
+* attribute wins.
+* @param container a container whose direct child rules to scan
+* @param defFor the component a child rule's selector belongs to, if any
+* @param out collected descriptions, per component, by attribute name
+*/
+const collectAttributeRuleDocs = (container, defFor, out) => {
+	for (const node of container.nodes) {
+		const prev = node.prev();
+		if (node.type !== "rule" || prev?.type !== "comment" || !isJsDocComment(prev.text)) continue;
+		let selectors;
+		try {
+			selectors = parseSelectorList(node.selector);
+		} catch {
+			continue;
+		}
+		const docs = normalizeJsDocText(prev.text);
+		for (const selector of selectors) {
+			const def = defFor(selector);
+			if (!def) continue;
+			const docsByName = out.get(def) ?? /* @__PURE__ */ new Map();
+			out.set(def, docsByName);
+			for (const attr of selector.attributes) if (!docsByName.has(attr.name)) docsByName.set(attr.name, docs);
+		}
+	}
+};
 const mergeLiteralUnion = (existingType, value) => {
 	const literal = JSON.stringify(value);
 	const escapeHatch = " | (string & {})";
@@ -1895,12 +1948,9 @@ const buildDefFromJsDocBlock = (block) => {
 			continue;
 		}
 		if (PROP_TAG_NAMES.has(tag.name)) {
-			const colonIndex = tag.text.indexOf(":");
-			const name = (colonIndex === -1 ? tag.text : tag.text.slice(0, colonIndex)).trim();
-			const docs = colonIndex === -1 ? "" : tag.text.slice(colonIndex + 1).trim();
-			if (name.startsWith("--")) properties.push({
-				name,
-				docs,
+			const prop = parseCustomPropertyTag(tag.text);
+			if (prop) properties.push({
+				...prop,
 				source: "explicit"
 			});
 			continue;
@@ -2186,15 +2236,18 @@ const updateComponentBuildConditionals = (moduleMap, cmps) => {
 		cmp.potentialCmpRefs = unique(cmp.potentialCmpRefs);
 	});
 };
+/** Extension-less local imports may name a file or a directory's `index` file. */
+const MODULE_PATH_SUFFIXES = [
+	"",
+	".tsx",
+	".ts",
+	".js",
+	"/index.tsx",
+	"/index.ts",
+	"/index.js"
+];
 const getModuleImports = (moduleMap, filePath, importedModules) => {
-	let moduleFile = moduleMap.get(filePath);
-	if (moduleFile == null) {
-		moduleFile = moduleMap.get(filePath + ".tsx");
-		if (moduleFile == null) {
-			moduleFile = moduleMap.get(filePath + ".ts");
-			if (moduleFile == null) moduleFile = moduleMap.get(filePath + ".js");
-		}
-	}
+	const moduleFile = MODULE_PATH_SUFFIXES.map((suffix) => moduleMap.get(filePath + suffix)).find((m) => m != null);
 	if (moduleFile != null && !importedModules.some((m) => m.sourceFilePath === moduleFile.sourceFilePath)) {
 		importedModules.push(moduleFile);
 		moduleFile.localImports.forEach((localImport) => {
@@ -6454,8 +6507,24 @@ let callbackIds = 0;
 const pending = new Map();
 const callbacks = new Map();
 
+const constructWorker = (workerPath, workerName) => {
+  try {
+    return new Worker(workerPath, {name:workerName});
+  } catch (e) {
+    // Worker() rejects a cross-origin URL (e.g. a library loaded from a CDN) - bootstrap it
+    // from a same-origin Blob instead
+    const blob = new Blob(['importScripts(' + JSON.stringify(workerPath) + ')'], { type: 'text/javascript' });
+    const url = URL.createObjectURL(blob);
+    try {
+      return new Worker(url, {name:workerName});
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  }
+};
+
 export const createWorker = (workerPath, workerName, workerMsgId) => {
-  const worker = new Worker(workerPath, {name:workerName});
+  const worker = constructWorker(workerPath, workerName);
 
   worker.addEventListener('message', ({data}) => {
     if (data) {
@@ -9549,10 +9618,22 @@ const stylesToMarkdown = (styles) => {
 	if (styles.length === 0) return content;
 	content.push(`## CSS Custom Properties`);
 	content.push(``);
+	const hasRegistrations = styles.some((s) => s.syntax || s.default);
+	const code = (text) => text ? `\`${text}\`` : "";
 	const table = new MarkdownTable();
-	table.addHeader(["Name", "Description"]);
+	table.addHeader(hasRegistrations ? [
+		"Name",
+		"Description",
+		"Syntax",
+		"Default"
+	] : ["Name", "Description"]);
 	styles.forEach((style) => {
-		table.addRow([`\`${style.name}\``, style.docs]);
+		const row = [code(style.name), style.docs];
+		table.addRow(hasRegistrations ? [
+			...row,
+			code(style.syntax),
+			code(style.default)
+		] : row);
 	});
 	content.push(...table.toMarkdown());
 	content.push(``);
@@ -14481,12 +14562,18 @@ const gatherVdomMeta = (m, args, typeChecker) => {
 };
 //#endregion
 //#region src/compiler/transformers/static-to-meta/call-expression.ts
-const parseCallExpression = (m, node, typeChecker) => {
+/**
+* @param m the module or component to record vdom metadata on
+* @param node the call expression to parse
+* @param typeChecker used to resolve functional components / JSX-returning calls to their source
+* @param moduleFile the module to record those dependencies on; defaults to `m` when it's a module
+*/
+const parseCallExpression = (m, node, typeChecker, moduleFile = "functionalComponentDeps" in m ? m : void 0) => {
 	if (node.arguments != null && node.arguments.length > 0) {
-		if (ts.isIdentifier(node.expression)) visitCallExpressionArgs(m, node.expression, node.arguments, typeChecker);
+		if (ts.isIdentifier(node.expression)) visitCallExpressionArgs(m, node.expression, node.arguments, typeChecker, moduleFile);
 		else if (ts.isPropertyAccessExpression(node.expression)) {
 			const n = node.expression.name;
-			if (ts.isIdentifier(n) && n) visitCallExpressionArgs(m, n, node.arguments, typeChecker);
+			if (ts.isIdentifier(n) && n) visitCallExpressionArgs(m, n, node.arguments, typeChecker, moduleFile);
 		}
 	} else if (ts.isPropertyAccessExpression(node.expression)) {
 		if (ts.isIdentifier(node.expression.name)) {
@@ -14496,24 +14583,20 @@ const parseCallExpression = (m, node, typeChecker) => {
 			if (!declarations || declarations.length === 0) return;
 			const sourceFile = declarations[0].getSourceFile();
 			if (!sourceFile) return;
-			const sourceFilePath = normalizePath(sourceFile.fileName);
-			const moduleFile = m;
-			if (moduleFile.functionalComponentDeps) {
-				if (!moduleFile.functionalComponentDeps.includes(sourceFilePath)) moduleFile.functionalComponentDeps.push(sourceFilePath);
-			}
+			addFunctionalComponentDep(moduleFile, sourceFile);
 		}
 	}
 };
-const visitCallExpressionArgs = (m, callExpressionName, args, typeChecker) => {
+const visitCallExpressionArgs = (m, callExpressionName, args, typeChecker, moduleFile) => {
 	const fnName = callExpressionName.escapedText;
 	if (fnName === "h" || fnName === "__stencil_h" || fnName === "createElement") {
-		visitCallExpressionArg(m, args[0], typeChecker);
+		visitCallExpressionArg(m, args[0], typeChecker, moduleFile);
 		if (fnName === "h" || fnName === "__stencil_h") gatherVdomMeta(m, args, typeChecker);
 	} else if (fnName === "jsx" || fnName === "jsxs" || fnName === "_jsx" || fnName === "_jsxs") {
-		visitCallExpressionArg(m, args[0], typeChecker);
+		visitCallExpressionArg(m, args[0], typeChecker, moduleFile);
 		gatherVdomMeta(m, args, typeChecker);
 		if (args.length > 2 && args[2]) m.hasVdomKey = true;
-	} else if (args.length > 1 && fnName === "createElementNS") visitCallExpressionArg(m, args[1], typeChecker);
+	} else if (args.length > 1 && fnName === "createElementNS") visitCallExpressionArg(m, args[1], typeChecker, moduleFile);
 	else if (fnName === "require" && args.length > 0 && m.originalImports) {
 		const arg = args[0];
 		if (ts.isStringLiteral(arg)) {
@@ -14521,7 +14604,7 @@ const visitCallExpressionArgs = (m, callExpressionName, args, typeChecker) => {
 		}
 	}
 };
-const visitCallExpressionArg = (m, arg, typeChecker) => {
+const visitCallExpressionArg = (m, arg, typeChecker, moduleFile) => {
 	if (ts.isStringLiteral(arg)) {
 		let tag = arg.text;
 		if (typeof tag === "string") {
@@ -14529,31 +14612,31 @@ const visitCallExpressionArg = (m, arg, typeChecker) => {
 			m.htmlTagNames.push(tag);
 			if (tag.includes("-")) m.potentialCmpRefs.push(tag);
 		}
-	} else if (typeChecker && ts.isIdentifier(arg)) resolveFunctionalComponentDep(m, arg, typeChecker);
+	} else if (typeChecker && ts.isIdentifier(arg)) resolveFunctionalComponentDep(moduleFile, arg, typeChecker);
 };
 /**
 * Resolves a functional component identifier to its source file and tracks it
 * as a dependency so that build-conditionals can be properly propagated.
+* Follows import / re-export aliases through to the declaring file.
 *
-* @param m the module or component metadata to track the dependency on
+* @param moduleFile the module to track the dependency on
 * @param identifier the identifier node representing the functional component
 * @param typeChecker the TypeScript type checker for symbol resolution
 */
-const resolveFunctionalComponentDep = (m, identifier, typeChecker) => {
+const resolveFunctionalComponentDep = (moduleFile, identifier, typeChecker) => {
+	if (!moduleFile) return;
 	try {
 		const symbol = typeChecker.getSymbolAtLocation(identifier);
 		if (!symbol) return;
-		const declarations = (typeChecker.getAliasedSymbol(symbol) || symbol).declarations;
-		if (!declarations || declarations.length === 0) return;
-		const sourceFile = declarations[0].getSourceFile();
-		if (!sourceFile) return;
-		const sourceFilePath = normalizePath(sourceFile.fileName);
-		const moduleFile = m;
-		if (moduleFile.functionalComponentDeps) {
-			if (!moduleFile.functionalComponentDeps.includes(sourceFilePath)) moduleFile.functionalComponentDeps.push(sourceFilePath);
-		}
+		const sourceFile = (symbol.flags & ts.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(symbol) : symbol).declarations?.[0]?.getSourceFile();
+		if (sourceFile) addFunctionalComponentDep(moduleFile, sourceFile);
 	} catch {}
 };
+const addFunctionalComponentDep = (moduleFile, sourceFile) => {
+	const deps = moduleFile?.functionalComponentDeps;
+	const sourceFilePath = normalizePath(sourceFile.fileName);
+	if (deps && !deps.includes(sourceFilePath)) deps.push(sourceFilePath);
+};
 //#endregion
 //#region src/compiler/transformers/add-component-meta-static.ts
 /**
@@ -16895,6 +16978,13 @@ function findReExport(sourceFile, className) {
 	}
 }
 /**
+* @param sourceFile the (barrel) source file to scan
+* @returns the module specifiers of its `export * from './x'` statements, in order
+*/
+function findStarReExportSpecifiers(sourceFile) {
+	return sourceFile.statements.flatMap((stmt) => ts.isExportDeclaration(stmt) && !stmt.exportClause && !stmt.isTypeOnly && stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier) ? [stmt.moduleSpecifier.text] : []);
+}
+/**
 * Finds `name`'s import in `sourceFile` and returns its module and origin name (before any `as`
 * aliasing; `'default'` for a default import).
 * @param sourceFile the source file to scan for a matching import
@@ -17021,12 +17111,20 @@ function findClassInJsModule(config, compilerCtx, source, className, hopsRemaini
 		};
 	}
 	if (hopsRemaining <= 0) return;
+	const readReExported = (moduleSpecifier) => {
+		const resolvedFileName = tsResolveModuleName(config, compilerCtx, moduleSpecifier, source.fileName)?.resolvedModule?.resolvedFileName;
+		return resolvedFileName ? readJsSourceFile(config, resolvedFileName) : void 0;
+	};
 	const reExport = findReExport(source, className);
-	if (!reExport) return;
-	const resolvedFileName = tsResolveModuleName(config, compilerCtx, reExport.moduleSpecifier, source.fileName)?.resolvedModule?.resolvedFileName;
-	const nextSource = resolvedFileName && readJsSourceFile(config, resolvedFileName);
-	if (!nextSource) return;
-	return findClassInJsModule(config, compilerCtx, nextSource, reExport.localName, hopsRemaining - 1);
+	if (reExport) {
+		const nextSource = readReExported(reExport.moduleSpecifier);
+		return nextSource && findClassInJsModule(config, compilerCtx, nextSource, reExport.localName, hopsRemaining - 1);
+	}
+	for (const moduleSpecifier of findStarReExportSpecifiers(source)) {
+		const nextSource = readReExported(moduleSpecifier);
+		const found = nextSource && findClassInJsModule(config, compilerCtx, nextSource, className, hopsRemaining - 1);
+		if (found) return found;
+	}
 }
 /**
 * Filters `dedupeMembers` down to entries not already present in `staticMembers`
@@ -17121,7 +17219,8 @@ function convertDiskSourceFileDecorators(sourceFile, config, target = ts.ScriptT
 /**
 * Resolves an `extends` target through a module specifier: resolves the
 * module, finds the named class/mixin-factory export, and adds it (and its
-* own ancestors) to `dependentClasses`. Follows one level of re-export (barrel file) when the
+* own ancestors) to `dependentClasses`. Follows one level of re-export (barrel file, named or
+* `export *`) when the
 * declaration isn't found directly in the resolved module.
 * @param compilerCtx the current compiler context
 * @param buildCtx the current build context
@@ -17142,7 +17241,9 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 	let keepLooking = true;
 	const foundFile = tsResolveModuleName(buildCtx.config, compilerCtx, moduleSpecifier, currentSource.fileName);
 	if (!foundFile?.resolvedModule || !className) return;
-	let foundSource = compilerCtx.moduleMap.get(foundFile.resolvedModule.resolvedFileName)?.staticSourceFile;
+	const resolvedFileName = foundFile.resolvedModule.resolvedFileName;
+	let foundSource = compilerCtx.moduleMap.get(resolvedFileName)?.staticSourceFile;
+	if (!foundSource && isJsFile(currentSource.fileName) && isJsFile(resolvedFileName)) foundSource = readJsSourceFile(buildCtx.config, resolvedFileName);
 	if (!foundSource) {
 		foundSource = tsGetSourceFile(buildCtx.config, foundFile);
 		if (!foundSource) {
@@ -17156,7 +17257,7 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 	}
 	const matchedStatement = findStatementByName(foundSource, className);
 	if (!matchedStatement) {
-		const reExport = barrelHopsRemaining > 0 ? findReExport(foundSource, className) : void 0;
+		const reExport = barrelHopsRemaining > 0 ? findReExport(foundSource, className) ?? findStarReExportOf(buildCtx.config, compilerCtx, foundSource, className) : void 0;
 		if (reExport) return resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, foundSource, reExport.moduleSpecifier, reExport.localName, dependentClasses, typeChecker, ogModule, targetScriptTarget, barrelHopsRemaining - 1, originalModuleSpecifier, originalContainingFile);
 		const err = buildWarn(buildCtx.diagnostics);
 		err.messageText = `Unable to find "${className}" in the imported module "${moduleSpecifier}".
@@ -17166,12 +17267,22 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 	}
 	let foundClassDeclaration = matchedStatement ? ts.isClassDeclaration(matchedStatement) ? matchedStatement : void 0 : void 0;
 	let foundClassSource = foundSource;
-	if (!foundClassDeclaration && matchedStatement) {
+	const findInJsEntry = () => {
+		if (!isDtsFile(foundSource.fileName) || isLocalModule(originalModuleSpecifier)) return;
+		const jsSource = resolveModuleJsEntry(buildCtx.config, compilerCtx, originalModuleSpecifier, originalContainingFile);
+		return jsSource && findClassInJsModule(buildCtx.config, compilerCtx, jsSource, className);
+	};
+	if (foundClassDeclaration) {
+		const foundInJs = findInJsEntry();
+		if (foundInJs) {
+			foundClassDeclaration = foundInJs.classNode;
+			foundClassSource = foundInJs.sourceFile;
+		}
+	} else if (matchedStatement) {
 		foundClassDeclaration = findClassWalk(matchedStatement);
 		keepLooking = false;
-		if (!foundClassDeclaration && isDtsFile(foundSource.fileName) && !isLocalModule(originalModuleSpecifier)) {
-			const jsSource = resolveModuleJsEntry(buildCtx.config, compilerCtx, originalModuleSpecifier, originalContainingFile);
-			const foundInJs = jsSource && findClassInJsModule(buildCtx.config, compilerCtx, jsSource, className);
+		if (!foundClassDeclaration) {
+			const foundInJs = findInJsEntry();
 			if (foundInJs) {
 				foundClassDeclaration = foundInJs.classNode;
 				foundClassSource = foundInJs.sourceFile;
@@ -17189,6 +17300,27 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 	}
 	return foundClassDeclaration;
 }
+/**
+* Finds the first `export * from './x'` in `barrel` whose target declares `className` directly.
+* @param config the current Stencil validated config
+* @param compilerCtx the current compiler context
+* @param barrel the source file to scan
+* @param className the declaration name to look for
+* @returns the re-export to follow, in `findReExport`'s shape, or `undefined`
+*/
+function findStarReExportOf(config, compilerCtx, barrel, className) {
+	for (const moduleSpecifier of findStarReExportSpecifiers(barrel)) {
+		const resolved = tsResolveModuleName(config, compilerCtx, moduleSpecifier, barrel.fileName);
+		const fileName = resolved?.resolvedModule?.resolvedFileName;
+		if (!fileName) continue;
+		const target = compilerCtx.moduleMap.get(fileName)?.staticSourceFile ?? (isJsFile(fileName) ? readJsSourceFile(config, fileName) : tsGetSourceFile(config, resolved));
+		if (target && findStatementByName(target, className)) return {
+			moduleSpecifier,
+			localName: className
+		};
+	}
+}
+const isJsFile = (fileName) => /\.[cm]?js$/.test(fileName);
 function convertDtsToJs(declarationSourceFile, compilerCtx) {
 	const jsPath = normalizePath(declarationSourceFile.replace(/\.d\.ts$/, ".js").replace("/types/", "/collection/"));
 	return compilerCtx.moduleMap.get(jsPath)?.staticSourceFile;
@@ -17625,7 +17757,7 @@ function reclassifyGlobalTypeReferences(members, declaringSf, declaringPath, res
 }
 /**
 * Looks for `name` as a direct top-level declaration in `sf`; if not found, follows one level of
-* re-export (barrel file) via `resolveImport` - matching `compiler-ctx-merge.ts`'s equivalent
+* re-export (barrel file, named or `export *`) via `resolveImport` - matching `compiler-ctx-merge.ts`'s equivalent
 * one-hop fallback (see `findReExport` in `shared.ts` for why it's capped at one hop).
 *
 * @param sf the source file to search
@@ -17642,20 +17774,25 @@ function findDeclarationOrReExport(sf, path, name, resolveImport) {
 		sourceFile: sf,
 		path
 	};
-	const reExport = findReExport(sf, name);
-	if (!reExport) return void 0;
-	const resolved = resolveImport(reExport.moduleSpecifier, path);
-	if (!resolved) return void 0;
-	const { code, path: resolvedPath } = resolved;
-	const isTs = resolvedPath.endsWith(".tsx") || resolvedPath.endsWith(".ts");
-	const reExportSf = ts.createSourceFile(resolvedPath, code, ts.ScriptTarget.ESNext, true, isTs ? ts.ScriptKind.TSX : ts.ScriptKind.JS);
-	const statement = findStatementByName(reExportSf, reExport.localName);
-	if (!statement) return void 0;
-	return {
-		statement,
-		sourceFile: reExportSf,
-		path: resolvedPath
+	const findIn = (moduleSpecifier, localName) => {
+		const resolved = resolveImport(moduleSpecifier, path);
+		if (!resolved) return void 0;
+		const { code, path: resolvedPath } = resolved;
+		const isTs = resolvedPath.endsWith(".tsx") || resolvedPath.endsWith(".ts");
+		const reExportSf = ts.createSourceFile(resolvedPath, code, ts.ScriptTarget.ESNext, true, isTs ? ts.ScriptKind.TSX : ts.ScriptKind.JS);
+		const statement = findStatementByName(reExportSf, localName);
+		return statement && {
+			statement,
+			sourceFile: reExportSf,
+			path: resolvedPath
+		};
 	};
+	const reExport = findReExport(sf, name);
+	if (reExport) return findIn(reExport.moduleSpecifier, reExport.localName);
+	for (const moduleSpecifier of findStarReExportSpecifiers(sf)) {
+		const found = findIn(moduleSpecifier, name);
+		if (found) return found;
+	}
 }
 /**
 * Recursively resolves a class's `extends` heritage into a flat, deduplicated
@@ -18231,7 +18368,7 @@ const parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile,
 	};
 	if (!isCollectionDependency) validateComponentMembers(cmpNode, buildCtx);
 	const visitComponentChildNode = (node) => {
-		if (ts.isCallExpression(node)) parseCallExpression(cmp, node, typeChecker);
+		if (ts.isCallExpression(node)) parseCallExpression(cmp, node, typeChecker, moduleFile);
 		else if (ts.isStringLiteral(node)) parseStringLiteral(cmp, node);
 		node.forEachChild(visitComponentChildNode);
 	};
@@ -18314,18 +18451,32 @@ const parseAssetsDirs = (staticMembers, componentFilePath) => {
 //#region src/compiler/transformers/static-to-meta/import.ts
 const parseModuleImport = (config, compilerCtx, buildCtx, moduleFile, dirPath, importNode, resolveCollections) => {
 	if (importNode.moduleSpecifier && ts.isStringLiteral(importNode.moduleSpecifier)) {
-		let importPath = importNode.moduleSpecifier.text;
+		const importPath = importNode.moduleSpecifier.text;
 		if (!moduleFile.originalImports.includes(importPath)) moduleFile.originalImports.push(importPath);
 		if (importPath === "@stencil/core/signals") moduleFile.hasSignalsImport = true;
-		if (isAbsolute$1(importPath)) {
-			importPath = normalizePath(importPath);
-			moduleFile.localImports.push(importPath);
-		} else if (importPath.startsWith(".")) {
-			importPath = normalizePath(join$2(dirPath, importPath));
-			moduleFile.localImports.push(importPath);
-		} else addExternalImport(config, compilerCtx, buildCtx, moduleFile, moduleFile.sourceFilePath, importPath, resolveCollections, !importNode.importClause);
+		const localPath = resolveLocalImportPath(dirPath, importPath);
+		if (localPath) moduleFile.localImports.push(localPath);
+		else addExternalImport(config, compilerCtx, buildCtx, moduleFile, moduleFile.sourceFilePath, importPath, resolveCollections, !importNode.importClause);
+	}
+};
+/**
+* Record a local `export … from './x'` re-export as a local import, so build conditionals
+* propagate through barrel files. Bare-specifier re-exports are left alone.
+*
+* @param moduleFile the module containing the re-export
+* @param dirPath the module's (normalized) directory
+* @param exportNode the export declaration
+*/
+const parseModuleReExport = (moduleFile, dirPath, exportNode) => {
+	if (exportNode.moduleSpecifier && ts.isStringLiteral(exportNode.moduleSpecifier)) {
+		const localPath = resolveLocalImportPath(dirPath, exportNode.moduleSpecifier.text);
+		if (localPath && !moduleFile.localImports.includes(localPath)) moduleFile.localImports.push(localPath);
 	}
 };
+const resolveLocalImportPath = (dirPath, importPath) => {
+	if (isAbsolute$1(importPath)) return normalizePath(importPath);
+	if (importPath.startsWith(".")) return normalizePath(join$2(dirPath, importPath));
+};
 //#endregion
 //#region src/compiler/transformers/static-to-meta/parse-static.ts
 /**
@@ -18408,6 +18559,9 @@ const updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileTex
 		} else if (ts.isImportDeclaration(node)) {
 			parseModuleImport(config, compilerCtx, buildCtx, moduleFile, srcDirPath, node, true);
 			return;
+		} else if (ts.isExportDeclaration(node)) {
+			parseModuleReExport(moduleFile, srcDirPath, node);
+			return;
 		} else if (ts.isCallExpression(node)) parseCallExpression(moduleFile, node, typeChecker);
 		else if (ts.isStringLiteral(node)) parseStringLiteral(moduleFile, node);
 		else if (ts.isVariableStatement(node)) node.declarationList.declarations.forEach((declaration) => {
@@ -24671,7 +24825,8 @@ const prerenderEnsureDir = (sys, prerenderCtx, p) => {
 * 2. A doc-commented `--foo: value;` declaration inside the component's "root" rule - `:host`
 *    for `shadow`/`scoped` encapsulation, or the component's own tag selector for `none`.
 * 3. A native `@property --foo { ... }` at-rule, with the `syntax`/`initial-value` descriptors
-*    surfaced as `syntax`/`default`. Not scoped - `@property` is a global registration.
+*    surfaced as `syntax`/`default`. Not scoped - `@property` is a global registration. For a
+*    property already documented by 1 or 2, it still supplies `syntax`/`default`.
 *
 * @param styleDocs the array to hold formatted CSS docstrings
 * @param styleText the CSS text we're working with
@@ -24732,10 +24887,17 @@ function parseScopedAndNativeStyleDocs(styleDocs, styleText, mode, tag, encapsul
 	});
 	root.walkAtRules("property", (node) => {
 		const propName = node.params.trim();
-		if (!propName.startsWith("--") || hasName(propName)) return;
+		if (!propName.startsWith("--")) return;
 		const { syntax, initialValue } = parsePropertyAtRuleDescriptors(node);
 		const prev = node.prev();
 		const docs = prev && prev.type === "comment" && isJsDocComment(prev.text) ? normalizeJsDocText(prev.text) : "";
+		const existing = styleDocs.find((styleDoc) => styleDoc.name === propName);
+		if (existing) {
+			existing.docs ||= docs;
+			if (syntax) existing.syntax ??= syntax;
+			if (initialValue) existing.default ??= initialValue;
+			return;
+		}
 		styleDocs.push({
 			name: propName,
 			docs,
@@ -24762,12 +24924,10 @@ function parseCssComment(styleDocs, comment, mode) {
 	}).join(" ").replace(/\t/g, " ").trim();
 	while (comment.includes("  ")) comment = comment.replace("  ", " ");
 	comment.split(CSS_PROP_ANNOTATION_RE).forEach((d) => {
-		const cssDocument = d.trim();
-		if (!cssDocument.startsWith(`--`)) return;
-		const splt = cssDocument.split(`:`);
+		const prop = parseCustomPropertyTag(d);
+		if (!prop) return;
 		const styleDoc = {
-			name: splt[0].trim(),
-			docs: (splt.shift() && splt.join(`:`)).trim(),
+			...prop,
 			annotation: "prop",
 			mode
 		};
@@ -25186,9 +25346,9 @@ const validateTsConfig = async (config, sys) => {
 			if (results.watchOptions) tsconfig.watchOptions = results.watchOptions;
 			if (results.options) {
 				tsconfig.compilerOptions = results.options;
-				if ((tsconfig.compilerOptions.target ?? ts.ScriptTarget.ES2017) < ts.ScriptTarget.ES2017) {
+				if ((tsconfig.compilerOptions.target ?? ts.ScriptTarget.ES2022) < ts.ScriptTarget.ES2022) {
 					const warn = buildWarn(tsconfig.diagnostics);
-					warn.messageText = `Stencil requires the tsconfig.json “target” setting to be “es2017” or higher. ES5 build output is no longer supported.`;
+					warn.messageText = `Stencil requires the tsconfig.json “target” setting to be “es2022” or higher, matching its supported browsers. Lower targets compile to larger, older syntax.`;
 				}
 				if (tsconfig.compilerOptions.module !== ts.ModuleKind.ESNext && !config._isTesting) {
 					const warn = buildWarn(tsconfig.diagnostics);
@@ -26409,6 +26569,7 @@ const convertStaticToMeta = (config, compilerCtx, buildCtx, typeChecker, collect
 		const visitNode = (node) => {
 			if (ts.isClassDeclaration(node)) return parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile, buildCtx, transformOpts);
 			else if (ts.isImportDeclaration(node)) parseModuleImport(config, compilerCtx, buildCtx, moduleFile, dirPath, node, !transformOpts.isolatedModules);
+			else if (ts.isExportDeclaration(node)) parseModuleReExport(moduleFile, dirPath, node);
 			else if (ts.isCallExpression(node)) parseCallExpression(moduleFile, node, typeChecker);
 			else if (ts.isStringLiteral(node)) parseStringLiteral(moduleFile, node);
 			return ts.visitEachChild(node, visitNode, transformCtx);

package/dist/declarations/stencil-public-compiler.d.ts

@@ -3316,7 +3316,9 @@ interface CopyTask {
   /**
    * Additional glob patterns to exclude from the copy operation, merged with
    * the built-in defaults: `__mocks__`, `__fixtures__`, `dist`, hidden dirs,
-   * `.ds_store`, `.gitignore`, `desktop.ini`, `thumbs.db`.
+   * `.ds_store`, `.gitignore`, `desktop.ini`, `thumbs.db`. For a directory
+   * `src`, patterns match paths relative to that directory; an explicitly
+   * named `src` file is never ignored.
    */
   ignore?: string[];
   /**
@@ -4460,7 +4462,7 @@ interface TranspileOptions {
  * transpile time — config-driven flags that are not derived from component
  * scanning or runtime environment detection.
  */
-type BuildOverrideKeys = 'hotModuleReplacement' | 'signalBacking' | 'vdomSignals' | 'lightDomPatches' | 'slotChildNodes' | 'slotCloneNode' | 'slotDomMutations' | 'slotTextContent' | 'lifecycleDOMEvents' | 'initializeNextTick';
+type BuildOverrideKeys = 'isDev' | 'isTesting' | 'hotModuleReplacement' | 'signalBacking' | 'vdomSignals' | 'lightDomPatches' | 'slotChildNodes' | 'slotCloneNode' | 'slotDomMutations' | 'slotTextContent' | 'lifecycleDOMEvents' | 'initializeNextTick';
 /**
  * Subset of Stencil's BUILD feature flags that can be overridden at transpile
  * time. Derived from {@link BuildConditionals} via `Pick` so the field list

package/dist/{index-CxpWC93f.d.mts → index-BGUOG9Wc.d.mts}

@@ -1,5 +1,9 @@
-import { ar as RafCallback, cr as TagTransformer, lr as UserBuildConditionals, n as ChildType, nr as ErrorHandler, p as HostElement, rr as FunctionalComponent, sr as ResolutionHandler, ur as VNode, v as PropsType, y as RuntimeRef } from "./index-C41EOWaQ.mjs";
+import { ar as RafCallback, cr as TagTransformer, lr as UserBuildConditionals, n as ChildType, nr as ErrorHandler, p as HostElement, rr as FunctionalComponent, sr as ResolutionHandler, ur as VNode, v as PropsType, y as RuntimeRef } from "./index-BogZpjP2.mjs";
 //#region src/client/client-build.d.ts
+/**
+ * `isDev` / `isTesting` are getters, not copies: the transpile path (e.g. `@stencil/unplugin`)
+ * sets `BUILD.*` overrides from each component module, which runs after this module is evaluated.
+ */
 declare const Build: UserBuildConditionals;
 //#endregion
 //#region src/client/client-log.d.ts