@stencil/core 4.40.1 → 4.41.0-dev.1767590127.4bb24de

package/compiler/stencil.js

@@ -1,5 +1,5 @@
 /*!
- Stencil Compiler v4.40.1 | MIT Licensed | https://stenciljs.com
+ Stencil Compiler v4.41.0-dev.1767590127.4bb24de | MIT Licensed | https://stenciljs.com
  */
 "use strict";
 var __create = Object.create;
@@ -25074,8 +25074,8 @@ ${lanes.join("\n")}
         return option.strictFlag ? getStrictOptionValue(options, option.name) : option.allowJsFlag ? getAllowJSCompilerOption(options) : options[option.name];
       }
       function getJSXTransformEnabled(options) {
-        const jsx = options.jsx;
-        return jsx === 2 || jsx === 4 || jsx === 5;
+        const jsx2 = options.jsx;
+        return jsx2 === 2 || jsx2 === 4 || jsx2 === 5;
       }
       function getJSXImplicitImportBase(compilerOptions, file) {
         const jsxImportSourcePragmas = file == null ? void 0 : file.pragmas.get("jsximportsource");
@@ -153086,8 +153086,8 @@ ${lanes.join("\n")}
           /* Ignore */
         };
       }
-      function jsxModeNeedsExplicitImport(jsx) {
-        return jsx === 2 || jsx === 3;
+      function jsxModeNeedsExplicitImport(jsx2) {
+        return jsx2 === 2 || jsx2 === 3;
       }
       function isSourceFileFromLibrary(program3, node) {
         return program3.isSourceFileFromExternalLibrary(node) || program3.isSourceFileDefaultLibrary(node);
@@ -178305,8 +178305,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return binaryExpr;
       }
       function doChange38(changeTracker, sf, node) {
-        const jsx = flattenInvalidBinaryExpr(node);
-        if (jsx) changeTracker.replaceNode(sf, node, factory.createJsxFragment(factory.createJsxOpeningFragment(), jsx, factory.createJsxJsxClosingFragment()));
+        const jsx2 = flattenInvalidBinaryExpr(node);
+        if (jsx2) changeTracker.replaceNode(sf, node, factory.createJsxFragment(factory.createJsxOpeningFragment(), jsx2, factory.createJsxJsxClosingFragment()));
       }
       function flattenInvalidBinaryExpr(node) {
         const children = [];
@@ -226972,7 +226972,7 @@ var init_parseAst = __esm({
         };
       }
     ];
-    parseAst = (input, { allowReturnOutsideFunction = false, jsx = false } = {}) => convertProgram(getAstBuffer((0, import_native.parse)(input, allowReturnOutsideFunction, jsx)));
+    parseAst = (input, { allowReturnOutsideFunction = false, jsx: jsx2 = false } = {}) => convertProgram(getAstBuffer((0, import_native.parse)(input, allowReturnOutsideFunction, jsx2)));
   }
 });
 
