@stencil/core 5.0.0-beta.10 → 5.0.0-beta.12

package/dist/{compiler-PoywOlbq.mjs → compiler-BjKDj129.mjs}

@@ -1,9 +1,9 @@
 import { n as __require } from "./rolldown-runtime-BhDjJH2R.mjs";
-import { S as HYDRATED_CSS } from "./client-Db2rdxUM.mjs";
+import { S as HYDRATED_CSS } from "./client-CdFmjaQa.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, 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-BKtLn2R9.mjs";
+import { i as CustomElementsExportBehaviorOptions, o as buildEvents, r as createNodeLogger, t as createNodeSys } from "./node-HKfDhPR3.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.10";
-const buildId = "1789054824";
-const vermoji = "🚘";
+const version = "5.0.0-beta.12";
+const buildId = "1789547794";
+const vermoji = "🏇";
 /**
 * Get the installed version of a tool/dependency.
 * Handles packages with exports maps that point to subdirectories.
@@ -2854,6 +2854,7 @@ const setPackageVersionByContent = (pkgVersions, pkgContent) => {
 		if (pkg.name && pkg.version) setPackageVersion(pkgVersions, pkg.name, pkg.version);
 	} catch {}
 };
+const isLocalModule = (p) => p.startsWith(".") || p.startsWith("/");
 const isNodeModulePath = (p) => normalizePath(p).split("/").includes("node_modules");
 const getModuleId = (orgImport) => {
 	if (orgImport.startsWith("~")) orgImport = orgImport.substring(1);
@@ -6024,7 +6025,8 @@ const addTagTransform$2 = (compilerCtx, buildCtx) => {
 					const expression = node.expression;
 					if (ts.isPropertyAccessExpression(expression) && ((expression.name.text === "get" || expression.name.text === "define" || expression.name.text === "whenDefined") && ts.isIdentifier(expression.expression) && expression.expression.text === "customElements" || expression.name.text === "createElement" && ts.isIdentifier(expression.expression) && expression.expression.text === "document")) {
 						const [firstArg, ...restArgs] = node.arguments;
-						if (firstArg) {
+						const alreadyTransformed = firstArg && ts.isCallExpression(firstArg) && ts.isIdentifier(firstArg.expression) && (firstArg.expression.text === "__stencil_transformTag" || firstArg.expression.text === "transformTag");
+						if (firstArg && !alreadyTransformed) {
 							const newFirstArg = ts.factory.createCallExpression(ts.factory.createIdentifier(TRANSFORM_TAG), void 0, [firstArg]);
 							newNode = ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [newFirstArg, ...restArgs]);
 						}
@@ -11230,10 +11232,13 @@ const MODE_RESOLUTION_CHAIN_DECLARATION = `modeResolutionChain = [];`;
 const SSR_FACTORY_INTRO = `
 //! let ${MODE_RESOLUTION_CHAIN_DECLARATION}
 
-// Capture native setTimeout/clearTimeout at module scope (before globalThis can be shadowed inside the factory).
+// Capture native at module scope (before globalThis can be shadowed inside the factory).
+
 // Used for the hydrate timeout timer to avoid being affected by constrainTimeouts.
 var $nativeSetTimeout = (typeof globalThis !== 'undefined' ? globalThis : global).setTimeout;
 var $nativeClearTimeout = (typeof globalThis !== 'undefined' ? globalThis : global).clearTimeout;
+// Used to abort in-flight fetch() calls and to call any user defined AbortControllers when ssr times out.
+var $stencilNativeAbortController = AbortController;
 
 export function ssrFactory($stencilWindow, $stencilHydrateOpts, $stencilHydrateResults, $stencilAfterHydrate, $stencilHydrateResolve) {
   var globalThis = $stencilWindow;
@@ -11326,8 +11331,46 @@ export function ssrFactory($stencilWindow, $stencilHydrateOpts, $stencilHydrateR
 
   var fetch, FetchError, Headers, Request, Response;
 
+  // Aborted when the render times out or errors, so in-flight fetch() calls
+  // made by component code stop holding the render's window/results alive
+  // instead of running to completion against a torn-down window. See #6864.
+  var $stencilAbortController = new $stencilNativeAbortController();
+
+  // Any AbortController a component creates itself is transparently wired to
+  // cascade-abort when the render times out too, so component code using the
+  // standard AbortController convention for its own cancellable work (axios,
+  // aws-sdk v3, the mongodb driver, etc.) gets cancelled automatically. 
+  var AbortController = function () {
+    var controller = new $stencilNativeAbortController();
+    $stencilAbortController.signal.addEventListener(
+      'abort',
+      function () {
+        controller.abort();
+      },
+      { once: true },
+    );
+    return controller;
+  };
+
+  function $stencilFetchSignal(callerSignal) {
+    if (!callerSignal) {
+      return $stencilAbortController.signal;
+    }
+    if (callerSignal.aborted || $stencilAbortController.signal.aborted) {
+      return callerSignal.aborted ? callerSignal : $stencilAbortController.signal;
+    }
+    var merged = new $stencilNativeAbortController();
+    var onAbort = function () { merged.abort(); };
+    callerSignal.addEventListener('abort', onAbort, { once: true });
+    $stencilAbortController.signal.addEventListener('abort', onAbort, { once: true });
+    return merged.signal;
+  }
+
   if (typeof $stencilWindow.fetch === 'function') {
-    fetch = $stencilWindow.fetch;
+    var $stencilRawFetch = $stencilWindow.fetch;
+    fetch = $stencilWindow.fetch = function(input, init) {
+      return $stencilRawFetch(input, Object.assign({}, init, { signal: $stencilFetchSignal(init && init.signal) }));
+    };
   } else {
     fetch = $stencilWindow.fetch = function() { throw new Error('fetch() is not implemented'); };
   }
@@ -11363,7 +11406,7 @@ export function ssrFactory($stencilWindow, $stencilHydrateOpts, $stencilHydrateR
 `;
 const SSR_FACTORY_OUTRO = `
     /*hydrateAppClosure end*/
-    ssrApp(window, $stencilHydrateOpts, $stencilHydrateResults, $stencilAfterHydrate, $stencilHydrateResolve);
+    ssrApp(window, $stencilHydrateOpts, $stencilHydrateResults, $stencilAfterHydrate, $stencilHydrateResolve, $stencilAbortController);
   }
 
   hydrateAppClosure($stencilWindow);
@@ -11637,6 +11680,40 @@ if (typeof globalThis !== "undefined") {
   if (typeof globalThis.clearInterval !== "function") globalThis.clearInterval = function() {};
 }
 `;
+const SSR_WASM_ABORT_CONTROLLER_POLYFILL = `
+if (typeof globalThis !== "undefined" && typeof globalThis.AbortController !== "function") {
+  function StencilPolyfillAbortSignal() {
+    this.aborted = false;
+    this.reason = undefined;
+    this._listeners = [];
+  }
+  StencilPolyfillAbortSignal.prototype.addEventListener = function(type, listener, options) {
+    if (type !== "abort" || typeof listener !== "function") return;
+    this._listeners.push({ listener: listener, once: !!(options && options.once) });
+  };
+  StencilPolyfillAbortSignal.prototype.removeEventListener = function(type, listener) {
+    if (type !== "abort") return;
+    this._listeners = this._listeners.filter(function(entry) { return entry.listener !== listener; });
+  };
+  StencilPolyfillAbortSignal.prototype.dispatchEvent = function(event) {
+    var signal = this;
+    signal._listeners.slice().forEach(function(entry) { entry.listener.call(signal, event); });
+    signal._listeners = signal._listeners.filter(function(entry) { return !entry.once; });
+    return true;
+  };
+  function StencilPolyfillAbortController() {
+    this.signal = new StencilPolyfillAbortSignal();
+  }
+  StencilPolyfillAbortController.prototype.abort = function(reason) {
+    if (this.signal.aborted) return;
+    this.signal.aborted = true;
+    this.signal.reason = reason;
+    this.signal.dispatchEvent({ type: "abort" });
+  };
+  globalThis.AbortController = StencilPolyfillAbortController;
+  globalThis.AbortSignal = StencilPolyfillAbortSignal;
+}
+`;
 const SSR_WASM_INTERFACE = `declare module "main" {
   export function renderToString(): void;
   export function setTagTransformer(): void;
@@ -11651,6 +11728,12 @@ module.exports = {
         return;
       }
       var inp = JSON.parse(Host.inputString());
+      // QuickJS-ng has no timers, so if hydration never settles on its own (a Promise
+      // nothing will ever resolve), the call doesn't hang - it just runs out of scheduled
+      // work and returns whatever was last written here. Write a diagnostic up front so
+      // that's a real error instead of silence, then overwrite it once renderToString()
+      // actually resolves.
+      Host.outputString(JSON.stringify({ __error: 'renderToString did not complete - a component may be waiting on work that never resolves' }));
       var result = await renderToString(inp.html, inp.options);
       Host.outputString(JSON.stringify(result));
     } catch(e) {
@@ -11707,7 +11790,7 @@ const generateSsrWasmApp = async (config, compilerCtx, buildCtx, outputTargets)
 			checks: { pluginTimings: config.logLevel === "debug" }
 		};
 		const rolldownOutput = await (await rolldown(rolldownOptions)).generate({
-			banner: generatePreamble(config) + SSR_WASM_TIMER_POLYFILL,
+			banner: generatePreamble(config) + SSR_WASM_TIMER_POLYFILL + SSR_WASM_ABORT_CONTROLLER_POLYFILL,
 			outro: SSR_WASM_OUTRO,
 			format: "iife",
 			name: "StencilSsrWasm",
@@ -15609,23 +15692,159 @@ function matchesNamedDeclaration(name) {
 	};
 }
 /**
-* Finds a re-export of `className` in `sourceFile` - `export { X } from './y'` or
-* `export { X as Y } from './y'` - as used by barrel entry points (e.g. `@stencil/core`'s own
-* public `index.d.mts`, which re-exports its runtime API from `./declarations/stencil-public-runtime`
-* rather than declaring it directly).
+* Finds a re-export of `className` in `sourceFile`: `export { X } from './y'`, or the
+* bundler-split shape `import { X as name } from './y'; export { name };` (no `from` clause).
 * @param sourceFile the (barrel) source file to scan
 * @param className the exported name to look for
-* @returns the module specifier and the name to look for in that module (the local name, before
-* any `as` aliasing), or `undefined` if no matching re-export is found
+* @returns the module specifier and name to look for there (before any `as` aliasing), or
+* `undefined` if not found
 */
 function findReExport(sourceFile, className) {
 	for (const stmt of sourceFile.statements) {
-		if (!ts.isExportDeclaration(stmt) || !stmt.moduleSpecifier || !ts.isStringLiteral(stmt.moduleSpecifier) || !stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) continue;
-		for (const element of stmt.exportClause.elements) if (element.name.text === className) return {
+		if (!ts.isExportDeclaration(stmt) || !stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) continue;
+		const element = stmt.exportClause.elements.find((el) => el.name.text === className);
+		if (!element) continue;
+		if (stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier)) return {
 			moduleSpecifier: stmt.moduleSpecifier.text,
 			localName: element.propertyName?.text ?? element.name.text
 		};
+		const importOrigin = findImportOrigin(sourceFile, element.propertyName?.text ?? element.name.text);
+		if (importOrigin) return importOrigin;
+	}
+}
+/**
+* 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
+* @param name the local (post-aliasing) name an import bound
+* @returns the import's module specifier and origin name, or `undefined` if `name` isn't imported
+*/
+function findImportOrigin(sourceFile, name) {
+	for (const stmt of sourceFile.statements) {
+		if (!ts.isImportDeclaration(stmt) || !stmt.importClause || !ts.isStringLiteral(stmt.moduleSpecifier)) continue;
+		const moduleSpecifier = stmt.moduleSpecifier.text;
+		if (stmt.importClause.name?.text === name) return {
+			moduleSpecifier,
+			localName: "default"
+		};
+		const bindings = stmt.importClause.namedBindings;
+		if (!bindings || !ts.isNamedImports(bindings)) continue;
+		const element = bindings.elements.find((el) => el.name.text === name);
+		if (element) return {
+			moduleSpecifier,
+			localName: element.propertyName?.text ?? element.name.text
+		};
+	}
+}
+/**
+* Finds `name` as a top-level declaration in `sf` (see `matchesNamedDeclaration`), following a
+* same-file export alias if `name` is only ever the public side of a local rename
+* (`export { RealName as name }`, no `from` clause).
+* @param sf the source file to search
+* @param name the declaration name to look for, which may only exist as an export alias
+* @returns the matched statement, or `undefined`
+*/
+function findStatementByName(sf, name) {
+	const direct = sf.statements.find(matchesNamedDeclaration(name));
+	if (direct) return direct;
+	for (const stmt of sf.statements) {
+		if (!ts.isExportDeclaration(stmt) || stmt.moduleSpecifier || !stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) continue;
+		const aliasedName = stmt.exportClause.elements.find((el) => el.name.text === name)?.propertyName?.text;
+		if (aliasedName && aliasedName !== name) return sf.statements.find(matchesNamedDeclaration(aliasedName));
+	}
+}
+/**
+* Picks the runtime target out of a `package.json` `exports` condition entry - prefers `import`
+* over `require`/`node`/`default`, recursing into nested condition objects.
+* @param entry an `exports` map value: a path string, or nested conditions
+* @returns the resolved relative path, or `undefined` if no usable condition was found
+*/
+function pickJsCondition(entry) {
+	if (typeof entry === "string") return entry;
+	if (typeof entry !== "object" || entry === null) return;
+	const conditions = entry;
+	for (const key of [
+		"import",
+		"require",
+		"node",
+		"default"
+	]) if (key in conditions) {
+		const picked = pickJsCondition(conditions[key]);
+		if (picked) return picked;
+	}
+}
+/**
+* Reads and parses `filePath` as JS, with parent nodes set - unlike `tsGetSourceFile`, which
+* never triggers binding, so `.parent` stays unset and `node.getSourceFile()` returns `undefined`.
+* @param config the current Stencil validated config
+* @param filePath the absolute path of the JS file to read and parse
+* @returns the parsed source file, or `undefined` if it couldn't be read
+*/
+function readJsSourceFile(config, filePath) {
+	try {
+		const text = config.sys.readFileSync(filePath);
+		if (typeof text !== "string") return;
+		return ts.createSourceFile(filePath, text, ts.ScriptTarget.ESNext, true, ts.ScriptKind.JS);
+	} catch {
+		return;
+	}
+}
+/**
+* Resolves the runtime JS entry for a bare (non-relative) module specifier by reading its
+* package's own `package.json` `exports` map, instead of `tsResolveModuleName` - which always
+* resolves to the package's `types` entry, an ambient signature with no body a mixin factory's
+* class can never be found inside.
+* @param config the current Stencil validated config
+* @param compilerCtx the current compiler context
+* @param moduleSpecifier the bare package specifier to resolve
+* @param containingFile the file the specifier was imported from
+* @returns the resolved JS source file, or `undefined` if it couldn't be resolved this way
+*/
+function resolveModuleJsEntry(config, compilerCtx, moduleSpecifier, containingFile) {
+	if (isLocalModule(moduleSpecifier)) return;
+	const pkgJsonPath = tsResolveModuleNamePackageJsonPath(config, compilerCtx, moduleSpecifier, containingFile);
+	if (!pkgJsonPath) return;
+	let pkgJson;
+	try {
+		pkgJson = JSON.parse(config.sys.readFileSync(pkgJsonPath));
+	} catch {
+		return;
+	}
+	const pkgName = pkgJson.name;
+	if (!pkgName || !moduleSpecifier.startsWith(pkgName) || !pkgJson.exports) return;
+	const subpath = moduleSpecifier === pkgName ? "." : `.${moduleSpecifier.slice(pkgName.length)}`;
+	const exportsMap = pkgJson.exports;
+	const conditionEntry = typeof exportsMap === "string" ? subpath === "." ? exportsMap : void 0 : exportsMap[subpath] ?? (subpath === "." ? exportsMap : void 0);
+	const target = conditionEntry && pickJsCondition(conditionEntry);
+	if (!target) return;
+	return readJsSourceFile(config, normalizePath(join$2(dirname$1(pkgJsonPath), target)));
+}
+/**
+* Finds `className`'s class inside a resolved JS entry (see `resolveModuleJsEntry`), following
+* re-export hops the same way `resolveAndProcessExtendedClass` walks a `.d.ts`/`.ts` source.
+* @param config the current Stencil validated config
+* @param compilerCtx the current compiler context
+* @param source the JS source file to search
+* @param className the class (or mixin factory) name to look for
+* @param hopsRemaining re-export hops still allowed before giving up
+* @returns the found class and the source file it's declared in, or `undefined`
+*/
+function findClassInJsModule(config, compilerCtx, source, className, hopsRemaining = 3) {
+	const matchedStatement = findStatementByName(source, className);
+	if (matchedStatement) {
+		const classNode = ts.isClassDeclaration(matchedStatement) ? matchedStatement : findClassWalk(matchedStatement);
+		return classNode && {
+			classNode,
+			sourceFile: source
+		};
 	}
+	if (hopsRemaining <= 0) return;
+	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);
 }
 /**
 * Filters `dedupeMembers` down to entries not already present in `staticMembers`
@@ -15733,9 +15952,11 @@ function convertDiskSourceFileDecorators(sourceFile, config, target = ts.ScriptT
 * @param ogModule the original module file of the class declaration
 * @param targetScriptTarget the script target to convert decorators with, if needed
 * @param barrelHopsRemaining re-export hops still allowed before giving up
+* @param originalModuleSpecifier the specifier this lookup started from, before any barrel hops
+* @param originalContainingFile the file `originalModuleSpecifier` was imported from
 * @returns the found class declaration, or `undefined`
 */