@@ -239392,12 +239392,12 @@ var init_node_entry = __esm({
         }
       }
       getRenderingMode() {
-        const jsx = this.scope.context.options.jsx;
-        const { mode, factory, importSource } = jsx;
+        const jsx2 = this.scope.context.options.jsx;
+        const { mode, factory, importSource } = jsx2;
         if (mode === "automatic") {
           return {
             factory: getRenderedJsxChildren(this.children) > 1 ? "jsxs" : "jsx",
-            importSource: jsx.jsxImportSource,
+            importSource: jsx2.jsxImportSource,
             mode
           };
         }
@@ -239449,8 +239449,8 @@ var init_node_entry = __esm({
         }
       }
       getRenderingMode() {
-        const jsx = this.scope.context.options.jsx;
-        const { mode, factory, importSource } = jsx;
+        const jsx2 = this.scope.context.options.jsx;
+        const { mode, factory, importSource } = jsx2;
         if (mode === "automatic") {
           let hasSpread = false;
           for (const attribute of this.openingElement.attributes) {
@@ -239659,12 +239659,12 @@ var init_node_entry = __esm({
         this.included = true;
         if (!this.deoptimized)
           this.applyDeoptimizations();
-        const jsx = this.scope.context.options.jsx;
-        if (jsx.mode === "automatic") {
+        const jsx2 = this.scope.context.options.jsx;
+        if (jsx2.mode === "automatic") {
           this.fragment = "Fragment";
-          this.fragmentVariable = getAndIncludeFactoryVariable("Fragment", false, jsx.jsxImportSource, this, context);
+          this.fragmentVariable = getAndIncludeFactoryVariable("Fragment", false, jsx2.jsxImportSource, this, context);
         } else {
-          const { fragment, importSource, mode } = jsx;
+          const { fragment, importSource, mode } = jsx2;
           if (fragment != null) {
             this.fragment = fragment;
             this.fragmentVariable = getAndIncludeFactoryVariable(fragment, mode === "preserve", importSource, this, context);
@@ -245765,7 +245765,7 @@ var import_typescript72 = __toESM(require_typescript_5_8_3_bundle_cache_min());
 
 // src/version.ts
 init_import_meta_url();
-var buildId = "1766528469";
+var buildId = "1767590127";
 var minfyJsId = "terser5.37.0_7";
 var optimizeCssId = "autoprefixer10.4.19_postcss8.5.6_7";
 var parse5Version = "7.2.1";
@@ -245773,8 +245773,8 @@ var rollupVersion = "4.34.9";
 var jqueryVersion = "4.0.0-pre";
 var terserVersion = "5.37.0";
 var typescriptVersion = "5.8.3";
-var vermoji = "\u{1F402}";
-var version = "4.40.1";
+var vermoji = "\u{1F4E3}";
+var version = "4.41.0-dev.1767590127.4bb24de";
 var versions = {
   stencil: version,
   parse5: parse5Version,
@@ -248940,6 +248940,12 @@ init_import_meta_url();
 // src/runtime/tag-transform.ts
 init_import_meta_url();
 
+// src/runtime/vdom/jsx-dev-runtime.ts
+init_import_meta_url();
+
+// src/runtime/vdom/jsx-runtime.ts
+init_import_meta_url();
+
 // src/runtime/vdom/vdom-annotations.ts
 init_import_meta_url();
 
@@ -249229,35 +249235,36 @@ var buildEvents = () => {
 
 // src/compiler/build/compiler-ctx.ts
 var CompilerContext = class {
-  constructor() {
-    this.version = 2;
-    this.activeBuildId = -1;
-    this.activeFilesAdded = [];
-    this.activeFilesDeleted = [];
-    this.activeFilesUpdated = [];
-    this.activeDirsAdded = [];
-    this.activeDirsDeleted = [];
-    this.addWatchDir = noop;
-    this.addWatchFile = noop;
-    this.cssModuleImports = /* @__PURE__ */ new Map();
-    this.changedFiles = /* @__PURE__ */ new Set();
-    this.changedModules = /* @__PURE__ */ new Set();
-    this.collections = [];
-    this.compilerOptions = null;
-    this.events = buildEvents();
-    this.hasSuccessfulBuild = false;
-    this.isActivelyBuilding = false;
-    this.lastBuildResults = null;
-    this.moduleMap = /* @__PURE__ */ new Map();
-    this.nodeMap = /* @__PURE__ */ new WeakMap();
-    this.resolvedCollections = /* @__PURE__ */ new Set();
-    this.rollupCache = /* @__PURE__ */ new Map();
-    this.rollupCacheHydrate = null;
-    this.rollupCacheLazy = null;
-    this.rollupCacheNative = null;
-    this.styleModeNames = /* @__PURE__ */ new Set();
-    this.worker = null;
-  }
+  version = 2;
+  activeBuildId = -1;
+  activeFilesAdded = [];
+  activeFilesDeleted = [];
+  activeFilesUpdated = [];
+  activeDirsAdded = [];
+  activeDirsDeleted = [];
+  addWatchDir = noop;
+  addWatchFile = noop;
+  cache;
+  cssModuleImports = /* @__PURE__ */ new Map();
+  changedFiles = /* @__PURE__ */ new Set();
+  changedModules = /* @__PURE__ */ new Set();
+  collections = [];
+  compilerOptions = null;
+  events = buildEvents();
+  fs;
+  hasSuccessfulBuild = false;
+  isActivelyBuilding = false;
+  lastBuildResults = null;
+  moduleMap = /* @__PURE__ */ new Map();
+  nodeMap = /* @__PURE__ */ new WeakMap();
+  resolvedCollections = /* @__PURE__ */ new Set();
+  rollupCache = /* @__PURE__ */ new Map();
+  rollupCacheHydrate = null;
+  rollupCacheLazy = null;
+  rollupCacheNative = null;
+  cachedGlobalStyle;
+  styleModeNames = /* @__PURE__ */ new Set();
+  worker = null;
   reset() {
     this.cache.clear();
     this.cssModuleImports.clear();
@@ -250521,15 +250528,18 @@ var getTypeReferenceLocation = (typeName, type, sourceFile, checker, program3) =
     const compilerHost = import_typescript9.default.createCompilerHost(options);
     const importHomeModule = getHomeModule(sourceFile, localImportPath, options, compilerHost, program3);
     if (importHomeModule) {
-      const importName = namedImportBindings.elements.find((nbe) => nbe.name.getText() === typeName).name;
+      const importElement = namedImportBindings.elements.find((nbe) => nbe.name.getText() === typeName);
+      const importName = importElement.name;
       const originalTypeName = getOriginalTypeName(importName, checker);
+      const importedAs = importElement.propertyName ? importElement.propertyName.getText() : typeName;
       const typeDecl = findTypeWithName(importHomeModule, originalTypeName);
       type = checker.getTypeAtLocation(typeDecl);
       const id = addToLibrary(type, originalTypeName, checker, normalizePath(importHomeModule.fileName, false));
       return {
         location: "import",
         path: localImportPath,
-        id
+        id,
+        referenceLocation: importedAs
       };
     }
   }
@@ -250558,6 +250568,35 @@ var getTypeReferenceLocation = (typeName, type, sourceFile, checker, program3) =
       id
     };
   }
+  const defaultImportDeclaration = sourceFile.statements.find((st) => {
+    if (!import_typescript9.default.isImportDeclaration(st) || !st.importClause) {
+      return false;
+    }
+    const defaultImportName = st.importClause.name;
+    return defaultImportName && defaultImportName.getText() === typeName;
+  });
+  if (defaultImportDeclaration) {
+    const localImportPath = defaultImportDeclaration.moduleSpecifier.text;
+    const options = program3.getCompilerOptions();
+    const compilerHost = import_typescript9.default.createCompilerHost(options);
+    const importHomeModule = getHomeModule(sourceFile, localImportPath, options, compilerHost, program3);
+    if (importHomeModule) {
+      const defaultExport = importHomeModule.statements.find(
+        (st) => import_typescript9.default.isExportAssignment(st) && !st.isExportEquals && import_typescript9.default.isIdentifier(st.expression) && st.expression.getText() === typeName
+      );
+      if (defaultExport) {
+        const typeDecl = findTypeWithName(importHomeModule, typeName);
+        type = checker.getTypeAtLocation(typeDecl);
+        const id = addToLibrary(type, typeName, checker, normalizePath(importHomeModule.fileName, false));
+        return {
+          location: "import",
+          path: localImportPath,
+          id,
+          isDefault: true
+        };
+      }
+    }
+  }
   return {
     location: "global",
     id: "global::" + typeName
@@ -256234,6 +256273,18 @@ var appDataPlugin = (config, compilerCtx, buildCtx, buildConditionals, platform)
       if (globalScripts.some((s) => s.path === id)) {
         const program3 = this.parse(code, {});
         const needsDefault = !program3.body.some((s) => s.type === "ExportDefaultDeclaration");
+        if (needsDefault) {
+          const diagnostic = {
+            level: "warn",
+            type: "build",
+            header: "Missing default export in globalScript",
+            messageText: `globalScript should export a default function.
+See: https://stenciljs.com/docs/config#globalscript`,
+            relFilePath: id,
+            lines: []
+          };
+          buildCtx.diagnostics.push(diagnostic);
+        }
         const defaultExport = needsDefault ? "\nexport const globalFn = () => {};\nexport default globalFn;" : "";
         code = code + defaultExport;
         const compilerOptions = { ...config.tsCompilerOptions };
@@ -256301,13 +256352,17 @@ var getGlobalScriptData = (config, compilerCtx) => {
 };
 var appendGlobalScripts = (globalScripts, s) => {
   if (globalScripts.length === 1) {
-    s.prepend(`import appGlobalScript from '${globalScripts[0].path}';
+    s.prepend(`import * as appGlobalScriptNs from '${globalScripts[0].path}';
+`);
+    s.prepend(`const appGlobalScript = appGlobalScriptNs.default || (() => {});
 `);
     s.append(`export const globalScripts = appGlobalScript;
 `);
   } else if (globalScripts.length > 1) {
     globalScripts.forEach((globalScript) => {
-      s.prepend(`import ${globalScript.defaultName} from '${globalScript.path}';
+      s.prepend(`import * as ${globalScript.defaultName}Ns from '${globalScript.path}';
+`);
+      s.prepend(`const ${globalScript.defaultName} = ${globalScript.defaultName}Ns.default || (() => {});
 `);
     });
     s.append(`export const globalScripts = () => {
@@ -269749,10 +269804,6 @@ var HYDRATE_FACTORY_INTRO = `
 // const ${MODE_RESOLUTION_CHAIN_DECLARATION}
 
 export function hydrateFactory($stencilWindow, $stencilHydrateOpts, $stencilHydrateResults, $stencilAfterHydrate, $stencilHydrateResolve) {
-  var everywhere;
-  try { everywhere = global || globalThis; } 
-  catch (e) { everywhere = window || globalThis; }
-
   var globalThis = $stencilWindow;
   var self = $stencilWindow;
   var top = $stencilWindow;
@@ -269779,6 +269830,11 @@ export function hydrateFactory($stencilWindow, $stencilHydrateOpts, $stencilHydr
   var setInterval = $stencilWindow.setInterval.bind($stencilWindow);
   var setTimeout = $stencilWindow.setTimeout.bind($stencilWindow);
 
+  // Tag transform functions are provided from the outer scope
+  // This ensures the factory uses the same instance as the runner
+  var setTagTransformer = $stencilTagTransform.setTagTransformer;
+  var transformTag = $stencilTagTransform.transformTag;
+
   var CharacterData = $stencilWindow.CharacterData;
   var CSS = $stencilWindow.CSS;
   var CustomEvent = $stencilWindow.CustomEvent;
@@ -269966,6 +270022,35 @@ var writeHydrateOutput = async (config, compilerCtx, buildCtx, outputTarget, rol
           `// const ${MODE_RESOLUTION_CHAIN_DECLARATION}`,
           `const ${MODE_RESOLUTION_CHAIN_DECLARATION}`
         );
+        const tagTransformFunctionPattern = /function (setTagTransformer|transformTag)\(/;
+        const match2 = code.match(tagTransformFunctionPattern);
+        if (match2) {
+          const injectCode = `
+// Tag transform state object for factory closure
+var $stencilTagTransform = { setTagTransformer: setTagTransformer, transformTag: transformTag };
+`;
+          const lastTransformTagIndex = code.lastIndexOf("function transformTag(");
+          const lastSetTagTransformerIndex = code.lastIndexOf("function setTagTransformer(");
+          const injectionPoint = Math.max(lastTransformTagIndex, lastSetTagTransformerIndex);
+          if (injectionPoint !== -1) {
+            let braceCount = 0;
+            let foundStart = false;
+            let injectionIndex = injectionPoint;
+            for (let i = injectionPoint; i < code.length; i++) {
+              if (code[i] === "{") {
+                foundStart = true;
+                braceCount++;
+              } else if (code[i] === "}") {
+                braceCount--;
+                if (foundStart && braceCount === 0) {
+                  injectionIndex = i + 1;
+                  break;
+                }
+              }
+            }
+            code = code.slice(0, injectionIndex) + injectCode + code.slice(injectionIndex);
+          }
+        }
         if (minify2) {
           const optimizeResults = await optimizeModule(config, compilerCtx, {
             input: code,
@@ -270041,8 +270126,8 @@ var generateHydrateApp = async (config, compilerCtx, buildCtx, outputTargets) =>
         {
           name: "hydrateAppPlugin",
           resolveId(id) {
-            if (id === STENCIL_HYDRATE_FACTORY_ID) {
-              return id;
+            if (id === STENCIL_HYDRATE_FACTORY_ID || id === "@hydrate-factory") {
+              return STENCIL_HYDRATE_FACTORY_ID;
             }
             if (id === STENCIL_MOCK_DOC_ID) {
               return mockDoc;
@@ -270353,7 +270438,7 @@ var lazyComponentTransform = (compilerCtx, transformOpts, buildCtx) => {
             return updateLazyComponentClass(transformOpts, styleStatements, node, moduleFile, cmp, buildCtx);
           } else if (module2 == null ? void 0 : module2.isMixin) {
             return updateMixin(node, moduleFile, cmp, transformOpts);
-          } else if (buildCtx.config._isTesting && buildCtx.config.flags.spec) {
+          } else if (buildCtx.config._isTesting && buildCtx.config.flags.spec && !buildCtx.config.flags.e2e) {
             return updateConstructor(node, Array.from(node.members), [], []);
           }
         }
@@ -271672,9 +271757,13 @@ var validateStats = (userConfig, userOutputs) => {
   if (userConfig.flags.stats) {
     const hasOutputTarget = userOutputs.some(isOutputTargetStats);
     if (!hasOutputTarget) {
-      outputTargets.push({
+      const statsOutput = {
         type: STATS
-      });
+      };
+      if (typeof userConfig.flags.stats === "string") {
+        statsOutput.file = userConfig.flags.stats;
+      }
+      outputTargets.push(statsOutput);
     }
   }
   outputTargets.push(...userOutputs.filter(isOutputTargetStats));
@@ -271953,6 +272042,9 @@ var validateDevServer = (config, diagnostics) => {
   if (!isBoolean(devServer.websocket)) {
     devServer.websocket = true;
   }
+  if (!isBoolean(devServer.strictPort)) {
+    devServer.strictPort = false;
+  }
   if (flags.ssr) {
     devServer.ssr = true;
   } else {
@@ -272044,9 +272136,7 @@ init_import_meta_url();
 // src/compiler/docs/readme/docs-util.ts
 init_import_meta_url();
 var MarkdownTable = class {
-  constructor() {
-    this.rows = [];
-  }
+  rows = [];
   addHeader(data) {
     this.addRow(data, true);
   }
@@ -272718,52 +272808,61 @@ var validateConfig = (userConfig = {}, bootstrapConfig) => {
 
 // src/compiler/build/build-ctx.ts
 var BuildContext = class {
+  buildId = -1;
+  buildMessages = [];
+  buildResults = null;
+  bundleBuildCount = 0;
+  collections = [];
+  completedTasks = [];
+  compilerCtx;
+  components = [];
+  componentGraph = /* @__PURE__ */ new Map();
+  config;
+  data = {};
+  buildStats = void 0;
+  esmBrowserComponentBundle;
+  esmComponentBundle;
+  es5ComponentBundle;
+  systemComponentBundle;
+  commonJsComponentBundle;
+  diagnostics = [];
+  dirsAdded = [];
+  dirsDeleted = [];
+  entryModules = [];
+  filesAdded = [];
+  filesChanged = [];
+  filesDeleted = [];
+  filesUpdated = [];
+  filesWritten = [];
+  globalStyle = void 0;
+  hasConfigChanges = false;
+  hasFinished = false;
+  hasHtmlChanges = false;
+  hasPrintedResults = false;
+  hasServiceWorkerChanges = false;
+  hasScriptChanges = true;
+  hasStyleChanges = true;
+  hydrateAppFilePath = null;
+  indexBuildCount = 0;
+  indexDoc = void 0;
+  isRebuild = false;
+  moduleFiles = [];
+  outputs = [];
+  packageJson = {};
+  packageJsonFilePath = null;
+  pendingCopyTasks = [];
+  requiresFullBuild = true;
+  scriptsAdded = [];
+  scriptsDeleted = [];
+  startTime = Date.now();
+  styleBuildCount = 0;
+  stylesPromise = null;
+  stylesUpdated = [];
+  timeSpan = null;
+  timestamp;
+  transpileBuildCount = 0;
+  validateTypesPromise;
   constructor(config, compilerCtx) {
-    this.buildId = -1;
-    this.buildMessages = [];
-    this.buildResults = null;
-    this.bundleBuildCount = 0;
-    this.collections = [];
-    this.completedTasks = [];
-    this.components = [];
-    this.componentGraph = /* @__PURE__ */ new Map();
-    this.data = {};
-    this.buildStats = void 0;
-    this.diagnostics = [];
-    this.dirsAdded = [];
-    this.dirsDeleted = [];
-    this.entryModules = [];
-    this.filesAdded = [];
-    this.filesChanged = [];
-    this.filesDeleted = [];
-    this.filesUpdated = [];
-    this.filesWritten = [];
-    this.globalStyle = void 0;
-    this.hasConfigChanges = false;
-    this.hasFinished = false;
-    this.hasHtmlChanges = false;
-    this.hasPrintedResults = false;
-    this.hasServiceWorkerChanges = false;
-    this.hasScriptChanges = true;
-    this.hasStyleChanges = true;
-    this.hydrateAppFilePath = null;
-    this.indexBuildCount = 0;
-    this.indexDoc = void 0;
-    this.isRebuild = false;
-    this.moduleFiles = [];
-    this.outputs = [];
-    this.packageJson = {};
-    this.packageJsonFilePath = null;
-    this.pendingCopyTasks = [];
-    this.requiresFullBuild = true;
-    this.scriptsAdded = [];
-    this.scriptsDeleted = [];
-    this.startTime = Date.now();
-    this.styleBuildCount = 0;
-    this.stylesPromise = null;
-    this.stylesUpdated = [];
-    this.timeSpan = null;
-    this.transpileBuildCount = 0;
     this.config = validateConfig(config, {}).config;
     this.compilerCtx = compilerCtx;
     this.buildId = ++this.compilerCtx.activeBuildId;
@@ -274491,12 +274590,21 @@ var updateImportReferenceFactory = (typeCounts, filePath, config) => {
         return;
       }
       const newTypeName = getIncrementTypeName(typeName);
+      let originalExportName;
+      if (typeReference.referenceLocation) {
+        originalExportName = typeReference.referenceLocation;
+      } else {
+        const typeIdParts = typeReference.id.split("::");
+        originalExportName = typeIdParts.length > 1 ? typeIdParts[typeIdParts.length - 1] : typeName;
+      }
       existingTypeImportData[importResolvedFile].push({
-        // Since we create a unique ID for each type for documentation generation purposes, we can parse
-        // that ID to get the original name for the export
-        originalName: typeReference.id.split("::").pop(),
+        // originalName: the name exported from the source module (for import { originalName as ... })
+        // localName: the name used in the component file (the alias if there is one)
+        // importName: Stencil-generated alias to avoid collisions in components.d.ts
+        originalName: originalExportName,
         localName: typeName,
-        importName: newTypeName
+        importName: newTypeName,
+        isDefault: typeReference.isDefault
       });
     });
     return existingTypeImportData;
@@ -274543,23 +274651,48 @@ var generateComponentTypesFile = (config, buildCtx, areTypesInternal) => {
   });
   c.push(COMPONENTS_DTS_HEADER);
   c.push(`import { HTMLStencilElement, JSXBase } from "@stencil/core/internal";`);
-  const expressions = Object.keys(typeImportData).map((filePath) => {
+  const imports = [];
+  const exports2 = [];
+  Object.keys(typeImportData).forEach((filePath) => {
     const typeData = typeImportData[filePath];
     let importFilePath = filePath;
     if ((0, import_path43.isAbsolute)(filePath)) {
       importFilePath = normalizePath("./" + relative(config.srcDir, filePath)).replace(/\.(tsx|ts)$/, "");
     }
-    return `{ ${typeData.sort(sortImportNames).map((td3) => {
-      if (td3.originalName === "") {
-        return `${td3.localName}`;
-      } else if (td3.originalName === td3.importName) {
-        return `${td3.originalName}`;
-      } else {
-        return `${td3.originalName} as ${td3.importName}`;
-      }
-    }).join(`, `)} } from "${importFilePath}";`;
+    const hasDefaultImport = typeData.some((td3) => td3.isDefault);
+    if (hasDefaultImport && typeData.length === 1) {
+      const td3 = typeData[0];
+      imports.push(`import ${td3.importName} from "${importFilePath}";`);
+      exports2.push(`export { default as ${td3.importName} } from "${importFilePath}";`);
+    } else if (hasDefaultImport) {
+      const defaultImport = typeData.find((td3) => td3.isDefault);
+      const namedImports = typeData.filter((td3) => !td3.isDefault);
+      const namedPart = namedImports.sort(sortImportNames).map((td3) => {
+        if (td3.originalName === "") {
+          return `${td3.localName}`;
+        } else if (td3.originalName === td3.importName) {
+          return `${td3.originalName}`;
+        } else {
+          return `${td3.originalName} as ${td3.importName}`;
+        }
+      }).join(`, `);
+      imports.push(`import ${defaultImport.importName}, { ${namedPart} } from "${importFilePath}";`);
+      exports2.push(`export { default as ${defaultImport.importName}, ${namedPart} } from "${importFilePath}";`);
+    } else {
+      const namedPart = typeData.sort(sortImportNames).map((td3) => {
+        if (td3.originalName === "") {
+          return `${td3.localName}`;
+        } else if (td3.originalName === td3.importName) {
+          return `${td3.originalName}`;
+        } else {
+          return `${td3.originalName} as ${td3.importName}`;
+        }
+      }).join(`, `);
+      imports.push(`import { ${namedPart} } from "${importFilePath}";`);
+      exports2.push(`export { ${namedPart} } from "${importFilePath}";`);
+    }
   });
-  c.push(...expressions.map((ref) => `import ${ref}`), ...expressions.map((ref) => `export ${ref}`));
+  c.push(...imports, ...exports2);
   c.push(`export namespace Components {`);
   c.push(...modules.map((m) => `${m.component}`));
   c.push(`}`);
@@ -278697,7 +278830,7 @@ var runTsProgram = async (config, compilerCtx, buildCtx, tsBuilder) => {
   buildCtx.diagnostics.push(...tsGlobal);
   buildCtx.diagnostics.push(...tsOptions);
   if (buildCtx.hasError) {
-    return false;
+    return [];
   }
   const tsProgram = tsBuilder.getProgram();
   const tsTypeChecker = tsProgram.getTypeChecker();
@@ -278754,7 +278887,32 @@ var runTsProgram = async (config, compilerCtx, buildCtx, tsBuilder) => {
   resolveComponentDependencies(buildCtx.components);
   validateTranspiledComponents(config, buildCtx);
   if (buildCtx.hasError) {
-    return false;
+    return [];
+  }
+  return emittedDts;
+};
+var validateTypesAfterGeneration = async (config, compilerCtx, buildCtx, tsBuilder, emittedDts) => {
+  const tsProgram = tsBuilder.getProgram();
+  const typesOutputTarget = config.outputTargets.filter(isOutputTargetDistTypes);
+  const componentsDtsPath = join(config.srcDir, "components.d.ts");
+  const componentsDtsExists = await compilerCtx.fs.access(componentsDtsPath);
+  if (config.validateTypes && componentsDtsExists) {
+    const sourceFiles = tsProgram.getSourceFiles().filter((sf) => {
+      const fileName = normalizePath(sf.fileName);
+      return !fileName.includes("node_modules") && !fileName.endsWith(".d.ts") && fileName.startsWith(normalizePath(config.srcDir));
+    });
+    for (const sourceFile of sourceFiles) {
+      const sourceSemanticDiagnostics = tsProgram.getSemanticDiagnostics(sourceFile);
+      const tsSemantic = loadTypeScriptDiagnostics(sourceSemanticDiagnostics);
+      if (config.devMode) {
+        tsSemantic.forEach((semanticDiagnostic) => {
+          if (semanticDiagnostic.code === "6133" || semanticDiagnostic.code === "6192") {
+            semanticDiagnostic.level = "warn";
+          }
+        });
+      }
+      buildCtx.diagnostics.push(...tsSemantic);
+    }
   }
   const hasTypesChanged = await generateAppTypes(config, compilerCtx, buildCtx, "src");
   if (typesOutputTarget.length > 0) {
@@ -278771,17 +278929,6 @@ var runTsProgram = async (config, compilerCtx, buildCtx, tsBuilder) => {
     });
     await Promise.all(srcRootDtsFiles);
   }
-  if (config.validateTypes && !hasTypesChanged) {
-    const tsSemantic = loadTypeScriptDiagnostics(tsBuilder.getSemanticDiagnostics());
-    if (config.devMode) {
-      tsSemantic.forEach((semanticDiagnostic) => {
-        if (semanticDiagnostic.code === "6133" || semanticDiagnostic.code === "6192") {
-          semanticDiagnostic.level = "warn";
-        }
-      });
-    }
-    buildCtx.diagnostics.push(...tsSemantic);
-  }
   return hasTypesChanged;
 };
 var getRelativeDts = (config, srcPath, emitDtsPath) => {
@@ -279681,9 +279828,17 @@ var build2 = async (config, compilerCtx, buildCtx, tsBuilder) => {
     await readPackageJson(config, compilerCtx, buildCtx);
     if (buildCtx.hasError) return buildAbort(buildCtx);
     const tsTimeSpan = buildCtx.createTimeSpan("transpile started");
-    const componentDtsChanged = await runTsProgram(config, compilerCtx, buildCtx, tsBuilder);
+    const emittedDts = await runTsProgram(config, compilerCtx, buildCtx, tsBuilder);
     tsTimeSpan.finish("transpile finished");
     if (buildCtx.hasError) return buildAbort(buildCtx);
+    const componentDtsChanged = await validateTypesAfterGeneration(
+      config,
+      compilerCtx,
+      buildCtx,
+      tsBuilder,
+      emittedDts
+    );
+    if (buildCtx.hasError) return buildAbort(buildCtx);
     if (config.watch && componentDtsChanged) {
       return null;
     }
@@ -280251,11 +280406,14 @@ var Cache = class {
   constructor(config, cacheFs) {
     this.config = config;
     this.cacheFs = cacheFs;
-    this.failed = 0;
-    this.skip = false;
     this.sys = config.sys;
     this.logger = config.logger;
   }
+  failed = 0;
+  skip = false;
+  sys;
+  logger;
+  buildCacheDir;
   async initCacheDir() {
     if (this.config._isTesting || !this.config.cacheDir) {
       return;
@@ -281606,6 +281764,10 @@ var parseCss = (css, filePath) => {
     });
   };
   class ParsePosition {
+    start;
+    end;
+    source;
+    content;
     constructor(start) {
       this.start = start;
       this.end = { line: lineno, column };
@@ -282901,7 +283063,7 @@ var transformCssToEsmModule = (input) => {
 };
 var generateTransformCssToEsm = (input, results) => {
   const s = new MagicString("");
-  results.styleText = results.styleText.replace(/`/g, "\\`").replace(/\u000c/g, "\\f").replace(/\u0008/g, "\\b").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\u000b/g, "\\v").replace(/\0/g, "\\0").replace(/\\/g, "\\\\");
+  results.styleText = results.styleText.replace(/\n/g, " ").replace(/\r/g, " ").replace(/\t/g, " ").replace(/`/g, "\\`").replace(/\u000c/g, "\\f").replace(/\u0008/g, "\\b").replace(/\u000b/g, "\\v").replace(/\0/g, "\\0").replace(/\\/g, "\\\\");
   if (input.addTagTransformers) {
     results.styleText = addTagTransformToCssString(results.styleText, input.tags);
   }