-function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, moduleSpecifier, className, dependentClasses, typeChecker, ogModule, targetScriptTarget = ts.ScriptTarget.ESNext, barrelHopsRemaining = 1) {
+function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, currentSource, moduleSpecifier, className, dependentClasses, typeChecker, ogModule, targetScriptTarget = ts.ScriptTarget.ESNext, barrelHopsRemaining = 1, originalModuleSpecifier = moduleSpecifier, originalContainingFile = currentSource.fileName) {
 	let keepLooking = true;
 	const foundFile = tsResolveModuleName(buildCtx.config, compilerCtx, moduleSpecifier, currentSource.fileName);
 	if (!foundFile?.resolvedModule || !className) return;
@@ -15751,10 +15972,10 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 		}
 		foundSource = convertDiskSourceFileDecorators(foundSource, buildCtx.config, targetScriptTarget);
 	}
-	const matchedStatement = foundSource.statements.find(matchesNamedDeclaration(className));
+	const matchedStatement = findStatementByName(foundSource, className);
 	if (!matchedStatement) {
 		const reExport = barrelHopsRemaining > 0 ? findReExport(foundSource, className) : void 0;
-		if (reExport) return resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration, foundSource, reExport.moduleSpecifier, reExport.localName, dependentClasses, typeChecker, ogModule, targetScriptTarget, barrelHopsRemaining - 1);
+		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}".
                   Please import class / mixin-factory declarations directly and not via barrel files.`;
@@ -15762,16 +15983,25 @@ function resolveAndProcessExtendedClass(compilerCtx, buildCtx, classDeclaration,
 		return;
 	}
 	let foundClassDeclaration = matchedStatement ? ts.isClassDeclaration(matchedStatement) ? matchedStatement : void 0 : void 0;
+	let foundClassSource = foundSource;
 	if (!foundClassDeclaration && 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 (foundInJs) {
+				foundClassDeclaration = foundInJs.classNode;
+				foundClassSource = foundInJs.sourceFile;
+			}
+		}
 		if (!foundClassDeclaration) warnMixinFactoryClassNotFound(buildCtx, className, classDeclaration);
 	}
 	if (foundClassDeclaration && !dependentClasses.some((dc) => dc.classNode === foundClassDeclaration)) {
 		dependentClasses.push({
 			classNode: foundClassDeclaration,
-			sourceFile: foundSource,
-			fileName: foundFile.resolvedModule.resolvedFileName
+			sourceFile: foundClassSource,
+			fileName: foundClassSource.fileName
 		});
 		if (keepLooking) buildExtendsTree(compilerCtx, foundClassDeclaration, dependentClasses, typeChecker, buildCtx, ogModule);
 	}
@@ -16178,19 +16408,6 @@ function getExtendsClassNames(node) {
 	if (ts.isCallExpression(expr) && expr.expression.getText() === "Mixin") return expr.arguments.filter(ts.isIdentifier).map((id) => id.text);
 	return [];
 }
-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;
-}
 /**
 * A single-file mini-program (see `convertInMemorySourceDecorators`) can
 * never load an imported module's own `SourceFile`, so a type that's
@@ -16214,7 +16431,7 @@ function reclassifyGlobalTypeReferences(members, declaringSf, declaringPath, res
 		if (!references) return;
 		Object.entries(references).forEach(([typeName, reference]) => {
 			if (reference.location !== "global") return;
-			const specifier = findImportSpecifier(declaringSf, typeName);
+			const specifier = findImportOrigin(declaringSf, typeName)?.moduleSpecifier;
 			if (!specifier) return;
 			const resolved = resolveImport(specifier, declaringPath);
 			reference.location = "import";
@@ -16237,7 +16454,7 @@ function reclassifyGlobalTypeReferences(members, declaringSf, declaringPath, res
 * differ from `sf`/`path` if resolved through a re-export), or `undefined`
 */
 function findDeclarationOrReExport(sf, path, name, resolveImport) {
-	const direct = sf.statements.find(matchesNamedDeclaration(name));
+	const direct = findStatementByName(sf, name);
 	if (direct) return {
 		statement: direct,
 		sourceFile: sf,
@@ -16250,7 +16467,7 @@ function findDeclarationOrReExport(sf, path, name, resolveImport) {
 	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 = reExportSf.statements.find(matchesNamedDeclaration(reExport.localName));
+	const statement = findStatementByName(reExportSf, reExport.localName);
 	if (!statement) return void 0;
 	return {
 		statement,
@@ -16287,7 +16504,7 @@ function resolveAncestors(classNode, sf, path, resolveImport, visited, ancestors
 		let foundSf = sf;
 		let foundPath = path;
 		let keepLooking = true;
-		const sameFileStatement = sf.statements.find(matchesNamedDeclaration(parentName));
+		const sameFileStatement = findStatementByName(sf, parentName);
 		if (sameFileStatement) {
 			if (ts.isClassDeclaration(sameFileStatement)) foundClass = sameFileStatement;
 			else {
@@ -16296,7 +16513,7 @@ function resolveAncestors(classNode, sf, path, resolveImport, visited, ancestors
 				if (!foundClass) warnMixinFactoryClassNotFound(buildCtx, parentName, rootClassDeclaration);
 			}
 		} else {
-			const specifier = findImportSpecifier(sf, parentName);
+			const specifier = findImportOrigin(sf, parentName)?.moduleSpecifier;
 			if (!specifier) continue;
 			const resolved = resolveImport(specifier, path);
 			if (!resolved) continue;
@@ -21816,6 +22033,39 @@ const DEFAULT_BROWSER_TARGETS = [
 //#endregion
 //#region src/compiler/style/css-parser/parse-css.ts
 /**
+* Splits a selector list on top-level commas in a single pass: a comma only
+* splits when it's outside a quoted string and at paren depth 0, so commas in
+* `:is(:a,:has(:b))` or `[title="a,b"]` aren't treated as separators.
+* Backslash escapes (inside or outside a string) are skipped so they can't shift state,
+* so e.g. `[title="a\,b"]` is treated as a single selector.
+* @param selectors The selector list to split
+* @returns An array of selectors, with whitespace trimmed from each selector
+*/
+const splitSelectorList = (selectors) => {
+	const parts = [];
+	let depth = 0;
+	let quote = null;
+	let start = 0;
+	for (let i = 0; i < selectors.length; i++) {
+		const ch = selectors[i];
+		if (quote) {
+			if (ch === "\\") i++;
+			else if (ch === quote) quote = null;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") quote = ch;
+		else if (ch === "\\") i++;
+		else if (ch === "(") depth++;
+		else if (ch === ")") depth = Math.max(0, depth - 1);
+		else if (ch === "," && depth === 0) {
+			parts.push(selectors.slice(start, i));
+			start = i + 1;
+		}
+	}
+	parts.push(selectors.slice(start));
+	return parts.map((s) => s.trim());
+};
+/**
 * Parses CSS string input into an AST representation.
 * Used for minification, finding & resolving URLs and during SSR / prerendering, removing unused selectors.
 *
@@ -21940,11 +22190,8 @@ const parseCss = (css, filePath) => {
 	const selector = () => {
 		const m = match(/^([^{]+)/);
 		if (!m) return null;
-		return trim(m[0]).replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/g, "").replace(/"(?:\\"|[^"])*"|'(?:\\'|[^'])*'/g, function(str) {
-			return str.replace(/,/g, "‌");
-		}).split(/\s*(?![^(]*\)),\s*/).map(function(s) {
-			return s.replace(/\u200C/g, ",");
-		});
+		const cleaned = trim(m[0]).replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/g, "");
+		return splitSelectorList(cleaned);
 	};
 	const declaration = () => {
 		const pos = position();

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

@@ -3732,6 +3732,10 @@ interface OutputTargetSsr extends OutputTargetBase {
    */
   cjs?: boolean;
 }
+/**
+ * Compiles the SSR hydrate app to a WASM plugin (via `extism-js`/QuickJS-ng) that can run
+ * outside of Node
+ */
 interface OutputTargetSsrWasm extends OutputTargetBase {
   type: 'ssr-wasm';
   /** Output directory. @default 'dist/ssr-wasm' */