@stencil/core 4.36.3 → 4.37.0

package/compiler/stencil.js

@@ -1,5 +1,5 @@
 /*!
- Stencil Compiler v4.36.3 | MIT Licensed | https://stenciljs.com
+ Stencil Compiler v4.37.0 | MIT Licensed | https://stenciljs.com
  */
 "use strict";
 var __create = Object.create;
@@ -77616,10 +77616,10 @@ ${lanes.join("\n")}
           const baseClassType = classType && getBaseTypes(classType)[0];
           return baseClassType && getTypeOfPropertyOfType(baseClassType, property3.escapedName);
         }
-        function isPropertyInClassDerivedFrom(prop, baseClass) {
+        function isPropertyInClassDerivedFrom(prop, baseClass2) {
           return forEachProperty2(prop, (sp) => {
             const sourceClass = getDeclaringClass(sp);
-            return sourceClass ? hasBaseType(sourceClass, baseClass) : false;
+            return sourceClass ? hasBaseType(sourceClass, baseClass2) : false;
           });
         }
         function isValidOverrideOf(sourceProp, targetProp) {
@@ -232674,7 +232674,7 @@ module.exports = __toCommonJS(index_exports);
 var import_typescript70 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/version.ts
-var buildId = "1755687753";
+var buildId = "1757722623";
 var minfyJsId = "terser5.37.0_7";
 var optimizeCssId = "autoprefixer10.4.19_postcss8.5.3_7";
 var parse5Version = "7.2.1";
@@ -232682,8 +232682,8 @@ var rollupVersion = "4.34.9";
 var jqueryVersion = "4.0.0-pre";
 var terserVersion = "5.37.0";
 var typescriptVersion = "5.5.4";
-var vermoji = "\u{1F408}";
-var version = "4.36.3";
+var vermoji = "\u26F4";
+var version = "4.37.0";
 var versions = {
   stencil: version,
   parse5: parse5Version,
@@ -234255,6 +234255,11 @@ var scopeCss = (cssText, scopeId, commentOriginalSelector) => {
 var CAPTURE_EVENT_SUFFIX = "Capture";
 var CAPTURE_EVENT_REGEX = new RegExp(CAPTURE_EVENT_SUFFIX + "$");
 
+// src/runtime/mixin.ts
+var baseClass = BUILD.lazyLoad ? class {
+} : globalThis.HTMLElement || class {
+};
+
 // src/utils/sourcemaps.ts
 function rollupToStencilSourceMap(rollupSourceMap) {
   if (!rollupSourceMap || !rollupSourceMap.file) {
@@ -234585,6 +234590,8 @@ var getModuleLegacy = (compilerCtx, sourceFilePath) => {
       sourceFilePath,
       jsFilePath,
       cmps: [],
+      isExtended: false,
+      isMixin: false,
       coreRuntimeApis: [],
       outputTargetCoreRuntimeApis: {},
       collectionName: null,
@@ -236260,17 +236267,261 @@ var transformToAbs = (copyTask, dest) => {
 };
 
 // src/compiler/output-targets/dist-collection/index.ts
-var import_typescript6 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript11 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/map-imports-to-path-aliases.ts
 var import_path7 = require("path");
-var import_typescript5 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript10 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/transform-utils.ts
+var import_typescript9 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+
+// src/compiler/transformers/component-lazy/lazy-constructor.ts
+var import_typescript5 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+
+// src/compiler/transformers/core-runtime-apis.ts
+var CREATE_EVENT = "__stencil_createEvent";
+var DEFINE_CUSTOM_ELEMENT = "__stencil_defineCustomElement";
+var GET_ELEMENT = "__stencil_getElement";
+var HOST = "__stencil_Host";
+var HTML_ELEMENT = "HTMLElement";
+var PROXY_CUSTOM_ELEMENT = "__stencil_proxyCustomElement";
+var REGISTER_INSTANCE = "__stencil_registerInstance";
+var REGISTER_HOST = "__stencil_registerHost";
+var H2 = "__stencil_h";
+var RUNTIME_APIS = {
+  createEvent: `createEvent as ${CREATE_EVENT}`,
+  defineCustomElement: `defineCustomElement as ${DEFINE_CUSTOM_ELEMENT}`,
+  getElement: `getElement as ${GET_ELEMENT}`,
+  h: `h as ${H2}`,
+  legacyH: `h`,
+  Host: `Host as ${HOST}`,
+  HTMLElement: HTML_ELEMENT,
+  proxyCustomElement: `proxyCustomElement as ${PROXY_CUSTOM_ELEMENT}`,
+  registerHost: `registerHost as ${REGISTER_HOST}`,
+  registerInstance: `registerInstance as ${REGISTER_INSTANCE}`
+};
+var addCoreRuntimeApi = (moduleFile, coreRuntimeApi) => {
+  if (!moduleFile.coreRuntimeApis.includes(coreRuntimeApi)) {
+    moduleFile.coreRuntimeApis.push(coreRuntimeApi);
+  }
+};
+var addOutputTargetCoreRuntimeApi = (moduleFile, outputTarget, coreRuntimeApi) => {
+  if (!moduleFile.outputTargetCoreRuntimeApis[outputTarget]) {
+    moduleFile.outputTargetCoreRuntimeApis[outputTarget] = [];
+  }
+  if (!moduleFile.outputTargetCoreRuntimeApis[outputTarget].includes(coreRuntimeApi)) {
+    moduleFile.outputTargetCoreRuntimeApis[outputTarget].push(coreRuntimeApi);
+  }
+};
+var addLegacyApis = (moduleFile) => {
+  addCoreRuntimeApi(moduleFile, RUNTIME_APIS.legacyH);
+};
+
+// src/compiler/transformers/create-event.ts
+var import_typescript3 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var addCreateEvents = (moduleFile, cmp) => {
+  var _a2;
+  if (!((_a2 = cmp == null ? void 0 : cmp.events) == null ? void 0 : _a2.length)) {
+    return [];
+  }
+  return cmp.events.map((ev) => {
+    addCoreRuntimeApi(moduleFile, RUNTIME_APIS.createEvent);
+    return import_typescript3.default.factory.createExpressionStatement(
+      import_typescript3.default.factory.createAssignment(
+        import_typescript3.default.factory.createPropertyAccessExpression(import_typescript3.default.factory.createThis(), import_typescript3.default.factory.createIdentifier(ev.method)),
+        import_typescript3.default.factory.createCallExpression(import_typescript3.default.factory.createIdentifier(CREATE_EVENT), void 0, [
+          import_typescript3.default.factory.createThis(),
+          import_typescript3.default.factory.createStringLiteral(ev.name),
+          import_typescript3.default.factory.createNumericLiteral(computeFlags(ev))
+        ])
+      )
+    );
+  });
+};
+var computeFlags = (eventMeta) => {
+  let flags = 0;
+  if (eventMeta.bubbles) {
+    flags |= 4 /* Bubbles */;
+  }
+  if (eventMeta.composed) {
+    flags |= 2 /* Composed */;
+  }
+  if (eventMeta.cancelable) {
+    flags |= 1 /* Cancellable */;
+  }
+  return flags;
+};
+
+// src/compiler/transformers/component-lazy/attach-internals.ts
 var import_typescript4 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
+// src/compiler/transformers/component-lazy/constants.ts
+var HOST_REF_ARG = "hostRef";
+
+// src/compiler/transformers/component-lazy/attach-internals.ts
+function createLazyAttachInternalsBinding(cmp) {
+  if (!(cmp == null ? void 0 : cmp.attachInternalsMemberName)) {
+    return [];
+  }
+  if (cmp.attachInternalsMemberName) {
+    return [
+      import_typescript4.default.factory.createIfStatement(
+        // the condition for the `if` statement here is just whether the
+        // following is defined:
+        //
+        // ```ts
+        // hostRef.$hostElement$["s-ei"]
+        // ```
+        hostRefElementInternalsPropAccess(),
+        import_typescript4.default.factory.createBlock(
+          [
+            // this `ts.factory` call creates the following statement:
+            //
+            // ```ts
+            // this.${ cmp.formInternalsMemberName } = hostRef.$hostElement$['s-ei'];
+            // ```
+            import_typescript4.default.factory.createExpressionStatement(
+              import_typescript4.default.factory.createBinaryExpression(
+                import_typescript4.default.factory.createPropertyAccessExpression(
+                  import_typescript4.default.factory.createThis(),
+                  // use the name set on the {@link d.ComponentCompilerMeta}
+                  import_typescript4.default.factory.createIdentifier(cmp.attachInternalsMemberName)
+                ),
+                import_typescript4.default.factory.createToken(import_typescript4.default.SyntaxKind.EqualsToken),
+                hostRefElementInternalsPropAccess()
+              )
+            )
+          ],
+          true
+        ),
+        import_typescript4.default.factory.createBlock(
+          [
+            // this `ts.factory` call creates the following statement:
+            //
+            // ```ts
+            // this.${ cmp.attachInternalsMemberName } = hostRef.$hostElement$.attachInternals();
+            // ```
+            import_typescript4.default.factory.createExpressionStatement(
+              import_typescript4.default.factory.createBinaryExpression(
+                import_typescript4.default.factory.createPropertyAccessExpression(
+                  import_typescript4.default.factory.createThis(),
+                  // use the name set on the {@link d.ComponentCompilerMeta}
+                  import_typescript4.default.factory.createIdentifier(cmp.attachInternalsMemberName)
+                ),
+                import_typescript4.default.factory.createToken(import_typescript4.default.SyntaxKind.EqualsToken),
+                import_typescript4.default.factory.createCallExpression(
+                  import_typescript4.default.factory.createPropertyAccessExpression(
+                    import_typescript4.default.factory.createPropertyAccessExpression(
+                      import_typescript4.default.factory.createIdentifier(HOST_REF_ARG),
+                      import_typescript4.default.factory.createIdentifier("$hostElement$")
+                    ),
+                    import_typescript4.default.factory.createIdentifier("attachInternals")
+                  ),
+                  void 0,
+                  []
+                )
+              )
+            ),
+            // this `ts.factory` call produces the following:
+            //
+            // ```ts
+            // hostRef.$hostElement$['s-ei'] = this.${ cmp.attachInternalsMemberName };
+            // ```
+            import_typescript4.default.factory.createExpressionStatement(
+              import_typescript4.default.factory.createBinaryExpression(
+                hostRefElementInternalsPropAccess(),
+                import_typescript4.default.factory.createToken(import_typescript4.default.SyntaxKind.EqualsToken),
+                import_typescript4.default.factory.createPropertyAccessExpression(
+                  import_typescript4.default.factory.createThis(),
+                  // use the name set on the {@link d.ComponentCompilerMeta}
+                  import_typescript4.default.factory.createIdentifier(cmp.attachInternalsMemberName)
+                )
+              )
+            )
+          ],
+          true
+        )
+      )
+    ];
+  } else {
+    return [];
+  }
+}
+function hostRefElementInternalsPropAccess() {
+  return import_typescript4.default.factory.createElementAccessExpression(
+    import_typescript4.default.factory.createPropertyAccessExpression(
+      import_typescript4.default.factory.createIdentifier(HOST_REF_ARG),
+      import_typescript4.default.factory.createIdentifier("$hostElement$")
+    ),
+    import_typescript4.default.factory.createStringLiteral("s-ei")
+  );
+}
+
+// src/compiler/transformers/component-lazy/lazy-constructor.ts
+var updateLazyComponentConstructor = (classMembers, classNode, moduleFile, cmp) => {
+  const cstrMethodArgs = [
+    import_typescript5.default.factory.createParameterDeclaration(void 0, void 0, import_typescript5.default.factory.createIdentifier(HOST_REF_ARG))
+  ];
+  const cstrStatements = [
+    registerInstanceStatement(moduleFile),
+    ...addCreateEvents(moduleFile, cmp),
+    ...createLazyAttachInternalsBinding(cmp)
+  ];
+  updateConstructor(classNode, classMembers, cstrStatements, cstrMethodArgs);
+};
+var registerInstanceStatement = (moduleFile) => {
+  addCoreRuntimeApi(moduleFile, RUNTIME_APIS.registerInstance);
+  return import_typescript5.default.factory.createExpressionStatement(
+    import_typescript5.default.factory.createCallExpression(import_typescript5.default.factory.createIdentifier(REGISTER_INSTANCE), void 0, [
+      import_typescript5.default.factory.createThis(),
+      import_typescript5.default.factory.createIdentifier(HOST_REF_ARG)
+    ])
+  );
+};
+
+// src/compiler/transformers/remove-static-meta-properties.ts
+var import_typescript6 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var removeStaticMetaProperties = (classNode) => {
+  if (classNode.members == null) {
+    return [];
+  }
+  return classNode.members.filter((classMember) => {
+    var _a2;
+    if ((_a2 = retrieveTsModifiers(classMember)) == null ? void 0 : _a2.some((m) => m.kind === import_typescript6.default.SyntaxKind.StaticKeyword)) {
+      const memberName = classMember.name.escapedText;
+      if (readOnlyArrayHasStringMember(STATIC_GETTERS_TO_REMOVE, memberName)) {
+        return false;
+      }
+    }
+    return true;
+  });
+};
+var STATIC_GETTERS_TO_REMOVE = [
+  // we want to remove `attachInternalsMemberName`, which is an 'internal' static
+  // property used to pass a string value along from the 'decorators-to-static'
+  // step through to the `ComponentCompilerMeta` phase, but we want to keep the
+  // `formAssociated` prop that we also set at the same time.
+  "attachInternalsMemberName",
+  "elementRef",
+  "encapsulation",
+  "events",
+  "is",
+  "listeners",
+  "methods",
+  "originalStyleUrls",
+  "properties",
+  "states",
+  "style",
+  "styleMode",
+  "styleUrl",
+  "styleUrls",
+  "styles",
+  "watchers"
+];
+
 // src/compiler/transformers/type-library.ts
-var import_typescript3 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript7 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var TYPE_LIBRARY = {};
 function addToLibrary(type, typeName, checker, pathToTypeModule) {
   pathToTypeModule = relative(process.cwd(), pathToTypeModule);
@@ -236295,13 +236546,13 @@ function getTypeLibrary() {
 }
 function addFileToLibrary(config, filePath) {
   const options = {
-    ...import_typescript3.default.getDefaultCompilerOptions(),
-    module: import_typescript3.default.ModuleKind.ESNext,
-    moduleResolution: import_typescript3.default.ModuleResolutionKind.Node10
+    ...import_typescript7.default.getDefaultCompilerOptions(),
+    module: import_typescript7.default.ModuleKind.ESNext,
+    moduleResolution: import_typescript7.default.ModuleResolutionKind.Node10
   };
-  const program3 = import_typescript3.default.createProgram([filePath], options);
+  const program3 = import_typescript7.default.createProgram([filePath], options);
   const checker = program3.getTypeChecker();
-  const compilerHost = import_typescript3.default.createCompilerHost(options);
+  const compilerHost = import_typescript7.default.createCompilerHost(options);
   const sourceFile = program3.getSourceFile(filePath);
   if (!sourceFile) {
     config.logger.warn(
@@ -236310,25 +236561,25 @@ function addFileToLibrary(config, filePath) {
     return;
   }
   function exportedTypesInSourceFile(sourceFile2, exportedTypeNodes = []) {
-    import_typescript3.default.forEachChild(sourceFile2, (node) => {
+    import_typescript7.default.forEachChild(sourceFile2, (node) => {
       if (isTypeDeclLike(node) && isExported(node) && isNotPrivate(node)) {
         exportedTypeNodes.push(node);
-      } else if (import_typescript3.default.isExportDeclaration(node)) {
-        if (!node.moduleSpecifier || !import_typescript3.default.isStringLiteral(node.moduleSpecifier)) {
+      } else if (import_typescript7.default.isExportDeclaration(node)) {
+        if (!node.moduleSpecifier || !import_typescript7.default.isStringLiteral(node.moduleSpecifier)) {
           return;
         }
         const exportHomeModule = getHomeModule(sourceFile2, node.moduleSpecifier.text, options, compilerHost, program3);
         if (!exportHomeModule) {
           return;
         }
-        if (node.exportClause && import_typescript3.default.isNamedExports(node.exportClause)) {
+        if (node.exportClause && import_typescript7.default.isNamedExports(node.exportClause)) {
           for (const exportSpecifier3 of node.exportClause.elements) {
             const identifier3 = exportSpecifier3.getChildAt(0);
             if (!identifier3) {
               return;
             }
             const name = getOriginalTypeName(identifier3, checker);
-            import_typescript3.default.forEachChild(exportHomeModule, (child) => {
+            import_typescript7.default.forEachChild(exportHomeModule, (child) => {
               if (isTypeDeclLike(child) && child.name.getText() === name) {
                 exportedTypeNodes.push(child);
               }
@@ -236349,7 +236600,7 @@ function addFileToLibrary(config, filePath) {
 }
 function getHomeModule(importer, importPath, options, compilerHost, program3) {
   var _a2;
-  const module2 = import_typescript3.default.resolveModuleName(importPath, importer.fileName, options, compilerHost);
+  const module2 = import_typescript7.default.resolveModuleName(importPath, importer.fileName, options, compilerHost);
   const resolvedFileName = (_a2 = module2 == null ? void 0 : module2.resolvedModule) == null ? void 0 : _a2.resolvedFileName;
   if (!resolvedFileName) {
     return void 0;
@@ -236359,7 +236610,7 @@ function getHomeModule(importer, importPath, options, compilerHost, program3) {
 }
 function findTypeWithName(module2, typeName) {
   let typeWithName;
-  import_typescript3.default.forEachChild(module2, (child) => {
+  import_typescript7.default.forEachChild(module2, (child) => {
     if (isTypeDeclLike(child) && child.name.getText() === typeName) {
       typeWithName = child;
     }
@@ -236376,16 +236627,16 @@ function getOriginalTypeName(identifier3, checker) {
   return name;
 }
 function unalias(symbol, checker) {
-  return symbol.flags & import_typescript3.default.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  return symbol.flags & import_typescript7.default.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
 }
 function isTypeDeclLike(node) {
-  return import_typescript3.default.isInterfaceDeclaration(node) || import_typescript3.default.isTypeAliasDeclaration(node) || import_typescript3.default.isEnumDeclaration(node);
+  return import_typescript7.default.isInterfaceDeclaration(node) || import_typescript7.default.isTypeAliasDeclaration(node) || import_typescript7.default.isEnumDeclaration(node);
 }
 function isExported(node) {
-  return (import_typescript3.default.getCombinedModifierFlags(node) & import_typescript3.default.ModifierFlags.Export) !== 0;
+  return (import_typescript7.default.getCombinedModifierFlags(node) & import_typescript7.default.ModifierFlags.Export) !== 0;
 }
 function isNotPrivate(node) {
-  const jsDocTags = import_typescript3.default.getJSDocTags(node);
+  const jsDocTags = import_typescript7.default.getJSDocTags(node);
   return !jsDocTags.some((tag) => tag.tagName.text === "private");
 }
 function getTypeDeclaration(checker, type) {
@@ -236400,7 +236651,7 @@ function getTypeDeclaration(checker, type) {
 }
 function getTypeDocstring(type, checker) {
   const symbol = type == null ? void 0 : type.symbol;
-  return symbol ? import_typescript3.default.displayPartsToString(symbol.getDocumentationComment(checker)) : "";
+  return symbol ? import_typescript7.default.displayPartsToString(symbol.getDocumentationComment(checker)) : "";
 }
 var getTypeId = (pathToTypeModule, typeName) => {
   return `${normalizePath(pathToTypeModule, false)}::${typeName}`;
@@ -236415,11 +236666,67 @@ function getSymbolForType(type) {
   return null;
 }
 
+// src/compiler/transformers/update-component-class.ts
+var import_typescript8 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var updateComponentClass = (transformOpts, classNode, heritageClauses, members) => {
+  var _a2, _b, _c;
+  let classModifiers = (_b = (_a2 = retrieveTsModifiers(classNode)) == null ? void 0 : _a2.slice()) != null ? _b : [];
+  if (transformOpts.module === "cjs") {
+    if (transformOpts.componentExport === "customelement") {
+      classModifiers = classModifiers.filter((m) => {
+        return m.kind !== import_typescript8.default.SyntaxKind.ExportKeyword;
+      });
+    }
+    return import_typescript8.default.factory.updateClassDeclaration(
+      classNode,
+      [...(_c = retrieveTsDecorators(classNode)) != null ? _c : [], ...classModifiers],
+      classNode.name,
+      classNode.typeParameters,
+      heritageClauses,
+      members
+    );
+  }
+  return createConstClass(transformOpts, classNode, heritageClauses, members);
+};
+var createConstClass = (transformOpts, classNode, heritageClauses, members) => {
+  var _a2;
+  const className = classNode.name;
+  const tsModifiers = (_a2 = retrieveTsModifiers(classNode)) != null ? _a2 : [];
+  const classHasExportKeyword = tsModifiers.some((m) => m.kind === import_typescript8.default.SyntaxKind.ExportKeyword);
+  const classModifiers = tsModifiers.filter((m) => {
+    return m.kind !== import_typescript8.default.SyntaxKind.ExportKeyword;
+  });
+  const constModifiers = [];
+  if (transformOpts.componentExport !== "customelement" && classHasExportKeyword) {
+    constModifiers.push(import_typescript8.default.factory.createModifier(import_typescript8.default.SyntaxKind.ExportKeyword));
+  }
+  return import_typescript8.default.factory.createVariableStatement(
+    constModifiers,
+    import_typescript8.default.factory.createVariableDeclarationList(
+      [
+        import_typescript8.default.factory.createVariableDeclaration(
+          className,
+          void 0,
+          void 0,
+          import_typescript8.default.factory.createClassExpression(
+            classModifiers,
+            void 0,
+            classNode.typeParameters,
+            heritageClauses,
+            members
+          )
+        )
+      ],
+      import_typescript8.default.NodeFlags.Const
+    )
+  );
+};
+
 // src/compiler/transformers/transform-utils.ts
 var isMemberPrivate = (member2) => {
   var _a2;
   return !!((_a2 = retrieveTsModifiers(member2)) == null ? void 0 : _a2.some(
-    (m) => m.kind === import_typescript4.default.SyntaxKind.PrivateKeyword || m.kind === import_typescript4.default.SyntaxKind.ProtectedKeyword
+    (m) => m.kind === import_typescript9.default.SyntaxKind.PrivateKeyword || m.kind === import_typescript9.default.SyntaxKind.ProtectedKeyword
   ));
 };
 var convertValueToLiteral = (val, refs = null) => {
@@ -236427,70 +236734,70 @@ var convertValueToLiteral = (val, refs = null) => {
     refs = /* @__PURE__ */ new WeakSet();
   }
   if (val === String) {
-    return import_typescript4.default.factory.createIdentifier("String");
+    return import_typescript9.default.factory.createIdentifier("String");
   }
   if (val === Number) {
-    return import_typescript4.default.factory.createIdentifier("Number");
+    return import_typescript9.default.factory.createIdentifier("Number");
   }
   if (val === Boolean) {
-    return import_typescript4.default.factory.createIdentifier("Boolean");
+    return import_typescript9.default.factory.createIdentifier("Boolean");
   }
   if (val === void 0) {
-    return import_typescript4.default.factory.createIdentifier("undefined");
+    return import_typescript9.default.factory.createIdentifier("undefined");
   }
   if (val === null) {
-    return import_typescript4.default.factory.createIdentifier("null");
+    return import_typescript9.default.factory.createIdentifier("null");
   }
   if (Array.isArray(val)) {
     return arrayToArrayLiteral(val, refs);
   }
   if (typeof val === "object") {
     if (val.__identifier && val.__escapedText) {
-      return import_typescript4.default.factory.createIdentifier(val.__escapedText);
+      return import_typescript9.default.factory.createIdentifier(val.__escapedText);
     }
     return objectToObjectLiteral(val, refs);
   }
   if (typeof val === "number") {
-    return import_typescript4.default.factory.createNumericLiteral(val);
+    return import_typescript9.default.factory.createNumericLiteral(val);
   }
   if (typeof val === "object" && "base10Value" in val) {
-    return import_typescript4.default.factory.createBigIntLiteral(val);
+    return import_typescript9.default.factory.createBigIntLiteral(val);
   }
   if (typeof val === "boolean") {
-    return val ? import_typescript4.default.factory.createTrue() : import_typescript4.default.factory.createFalse();
+    return val ? import_typescript9.default.factory.createTrue() : import_typescript9.default.factory.createFalse();
   }
   if (typeof val === "string") {
-    return import_typescript4.default.factory.createStringLiteral(val, void 0);
+    return import_typescript9.default.factory.createStringLiteral(val, void 0);
   }
-  return import_typescript4.default.factory.createStringLiteralFromNode(val);
+  return import_typescript9.default.factory.createStringLiteralFromNode(val);
 };
 var arrayToArrayLiteral = (list, refs) => {
   const newList = list.map((l) => {
     return convertValueToLiteral(l, refs);
   });
-  return import_typescript4.default.factory.createArrayLiteralExpression(newList);
+  return import_typescript9.default.factory.createArrayLiteralExpression(newList);
 };
 var objectToObjectLiteral = (obj, refs) => {
   if (refs.has(obj)) {
-    return import_typescript4.default.factory.createIdentifier("undefined");
+    return import_typescript9.default.factory.createIdentifier("undefined");
   }
   refs.add(obj);
   const newProperties = Object.keys(obj).map((key) => {
-    const prop = import_typescript4.default.factory.createPropertyAssignment(
-      import_typescript4.default.factory.createStringLiteral(key),
+    const prop = import_typescript9.default.factory.createPropertyAssignment(
+      import_typescript9.default.factory.createStringLiteral(key),
       convertValueToLiteral(obj[key], refs)
     );
     return prop;
   });
-  return import_typescript4.default.factory.createObjectLiteralExpression(newProperties, true);
+  return import_typescript9.default.factory.createObjectLiteralExpression(newProperties, true);
 };
 var createStaticGetter = (propName, returnExpression) => {
-  return import_typescript4.default.factory.createGetAccessorDeclaration(
-    [import_typescript4.default.factory.createToken(import_typescript4.default.SyntaxKind.StaticKeyword)],
+  return import_typescript9.default.factory.createGetAccessorDeclaration(
+    [import_typescript9.default.factory.createToken(import_typescript9.default.SyntaxKind.StaticKeyword)],
     propName,
     [],
     void 0,
-    import_typescript4.default.factory.createBlock([import_typescript4.default.factory.createReturnStatement(returnExpression)])
+    import_typescript9.default.factory.createBlock([import_typescript9.default.factory.createReturnStatement(returnExpression)])
   );
 };
 var getStaticValue = (staticMembers, staticName) => {
@@ -236504,31 +236811,31 @@ var getStaticValue = (staticMembers, staticName) => {
     return null;
   }
   const rtnStatement = staticMember.body.statements.find(
-    (s) => s.kind === import_typescript4.default.SyntaxKind.ReturnStatement
+    (s) => s.kind === import_typescript9.default.SyntaxKind.ReturnStatement
   );
   if (!rtnStatement || !rtnStatement.expression) {
     return null;
   }
   const expKind = rtnStatement.expression.kind;
-  if (expKind === import_typescript4.default.SyntaxKind.StringLiteral) {
+  if (expKind === import_typescript9.default.SyntaxKind.StringLiteral) {
     return rtnStatement.expression.text;
   }
-  if (expKind === import_typescript4.default.SyntaxKind.NoSubstitutionTemplateLiteral) {
+  if (expKind === import_typescript9.default.SyntaxKind.NoSubstitutionTemplateLiteral) {
     return rtnStatement.expression.text;
   }
-  if (expKind === import_typescript4.default.SyntaxKind.TrueKeyword) {
+  if (expKind === import_typescript9.default.SyntaxKind.TrueKeyword) {
     return true;
   }
-  if (expKind === import_typescript4.default.SyntaxKind.FalseKeyword) {
+  if (expKind === import_typescript9.default.SyntaxKind.FalseKeyword) {
     return false;
   }
-  if (expKind === import_typescript4.default.SyntaxKind.ObjectLiteralExpression) {
+  if (expKind === import_typescript9.default.SyntaxKind.ObjectLiteralExpression) {
     return objectLiteralToObjectMap(rtnStatement.expression);
   }
-  if (expKind === import_typescript4.default.SyntaxKind.ArrayLiteralExpression && rtnStatement.expression.elements) {
+  if (expKind === import_typescript9.default.SyntaxKind.ArrayLiteralExpression && rtnStatement.expression.elements) {
     return arrayLiteralToArray(rtnStatement.expression);
   }
-  if (expKind === import_typescript4.default.SyntaxKind.Identifier) {
+  if (expKind === import_typescript9.default.SyntaxKind.Identifier) {
     const identifier3 = rtnStatement.expression;
     if (typeof identifier3.escapedText === "string") {
       return getIdentifierValue(identifier3.escapedText);
@@ -236547,19 +236854,19 @@ var arrayLiteralToArray = (arr) => {
   return arr.elements.map((element) => {
     let val;
     switch (element.kind) {
-      case import_typescript4.default.SyntaxKind.ObjectLiteralExpression:
+      case import_typescript9.default.SyntaxKind.ObjectLiteralExpression:
         val = objectLiteralToObjectMap(element);
         break;
-      case import_typescript4.default.SyntaxKind.StringLiteral:
+      case import_typescript9.default.SyntaxKind.StringLiteral:
         val = element.text;
         break;
-      case import_typescript4.default.SyntaxKind.TrueKeyword:
+      case import_typescript9.default.SyntaxKind.TrueKeyword:
         val = true;
         break;
-      case import_typescript4.default.SyntaxKind.FalseKeyword:
+      case import_typescript9.default.SyntaxKind.FalseKeyword:
         val = false;
         break;
-      case import_typescript4.default.SyntaxKind.Identifier:
+      case import_typescript9.default.SyntaxKind.Identifier:
         const escapedText = element.escapedText;
         if (escapedText === "String") {
           val = String;
@@ -236569,7 +236876,7 @@ var arrayLiteralToArray = (arr) => {
           val = Boolean;
         }
         break;
-      case import_typescript4.default.SyntaxKind.PropertyAccessExpression:
+      case import_typescript9.default.SyntaxKind.PropertyAccessExpression:
       default:
         val = element;
     }
@@ -236582,29 +236889,29 @@ var objectLiteralToObjectMap = (objectLiteral) => {
   for (const propAssignment of properties) {
     const propName = getTextOfPropertyName(propAssignment.name);
     let val;
-    if (import_typescript4.default.isShorthandPropertyAssignment(propAssignment)) {
+    if (import_typescript9.default.isShorthandPropertyAssignment(propAssignment)) {
       val = getIdentifierValue(propName);
-    } else if (import_typescript4.default.isPropertyAssignment(propAssignment)) {
+    } else if (import_typescript9.default.isPropertyAssignment(propAssignment)) {
       switch (propAssignment.initializer.kind) {
-        case import_typescript4.default.SyntaxKind.ArrayLiteralExpression:
+        case import_typescript9.default.SyntaxKind.ArrayLiteralExpression:
           val = arrayLiteralToArray(propAssignment.initializer);
           break;
-        case import_typescript4.default.SyntaxKind.ObjectLiteralExpression:
+        case import_typescript9.default.SyntaxKind.ObjectLiteralExpression:
           val = objectLiteralToObjectMap(propAssignment.initializer);
           break;
-        case import_typescript4.default.SyntaxKind.StringLiteral:
+        case import_typescript9.default.SyntaxKind.StringLiteral:
           val = propAssignment.initializer.text;
           break;
-        case import_typescript4.default.SyntaxKind.NoSubstitutionTemplateLiteral:
+        case import_typescript9.default.SyntaxKind.NoSubstitutionTemplateLiteral:
           val = propAssignment.initializer.text;
           break;
-        case import_typescript4.default.SyntaxKind.TrueKeyword:
+        case import_typescript9.default.SyntaxKind.TrueKeyword:
           val = true;
           break;
-        case import_typescript4.default.SyntaxKind.FalseKeyword:
+        case import_typescript9.default.SyntaxKind.FalseKeyword:
           val = false;
           break;
-        case import_typescript4.default.SyntaxKind.Identifier:
+        case import_typescript9.default.SyntaxKind.Identifier:
           const escapedText = propAssignment.initializer.escapedText;
           if (escapedText === "String") {
             val = String;
@@ -236620,7 +236927,7 @@ var objectLiteralToObjectMap = (objectLiteral) => {
             val = getIdentifierValue(propAssignment.initializer.escapedText);
           }
           break;
-        case import_typescript4.default.SyntaxKind.PropertyAccessExpression:
+        case import_typescript9.default.SyntaxKind.PropertyAccessExpression:
         default:
           val = propAssignment.initializer;
       }
@@ -236638,14 +236945,14 @@ var getIdentifierValue = (escapedText) => {
 };
 var getTextOfPropertyName = (propName) => {
   switch (propName.kind) {
-    case import_typescript4.default.SyntaxKind.Identifier:
+    case import_typescript9.default.SyntaxKind.Identifier:
       return propName.text;
-    case import_typescript4.default.SyntaxKind.StringLiteral:
-    case import_typescript4.default.SyntaxKind.NumericLiteral:
+    case import_typescript9.default.SyntaxKind.StringLiteral:
+    case import_typescript9.default.SyntaxKind.NumericLiteral:
       return propName.text;
-    case import_typescript4.default.SyntaxKind.ComputedPropertyName:
+    case import_typescript9.default.SyntaxKind.ComputedPropertyName:
       const expression = propName.expression;
-      if (import_typescript4.default.isStringLiteral(expression) || import_typescript4.default.isNumericLiteral(expression)) {
+      if (import_typescript9.default.isStringLiteral(expression) || import_typescript9.default.isNumericLiteral(expression)) {
         return propName.expression.text;
       }
   }
@@ -236660,7 +236967,7 @@ var getAttributeTypeInfo = (baseNode, sourceFile, checker, program3) => {
   return allReferences;
 };
 var getEntityName = (entity) => {
-  if (import_typescript4.default.isIdentifier(entity)) {
+  if (import_typescript9.default.isIdentifier(entity)) {
     return entity.escapedText.toString();
   } else {
     return getEntityName(entity.left);
@@ -236669,13 +236976,13 @@ var getEntityName = (entity) => {
 var getAllTypeReferences = (checker, node) => {
   const referencedTypes = [];
   const visit2 = (node2) => {
-    if (import_typescript4.default.isTypeReferenceNode(node2)) {
+    if (import_typescript9.default.isTypeReferenceNode(node2)) {
       referencedTypes.push({
         name: getEntityName(node2.typeName),
         type: checker.getTypeFromTypeNode(node2)
       });
       if (node2.typeArguments) {
-        node2.typeArguments.filter((typeArg) => import_typescript4.default.isTypeReferenceNode(typeArg)).forEach((typeRef) => {
+        node2.typeArguments.filter((typeArg) => import_typescript9.default.isTypeReferenceNode(typeArg)).forEach((typeRef) => {
           const typeName = typeRef.typeName;
           if (typeName && typeName.escapedText) {
             referencedTypes.push({
@@ -236686,7 +236993,7 @@ var getAllTypeReferences = (checker, node) => {
         });
       }
     }
-    return import_typescript4.default.forEachChild(node2, visit2);
+    return import_typescript9.default.forEachChild(node2, visit2);
   };
   visit2(node);
   return referencedTypes;
@@ -236694,17 +237001,17 @@ var getAllTypeReferences = (checker, node) => {
 var getTypeReferenceLocation = (typeName, type, sourceFile, checker, program3) => {
   var _a2;
   const importTypeDeclaration = sourceFile.statements.find((st) => {
-    const statement = import_typescript4.default.isImportDeclaration(st) && st.importClause && import_typescript4.default.isImportClause(st.importClause) && st.importClause.namedBindings && import_typescript4.default.isNamedImports(st.importClause.namedBindings) && Array.isArray(st.importClause.namedBindings.elements) && st.importClause.namedBindings.elements.find((nbe) => nbe.name.getText() === typeName);
+    const statement = import_typescript9.default.isImportDeclaration(st) && st.importClause && import_typescript9.default.isImportClause(st.importClause) && st.importClause.namedBindings && import_typescript9.default.isNamedImports(st.importClause.namedBindings) && Array.isArray(st.importClause.namedBindings.elements) && st.importClause.namedBindings.elements.find((nbe) => nbe.name.getText() === typeName);
     if (!statement) {
       return false;
     }
     return true;
   });
   const namedImportBindings = (_a2 = importTypeDeclaration == null ? void 0 : importTypeDeclaration.importClause) == null ? void 0 : _a2.namedBindings;
-  if (importTypeDeclaration && import_typescript4.default.isNamedImports(namedImportBindings)) {
+  if (importTypeDeclaration && import_typescript9.default.isNamedImports(namedImportBindings)) {
     const localImportPath = importTypeDeclaration.moduleSpecifier.text;
     const options = program3.getCompilerOptions();
-    const compilerHost = import_typescript4.default.createCompilerHost(options);
+    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;
@@ -236721,11 +237028,11 @@ var getTypeReferenceLocation = (typeName, type, sourceFile, checker, program3) =
   }
   const isExported2 = sourceFile.statements.some((st) => {
     const statementModifiers = retrieveTsModifiers(st);
-    const isDeclarationExported = (statement) => statement.name.getText() === typeName && Array.isArray(statementModifiers) && statementModifiers.some((mod) => mod.kind === import_typescript4.default.SyntaxKind.ExportKeyword);
-    const isInterfaceDeclarationExported = import_typescript4.default.isInterfaceDeclaration(st) && isDeclarationExported(st);
-    const isTypeAliasDeclarationExported = import_typescript4.default.isTypeAliasDeclaration(st) && isDeclarationExported(st);
-    const isEnumDeclarationExported = import_typescript4.default.isEnumDeclaration(st) && isDeclarationExported(st);
-    const isTypeInExportDeclaration = import_typescript4.default.isExportDeclaration(st) && import_typescript4.default.isNamedExports(st.exportClause) && st.exportClause.elements.some((nee) => nee.name.getText() === typeName);
+    const isDeclarationExported = (statement) => statement.name.getText() === typeName && Array.isArray(statementModifiers) && statementModifiers.some((mod) => mod.kind === import_typescript9.default.SyntaxKind.ExportKeyword);
+    const isInterfaceDeclarationExported = import_typescript9.default.isInterfaceDeclaration(st) && isDeclarationExported(st);
+    const isTypeAliasDeclarationExported = import_typescript9.default.isTypeAliasDeclaration(st) && isDeclarationExported(st);
+    const isEnumDeclarationExported = import_typescript9.default.isEnumDeclaration(st) && isDeclarationExported(st);
+    const isTypeInExportDeclaration = import_typescript9.default.isExportDeclaration(st) && import_typescript9.default.isNamedExports(st.exportClause) && st.exportClause.elements.some((nee) => nee.name.getText() === typeName);
     return isInterfaceDeclarationExported || isTypeAliasDeclarationExported || isEnumDeclarationExported || isTypeInExportDeclaration;
   });
   if (isExported2) {
@@ -236768,7 +237075,7 @@ var resolveType = (checker, type) => {
   }
 };
 var typeToString = (checker, type) => {
-  const TYPE_FORMAT_FLAGS = import_typescript4.default.TypeFormatFlags.NoTruncation | import_typescript4.default.TypeFormatFlags.InTypeAlias | import_typescript4.default.TypeFormatFlags.InElementType;
+  const TYPE_FORMAT_FLAGS = import_typescript9.default.TypeFormatFlags.NoTruncation | import_typescript9.default.TypeFormatFlags.InTypeAlias | import_typescript9.default.TypeFormatFlags.InElementType;
   return checker.typeToString(type, void 0, TYPE_FORMAT_FLAGS);
 };
 var parseDocsType = (checker, type, parts) => {
@@ -236805,6 +237112,11 @@ var getComponentMeta = (compilerCtx, tsSourceFile, node) => {
   }
   return void 0;
 };
+var updateMixin = (classNode, moduleFile, cmp, transformOpts) => {
+  const classMembers = removeStaticMetaProperties(classNode);
+  updateLazyComponentConstructor(classMembers, classNode, moduleFile, cmp);
+  return updateComponentClass(transformOpts, classNode, classNode.heritageClauses, classMembers);
+};
 var getComponentTagName = (staticMembers) => {
   if (staticMembers.length > 0) {
     const tagName = getStaticValue(staticMembers, "is");
@@ -236817,7 +237129,7 @@ var getComponentTagName = (staticMembers) => {
 var isStaticGetter = (member2) => {
   var _a2;
   const modifiers = retrieveTsModifiers(member2);
-  return (_a2 = member2.kind === import_typescript4.default.SyntaxKind.GetAccessor && Array.isArray(modifiers) && modifiers.some(({ kind }) => kind === import_typescript4.default.SyntaxKind.StaticKeyword)) != null ? _a2 : false;
+  return (_a2 = member2.kind === import_typescript9.default.SyntaxKind.GetAccessor && Array.isArray(modifiers) && modifiers.some(({ kind }) => kind === import_typescript9.default.SyntaxKind.StaticKeyword)) != null ? _a2 : false;
 };
 var serializeSymbol = (checker, symbol) => {
   if (!checker || !symbol) {
@@ -236828,7 +237140,7 @@ var serializeSymbol = (checker, symbol) => {
   }
   return {
     tags: mapJSDocTagInfo(symbol.getJsDocTags()),
-    text: import_typescript4.default.displayPartsToString(symbol.getDocumentationComment(checker))
+    text: import_typescript9.default.displayPartsToString(symbol.getDocumentationComment(checker))
   };
 };
 var mapJSDocTagInfo = (tags) => {
@@ -236841,7 +237153,7 @@ var isInternal = (jsDocs) => {
   return !!(jsDocs && jsDocs.tags.some((s) => s.name === "internal"));
 };
 var isMethod = (member2, methodName) => {
-  return import_typescript4.default.isMethodDeclaration(member2) && member2.name && member2.name.escapedText === methodName;
+  return import_typescript9.default.isMethodDeclaration(member2) && member2.name && member2.name.escapedText === methodName;
 };
 var createImportStatement = (importFnNames, importPath) => {
   const importSpecifiers = importFnNames.map((importKey) => {
@@ -236852,20 +237164,20 @@ var createImportStatement = (importFnNames, importPath) => {
       importAs = splt[1];
       importFnName = splt[0];
     }
-    return import_typescript4.default.factory.createImportSpecifier(
+    return import_typescript9.default.factory.createImportSpecifier(
       false,
-      typeof importFnName === "string" && importFnName !== importAs ? import_typescript4.default.factory.createIdentifier(importFnName) : void 0,
-      import_typescript4.default.factory.createIdentifier(importAs)
+      typeof importFnName === "string" && importFnName !== importAs ? import_typescript9.default.factory.createIdentifier(importFnName) : void 0,
+      import_typescript9.default.factory.createIdentifier(importAs)
     );
   });
-  return import_typescript4.default.factory.createImportDeclaration(
+  return import_typescript9.default.factory.createImportDeclaration(
     void 0,
-    import_typescript4.default.factory.createImportClause(false, void 0, import_typescript4.default.factory.createNamedImports(importSpecifiers)),
-    import_typescript4.default.factory.createStringLiteral(importPath)
+    import_typescript9.default.factory.createImportClause(false, void 0, import_typescript9.default.factory.createNamedImports(importSpecifiers)),
+    import_typescript9.default.factory.createStringLiteral(importPath)
   );
 };
 var createRequireStatement = (importFnNames, importPath) => {
-  const importBinding = import_typescript4.default.factory.createObjectBindingPattern(
+  const importBinding = import_typescript9.default.factory.createObjectBindingPattern(
     importFnNames.map((importKey) => {
       const splt = importKey.split(" as ");
       let importAs = importKey;
@@ -236874,25 +237186,25 @@ var createRequireStatement = (importFnNames, importPath) => {
         importAs = splt[1];
         importFnName = splt[0];
       }
-      return import_typescript4.default.factory.createBindingElement(void 0, importFnName, importAs);
+      return import_typescript9.default.factory.createBindingElement(void 0, importFnName, importAs);
     })
   );
-  return import_typescript4.default.factory.createVariableStatement(
+  return import_typescript9.default.factory.createVariableStatement(
     void 0,
-    import_typescript4.default.factory.createVariableDeclarationList(
+    import_typescript9.default.factory.createVariableDeclarationList(
       [
-        import_typescript4.default.factory.createVariableDeclaration(
+        import_typescript9.default.factory.createVariableDeclaration(
           importBinding,
           void 0,
           void 0,
-          import_typescript4.default.factory.createCallExpression(
-            import_typescript4.default.factory.createIdentifier("require"),
+          import_typescript9.default.factory.createCallExpression(
+            import_typescript9.default.factory.createIdentifier("require"),
             [],
-            [import_typescript4.default.factory.createStringLiteral(importPath)]
+            [import_typescript9.default.factory.createStringLiteral(importPath)]
           )
         )
       ],
-      import_typescript4.default.NodeFlags.Const
+      import_typescript9.default.NodeFlags.Const
     )
   );
 };
@@ -236901,36 +237213,49 @@ var retrieveModifierLike = (node) => {
   return [...(_a2 = retrieveTsDecorators(node)) != null ? _a2 : [], ...(_b = retrieveTsModifiers(node)) != null ? _b : []];
 };
 var retrieveTsDecorators = (node) => {
-  return import_typescript4.default.canHaveDecorators(node) ? import_typescript4.default.getDecorators(node) : void 0;
+  return import_typescript9.default.canHaveDecorators(node) ? import_typescript9.default.getDecorators(node) : void 0;
 };
 var retrieveTsModifiers = (node) => {
-  return import_typescript4.default.canHaveModifiers(node) ? import_typescript4.default.getModifiers(node) : void 0;
+  return import_typescript9.default.canHaveModifiers(node) ? import_typescript9.default.getModifiers(node) : void 0;
 };
-var updateConstructor = (classNode, classMembers, statements, parameters) => {
-  var _a2, _b, _c;
-  const constructorIndex = classMembers.findIndex((m) => m.kind === import_typescript4.default.SyntaxKind.Constructor);
+function foundSuper(constructorBodyStatements) {
+  return constructorBodyStatements == null ? void 0 : constructorBodyStatements.find(
+    (s) => import_typescript9.default.isExpressionStatement(s) && import_typescript9.default.isCallExpression(s.expression) && s.expression.expression.kind === import_typescript9.default.SyntaxKind.SuperKeyword
+  );
+}
+var updateConstructor = (classNode, classMembers, statements, parameters, includeFalseArg) => {
+  var _a2, _b;
+  const constructorIndex = classMembers.findIndex((m) => m.kind === import_typescript9.default.SyntaxKind.Constructor);
   const constructorMethod = classMembers[constructorIndex];
   if (constructorIndex < 0 && !(statements == null ? void 0 : statements.length) && !needsSuper(classNode)) return classMembers;
-  if (constructorIndex >= 0 && import_typescript4.default.isConstructorDeclaration(constructorMethod)) {
-    const constructorBodyStatements = (_b = (_a2 = constructorMethod.body) == null ? void 0 : _a2.statements) != null ? _b : import_typescript4.default.factory.createNodeArray();
-    const hasSuper = constructorBodyStatements.some((s) => s.kind === import_typescript4.default.SyntaxKind.SuperKeyword);
-    if (!hasSuper && needsSuper(classNode)) {
-      statements = [createConstructorBodyWithSuper(), ...statements, ...constructorBodyStatements];
+  if (constructorIndex >= 0 && import_typescript9.default.isConstructorDeclaration(constructorMethod)) {
+    const constructorBodyStatements = (_a2 = constructorMethod.body) == null ? void 0 : _a2.statements;
+    let foundSuperCall = foundSuper(constructorBodyStatements);
+    if (!foundSuperCall && needsSuper(classNode)) {
+      statements = [createConstructorBodyWithSuper(includeFalseArg), ...statements, ...constructorBodyStatements];
     } else {
-      statements = [...statements, ...constructorBodyStatements];
+      const updatedStatements = constructorBodyStatements.filter((s) => s !== foundSuperCall);
+      if (foundSuperCall) {
+        if (includeFalseArg) {
+          foundSuperCall = createConstructorBodyWithSuper(includeFalseArg);
+        }
+        statements = [foundSuperCall, ...statements, ...updatedStatements];
+      } else {
+        statements = [...statements, ...updatedStatements];
+      }
     }
-    classMembers[constructorIndex] = import_typescript4.default.factory.updateConstructorDeclaration(
+    classMembers[constructorIndex] = import_typescript9.default.factory.updateConstructorDeclaration(
       constructorMethod,
       retrieveTsModifiers(constructorMethod),
       constructorMethod.parameters.concat(parameters != null ? parameters : []),
-      import_typescript4.default.factory.updateBlock((_c = constructorMethod == null ? void 0 : constructorMethod.body) != null ? _c : import_typescript4.default.factory.createBlock([]), statements)
+      import_typescript9.default.factory.updateBlock((_b = constructorMethod == null ? void 0 : constructorMethod.body) != null ? _b : import_typescript9.default.factory.createBlock([]), statements)
     );
   } else {
     if (needsSuper(classNode)) {
-      statements = [createConstructorBodyWithSuper(), ...statements];
+      statements = [createConstructorBodyWithSuper(includeFalseArg), ...statements];
     }
     classMembers.unshift(
-      import_typescript4.default.factory.createConstructorDeclaration(void 0, parameters != null ? parameters : [], import_typescript4.default.factory.createBlock(statements, true))
+      import_typescript9.default.factory.createConstructorDeclaration(void 0, parameters != null ? parameters : [], import_typescript9.default.factory.createBlock(statements, true))
     );
   }
   return classMembers;
@@ -236938,20 +237263,24 @@ var updateConstructor = (classNode, classMembers, statements, parameters) => {
 var needsSuper = (classDeclaration3) => {
   const hasHeritageClauses = classDeclaration3.heritageClauses && classDeclaration3.heritageClauses.length > 0;
   if (hasHeritageClauses) {
-    return classDeclaration3.heritageClauses.some((clause) => clause.token === import_typescript4.default.SyntaxKind.ExtendsKeyword);
+    return classDeclaration3.heritageClauses.some((clause) => clause.token === import_typescript9.default.SyntaxKind.ExtendsKeyword);
   }
   return false;
 };
-var createConstructorBodyWithSuper = () => {
-  return import_typescript4.default.factory.createExpressionStatement(
-    import_typescript4.default.factory.createCallExpression(import_typescript4.default.factory.createIdentifier("super"), void 0, void 0)
+var createConstructorBodyWithSuper = (includeFalseArg) => {
+  return import_typescript9.default.factory.createExpressionStatement(
+    import_typescript9.default.factory.createCallExpression(
+      import_typescript9.default.factory.createIdentifier("super"),
+      void 0,
+      includeFalseArg ? [import_typescript9.default.factory.createFalse()] : void 0
+    )
   );
 };
 var tsPropDeclName = (node, typeChecker) => {
-  const declarationName = import_typescript4.default.getNameOfDeclaration(node);
+  const declarationName = import_typescript9.default.getNameOfDeclaration(node);
   let staticName = declarationName.getText();
   let dynamicName;
-  if (import_typescript4.default.isComputedPropertyName(declarationName)) {
+  if (import_typescript9.default.isComputedPropertyName(declarationName)) {
     dynamicName = declarationName.expression.getText();
     const type = typeChecker.getTypeAtLocation(declarationName.expression);
     if (type != null && type.isLiteral()) {
@@ -236972,19 +237301,19 @@ function getExternalStyles(style) {
 // src/compiler/transformers/map-imports-to-path-aliases.ts
 var mapImportsToPathAliases = (config, destinationFilePath, outputTarget) => {
   return (transformCtx) => {
-    const compilerHost = import_typescript5.default.createCompilerHost(config.tsCompilerOptions);
+    const compilerHost = import_typescript10.default.createCompilerHost(config.tsCompilerOptions);
     const visit2 = (sourceFile) => (node) => {
       var _a2, _b;
-      if (outputTarget.transformAliasedImportPaths && import_typescript5.default.isImportDeclaration(node) && import_typescript5.default.isStringLiteral(node.moduleSpecifier)) {
+      if (outputTarget.transformAliasedImportPaths && import_typescript10.default.isImportDeclaration(node) && import_typescript10.default.isStringLiteral(node.moduleSpecifier)) {
         let importPath = node.moduleSpecifier.text;
         if (!importPath.startsWith(".")) {
-          const module2 = import_typescript5.default.resolveModuleName(importPath, sourceFile, config.tsCompilerOptions, compilerHost);
+          const module2 = import_typescript10.default.resolveModuleName(importPath, sourceFile, config.tsCompilerOptions, compilerHost);
           const hasResolvedFileName = ((_a2 = module2.resolvedModule) == null ? void 0 : _a2.resolvedFileName) != null;
           const isModuleFromNodeModules = ((_b = module2.resolvedModule) == null ? void 0 : _b.isExternalLibraryImport) === true;
           const shouldTranspileImportPath = hasResolvedFileName && !isModuleFromNodeModules;
           if (shouldTranspileImportPath) {
             const extensionRegex = new RegExp(
-              Object.values(import_typescript5.default.Extension).map((extension) => `${extension}$`).join("|")
+              Object.values(import_typescript10.default.Extension).map((extension) => `${extension}$`).join("|")
             );
             const resolvePathInDestination = module2.resolvedModule.resolvedFileName.replace(
               config.srcDir,
@@ -237004,10 +237333,10 @@ var mapImportsToPathAliases = (config, destinationFilePath, outputTarget) => {
           node.assertClause
         );
       }
-      return import_typescript5.default.visitEachChild(node, visit2(sourceFile), transformCtx);
+      return import_typescript10.default.visitEachChild(node, visit2(sourceFile), transformCtx);
     };
     return (tsSourceFile) => {
-      return import_typescript5.default.visitEachChild(tsSourceFile, visit2(tsSourceFile.fileName), transformCtx);
+      return import_typescript10.default.visitEachChild(tsSourceFile, visit2(tsSourceFile.fileName), transformCtx);
     };
   };
 };
@@ -237033,10 +237362,10 @@ ${code}`;
           outputTargets.map(async (target) => {
             const relPath = relative(config.srcDir, mod.jsFilePath);
             const filePath = join(target.collectionDir, relPath);
-            const { outputText } = import_typescript6.default.transpileModule(code, {
+            const { outputText } = import_typescript11.default.transpileModule(code, {
               fileName: mod.sourceFilePath,
               compilerOptions: {
-                target: import_typescript6.default.ScriptTarget.Latest
+                target: import_typescript11.default.ScriptTarget.Latest
               },
               transformers: {
                 after: [mapImportsToPathAliases(config, filePath, target)]
@@ -241683,10 +242012,10 @@ var createComponentExport = (cmp) => {
 
 // src/compiler/bundle/app-data-plugin.ts
 var import_path12 = require("path");
-var import_typescript8 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript13 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/remove-collection-imports.ts
-var import_typescript7 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript12 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var removeCollectionImports = (compilerCtx) => {
   return () => {
     return (tsSourceFile) => {
@@ -241694,8 +242023,8 @@ var removeCollectionImports = (compilerCtx) => {
       const statements = tsSourceFile.statements.slice();
       for (let i = statements.length - 1; i >= 0; i--) {
         const n3 = statements[i];
-        if (import_typescript7.default.isImportDeclaration(n3)) {
-          if (!n3.importClause && n3.moduleSpecifier && import_typescript7.default.isStringLiteral(n3.moduleSpecifier)) {
+        if (import_typescript12.default.isImportDeclaration(n3)) {
+          if (!n3.importClause && n3.moduleSpecifier && import_typescript12.default.isStringLiteral(n3.moduleSpecifier)) {
             const importPath = n3.moduleSpecifier.text;
             const isCollectionImport = compilerCtx.collections.some((c) => {
               return c.collectionName === importPath || c.moduleId === importPath;
@@ -241708,7 +242037,7 @@ var removeCollectionImports = (compilerCtx) => {
         }
       }
       if (madeUpdates) {
-        return import_typescript7.default.factory.updateSourceFile(tsSourceFile, statements);
+        return import_typescript12.default.factory.updateSourceFile(tsSourceFile, statements);
       }
       return tsSourceFile;
     };
@@ -241791,8 +242120,8 @@ var appDataPlugin = (config, compilerCtx, buildCtx, buildConditionals, platform)
         const defaultExport = needsDefault ? "\nexport const globalFn = () => {};\nexport default globalFn;" : "";
         code = code + defaultExport;
         const compilerOptions = { ...config.tsCompilerOptions };
-        compilerOptions.module = import_typescript8.default.ModuleKind.ESNext;
-        const results = import_typescript8.default.transpileModule(code, {
+        compilerOptions.module = import_typescript13.default.ModuleKind.ESNext;
+        const results = import_typescript13.default.transpileModule(code, {
           compilerOptions,
           fileName: id,
           transformers: {
@@ -243215,15 +243544,15 @@ var serverPlugin = (config, platform) => {
 
 // src/compiler/bundle/typescript-plugin.ts
 var import_path24 = require("path");
-var import_typescript11 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript16 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/sys/typescript/typescript-resolve-module.ts
 var import_path23 = require("path");
-var import_typescript10 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript15 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/sys/typescript/typescript-sys.ts
 var import_path22 = require("path");
-var import_typescript9 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript14 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/sys/environment.ts
 var IS_WINDOWS_ENV = process.platform === "win32";
@@ -243302,7 +243631,7 @@ var patchTsSystemFileSystem = (config, compilerSys, inMemoryFs, tsSys) => {
   };
   tsSys.readDirectory = (path7, extensions, exclude, include, depth) => {
     const cwd = compilerSys.getCurrentDirectory();
-    return import_typescript9.default.matchFiles(
+    return import_typescript14.default.matchFiles(
       path7,
       extensions,
       exclude,
@@ -243338,11 +243667,11 @@ var patchTsSystemWatch = (compilerSystem, tsSys) => {
   tsSys.watchFile = (p, cb) => {
     const watcher = compilerSystem.watchFile(p, (filePath, eventKind) => {
       if (eventKind === "fileAdd") {
-        cb(filePath, import_typescript9.default.FileWatcherEventKind.Created);
+        cb(filePath, import_typescript14.default.FileWatcherEventKind.Created);
       } else if (eventKind === "fileUpdate") {
-        cb(filePath, import_typescript9.default.FileWatcherEventKind.Changed);
+        cb(filePath, import_typescript14.default.FileWatcherEventKind.Changed);
       } else if (eventKind === "fileDelete") {
-        cb(filePath, import_typescript9.default.FileWatcherEventKind.Deleted);
+        cb(filePath, import_typescript14.default.FileWatcherEventKind.Deleted);
       }
     });
     return {
@@ -243353,15 +243682,15 @@ var patchTsSystemWatch = (compilerSystem, tsSys) => {
   };
 };
 var patchTypescript = (config, inMemoryFs) => {
-  if (!import_typescript9.default.__patched) {
-    patchTsSystemFileSystem(config, config.sys, inMemoryFs, import_typescript9.default.sys);
-    patchTsSystemWatch(config.sys, import_typescript9.default.sys);
-    import_typescript9.default.__patched = true;
+  if (!import_typescript14.default.__patched) {
+    patchTsSystemFileSystem(config, config.sys, inMemoryFs, import_typescript14.default.sys);
+    patchTsSystemWatch(config.sys, import_typescript14.default.sys);
+    import_typescript14.default.__patched = true;
   }
 };
 var patchTypeScriptSysMinimum = () => {
-  if (!import_typescript9.default.sys) {
-    import_typescript9.default.sys = {
+  if (!import_typescript14.default.sys) {
+    import_typescript14.default.sys = {
       args: [],
       createDirectory: noop,
       directoryExists: () => false,
@@ -243397,9 +243726,9 @@ var getTypescriptPathFromUrl = (config, tsExecutingUrl, url) => {
 
 // src/compiler/sys/typescript/typescript-resolve-module.ts
 var tsResolveModuleName = (config, compilerCtx, moduleName, containingFile) => {
-  const resolveModuleName = import_typescript10.default.__resolveModuleName || import_typescript10.default.resolveModuleName;
+  const resolveModuleName = import_typescript15.default.__resolveModuleName || import_typescript15.default.resolveModuleName;
   if (moduleName && resolveModuleName && config.tsCompilerOptions) {
-    const host = patchTsSystemFileSystem(config, config.sys, compilerCtx.fs, import_typescript10.default.sys);
+    const host = patchTsSystemFileSystem(config, config.sys, compilerCtx.fs, import_typescript15.default.sys);
     const compilerOptions = { ...config.tsCompilerOptions };
     compilerOptions.resolveJsonModule = true;
     return resolveModuleName(moduleName, containingFile, compilerOptions, host);
@@ -243438,6 +243767,8 @@ var createModule = (staticSourceFile, staticSourceFileText, emitFilepath) => ({
   staticSourceFile,
   staticSourceFileText,
   cmps: [],
+  isExtended: false,
+  isMixin: false,
   coreRuntimeApis: [],
   outputTargetCoreRuntimeApis: {},
   collectionName: null,
@@ -243505,8 +243836,8 @@ var typescriptPlugin = (compilerCtx, bundleOpts, config) => {
       if ((0, import_path24.isAbsolute)(id)) {
         const fsFilePath = normalizeFsPath(id);
         const mod = getModule(compilerCtx, fsFilePath);
-        if (mod && mod.cmps.length > 0) {
-          const tsResult = import_typescript11.default.transpileModule(mod.staticSourceFileText, {
+        if (mod == null ? void 0 : mod.cmps) {
+          const tsResult = import_typescript16.default.transpileModule(mod.staticSourceFileText, {
             compilerOptions: config.tsCompilerOptions,
             fileName: mod.sourceFilePath,
             transformers: {
@@ -243566,7 +243897,7 @@ var userIndexPlugin = (config, compilerCtx) => {
 
 // src/compiler/optimize/optimize-module.ts
 var import_merge_source_map = __toESM(require_merge_source_map());
-var import_typescript12 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript17 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
 var schemeRegex = /^[\w+.-]+:\/\//;
@@ -252186,13 +252517,13 @@ var prepareModule = async (input, minifyOpts, transpileToEs5, inlineHelpers) =>
     sourceMap: null
   };
   if (transpileToEs5) {
-    const tsResults = import_typescript12.default.transpileModule(input, {
+    const tsResults = import_typescript17.default.transpileModule(input, {
       fileName: "module.ts",
       compilerOptions: {
         sourceMap: !!minifyOpts.sourceMap,
         allowJs: true,
-        target: import_typescript12.default.ScriptTarget.ES5,
-        module: import_typescript12.default.ModuleKind.ESNext,
+        target: import_typescript17.default.ScriptTarget.ES5,
+        module: import_typescript17.default.ModuleKind.ESNext,
         removeComments: false,
         isolatedModules: true,
         skipLibCheck: true,
@@ -252768,7 +253099,7 @@ function assertIsObjectHook(hook) {
 }
 
 // src/compiler/transformers/component-native/add-define-custom-element-function.ts
-var import_typescript13 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript18 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var addDefineCustomElementFunctions = (compilerCtx, components, outputTarget) => {
   return () => {
     return (tsSourceFile) => {
@@ -252779,10 +253110,10 @@ var addDefineCustomElementFunctions = (compilerCtx, components, outputTarget) =>
       if (moduleFile.cmps.length) {
         const principalComponent = moduleFile.cmps[0];
         tagNames.push(principalComponent.tagName);
-        const customElementsDefineCallExpression = import_typescript13.default.factory.createCallExpression(
-          import_typescript13.default.factory.createPropertyAccessExpression(import_typescript13.default.factory.createIdentifier("customElements"), "define"),
+        const customElementsDefineCallExpression = import_typescript18.default.factory.createCallExpression(
+          import_typescript18.default.factory.createPropertyAccessExpression(import_typescript18.default.factory.createIdentifier("customElements"), "define"),
           void 0,
-          [import_typescript13.default.factory.createIdentifier("tagName"), import_typescript13.default.factory.createIdentifier(principalComponent.componentClassName)]
+          [import_typescript18.default.factory.createIdentifier("tagName"), import_typescript18.default.factory.createIdentifier(principalComponent.componentClassName)]
         );
         caseStatements.push(
           createCustomElementsDefineCase(principalComponent.tagName, customElementsDefineCallExpression)
@@ -252796,7 +253127,7 @@ var addDefineCustomElementFunctions = (compilerCtx, components, outputTarget) =>
           newStatements.push(conditionalDefineCustomElementCall);
         }
       }
-      tsSourceFile = import_typescript13.default.factory.updateSourceFile(tsSourceFile, [...tsSourceFile.statements, ...newStatements]);
+      tsSourceFile = import_typescript18.default.factory.updateSourceFile(tsSourceFile, [...tsSourceFile.statements, ...newStatements]);
       return tsSourceFile;
     };
   };
@@ -252809,83 +253140,83 @@ var setupComponentDependencies = (moduleFile, components, newStatements, caseSta
       const importAs = `$${exportName}DefineCustomElement`;
       tagNames.push(foundDep.tagName);
       newStatements.push(createImportStatement([`defineCustomElement as ${importAs}`], foundDep.sourceFilePath));
-      const callExpression3 = import_typescript13.default.factory.createCallExpression(import_typescript13.default.factory.createIdentifier(importAs), void 0, []);
+      const callExpression3 = import_typescript18.default.factory.createCallExpression(import_typescript18.default.factory.createIdentifier(importAs), void 0, []);
       caseStatements.push(createCustomElementsDefineCase(foundDep.tagName, callExpression3));
     });
   });
 };
 var createCustomElementsDefineCase = (tagName, actionExpression) => {
-  return import_typescript13.default.factory.createCaseClause(import_typescript13.default.factory.createStringLiteral(tagName), [
-    import_typescript13.default.factory.createIfStatement(
-      import_typescript13.default.factory.createPrefixUnaryExpression(
-        import_typescript13.default.SyntaxKind.ExclamationToken,
-        import_typescript13.default.factory.createCallExpression(
-          import_typescript13.default.factory.createPropertyAccessExpression(import_typescript13.default.factory.createIdentifier("customElements"), "get"),
+  return import_typescript18.default.factory.createCaseClause(import_typescript18.default.factory.createStringLiteral(tagName), [
+    import_typescript18.default.factory.createIfStatement(
+      import_typescript18.default.factory.createPrefixUnaryExpression(
+        import_typescript18.default.SyntaxKind.ExclamationToken,
+        import_typescript18.default.factory.createCallExpression(
+          import_typescript18.default.factory.createPropertyAccessExpression(import_typescript18.default.factory.createIdentifier("customElements"), "get"),
           void 0,
-          [import_typescript13.default.factory.createIdentifier("tagName")]
+          [import_typescript18.default.factory.createIdentifier("tagName")]
         )
       ),
-      import_typescript13.default.factory.createBlock([import_typescript13.default.factory.createExpressionStatement(actionExpression)])
+      import_typescript18.default.factory.createBlock([import_typescript18.default.factory.createExpressionStatement(actionExpression)])
     ),
-    import_typescript13.default.factory.createBreakStatement()
+    import_typescript18.default.factory.createBreakStatement()
   ]);
 };
 var addDefineCustomElementFunction = (tagNames, newStatements, caseStatements) => {
-  const newExpression3 = import_typescript13.default.factory.createFunctionDeclaration(
-    [import_typescript13.default.factory.createModifier(import_typescript13.default.SyntaxKind.ExportKeyword)],
+  const newExpression3 = import_typescript18.default.factory.createFunctionDeclaration(
+    [import_typescript18.default.factory.createModifier(import_typescript18.default.SyntaxKind.ExportKeyword)],
     void 0,
-    import_typescript13.default.factory.createIdentifier("defineCustomElement"),
+    import_typescript18.default.factory.createIdentifier("defineCustomElement"),
     void 0,
     [],
     void 0,
-    import_typescript13.default.factory.createBlock(
+    import_typescript18.default.factory.createBlock(
       [
-        import_typescript13.default.factory.createIfStatement(
-          import_typescript13.default.factory.createStrictEquality(
-            import_typescript13.default.factory.createTypeOfExpression(import_typescript13.default.factory.createIdentifier("customElements")),
-            import_typescript13.default.factory.createStringLiteral("undefined")
+        import_typescript18.default.factory.createIfStatement(
+          import_typescript18.default.factory.createStrictEquality(
+            import_typescript18.default.factory.createTypeOfExpression(import_typescript18.default.factory.createIdentifier("customElements")),
+            import_typescript18.default.factory.createStringLiteral("undefined")
           ),
-          import_typescript13.default.factory.createBlock([import_typescript13.default.factory.createReturnStatement()])
+          import_typescript18.default.factory.createBlock([import_typescript18.default.factory.createReturnStatement()])
         ),
-        import_typescript13.default.factory.createVariableStatement(
+        import_typescript18.default.factory.createVariableStatement(
           void 0,
-          import_typescript13.default.factory.createVariableDeclarationList(
+          import_typescript18.default.factory.createVariableDeclarationList(
             [
-              import_typescript13.default.factory.createVariableDeclaration(
+              import_typescript18.default.factory.createVariableDeclaration(
                 "components",
                 void 0,
                 void 0,
-                import_typescript13.default.factory.createArrayLiteralExpression(
-                  tagNames.map((tagName) => import_typescript13.default.factory.createStringLiteral(tagName))
+                import_typescript18.default.factory.createArrayLiteralExpression(
+                  tagNames.map((tagName) => import_typescript18.default.factory.createStringLiteral(tagName))
                 )
               )
             ],
-            import_typescript13.default.NodeFlags.Const
+            import_typescript18.default.NodeFlags.Const
           )
         ),
-        import_typescript13.default.factory.createExpressionStatement(
-          import_typescript13.default.factory.createCallExpression(
-            import_typescript13.default.factory.createPropertyAccessExpression(import_typescript13.default.factory.createIdentifier("components"), "forEach"),
+        import_typescript18.default.factory.createExpressionStatement(
+          import_typescript18.default.factory.createCallExpression(
+            import_typescript18.default.factory.createPropertyAccessExpression(import_typescript18.default.factory.createIdentifier("components"), "forEach"),
             void 0,
             [
-              import_typescript13.default.factory.createArrowFunction(
+              import_typescript18.default.factory.createArrowFunction(
                 void 0,
                 void 0,
                 [
-                  import_typescript13.default.factory.createParameterDeclaration(
+                  import_typescript18.default.factory.createParameterDeclaration(
                     void 0,
                     void 0,
-                    import_typescript13.default.factory.createIdentifier("tagName"),
+                    import_typescript18.default.factory.createIdentifier("tagName"),
                     void 0,
                     void 0
                   )
                 ],
                 void 0,
-                import_typescript13.default.factory.createToken(import_typescript13.default.SyntaxKind.EqualsGreaterThanToken),
-                import_typescript13.default.factory.createBlock([
-                  import_typescript13.default.factory.createSwitchStatement(
-                    import_typescript13.default.factory.createIdentifier("tagName"),
-                    import_typescript13.default.factory.createCaseBlock(caseStatements)
+                import_typescript18.default.factory.createToken(import_typescript18.default.SyntaxKind.EqualsGreaterThanToken),
+                import_typescript18.default.factory.createBlock([
+                  import_typescript18.default.factory.createSwitchStatement(
+                    import_typescript18.default.factory.createIdentifier("tagName"),
+                    import_typescript18.default.factory.createCaseBlock(caseStatements)
                   )
                 ])
               )
@@ -252899,72 +253230,31 @@ var addDefineCustomElementFunction = (tagNames, newStatements, caseStatements) =
   newStatements.push(newExpression3);
 };
 function createAutoDefinitionExpression(componentName) {
-  return import_typescript13.default.factory.createExpressionStatement(
-    import_typescript13.default.factory.createCallExpression(import_typescript13.default.factory.createIdentifier("defineCustomElement"), void 0, [
-      import_typescript13.default.factory.createIdentifier(componentName)
+  return import_typescript18.default.factory.createExpressionStatement(
+    import_typescript18.default.factory.createCallExpression(import_typescript18.default.factory.createIdentifier("defineCustomElement"), void 0, [
+      import_typescript18.default.factory.createIdentifier(componentName)
     ])
   );
 }
 
 // src/compiler/transformers/component-native/proxy-custom-element-function.ts
-var import_typescript16 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-
-// src/compiler/transformers/add-component-meta-proxy.ts
-var import_typescript14 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-
-// src/compiler/transformers/core-runtime-apis.ts
-var CREATE_EVENT = "__stencil_createEvent";
-var DEFINE_CUSTOM_ELEMENT = "__stencil_defineCustomElement";
-var GET_ELEMENT = "__stencil_getElement";
-var HOST = "__stencil_Host";
-var HTML_ELEMENT = "HTMLElement";
-var PROXY_CUSTOM_ELEMENT = "__stencil_proxyCustomElement";
-var REGISTER_INSTANCE = "__stencil_registerInstance";
-var REGISTER_HOST = "__stencil_registerHost";
-var H2 = "__stencil_h";
-var RUNTIME_APIS = {
-  createEvent: `createEvent as ${CREATE_EVENT}`,
-  defineCustomElement: `defineCustomElement as ${DEFINE_CUSTOM_ELEMENT}`,
-  getElement: `getElement as ${GET_ELEMENT}`,
-  h: `h as ${H2}`,
-  legacyH: `h`,
-  Host: `Host as ${HOST}`,
-  HTMLElement: HTML_ELEMENT,
-  proxyCustomElement: `proxyCustomElement as ${PROXY_CUSTOM_ELEMENT}`,
-  registerHost: `registerHost as ${REGISTER_HOST}`,
-  registerInstance: `registerInstance as ${REGISTER_INSTANCE}`
-};
-var addCoreRuntimeApi = (moduleFile, coreRuntimeApi) => {
-  if (!moduleFile.coreRuntimeApis.includes(coreRuntimeApi)) {
-    moduleFile.coreRuntimeApis.push(coreRuntimeApi);
-  }
-};
-var addOutputTargetCoreRuntimeApi = (moduleFile, outputTarget, coreRuntimeApi) => {
-  if (!moduleFile.outputTargetCoreRuntimeApis[outputTarget]) {
-    moduleFile.outputTargetCoreRuntimeApis[outputTarget] = [];
-  }
-  if (!moduleFile.outputTargetCoreRuntimeApis[outputTarget].includes(coreRuntimeApi)) {
-    moduleFile.outputTargetCoreRuntimeApis[outputTarget].push(coreRuntimeApi);
-  }
-};
-var addLegacyApis = (moduleFile) => {
-  addCoreRuntimeApi(moduleFile, RUNTIME_APIS.legacyH);
-};
+var import_typescript21 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/add-component-meta-proxy.ts
+var import_typescript19 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var addModuleMetadataProxies = (tsSourceFile, moduleFile) => {
   const statements = tsSourceFile.statements.slice();
   addCoreRuntimeApi(moduleFile, RUNTIME_APIS.proxyCustomElement);
   statements.push(...moduleFile.cmps.map(createComponentMetadataProxy));
-  return import_typescript14.default.factory.updateSourceFile(tsSourceFile, statements);
+  return import_typescript19.default.factory.updateSourceFile(tsSourceFile, statements);
 };
 var createComponentMetadataProxy = (compilerMeta) => {
   const compactMeta = formatComponentRuntimeMeta(compilerMeta, true);
-  const literalCmpClassName = import_typescript14.default.factory.createIdentifier(compilerMeta.componentClassName);
+  const literalCmpClassName = import_typescript19.default.factory.createIdentifier(compilerMeta.componentClassName);
   const literalMeta = convertValueToLiteral(compactMeta);
-  return import_typescript14.default.factory.createExpressionStatement(
-    import_typescript14.default.factory.createCallExpression(
-      import_typescript14.default.factory.createIdentifier(PROXY_CUSTOM_ELEMENT),
+  return import_typescript19.default.factory.createExpressionStatement(
+    import_typescript19.default.factory.createCallExpression(
+      import_typescript19.default.factory.createIdentifier(PROXY_CUSTOM_ELEMENT),
       [],
       [literalCmpClassName, literalMeta]
     )
@@ -252973,11 +253263,11 @@ var createComponentMetadataProxy = (compilerMeta) => {
 var createClassMetadataProxy = (compilerMeta, clazz) => {
   const compactMeta = formatComponentRuntimeMeta(compilerMeta, true);
   const literalMeta = convertValueToLiteral(compactMeta);
-  return import_typescript14.default.factory.createCallExpression(import_typescript14.default.factory.createIdentifier(PROXY_CUSTOM_ELEMENT), [], [clazz, literalMeta]);
+  return import_typescript19.default.factory.createCallExpression(import_typescript19.default.factory.createIdentifier(PROXY_CUSTOM_ELEMENT), [], [clazz, literalMeta]);
 };
 
 // src/compiler/transformers/add-imports.ts
-var import_typescript15 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript20 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var addImports = (transformOpts, tsSourceFile, importFnNames, importPath) => {
   if (importFnNames.length === 0) {
     return tsSourceFile;
@@ -252986,12 +253276,12 @@ var addImports = (transformOpts, tsSourceFile, importFnNames, importPath) => {
     const newRequire = createRequireStatement(importFnNames, importPath);
     const statements2 = tsSourceFile.statements.slice();
     statements2.splice(2, 0, newRequire);
-    return import_typescript15.default.factory.updateSourceFile(tsSourceFile, statements2);
+    return import_typescript20.default.factory.updateSourceFile(tsSourceFile, statements2);
   }
   const newImport = createImportStatement(importFnNames, importPath);
   const statements = tsSourceFile.statements.slice();
   statements.unshift(newImport);
-  return import_typescript15.default.factory.updateSourceFile(tsSourceFile, statements);
+  return import_typescript20.default.factory.updateSourceFile(tsSourceFile, statements);
 };
 
 // src/compiler/transformers/component-native/proxy-custom-element-function.ts
@@ -253004,42 +253294,42 @@ var proxyCustomElement2 = (compilerCtx, transformOpts) => {
       }
       const principalComponent = moduleFile.cmps[0];
       for (const [stmtIndex, stmt] of tsSourceFile.statements.entries()) {
-        if (import_typescript16.default.isVariableStatement(stmt)) {
+        if (import_typescript21.default.isVariableStatement(stmt)) {
           for (const [declarationIndex, declaration] of stmt.declarationList.declarations.entries()) {
             if (declaration.name.getText() !== principalComponent.componentClassName) {
               continue;
             }
-            if (!import_typescript16.default.isClassExpression(declaration.initializer)) {
+            if (!import_typescript21.default.isClassExpression(declaration.initializer)) {
               continue;
             }
-            const renamedClassExpression = import_typescript16.default.factory.updateClassExpression(
+            const renamedClassExpression = import_typescript21.default.factory.updateClassExpression(
               declaration.initializer,
-              import_typescript16.default.getModifiers(declaration.initializer),
-              import_typescript16.default.factory.createIdentifier(principalComponent.componentClassName),
+              import_typescript21.default.getModifiers(declaration.initializer),
+              import_typescript21.default.factory.createIdentifier(principalComponent.componentClassName),
               declaration.initializer.typeParameters,
               declaration.initializer.heritageClauses,
               declaration.initializer.members
             );
             const proxyCreationCall = createClassMetadataProxy(principalComponent, renamedClassExpression);
-            import_typescript16.default.addSyntheticLeadingComment(proxyCreationCall, import_typescript16.default.SyntaxKind.MultiLineCommentTrivia, "@__PURE__", false);
-            const proxiedComponentDeclaration = import_typescript16.default.factory.updateVariableDeclaration(
+            import_typescript21.default.addSyntheticLeadingComment(proxyCreationCall, import_typescript21.default.SyntaxKind.MultiLineCommentTrivia, "@__PURE__", false);
+            const proxiedComponentDeclaration = import_typescript21.default.factory.updateVariableDeclaration(
               declaration,
               declaration.name,
               declaration.exclamationToken,
               declaration.type,
               proxyCreationCall
             );
-            const updatedDeclarationList = import_typescript16.default.factory.updateVariableDeclarationList(stmt.declarationList, [
+            const updatedDeclarationList = import_typescript21.default.factory.updateVariableDeclarationList(stmt.declarationList, [
               ...stmt.declarationList.declarations.slice(0, declarationIndex),
               proxiedComponentDeclaration,
               ...stmt.declarationList.declarations.slice(declarationIndex + 1)
             ]);
-            const updatedVariableStatement = import_typescript16.default.factory.updateVariableStatement(
+            const updatedVariableStatement = import_typescript21.default.factory.updateVariableStatement(
               stmt,
               stmt.modifiers,
               updatedDeclarationList
             );
-            tsSourceFile = import_typescript16.default.factory.updateSourceFile(tsSourceFile, [
+            tsSourceFile = import_typescript21.default.factory.updateSourceFile(tsSourceFile, [
               ...tsSourceFile.statements.slice(0, stmtIndex),
               updatedVariableStatement,
               ...tsSourceFile.statements.slice(stmtIndex + 1)
@@ -253060,10 +253350,10 @@ var proxyCustomElement2 = (compilerCtx, transformOpts) => {
 };
 
 // src/compiler/transformers/component-native/tranform-to-native-component.ts
-var import_typescript30 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript32 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/define-custom-element.ts
-var import_typescript17 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript22 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var defineCustomElement2 = (tsSourceFile, moduleFile, transformOpts) => {
   let statements = tsSourceFile.statements.slice();
   statements.push(
@@ -253074,31 +253364,31 @@ var defineCustomElement2 = (tsSourceFile, moduleFile, transformOpts) => {
   if (transformOpts.module === "cjs") {
     statements = removeComponentCjsExport(statements, moduleFile);
   }
-  return import_typescript17.default.factory.updateSourceFile(tsSourceFile, statements);
+  return import_typescript22.default.factory.updateSourceFile(tsSourceFile, statements);
 };
 var addDefineCustomElement = (moduleFile, compilerMeta) => {
   if (compilerMeta.isPlain) {
-    return import_typescript17.default.factory.createExpressionStatement(
-      import_typescript17.default.factory.createCallExpression(
-        import_typescript17.default.factory.createPropertyAccessExpression(
-          import_typescript17.default.factory.createIdentifier("customElements"),
-          import_typescript17.default.factory.createIdentifier("define")
+    return import_typescript22.default.factory.createExpressionStatement(
+      import_typescript22.default.factory.createCallExpression(
+        import_typescript22.default.factory.createPropertyAccessExpression(
+          import_typescript22.default.factory.createIdentifier("customElements"),
+          import_typescript22.default.factory.createIdentifier("define")
         ),
         [],
         [
-          import_typescript17.default.factory.createStringLiteral(compilerMeta.tagName),
-          import_typescript17.default.factory.createIdentifier(compilerMeta.componentClassName)
+          import_typescript22.default.factory.createStringLiteral(compilerMeta.tagName),
+          import_typescript22.default.factory.createIdentifier(compilerMeta.componentClassName)
         ]
       )
     );
   }
   addCoreRuntimeApi(moduleFile, RUNTIME_APIS.defineCustomElement);
   const compactMeta = formatComponentRuntimeMeta(compilerMeta, true);
-  const liternalCmpClassName = import_typescript17.default.factory.createIdentifier(compilerMeta.componentClassName);
+  const liternalCmpClassName = import_typescript22.default.factory.createIdentifier(compilerMeta.componentClassName);
   const liternalMeta = convertValueToLiteral(compactMeta);
-  return import_typescript17.default.factory.createExpressionStatement(
-    import_typescript17.default.factory.createCallExpression(
-      import_typescript17.default.factory.createIdentifier(DEFINE_CUSTOM_ELEMENT),
+  return import_typescript22.default.factory.createExpressionStatement(
+    import_typescript22.default.factory.createCallExpression(
+      import_typescript22.default.factory.createIdentifier(DEFINE_CUSTOM_ELEMENT),
       [],
       [liternalCmpClassName, liternalMeta]
     )
@@ -253107,12 +253397,12 @@ var addDefineCustomElement = (moduleFile, compilerMeta) => {
 var removeComponentCjsExport = (statements, moduleFile) => {
   const cmpClassNames = new Set(moduleFile.cmps.map((cmp) => cmp.componentClassName));
   return statements.filter((s) => {
-    if (s.kind === import_typescript17.default.SyntaxKind.ExpressionStatement) {
+    if (s.kind === import_typescript22.default.SyntaxKind.ExpressionStatement) {
       const exp = s.expression;
-      if (exp && exp.kind === import_typescript17.default.SyntaxKind.BinaryExpression) {
+      if (exp && exp.kind === import_typescript22.default.SyntaxKind.BinaryExpression) {
         const left = exp.left;
-        if (left && left.kind === import_typescript17.default.SyntaxKind.PropertyAccessExpression) {
-          if (left.expression && left.expression.kind === import_typescript17.default.SyntaxKind.Identifier) {
+        if (left && left.kind === import_typescript22.default.SyntaxKind.PropertyAccessExpression) {
+          if (left.expression && left.expression.kind === import_typescript22.default.SyntaxKind.Identifier) {
             const leftText = left.expression;
             if (leftText.text === "exports") {
               const right = exp.right;
@@ -253129,7 +253419,7 @@ var removeComponentCjsExport = (statements, moduleFile) => {
 };
 
 // src/compiler/transformers/style-imports.ts
-var import_typescript18 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript23 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var updateStyleImports = (transformOpts, tsSourceFile, moduleFile) => {
   if (transformOpts.module === "cjs") {
     return updateCjsStyleRequires(transformOpts, tsSourceFile, moduleFile);
@@ -253155,27 +253445,27 @@ var updateEsmStyleImports = (transformOpts, tsSourceFile, moduleFile) => {
   if (updateSourceFile) {
     let lastImportIndex = -1;
     for (let i = 0; i < statements.length; i++) {
-      if (import_typescript18.default.isImportDeclaration(statements[i])) {
+      if (import_typescript23.default.isImportDeclaration(statements[i])) {
         lastImportIndex = i;
       }
     }
     statements.splice(lastImportIndex + 1, 0, ...styleImports);
-    return import_typescript18.default.factory.updateSourceFile(tsSourceFile, statements);
+    return import_typescript23.default.factory.updateSourceFile(tsSourceFile, statements);
   }
   return tsSourceFile;
 };
 var updateEsmStyleImportPath = (transformOpts, tsSourceFile, statements, cmp, style) => {
   for (let i = 0; i < statements.length; i++) {
     const n3 = statements[i];
-    if (import_typescript18.default.isImportDeclaration(n3) && n3.importClause && n3.moduleSpecifier && import_typescript18.default.isStringLiteral(n3.moduleSpecifier)) {
+    if (import_typescript23.default.isImportDeclaration(n3) && n3.importClause && n3.moduleSpecifier && import_typescript23.default.isStringLiteral(n3.moduleSpecifier)) {
       if (n3.importClause.name && n3.importClause.name.escapedText === style.styleIdentifier) {
         const orgImportPath = n3.moduleSpecifier.text;
         const importPath = getStyleImportPath(transformOpts, tsSourceFile, cmp, style, orgImportPath);
-        statements[i] = import_typescript18.default.factory.updateImportDeclaration(
+        statements[i] = import_typescript23.default.factory.updateImportDeclaration(
           n3,
           retrieveTsModifiers(n3),
           n3.importClause,
-          import_typescript18.default.factory.createStringLiteral(importPath),
+          import_typescript23.default.factory.createStringLiteral(importPath),
           void 0
         );
         break;
@@ -253188,34 +253478,34 @@ var createStyleImport = (transformOpts, tsSourceFile, cmp, style, moduleType = "
   const imports = [];
   for (const [i, externalStyle] of Object.entries(getExternalStyles(style))) {
     const styleIdentifier = `${style.styleIdentifier}${i}`;
-    const importIdentifier = import_typescript18.default.factory.createIdentifier(styleIdentifier);
+    const importIdentifier = import_typescript23.default.factory.createIdentifier(styleIdentifier);
     const importPath = getStyleImportPath(transformOpts, tsSourceFile, cmp, style, externalStyle);
     if (moduleType === "esm") {
       imports.push(
-        import_typescript18.default.factory.createImportDeclaration(
+        import_typescript23.default.factory.createImportDeclaration(
           void 0,
-          import_typescript18.default.factory.createImportClause(false, importIdentifier, void 0),
-          import_typescript18.default.factory.createStringLiteral(importPath)
+          import_typescript23.default.factory.createImportClause(false, importIdentifier, void 0),
+          import_typescript23.default.factory.createStringLiteral(importPath)
         )
       );
     } else if (moduleType === "cjs") {
       imports.push(
-        import_typescript18.default.factory.createVariableStatement(
+        import_typescript23.default.factory.createVariableStatement(
           void 0,
-          import_typescript18.default.factory.createVariableDeclarationList(
+          import_typescript23.default.factory.createVariableDeclarationList(
             [
-              import_typescript18.default.factory.createVariableDeclaration(
+              import_typescript23.default.factory.createVariableDeclaration(
                 importIdentifier,
                 void 0,
                 void 0,
-                import_typescript18.default.factory.createCallExpression(
-                  import_typescript18.default.factory.createIdentifier("require"),
+                import_typescript23.default.factory.createCallExpression(
+                  import_typescript23.default.factory.createIdentifier("require"),
                   [],
-                  [import_typescript18.default.factory.createStringLiteral(importPath)]
+                  [import_typescript23.default.factory.createStringLiteral(importPath)]
                 )
               )
             ],
-            import_typescript18.default.NodeFlags.Const
+            import_typescript23.default.NodeFlags.Const
           )
         )
       );
@@ -253235,7 +253525,7 @@ var updateCjsStyleRequires = (transformOpts, tsSourceFile, moduleFile) => {
     });
   });
   if (styleRequires.length > 0) {
-    return import_typescript18.default.factory.updateSourceFile(tsSourceFile, [...styleRequires, ...tsSourceFile.statements]);
+    return import_typescript23.default.factory.updateSourceFile(tsSourceFile, [...styleRequires, ...tsSourceFile.statements]);
   }
   return tsSourceFile;
 };
@@ -253251,25 +253541,25 @@ var getStyleImportPath = (transformOpts, tsSourceFile, cmp, style, importPath) =
 };
 
 // src/compiler/transformers/component-native/native-component.ts
-var import_typescript29 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript31 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/host-data-transform.ts
-var import_typescript19 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript24 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var transformHostData = (classElements, moduleFile) => {
   const hasHostData = classElements.some(
-    (e) => import_typescript19.default.isMethodDeclaration(e) && e.name.escapedText === "hostData"
+    (e) => import_typescript24.default.isMethodDeclaration(e) && e.name.escapedText === "hostData"
   );
   if (hasHostData) {
     const renderIndex = classElements.findIndex(
-      (e) => import_typescript19.default.isMethodDeclaration(e) && e.name.escapedText === "render"
+      (e) => import_typescript24.default.isMethodDeclaration(e) && e.name.escapedText === "render"
     );
     if (renderIndex >= 0) {
       const renderMethod = classElements[renderIndex];
-      classElements[renderIndex] = import_typescript19.default.factory.updateMethodDeclaration(
+      classElements[renderIndex] = import_typescript24.default.factory.updateMethodDeclaration(
         renderMethod,
         retrieveModifierLike(renderMethod),
         renderMethod.asteriskToken,
-        import_typescript19.default.factory.createIdentifier(INTERNAL_RENDER),
+        import_typescript24.default.factory.createIdentifier(INTERNAL_RENDER),
         renderMethod.questionToken,
         renderMethod.typeParameters,
         renderMethod.parameters,
@@ -253285,10 +253575,10 @@ var syntheticRender = (moduleFile, hasRender) => {
   addCoreRuntimeApi(moduleFile, RUNTIME_APIS.h);
   const hArguments = [
     // __stencil_Host
-    import_typescript19.default.factory.createIdentifier(HOST),
+    import_typescript24.default.factory.createIdentifier(HOST),
     // this.hostData()
-    import_typescript19.default.factory.createCallExpression(
-      import_typescript19.default.factory.createPropertyAccessExpression(import_typescript19.default.factory.createThis(), "hostData"),
+    import_typescript24.default.factory.createCallExpression(
+      import_typescript24.default.factory.createPropertyAccessExpression(import_typescript24.default.factory.createThis(), "hostData"),
       void 0,
       void 0
     )
@@ -253296,14 +253586,14 @@ var syntheticRender = (moduleFile, hasRender) => {
   if (hasRender) {
     hArguments.push(
       // this.render()
-      import_typescript19.default.factory.createCallExpression(
-        import_typescript19.default.factory.createPropertyAccessExpression(import_typescript19.default.factory.createThis(), INTERNAL_RENDER),
+      import_typescript24.default.factory.createCallExpression(
+        import_typescript24.default.factory.createPropertyAccessExpression(import_typescript24.default.factory.createThis(), INTERNAL_RENDER),
         void 0,
         void 0
       )
     );
   }
-  return import_typescript19.default.factory.createMethodDeclaration(
+  return import_typescript24.default.factory.createMethodDeclaration(
     void 0,
     void 0,
     "render",
@@ -253311,111 +253601,15 @@ var syntheticRender = (moduleFile, hasRender) => {
     void 0,
     [],
     void 0,
-    import_typescript19.default.factory.createBlock([
-      import_typescript19.default.factory.createReturnStatement(
-        import_typescript19.default.factory.createCallExpression(import_typescript19.default.factory.createIdentifier(H2), void 0, hArguments)
+    import_typescript24.default.factory.createBlock([
+      import_typescript24.default.factory.createReturnStatement(
+        import_typescript24.default.factory.createCallExpression(import_typescript24.default.factory.createIdentifier(H2), void 0, hArguments)
       )
     ])
   );
 };
 var INTERNAL_RENDER = "__stencil_render";
 
-// src/compiler/transformers/remove-static-meta-properties.ts
-var import_typescript20 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-var removeStaticMetaProperties = (classNode) => {
-  if (classNode.members == null) {
-    return [];
-  }
-  return classNode.members.filter((classMember) => {
-    var _a2;
-    if ((_a2 = retrieveTsModifiers(classMember)) == null ? void 0 : _a2.some((m) => m.kind === import_typescript20.default.SyntaxKind.StaticKeyword)) {
-      const memberName = classMember.name.escapedText;
-      if (readOnlyArrayHasStringMember(STATIC_GETTERS_TO_REMOVE, memberName)) {
-        return false;
-      }
-    }
-    return true;
-  });
-};
-var STATIC_GETTERS_TO_REMOVE = [
-  // we want to remove `attachInternalsMemberName`, which is an 'internal' static
-  // property used to pass a string value along from the 'decorators-to-static'
-  // step through to the `ComponentCompilerMeta` phase, but we want to keep the
-  // `formAssociated` prop that we also set at the same time.
-  "attachInternalsMemberName",
-  "elementRef",
-  "encapsulation",
-  "events",
-  "is",
-  "listeners",
-  "methods",
-  "originalStyleUrls",
-  "properties",
-  "states",
-  "style",
-  "styleMode",
-  "styleUrl",
-  "styleUrls",
-  "styles",
-  "watchers"
-];
-
-// src/compiler/transformers/update-component-class.ts
-var import_typescript21 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-var updateComponentClass = (transformOpts, classNode, heritageClauses, members) => {
-  var _a2, _b, _c;
-  let classModifiers = (_b = (_a2 = retrieveTsModifiers(classNode)) == null ? void 0 : _a2.slice()) != null ? _b : [];
-  if (transformOpts.module === "cjs") {
-    if (transformOpts.componentExport === "customelement") {
-      classModifiers = classModifiers.filter((m) => {
-        return m.kind !== import_typescript21.default.SyntaxKind.ExportKeyword;
-      });
-    }
-    return import_typescript21.default.factory.updateClassDeclaration(
-      classNode,
-      [...(_c = retrieveTsDecorators(classNode)) != null ? _c : [], ...classModifiers],
-      classNode.name,
-      classNode.typeParameters,
-      heritageClauses,
-      members
-    );
-  }
-  return createConstClass(transformOpts, classNode, heritageClauses, members);
-};
-var createConstClass = (transformOpts, classNode, heritageClauses, members) => {
-  var _a2;
-  const className = classNode.name;
-  const tsModifiers = (_a2 = retrieveTsModifiers(classNode)) != null ? _a2 : [];
-  const classHasExportKeyword = tsModifiers.some((m) => m.kind === import_typescript21.default.SyntaxKind.ExportKeyword);
-  const classModifiers = tsModifiers.filter((m) => {
-    return m.kind !== import_typescript21.default.SyntaxKind.ExportKeyword;
-  });
-  const constModifiers = [];
-  if (transformOpts.componentExport !== "customelement" && classHasExportKeyword) {
-    constModifiers.push(import_typescript21.default.factory.createModifier(import_typescript21.default.SyntaxKind.ExportKeyword));
-  }
-  return import_typescript21.default.factory.createVariableStatement(
-    constModifiers,
-    import_typescript21.default.factory.createVariableDeclarationList(
-      [
-        import_typescript21.default.factory.createVariableDeclaration(
-          className,
-          void 0,
-          void 0,
-          import_typescript21.default.factory.createClassExpression(
-            classModifiers,
-            void 0,
-            classNode.typeParameters,
-            heritageClauses,
-            members
-          )
-        )
-      ],
-      import_typescript21.default.NodeFlags.Const
-    )
-  );
-};
-
 // src/compiler/transformers/watcher-meta-transform.ts
 var addWatchers = (classMembers, cmp) => {
   if (cmp.watchers.length > 0) {
@@ -253429,24 +253623,24 @@ var addWatchers = (classMembers, cmp) => {
 };
 
 // src/compiler/transformers/component-native/native-connected-callback.ts
-var import_typescript22 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript25 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var addNativeConnectedCallback = (classMembers, cmp) => {
   if (cmp.isPlain && cmp.hasRenderFn) {
-    const fnCall = import_typescript22.default.factory.createExpressionStatement(
-      import_typescript22.default.factory.createAssignment(
-        import_typescript22.default.factory.createPropertyAccessExpression(import_typescript22.default.factory.createThis(), "textContent"),
-        import_typescript22.default.factory.createCallExpression(
-          import_typescript22.default.factory.createPropertyAccessExpression(import_typescript22.default.factory.createThis(), "render"),
+    const fnCall = import_typescript25.default.factory.createExpressionStatement(
+      import_typescript25.default.factory.createAssignment(
+        import_typescript25.default.factory.createPropertyAccessExpression(import_typescript25.default.factory.createThis(), "textContent"),
+        import_typescript25.default.factory.createCallExpression(
+          import_typescript25.default.factory.createPropertyAccessExpression(import_typescript25.default.factory.createThis(), "render"),
           void 0,
           void 0
         )
       )
     );
     const connectedCallback2 = classMembers.find((classMember) => {
-      return import_typescript22.default.isMethodDeclaration(classMember) && classMember.name.escapedText === CONNECTED_CALLBACK;
+      return import_typescript25.default.isMethodDeclaration(classMember) && classMember.name.escapedText === CONNECTED_CALLBACK;
     });
     if (connectedCallback2 != null) {
-      const callbackMethod = import_typescript22.default.factory.createMethodDeclaration(
+      const callbackMethod = import_typescript25.default.factory.createMethodDeclaration(
         void 0,
         void 0,
         CONNECTED_CALLBACK,
@@ -253454,12 +253648,12 @@ var addNativeConnectedCallback = (classMembers, cmp) => {
         void 0,
         [],
         void 0,
-        import_typescript22.default.factory.createBlock([fnCall, ...connectedCallback2.body.statements], true)
+        import_typescript25.default.factory.createBlock([fnCall, ...connectedCallback2.body.statements], true)
       );
       const index2 = classMembers.indexOf(connectedCallback2);
       classMembers[index2] = callbackMethod;
     } else {
-      const callbackMethod = import_typescript22.default.factory.createMethodDeclaration(
+      const callbackMethod = import_typescript25.default.factory.createMethodDeclaration(
         void 0,
         void 0,
         CONNECTED_CALLBACK,
@@ -253467,7 +253661,7 @@ var addNativeConnectedCallback = (classMembers, cmp) => {
         void 0,
         [],
         void 0,
-        import_typescript22.default.factory.createBlock([fnCall], true)
+        import_typescript25.default.factory.createBlock([fnCall], true)
       );
       classMembers.push(callbackMethod);
     }
@@ -253476,56 +253670,25 @@ var addNativeConnectedCallback = (classMembers, cmp) => {
 var CONNECTED_CALLBACK = "connectedCallback";
 
 // src/compiler/transformers/component-native/native-constructor.ts
-var import_typescript25 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-
-// src/compiler/transformers/create-event.ts
-var import_typescript23 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-var addCreateEvents = (moduleFile, cmp) => {
-  return cmp.events.map((ev) => {
-    addCoreRuntimeApi(moduleFile, RUNTIME_APIS.createEvent);
-    return import_typescript23.default.factory.createExpressionStatement(
-      import_typescript23.default.factory.createAssignment(
-        import_typescript23.default.factory.createPropertyAccessExpression(import_typescript23.default.factory.createThis(), import_typescript23.default.factory.createIdentifier(ev.method)),
-        import_typescript23.default.factory.createCallExpression(import_typescript23.default.factory.createIdentifier(CREATE_EVENT), void 0, [
-          import_typescript23.default.factory.createThis(),
-          import_typescript23.default.factory.createStringLiteral(ev.name),
-          import_typescript23.default.factory.createNumericLiteral(computeFlags(ev))
-        ])
-      )
-    );
-  });
-};
-var computeFlags = (eventMeta) => {
-  let flags = 0;
-  if (eventMeta.bubbles) {
-    flags |= 4 /* Bubbles */;
-  }
-  if (eventMeta.composed) {
-    flags |= 2 /* Composed */;
-  }
-  if (eventMeta.cancelable) {
-    flags |= 1 /* Cancellable */;
-  }
-  return flags;
-};
+var import_typescript27 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/component-native/attach-internals.ts
-var import_typescript24 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript26 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 function createNativeAttachInternalsBinding(cmp) {
   if (cmp.attachInternalsMemberName) {
     return [
-      import_typescript24.default.factory.createExpressionStatement(
-        import_typescript24.default.factory.createBinaryExpression(
-          import_typescript24.default.factory.createPropertyAccessExpression(
-            import_typescript24.default.factory.createThis(),
+      import_typescript26.default.factory.createExpressionStatement(
+        import_typescript26.default.factory.createBinaryExpression(
+          import_typescript26.default.factory.createPropertyAccessExpression(
+            import_typescript26.default.factory.createThis(),
             // use the name set on the {@link d.ComponentCompilerMeta}
-            import_typescript24.default.factory.createIdentifier(cmp.attachInternalsMemberName)
+            import_typescript26.default.factory.createIdentifier(cmp.attachInternalsMemberName)
           ),
-          import_typescript24.default.factory.createToken(import_typescript24.default.SyntaxKind.EqualsToken),
-          import_typescript24.default.factory.createCallExpression(
-            import_typescript24.default.factory.createPropertyAccessExpression(
-              import_typescript24.default.factory.createThis(),
-              import_typescript24.default.factory.createIdentifier("attachInternals")
+          import_typescript26.default.factory.createToken(import_typescript26.default.SyntaxKind.EqualsToken),
+          import_typescript26.default.factory.createCallExpression(
+            import_typescript26.default.factory.createPropertyAccessExpression(
+              import_typescript26.default.factory.createThis(),
+              import_typescript26.default.factory.createIdentifier("attachInternals")
             ),
             void 0,
             []
@@ -253543,12 +253706,15 @@ var updateNativeConstructor = (classMembers, moduleFile, cmp, classNode) => {
   if (cmp.isPlain) {
     return;
   }
+  const cstrMethodArgs = [
+    import_typescript27.default.factory.createParameterDeclaration(void 0, void 0, import_typescript27.default.factory.createIdentifier("registerHost"))
+  ];
   const nativeCstrStatements = [
     ...nativeInit(cmp),
     ...addCreateEvents(moduleFile, cmp),
     ...createNativeAttachInternalsBinding(cmp)
   ];
-  updateConstructor(classNode, classMembers, nativeCstrStatements);
+  updateConstructor(classNode, classMembers, nativeCstrStatements, cstrMethodArgs, cmp.doesExtend);
 };
 var nativeInit = (cmp) => {
   const initStatements = [nativeRegisterHostStatement()];
@@ -253558,18 +253724,30 @@ var nativeInit = (cmp) => {
   return initStatements;
 };
 var nativeRegisterHostStatement = () => {
-  return import_typescript25.default.factory.createExpressionStatement(
-    import_typescript25.default.factory.createCallExpression(
-      import_typescript25.default.factory.createPropertyAccessExpression(import_typescript25.default.factory.createThis(), import_typescript25.default.factory.createIdentifier("__registerHost")),
-      void 0,
-      void 0
-    )
+  return import_typescript27.default.factory.createIfStatement(
+    import_typescript27.default.factory.createBinaryExpression(
+      import_typescript27.default.factory.createIdentifier("registerHost"),
+      import_typescript27.default.SyntaxKind.ExclamationEqualsEqualsToken,
+      import_typescript27.default.factory.createFalse()
+    ),
+    import_typescript27.default.factory.createBlock([
+      import_typescript27.default.factory.createExpressionStatement(
+        import_typescript27.default.factory.createCallExpression(
+          import_typescript27.default.factory.createPropertyAccessExpression(
+            import_typescript27.default.factory.createThis(),
+            import_typescript27.default.factory.createIdentifier("__registerHost")
+          ),
+          void 0,
+          void 0
+        )
+      )
+    ])
   );
 };
 var nativeAttachShadowStatement = () => {
-  return import_typescript25.default.factory.createExpressionStatement(
-    import_typescript25.default.factory.createCallExpression(
-      import_typescript25.default.factory.createPropertyAccessExpression(import_typescript25.default.factory.createThis(), import_typescript25.default.factory.createIdentifier("__attachShadow")),
+  return import_typescript27.default.factory.createExpressionStatement(
+    import_typescript27.default.factory.createCallExpression(
+      import_typescript27.default.factory.createPropertyAccessExpression(import_typescript27.default.factory.createThis(), import_typescript27.default.factory.createIdentifier("__attachShadow")),
       void 0,
       void 0
     )
@@ -253577,21 +253755,21 @@ var nativeAttachShadowStatement = () => {
 };
 
 // src/compiler/transformers/component-native/native-element-getter.ts
-var import_typescript26 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript28 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var addNativeElementGetter = (classMembers, cmp) => {
   if (cmp.elementRef) {
-    const getter = import_typescript26.default.factory.createGetAccessorDeclaration(
+    const getter = import_typescript28.default.factory.createGetAccessorDeclaration(
       void 0,
       cmp.elementRef,
       [],
       void 0,
-      import_typescript26.default.factory.createBlock([import_typescript26.default.factory.createReturnStatement(import_typescript26.default.factory.createThis())])
+      import_typescript28.default.factory.createBlock([import_typescript28.default.factory.createReturnStatement(import_typescript28.default.factory.createThis())])
     );
-    import_typescript26.default.SyntaxKind.AmpersandToken;
+    import_typescript28.default.SyntaxKind.AmpersandToken;
     const index2 = classMembers.findIndex(
       (member2) => {
         var _a2;
-        return member2.kind === import_typescript26.default.SyntaxKind.PropertyDeclaration && ((_a2 = member2.name) == null ? void 0 : _a2.escapedText) === cmp.elementRef;
+        return member2.kind === import_typescript28.default.SyntaxKind.PropertyDeclaration && ((_a2 = member2.name) == null ? void 0 : _a2.escapedText) === cmp.elementRef;
       }
     );
     if (index2 >= 0) {
@@ -253608,10 +253786,10 @@ var addNativeComponentMeta = (classMembers, cmp) => {
 };
 
 // src/compiler/transformers/component-native/native-static-style.ts
-var import_typescript28 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript30 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/add-static-style.ts
-var import_typescript27 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript29 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var addStaticStyleGetterWithinClass = (classMembers, cmp) => {
   const styleLiteral = getStyleLiteral(cmp);
   if (styleLiteral) {
@@ -253621,9 +253799,9 @@ var addStaticStyleGetterWithinClass = (classMembers, cmp) => {
 var addStaticStylePropertyToClass = (styleStatements, cmp) => {
   const styleLiteral = getStyleLiteral(cmp);
   if (styleLiteral) {
-    const statement = import_typescript27.default.factory.createExpressionStatement(
-      import_typescript27.default.factory.createAssignment(
-        import_typescript27.default.factory.createPropertyAccessExpression(import_typescript27.default.factory.createIdentifier(cmp.componentClassName), "style"),
+    const statement = import_typescript29.default.factory.createExpressionStatement(
+      import_typescript29.default.factory.createAssignment(
+        import_typescript29.default.factory.createPropertyAccessExpression(import_typescript29.default.factory.createIdentifier(cmp.componentClassName), "style"),
         styleLiteral
       )
     );
@@ -253645,19 +253823,19 @@ var getMultipleModeStyle = (cmp, styles2) => {
   styles2.forEach((style) => {
     if (typeof style.styleStr === "string") {
       const styleLiteral = createStyleLiteral(cmp, style);
-      const propStr = import_typescript27.default.factory.createPropertyAssignment(style.modeName, styleLiteral);
+      const propStr = import_typescript29.default.factory.createPropertyAssignment(style.modeName, styleLiteral);
       styleModes.push(propStr);
     } else if (Array.isArray(style.externalStyles) && style.externalStyles.length > 0) {
       const styleUrlIdentifier = createStyleIdentifier(cmp, style);
-      const propUrlIdentifier = import_typescript27.default.factory.createPropertyAssignment(style.modeName, styleUrlIdentifier);
+      const propUrlIdentifier = import_typescript29.default.factory.createPropertyAssignment(style.modeName, styleUrlIdentifier);
       styleModes.push(propUrlIdentifier);
     } else if (typeof style.styleIdentifier === "string") {
-      const styleIdentifier = import_typescript27.default.factory.createIdentifier(style.styleIdentifier);
-      const propIdentifier = import_typescript27.default.factory.createPropertyAssignment(style.modeName, styleIdentifier);
+      const styleIdentifier = import_typescript29.default.factory.createIdentifier(style.styleIdentifier);
+      const propIdentifier = import_typescript29.default.factory.createPropertyAssignment(style.modeName, styleIdentifier);
       styleModes.push(propIdentifier);
     }
   });
-  return import_typescript27.default.factory.createObjectLiteralExpression(styleModes, true);
+  return import_typescript29.default.factory.createObjectLiteralExpression(styleModes, true);
 };
 var getSingleStyle = (cmp, style) => {
   if (typeof style.styleStr === "string") {
@@ -253667,16 +253845,16 @@ var getSingleStyle = (cmp, style) => {
     return createStyleIdentifier(cmp, style);
   }
   if (typeof style.styleIdentifier === "string") {
-    return import_typescript27.default.factory.createIdentifier(style.styleIdentifier);
+    return import_typescript29.default.factory.createIdentifier(style.styleIdentifier);
   }
   return null;
 };
 var createStyleLiteral = (cmp, style) => {
   if (cmp.encapsulation === "scoped") {
     const scopeId = getScopeId2(cmp.tagName, style.modeName);
-    return import_typescript27.default.factory.createStringLiteral(scopeCss(style.styleStr, scopeId, false));
+    return import_typescript29.default.factory.createStringLiteral(scopeCss(style.styleStr, scopeId, false));
   }
-  return import_typescript27.default.factory.createStringLiteral(style.styleStr);
+  return import_typescript29.default.factory.createStringLiteral(style.styleStr);
 };
 var createStyleIdentifier = (cmp, style) => {
   const externalStyles = getExternalStyles(style);
@@ -253690,11 +253868,11 @@ var createStyleIdentifier = (cmp, style) => {
 var createIdentifierFromStyleIdentifier = (styleIdentifier, externalStyleIds) => {
   const id = externalStyleIds[0];
   if (externalStyleIds.length === 1) {
-    return import_typescript27.default.factory.createIdentifier(styleIdentifier + id);
+    return import_typescript29.default.factory.createIdentifier(styleIdentifier + id);
   }
-  return import_typescript27.default.factory.createBinaryExpression(
+  return import_typescript29.default.factory.createBinaryExpression(
     createIdentifierFromStyleIdentifier(styleIdentifier, [id]),
-    import_typescript27.default.SyntaxKind.PlusToken,
+    import_typescript29.default.SyntaxKind.PlusToken,
     createIdentifierFromStyleIdentifier(styleIdentifier, externalStyleIds.slice(1))
   );
 };
@@ -253714,19 +253892,19 @@ var addMultipleModeStyleGetter = (classMembers, cmp, styles2) => {
   styles2.forEach((style) => {
     if (typeof style.styleStr === "string") {
       const styleLiteral = createStyleLiteral2(cmp, style);
-      const propStr = import_typescript28.default.factory.createPropertyAssignment(style.modeName, styleLiteral);
+      const propStr = import_typescript30.default.factory.createPropertyAssignment(style.modeName, styleLiteral);
       styleModes.push(propStr);
     } else if (Array.isArray(style.externalStyles) && style.externalStyles.length > 0) {
       const styleUrlIdentifier = createStyleIdentifier(cmp, style);
-      const propUrlIdentifier = import_typescript28.default.factory.createPropertyAssignment(style.modeName, styleUrlIdentifier);
+      const propUrlIdentifier = import_typescript30.default.factory.createPropertyAssignment(style.modeName, styleUrlIdentifier);
       styleModes.push(propUrlIdentifier);
     } else if (typeof style.styleIdentifier === "string") {
-      const styleIdentifier = import_typescript28.default.factory.createIdentifier(style.styleIdentifier);
-      const propIdentifier = import_typescript28.default.factory.createPropertyAssignment(style.modeName, styleIdentifier);
+      const styleIdentifier = import_typescript30.default.factory.createIdentifier(style.styleIdentifier);
+      const propIdentifier = import_typescript30.default.factory.createPropertyAssignment(style.modeName, styleIdentifier);
       styleModes.push(propIdentifier);
     }
   });
-  const styleObj = import_typescript28.default.factory.createObjectLiteralExpression(styleModes, true);
+  const styleObj = import_typescript30.default.factory.createObjectLiteralExpression(styleModes, true);
   classMembers.push(createStaticGetter("style", styleObj));
 };
 var addSingleStyleGetter = (classMembers, cmp, style) => {
@@ -253737,16 +253915,16 @@ var addSingleStyleGetter = (classMembers, cmp, style) => {
     const styleUrlIdentifier = createStyleIdentifier(cmp, style);
     classMembers.push(createStaticGetter("style", styleUrlIdentifier));
   } else if (typeof style.styleIdentifier === "string") {
-    const styleIdentifier = import_typescript28.default.factory.createIdentifier(style.styleIdentifier);
+    const styleIdentifier = import_typescript30.default.factory.createIdentifier(style.styleIdentifier);
     classMembers.push(createStaticGetter("style", styleIdentifier));
   }
 };
 var createStyleLiteral2 = (cmp, style) => {
   if (cmp.encapsulation === "scoped") {
     const scopeId = getScopeId2(cmp.tagName, style.modeName);
-    return import_typescript28.default.factory.createStringLiteral(scopeCss(style.styleStr, scopeId, false));
+    return import_typescript30.default.factory.createStringLiteral(scopeCss(style.styleStr, scopeId, false));
   }
-  return import_typescript28.default.factory.createStringLiteral(style.styleStr);
+  return import_typescript30.default.factory.createStringLiteral(style.styleStr);
 };
 
 // src/compiler/transformers/component-native/native-component.ts
@@ -253755,17 +253933,37 @@ var updateNativeComponentClass = (transformOpts, classNode, moduleFile, cmp) =>
   const members = updateNativeHostComponentMembers(transformOpts, withHeritageClauses, moduleFile, cmp);
   return updateComponentClass(transformOpts, withHeritageClauses, withHeritageClauses.heritageClauses, members);
 };
+var updateNativeExtendedClass = (node, moduleFile, transformOpts) => {
+  var _a2, _b;
+  let withHeritageClauses = updateNativeHostComponentHeritageClauses(node, moduleFile);
+  const ctor = withHeritageClauses.members.find(import_typescript31.default.isConstructorDeclaration);
+  if (!foundSuper((_a2 = ctor == null ? void 0 : ctor.body) == null ? void 0 : _a2.statements)) {
+    const params = Array.from((_b = ctor == null ? void 0 : ctor.parameters) != null ? _b : []);
+    withHeritageClauses = import_typescript31.default.factory.updateClassDeclaration(
+      withHeritageClauses,
+      withHeritageClauses.modifiers,
+      withHeritageClauses.name,
+      withHeritageClauses.typeParameters,
+      withHeritageClauses.heritageClauses,
+      updateConstructor(withHeritageClauses, Array.from(withHeritageClauses.members), [], params, true)
+    );
+  }
+  return updateComponentClass(
+    transformOpts,
+    withHeritageClauses,
+    withHeritageClauses.heritageClauses,
+    removeStaticMetaProperties(withHeritageClauses)
+  );
+};
 var updateNativeHostComponentHeritageClauses = (classNode, moduleFile) => {
   if (classNode.heritageClauses != null && classNode.heritageClauses.length > 0) {
     return classNode;
   }
-  if (moduleFile.cmps.length >= 1) {
-    addOutputTargetCoreRuntimeApi(moduleFile, DIST_CUSTOM_ELEMENTS, RUNTIME_APIS.HTMLElement);
-  }
-  const heritageClause = import_typescript29.default.factory.createHeritageClause(import_typescript29.default.SyntaxKind.ExtendsKeyword, [
-    import_typescript29.default.factory.createExpressionWithTypeArguments(import_typescript29.default.factory.createIdentifier(HTML_ELEMENT), [])
+  addOutputTargetCoreRuntimeApi(moduleFile, DIST_CUSTOM_ELEMENTS, RUNTIME_APIS.HTMLElement);
+  const heritageClause = import_typescript31.default.factory.createHeritageClause(import_typescript31.default.SyntaxKind.ExtendsKeyword, [
+    import_typescript31.default.factory.createExpressionWithTypeArguments(import_typescript31.default.factory.createIdentifier(HTML_ELEMENT), [])
   ]);
-  return import_typescript29.default.factory.updateClassDeclaration(
+  return import_typescript31.default.factory.updateClassDeclaration(
     classNode,
     classNode.modifiers,
     classNode.name,
@@ -253797,15 +253995,18 @@ var nativeComponentTransform = (compilerCtx, transformOpts) => {
       var _a2, _b;
       const moduleFile = getModuleFromSourceFile(compilerCtx, tsSourceFile);
       const visitNode = (node) => {
-        if (import_typescript30.default.isClassDeclaration(node)) {
+        var _a3;
+        if (import_typescript32.default.isClassDeclaration(node)) {
           const cmp = getComponentMeta(compilerCtx, tsSourceFile, node);
           if (cmp != null) {
             return updateNativeComponentClass(transformOpts, node, moduleFile, cmp);
+          } else if ((_a3 = compilerCtx.moduleMap.get(tsSourceFile.fileName)) == null ? void 0 : _a3.isExtended) {
+            return updateNativeExtendedClass(node, moduleFile, transformOpts);
           }
         }
-        return import_typescript30.default.visitEachChild(node, visitNode, transformCtx);
+        return import_typescript32.default.visitEachChild(node, visitNode, transformCtx);
       };
-      tsSourceFile = import_typescript30.default.visitEachChild(tsSourceFile, visitNode, transformCtx);
+      tsSourceFile = import_typescript32.default.visitEachChild(tsSourceFile, visitNode, transformCtx);
       if (moduleFile.cmps.length > 0) {
         if (transformOpts.componentExport === "customelement") {
           tsSourceFile = defineCustomElement2(tsSourceFile, moduleFile, transformOpts);
@@ -253829,23 +254030,23 @@ var nativeComponentTransform = (compilerCtx, transformOpts) => {
 
 // src/compiler/transformers/rewrite-aliased-paths.ts
 var import_path25 = require("path");
-var import_typescript31 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript33 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 function rewriteAliasedDTSImportPaths(transformCtx) {
-  const compilerHost = import_typescript31.default.createCompilerHost(transformCtx.getCompilerOptions());
+  const compilerHost = import_typescript33.default.createCompilerHost(transformCtx.getCompilerOptions());
   return (tsBundleOrSourceFile) => {
-    const fileName = import_typescript31.default.isBundle(tsBundleOrSourceFile) ? tsBundleOrSourceFile.getSourceFile().fileName : tsBundleOrSourceFile.fileName;
-    return import_typescript31.default.visitEachChild(tsBundleOrSourceFile, visit(compilerHost, transformCtx, fileName), transformCtx);
+    const fileName = import_typescript33.default.isBundle(tsBundleOrSourceFile) ? tsBundleOrSourceFile.getSourceFile().fileName : tsBundleOrSourceFile.fileName;
+    return import_typescript33.default.visitEachChild(tsBundleOrSourceFile, visit(compilerHost, transformCtx, fileName), transformCtx);
   };
 }
 function rewriteAliasedSourceFileImportPaths(transformCtx) {
-  const compilerHost = import_typescript31.default.createCompilerHost(transformCtx.getCompilerOptions());
+  const compilerHost = import_typescript33.default.createCompilerHost(transformCtx.getCompilerOptions());
   return (tsSourceFile) => {
-    return import_typescript31.default.visitEachChild(tsSourceFile, visit(compilerHost, transformCtx, tsSourceFile.fileName), transformCtx);
+    return import_typescript33.default.visitEachChild(tsSourceFile, visit(compilerHost, transformCtx, tsSourceFile.fileName), transformCtx);
   };
 }
 function visit(compilerHost, transformCtx, sourceFilePath) {
   return (node) => {
-    if (!import_typescript31.default.isImportDeclaration(node)) {
+    if (!import_typescript33.default.isImportDeclaration(node)) {
       return node;
     }
     return rewriteAliasedImport(compilerHost, transformCtx, sourceFilePath, node);
@@ -253853,14 +254054,14 @@ function visit(compilerHost, transformCtx, sourceFilePath) {
 }
 function rewriteAliasedImport(compilerHost, transformCtx, sourceFilePath, node) {
   var _a2, _b;
-  if (!import_typescript31.default.isStringLiteral(node.moduleSpecifier)) {
+  if (!import_typescript33.default.isStringLiteral(node.moduleSpecifier)) {
     return node;
   }
   let importPath = node.moduleSpecifier.text;
   if (importPath.startsWith(".")) {
     return node;
   }
-  const module2 = import_typescript31.default.resolveModuleName(importPath, sourceFilePath, transformCtx.getCompilerOptions(), compilerHost);
+  const module2 = import_typescript33.default.resolveModuleName(importPath, sourceFilePath, transformCtx.getCompilerOptions(), compilerHost);
   const hasResolvedFileName = ((_a2 = module2.resolvedModule) == null ? void 0 : _a2.resolvedFileName) != null;
   const isModuleFromNodeModules = ((_b = module2.resolvedModule) == null ? void 0 : _b.isExternalLibraryImport) === true;
   const shouldTranspileImportPath = hasResolvedFileName && !isModuleFromNodeModules;
@@ -253868,7 +254069,7 @@ function rewriteAliasedImport(compilerHost, transformCtx, sourceFilePath, node)
     return node;
   }
   const extensionRegex = new RegExp(
-    Object.values(import_typescript31.default.Extension).map((extension) => `${extension}$`.replace(".", "\\.")).join("|")
+    Object.values(import_typescript33.default.Extension).map((extension) => `${extension}$`.replace(".", "\\.")).join("|")
   );
   const resolvePathInDestination = module2.resolvedModule.resolvedFileName;
   importPath = normalizePath(relative((0, import_path25.dirname)(sourceFilePath), resolvePathInDestination).replace(extensionRegex, ""));
@@ -253916,7 +254117,7 @@ function rewriteAliasedImport(compilerHost, transformCtx, sourceFilePath, node)
 }
 
 // src/compiler/transformers/update-stencil-core-import.ts
-var import_typescript32 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript34 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var updateStencilCoreImports = (updatedCoreImportPath) => {
   return () => {
     return (tsSourceFile) => {
@@ -253926,26 +254127,26 @@ var updateStencilCoreImports = (updatedCoreImportPath) => {
       let madeChanges = false;
       const newStatements = [];
       tsSourceFile.statements.forEach((s) => {
-        if (import_typescript32.default.isImportDeclaration(s)) {
-          if (s.moduleSpecifier != null && import_typescript32.default.isStringLiteral(s.moduleSpecifier)) {
+        if (import_typescript34.default.isImportDeclaration(s)) {
+          if (s.moduleSpecifier != null && import_typescript34.default.isStringLiteral(s.moduleSpecifier)) {
             if (s.moduleSpecifier.text === STENCIL_CORE_ID) {
-              if (s.importClause && s.importClause.namedBindings && s.importClause.namedBindings.kind === import_typescript32.default.SyntaxKind.NamedImports) {
+              if (s.importClause && s.importClause.namedBindings && s.importClause.namedBindings.kind === import_typescript34.default.SyntaxKind.NamedImports) {
                 const origImports = s.importClause.namedBindings.elements;
                 const keepImports = origImports.map((e) => e.getText()).filter((name) => KEEP_IMPORTS.has(name));
                 if (keepImports.length > 0) {
-                  const newImport = import_typescript32.default.factory.updateImportDeclaration(
+                  const newImport = import_typescript34.default.factory.updateImportDeclaration(
                     s,
                     void 0,
-                    import_typescript32.default.factory.createImportClause(
+                    import_typescript34.default.factory.createImportClause(
                       false,
                       void 0,
-                      import_typescript32.default.factory.createNamedImports(
+                      import_typescript34.default.factory.createNamedImports(
                         keepImports.map(
-                          (name) => import_typescript32.default.factory.createImportSpecifier(false, void 0, import_typescript32.default.factory.createIdentifier(name))
+                          (name) => import_typescript34.default.factory.createImportSpecifier(false, void 0, import_typescript34.default.factory.createIdentifier(name))
                         )
                       )
                     ),
-                    import_typescript32.default.factory.createStringLiteral(updatedCoreImportPath),
+                    import_typescript34.default.factory.createStringLiteral(updatedCoreImportPath),
                     void 0
                   );
                   newStatements.push(newImport);
@@ -253959,7 +254160,7 @@ var updateStencilCoreImports = (updatedCoreImportPath) => {
         newStatements.push(s);
       });
       if (madeChanges) {
-        return import_typescript32.default.factory.updateSourceFile(
+        return import_typescript34.default.factory.updateSourceFile(
           tsSourceFile,
           newStatements,
           tsSourceFile.isDeclarationFile,
@@ -253989,7 +254190,8 @@ var KEEP_IMPORTS = /* @__PURE__ */ new Set([
   "forceUpdate",
   "getRenderingRef",
   "forceModeUpdate",
-  "setErrorHandler"
+  "setErrorHandler",
+  "Mixin"
 ]);
 
 // src/compiler/app-core/app-data.ts
@@ -254136,6 +254338,7 @@ var getCustomElementsBuildConditionals = (config, cmps) => {
   build2.hydrateServerSide = false;
   build2.asyncQueue = config.taskQueue === "congestionAsync";
   build2.taskQueue = config.taskQueue !== "immediate";
+  build2.initializeNextTick = config.extras.initializeNextTick;
   updateBuildConditionals(config, build2);
   build2.devTools = false;
   return build2;
@@ -254330,133 +254533,6 @@ var import_typescript37 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 // src/compiler/transformers/component-hydrate/hydrate-component.ts
 var import_typescript36 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
-// src/compiler/transformers/component-lazy/lazy-constructor.ts
-var import_typescript34 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-
-// src/compiler/transformers/component-lazy/attach-internals.ts
-var import_typescript33 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-
-// src/compiler/transformers/component-lazy/constants.ts
-var HOST_REF_ARG = "hostRef";
-
-// src/compiler/transformers/component-lazy/attach-internals.ts
-function createLazyAttachInternalsBinding(cmp) {
-  if (cmp.attachInternalsMemberName) {
-    return [
-      import_typescript33.default.factory.createIfStatement(
-        // the condition for the `if` statement here is just whether the
-        // following is defined:
-        //
-        // ```ts
-        // hostRef.$hostElement$["s-ei"]
-        // ```
-        hostRefElementInternalsPropAccess(),
-        import_typescript33.default.factory.createBlock(
-          [
-            // this `ts.factory` call creates the following statement:
-            //
-            // ```ts
-            // this.${ cmp.formInternalsMemberName } = hostRef.$hostElement$['s-ei'];
-            // ```
-            import_typescript33.default.factory.createExpressionStatement(
-              import_typescript33.default.factory.createBinaryExpression(
-                import_typescript33.default.factory.createPropertyAccessExpression(
-                  import_typescript33.default.factory.createThis(),
-                  // use the name set on the {@link d.ComponentCompilerMeta}
-                  import_typescript33.default.factory.createIdentifier(cmp.attachInternalsMemberName)
-                ),
-                import_typescript33.default.factory.createToken(import_typescript33.default.SyntaxKind.EqualsToken),
-                hostRefElementInternalsPropAccess()
-              )
-            )
-          ],
-          true
-        ),
-        import_typescript33.default.factory.createBlock(
-          [
-            // this `ts.factory` call creates the following statement:
-            //
-            // ```ts
-            // this.${ cmp.attachInternalsMemberName } = hostRef.$hostElement$.attachInternals();
-            // ```
-            import_typescript33.default.factory.createExpressionStatement(
-              import_typescript33.default.factory.createBinaryExpression(
-                import_typescript33.default.factory.createPropertyAccessExpression(
-                  import_typescript33.default.factory.createThis(),
-                  // use the name set on the {@link d.ComponentCompilerMeta}
-                  import_typescript33.default.factory.createIdentifier(cmp.attachInternalsMemberName)
-                ),
-                import_typescript33.default.factory.createToken(import_typescript33.default.SyntaxKind.EqualsToken),
-                import_typescript33.default.factory.createCallExpression(
-                  import_typescript33.default.factory.createPropertyAccessExpression(
-                    import_typescript33.default.factory.createPropertyAccessExpression(
-                      import_typescript33.default.factory.createIdentifier(HOST_REF_ARG),
-                      import_typescript33.default.factory.createIdentifier("$hostElement$")
-                    ),
-                    import_typescript33.default.factory.createIdentifier("attachInternals")
-                  ),
-                  void 0,
-                  []
-                )
-              )
-            ),
-            // this `ts.factory` call produces the following:
-            //
-            // ```ts
-            // hostRef.$hostElement$['s-ei'] = this.${ cmp.attachInternalsMemberName };
-            // ```
-            import_typescript33.default.factory.createExpressionStatement(
-              import_typescript33.default.factory.createBinaryExpression(
-                hostRefElementInternalsPropAccess(),
-                import_typescript33.default.factory.createToken(import_typescript33.default.SyntaxKind.EqualsToken),
-                import_typescript33.default.factory.createPropertyAccessExpression(
-                  import_typescript33.default.factory.createThis(),
-                  // use the name set on the {@link d.ComponentCompilerMeta}
-                  import_typescript33.default.factory.createIdentifier(cmp.attachInternalsMemberName)
-                )
-              )
-            )
-          ],
-          true
-        )
-      )
-    ];
-  } else {
-    return [];
-  }
-}
-function hostRefElementInternalsPropAccess() {
-  return import_typescript33.default.factory.createElementAccessExpression(
-    import_typescript33.default.factory.createPropertyAccessExpression(
-      import_typescript33.default.factory.createIdentifier(HOST_REF_ARG),
-      import_typescript33.default.factory.createIdentifier("$hostElement$")
-    ),
-    import_typescript33.default.factory.createStringLiteral("s-ei")
-  );
-}
-
-// src/compiler/transformers/component-lazy/lazy-constructor.ts
-var updateLazyComponentConstructor = (classMembers, classNode, moduleFile, cmp) => {
-  const cstrMethodArgs = [
-    import_typescript34.default.factory.createParameterDeclaration(void 0, void 0, import_typescript34.default.factory.createIdentifier(HOST_REF_ARG))
-  ];
-  const cstrStatements = [
-    registerInstanceStatement(moduleFile),
-    ...addCreateEvents(moduleFile, cmp),
-    ...createLazyAttachInternalsBinding(cmp)
-  ];
-  updateConstructor(classNode, classMembers, cstrStatements, cstrMethodArgs);
-};
-var registerInstanceStatement = (moduleFile) => {
-  addCoreRuntimeApi(moduleFile, RUNTIME_APIS.registerInstance);
-  return import_typescript34.default.factory.createExpressionStatement(
-    import_typescript34.default.factory.createCallExpression(import_typescript34.default.factory.createIdentifier(REGISTER_INSTANCE), void 0, [
-      import_typescript34.default.factory.createThis(),
-      import_typescript34.default.factory.createIdentifier(HOST_REF_ARG)
-    ])
-  );
-};
-
 // src/compiler/transformers/component-lazy/lazy-element-getter.ts
 var import_typescript35 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var addLazyElementGetter = (classMembers, moduleFile, cmp) => {
@@ -254546,10 +254622,13 @@ var hydrateComponentTransform = (compilerCtx, transformOpts) => {
     return (tsSourceFile) => {
       const moduleFile = getModuleFromSourceFile(compilerCtx, tsSourceFile);
       const visitNode = (node) => {
+        var _a2;
         if (import_typescript37.default.isClassDeclaration(node)) {
           const cmp = getComponentMeta(compilerCtx, tsSourceFile, node);
           if (cmp != null) {
             return updateHydrateComponentClass(node, moduleFile, cmp);
+          } else if ((_a2 = compilerCtx.moduleMap.get(tsSourceFile.fileName)) == null ? void 0 : _a2.isMixin) {
+            return updateMixin(node, moduleFile, cmp, transformOpts);
           }
         }
         return import_typescript37.default.visitEachChild(node, visitNode, transformCtx);
@@ -255216,8 +255295,11 @@ var lazyComponentTransform = (compilerCtx, transformOpts) => {
       const visitNode = (node) => {
         if (import_typescript38.default.isClassDeclaration(node)) {
           const cmp = getComponentMeta(compilerCtx, tsSourceFile, node);
+          const module2 = compilerCtx.moduleMap.get(tsSourceFile.fileName);
           if (cmp != null) {
             return updateLazyComponentClass(transformOpts, styleStatements, node, moduleFile, cmp);
+          } else if (module2 == null ? void 0 : module2.isMixin) {
+            return updateMixin(node, moduleFile, cmp, transformOpts);
           }
         }
         return import_typescript38.default.visitEachChild(node, visitNode, transformCtx);
@@ -255276,9 +255358,9 @@ var generateRollupOutput = async (build2, options, config, entryModules) => {
 };
 
 // src/compiler/output-targets/dist-lazy/write-lazy-entry-module.ts
-var writeLazyModule = async (config, compilerCtx, outputTargetType, destinations, entryModule, shouldHash, code, sourceMap, sufix) => {
-  const bundleId = await getBundleId(config, entryModule.entryKey, shouldHash, code, sufix);
-  const fileName = `${bundleId}.entry.js`;
+var writeLazyModule = async (compilerCtx, outputTargetType, destinations, code, sourceMap, rollupResult) => {
+  const fileName = rollupResult.fileName;
+  const bundleId = fileName.replace(".entry.js", "");
   if (sourceMap) {
     code = code + getSourceMappingUrlForEndOfFile(fileName);
   }
@@ -255296,21 +255378,9 @@ var writeLazyModule = async (config, compilerCtx, outputTargetType, destinations
     code
   };
 };
-var getBundleId = async (config, entryKey, shouldHash, code, sufix) => {
-  if (shouldHash) {
-    const hash = await config.sys.generateContentHash(code, config.hashedFileNameLength);
-    return `p-${hash}${sufix}`;
-  }
-  const components = entryKey.split(".");
-  let bundleId = components[0];
-  if (components.length > 2) {
-    bundleId = `${bundleId}_${components.length - 1}`;
-  }
-  return bundleId + sufix;
-};
 
 // src/compiler/output-targets/dist-lazy/generate-lazy-module.ts
-var generateLazyModules = async (config, compilerCtx, buildCtx, outputTargetType, destinations, results, sourceTarget, isBrowserBuild, sufix) => {
+var generateLazyModules = async (config, compilerCtx, buildCtx, outputTargetType, destinations, results, sourceTarget, isBrowserBuild) => {
   if (!Array.isArray(destinations) || destinations.length === 0) {
     return [];
   }
@@ -255329,8 +255399,7 @@ var generateLazyModules = async (config, compilerCtx, buildCtx, outputTargetType
         destinations,
         sourceTarget,
         shouldMinify,
-        isBrowserBuild,
-        sufix
+        isBrowserBuild
       );
     })
   );
@@ -255419,9 +255488,8 @@ var generateCaseClauseCjs = (bundleId) => {
                         /* webpackMode: "lazy" */
                         './${bundleId}.entry.js')); }).then(processMod, consoleError);`;
 };
-var generateLazyEntryModule = async (config, compilerCtx, buildCtx, rollupResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild, sufix) => {
+var generateLazyEntryModule = async (config, compilerCtx, buildCtx, rollupResult, outputTargetType, destinations, sourceTarget, shouldMinify, isBrowserBuild) => {
   const entryModule = buildCtx.entryModules.find((entryModule2) => entryModule2.entryKey === rollupResult.entryKey);
-  const shouldHash = config.hashFileNames && isBrowserBuild;
   const { code, sourceMap } = await convertChunk(
     config,
     compilerCtx,
@@ -255433,17 +255501,7 @@ var generateLazyEntryModule = async (config, compilerCtx, buildCtx, rollupResult
     rollupResult.code,
     rollupResult.map
   );
-  const output = await writeLazyModule(
-    config,
-    compilerCtx,
-    outputTargetType,
-    destinations,
-    entryModule,
-    shouldHash,
-    code,
-    sourceMap,
-    sufix
-  );
+  const output = await writeLazyModule(compilerCtx, outputTargetType, destinations, code, sourceMap, rollupResult);
   return {
     rollupResult,
     entryKey: rollupResult.entryKey,
@@ -255586,6 +255644,54 @@ var convertChunk = async (config, compilerCtx, buildCtx, sourceTarget, shouldMin
   return { code, sourceMap };
 };
 
+// src/compiler/output-targets/dist-lazy/lazy-bundleid-plugin.ts
+var lazyBundleIdPlugin = (buildCtx, config, shouldHash, suffix) => {
+  const getBundleId = async (entryKey, code, suffix2) => {
+    var _a2;
+    if (shouldHash && ((_a2 = config.sys) == null ? void 0 : _a2.generateContentHash)) {
+      const hash = await config.sys.generateContentHash(code, config.hashedFileNameLength);
+      return `p-${hash}${suffix2}`;
+    }
+    const components = entryKey.split(".");
+    let bundleId = components[0];
+    if (components.length > 2) {
+      bundleId = `${bundleId}_${components.length - 1}`;
+    }
+    return bundleId + suffix2;
+  };
+  return {
+    name: "lazyBundleIdPlugin",
+    async generateBundle(_, bundle) {
+      const files = Object.entries(bundle);
+      const map2 = /* @__PURE__ */ new Map();
+      for (const [_key, file] of files) {
+        if (!file.isEntry) continue;
+        const entryModule = buildCtx.entryModules.find((em) => em.entryKey === file.name);
+        if (!entryModule) continue;
+        map2.set(file.fileName, await getBundleId(file.name, file.code, suffix) + ".entry.js");
+      }
+      if (!map2.size) return;
+      for (const [_key, file] of files) {
+        if (!file.isEntry) continue;
+        file.facadeModuleId = map2.get(file.fileName) || file.facadeModuleId;
+        file.fileName = map2.get(file.fileName) || file.fileName;
+        const magicString = new MagicString(file.code);
+        file.imports.forEach((imported, i) => {
+          const replaced = map2.get(imported);
+          if (replaced) {
+            magicString.replaceAll(imported, replaced);
+            file.imports[i] = replaced;
+          }
+        });
+        file.code = magicString.toString();
+        if (config.sourceMap) {
+          file.map = magicString.generateMap();
+        }
+      }
+    }
+  };
+};
+
 // src/compiler/output-targets/dist-lazy/generate-cjs.ts
 var generateCjs = async (config, compilerCtx, buildCtx, rollupBuild, outputTargets) => {
   const cjsOutputs = outputTargets.filter((o) => !!o.cjsDir);
@@ -255596,7 +255702,8 @@ var generateCjs = async (config, compilerCtx, buildCtx, rollupBuild, outputTarge
       format: "cjs",
       entryFileNames: "[name].cjs.js",
       assetFileNames: "[name]-[hash][extname]",
-      sourcemap: config.sourceMap
+      sourcemap: config.sourceMap,
+      plugins: [lazyBundleIdPlugin(buildCtx, config, false, ".cjs")]
     };
     if (!!config.extras.experimentalImportInjection || !!config.extras.enableImportInjection) {
       esmOpts.interop = "auto";
@@ -255613,8 +255720,7 @@ var generateCjs = async (config, compilerCtx, buildCtx, rollupBuild, outputTarge
         destinations,
         results,
         "es2017",
-        false,
-        ".cjs"
+        false
       );
       await generateShortcuts(compilerCtx, results, cjsOutputs);
     }
@@ -255646,7 +255752,8 @@ var generateEsm = async (config, compilerCtx, buildCtx, rollupBuild, outputTarge
       format: "es",
       entryFileNames: "[name].js",
       assetFileNames: "[name]-[hash][extname]",
-      sourcemap: config.sourceMap
+      sourcemap: config.sourceMap,
+      plugins: [lazyBundleIdPlugin(buildCtx, config, false, "")]
     };
     const outputTargetType = esmOutputs[0].type;
     const output = await generateRollupOutput(rollupBuild, esmOpts, config, buildCtx.entryModules);
@@ -255660,8 +255767,7 @@ var generateEsm = async (config, compilerCtx, buildCtx, rollupBuild, outputTarge
         es2017destinations,
         output,
         "es2017",
-        false,
-        ""
+        false
       );
       const es5destinations = esmEs5Outputs.map((o) => o.esmEs5Dir).filter((esmEs5Dir) => typeof esmEs5Dir === "string");
       buildCtx.es5ComponentBundle = await generateLazyModules(
@@ -255672,8 +255778,7 @@ var generateEsm = async (config, compilerCtx, buildCtx, rollupBuild, outputTarge
         es5destinations,
         output,
         "es5",
-        false,
-        ""
+        false
       );
       if (config.buildEs5) {
         await copyPolyfills(config, compilerCtx, esmOutputs);
@@ -255725,7 +255830,8 @@ var generateEsmBrowser = async (config, compilerCtx, buildCtx, rollupBuild, outp
       entryFileNames: "[name].esm.js",
       chunkFileNames: config.hashFileNames ? "p-[hash].js" : "[name]-[hash].js",
       assetFileNames: config.hashFileNames ? "p-[hash][extname]" : "[name]-[hash][extname]",
-      sourcemap: config.sourceMap
+      sourcemap: config.sourceMap,
+      plugins: [lazyBundleIdPlugin(buildCtx, config, config.hashFileNames, "")]
     };
     const output = await generateRollupOutput(rollupBuild, esmOpts, config, buildCtx.entryModules);
     if (output != null) {
@@ -255738,8 +255844,7 @@ var generateEsmBrowser = async (config, compilerCtx, buildCtx, rollupBuild, outp
         es2017destinations,
         output,
         "es2017",
-        true,
-        ""
+        true
       );
     }
   }
@@ -255778,7 +255883,8 @@ var generateSystem = async (config, compilerCtx, buildCtx, rollupBuild, outputTa
       entryFileNames: config.hashFileNames ? "p-[hash].system.js" : "[name].system.js",
       chunkFileNames: config.hashFileNames ? "p-[hash].system.js" : "[name]-[hash].system.js",
       assetFileNames: config.hashFileNames ? "p-[hash][extname]" : "[name]-[hash][extname]",
-      sourcemap: config.sourceMap
+      sourcemap: config.sourceMap,
+      plugins: [lazyBundleIdPlugin(buildCtx, config, config.hashFileNames, ".system")]
     };
     const results = await generateRollupOutput(rollupBuild, esmOpts, config, buildCtx.entryModules);
     if (results != null) {
@@ -255791,8 +255897,7 @@ var generateSystem = async (config, compilerCtx, buildCtx, rollupBuild, outputTa
         destinations,
         results,
         "es5",
-        true,
-        ".system"
+        true
       );
       await generateSystemLoaders(config, compilerCtx, results, systemOutputs);
     }
@@ -260435,14 +260540,6 @@ var componentDecoratorToStatic = (config, typeChecker, diagnostics, cmpNode, new
 };
 var validateComponent = (config, diagnostics, typeChecker, componentOptions, cmpNode, componentDecorator) => {
   var _a2;
-  const extendNode = cmpNode.heritageClauses && cmpNode.heritageClauses.find((c) => c.token === import_typescript45.default.SyntaxKind.ExtendsKeyword);
-  if (extendNode) {
-    const err2 = buildError(diagnostics);
-    err2.messageText = `Classes decorated with @Component can not extend from a base class.
-    Stencil needs to be able to switch between different base classes in order to implement the different output targets such as: lazy and raw web components.`;
-    augmentDiagnosticWithNode(err2, extendNode);
-    return false;
-  }
   if (componentOptions.shadow && componentOptions.scoped) {
     const err2 = buildError(diagnostics);
     err2.messageText = `Components cannot be "scoped" and "shadow" at the same time, they are mutually exclusive configurations.`;
@@ -261621,16 +261718,25 @@ var visitClassDeclaration = (config, diagnostics, typeChecker, program3, classNo
   var _a2, _b, _c;
   const importAliasMap = new ImportAliasMap(sourceFile);
   const componentDecorator = (_a2 = retrieveTsDecorators(classNode)) == null ? void 0 : _a2.find(isDecoratorNamed(importAliasMap.get("Component")));
-  if (!componentDecorator) {
-    return classNode;
-  }
   const classMembers = classNode.members;
   const decoratedMembers = classMembers.filter((member2) => {
     var _a3, _b2;
     return ((_b2 = (_a3 = retrieveTsDecorators(member2)) == null ? void 0 : _a3.length) != null ? _b2 : 0) > 0;
   });
+  if (!decoratedMembers.length && !componentDecorator) {
+    return classNode;
+  }
   const filteredMethodsAndFields = removeStencilMethodDecorators(Array.from(classMembers), diagnostics, importAliasMap);
-  componentDecoratorToStatic(config, typeChecker, diagnostics, classNode, filteredMethodsAndFields, componentDecorator);
+  if (componentDecorator) {
+    componentDecoratorToStatic(
+      config,
+      typeChecker,
+      diagnostics,
+      classNode,
+      filteredMethodsAndFields,
+      componentDecorator
+    );
+  }
   if (decoratedMembers.length > 0) {
     propDecoratorsToStatic(
       diagnostics,
@@ -261959,23 +262065,24 @@ var setComponentBuildConditionals = (cmpMeta) => {
 
 // src/compiler/transformers/detect-modern-prop-decls.ts
 var import_typescript58 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-var detectModernPropDeclarations = (classNode, cmp) => {
+var detectModernPropDeclarations = (classNode) => {
   const parsedProps = getStaticValue(classNode.members, "properties");
   const parsedStates = getStaticValue(classNode.members, "states");
   if (!parsedProps && !parsedStates) {
-    cmp.hasModernPropertyDecls = false;
-    return;
+    return false;
   }
   const members = [...Object.entries(parsedProps || {}), ...Object.entries(parsedStates || {})];
+  let hasModernPropertyDecls = false;
   for (const [propName, meta] of members) {
     const dynamicPropName = meta.ogPropName || "";
     const prop = classNode.members.find((m) => {
       return import_typescript58.default.isPropertyDeclaration(m) && (import_typescript58.default.isComputedPropertyName(m.name) && m.name.expression.getText() === dynamicPropName || m.name.getText() === propName);
     });
     if (!prop) continue;
-    cmp.hasModernPropertyDecls = true;
+    hasModernPropertyDecls = true;
     break;
   }
+  return hasModernPropertyDecls;
 };
 
 // src/compiler/transformers/static-to-meta/attach-internals.ts
@@ -261989,14 +262096,8 @@ var parseAttachInternals = (staticMembers) => {
 };
 
 // src/compiler/transformers/static-to-meta/class-methods.ts
-var import_typescript59 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-var parseClassMethods = (cmpNode, cmpMeta) => {
-  const classMembers = cmpNode.members;
-  if (!classMembers || classMembers.length === 0) {
-    return;
-  }
-  const classMethods = classMembers.filter((m) => import_typescript59.default.isMethodDeclaration(m));
-  if (classMethods.length === 0) {
+var parseClassMethods = (classMethods, cmpMeta) => {
+  if (!(classMethods == null ? void 0 : classMethods.length)) {
     return;
   }
   const hasHostData = classMethods.some((m) => isMethod(m, "hostData"));
@@ -262043,116 +262144,12 @@ var parseStaticShadowDelegatesFocus = (encapsulation, staticMembers) => {
   return null;
 };
 
-// src/compiler/transformers/static-to-meta/events.ts
-var parseStaticEvents = (staticMembers) => {
-  const parsedEvents = getStaticValue(staticMembers, "events");
-  if (!parsedEvents || parsedEvents.length === 0) {
-    return [];
-  }
-  return parsedEvents.map((parsedEvent) => {
-    return {
-      name: parsedEvent.name,
-      method: parsedEvent.method,
-      bubbles: parsedEvent.bubbles,
-      cancelable: parsedEvent.cancelable,
-      composed: parsedEvent.composed,
-      docs: parsedEvent.docs,
-      complexType: parsedEvent.complexType,
-      internal: isInternal(parsedEvent.docs)
-    };
-  });
-};
-
 // src/compiler/transformers/static-to-meta/form-associated.ts
 var parseFormAssociated = (staticMembers) => {
   const isFormAssociated = getStaticValue(staticMembers, "formAssociated");
   return typeof isFormAssociated === "boolean" && isFormAssociated;
 };
 
-// src/compiler/transformers/static-to-meta/listeners.ts
-var parseStaticListeners = (staticMembers) => {
-  const parsedListeners = getStaticValue(staticMembers, "listeners");
-  if (!parsedListeners || parsedListeners.length === 0) {
-    return [];
-  }
-  return parsedListeners.map((parsedListener) => {
-    return {
-      name: parsedListener.name,
-      method: parsedListener.method,
-      capture: !!parsedListener.capture,
-      passive: !!parsedListener.passive,
-      target: parsedListener.target
-    };
-  });
-};
-
-// src/compiler/transformers/static-to-meta/methods.ts
-var parseStaticMethods = (staticMembers) => {
-  const parsedMethods = getStaticValue(staticMembers, "methods");
-  if (!parsedMethods) {
-    return [];
-  }
-  const methodNames = Object.keys(parsedMethods);
-  if (methodNames.length === 0) {
-    return [];
-  }
-  return methodNames.map((methodName) => {
-    return {
-      name: methodName,
-      docs: parsedMethods[methodName].docs,
-      complexType: parsedMethods[methodName].complexType,
-      internal: isInternal(parsedMethods[methodName].docs)
-    };
-  });
-};
-
-// src/compiler/transformers/static-to-meta/props.ts
-var parseStaticProps = (staticMembers) => {
-  const parsedProps = getStaticValue(staticMembers, "properties");
-  if (!parsedProps) {
-    return [];
-  }
-  const propNames = Object.keys(parsedProps);
-  if (propNames.length === 0) {
-    return [];
-  }
-  return propNames.map((propName) => {
-    const val = parsedProps[propName];
-    return {
-      name: propName,
-      type: val.type,
-      attribute: val.attribute ? val.attribute.toLowerCase() : void 0,
-      reflect: typeof val.reflect === "boolean" ? val.reflect : false,
-      mutable: !!val.mutable,
-      required: !!val.required,
-      optional: !!val.optional,
-      defaultValue: val.defaultValue,
-      complexType: val.complexType,
-      docs: val.docs,
-      internal: isInternal(val.docs),
-      getter: !!val.getter,
-      setter: !!val.setter
-    };
-  });
-};
-
-// src/compiler/transformers/static-to-meta/states.ts
-var parseStaticStates = (staticMembers) => {
-  const parsedStates = getStaticValue(staticMembers, "states");
-  if (!parsedStates) {
-    return [];
-  }
-  const stateNames = Object.keys(parsedStates);
-  if (stateNames.length === 0) {
-    return [];
-  }
-  return stateNames.map((stateName) => {
-    return {
-      name: stateName
-    };
-  });
-};
-
 // src/compiler/transformers/static-to-meta/string-literal.ts
 var parseStringLiteral = (m, node) => {
   if (typeof node.text === "string" && node.text.includes("</")) {
@@ -262275,6 +262272,113 @@ var parseStyleIdentifier = (parsedStyle, modeName) => {
   return style;
 };
 
+// src/compiler/transformers/static-to-meta/class-extension.ts
+var import_typescript59 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+
+// src/compiler/transformers/static-to-meta/events.ts
+var parseStaticEvents = (staticMembers) => {
+  const parsedEvents = getStaticValue(staticMembers, "events");
+  if (!parsedEvents || parsedEvents.length === 0) {
+    return [];
+  }
+  return parsedEvents.map((parsedEvent) => {
+    return {
+      name: parsedEvent.name,
+      method: parsedEvent.method,
+      bubbles: parsedEvent.bubbles,
+      cancelable: parsedEvent.cancelable,
+      composed: parsedEvent.composed,
+      docs: parsedEvent.docs,
+      complexType: parsedEvent.complexType,
+      internal: isInternal(parsedEvent.docs)
+    };
+  });
+};
+
+// src/compiler/transformers/static-to-meta/listeners.ts
+var parseStaticListeners = (staticMembers) => {
+  const parsedListeners = getStaticValue(staticMembers, "listeners");
+  if (!parsedListeners || parsedListeners.length === 0) {
+    return [];
+  }
+  return parsedListeners.map((parsedListener) => {
+    return {
+      name: parsedListener.name,
+      method: parsedListener.method,
+      capture: !!parsedListener.capture,
+      passive: !!parsedListener.passive,
+      target: parsedListener.target
+    };
+  });
+};
+
+// src/compiler/transformers/static-to-meta/methods.ts
+var parseStaticMethods = (staticMembers) => {
+  const parsedMethods = getStaticValue(staticMembers, "methods");
+  if (!parsedMethods) {
+    return [];
+  }
+  const methodNames = Object.keys(parsedMethods);
+  if (methodNames.length === 0) {
+    return [];
+  }
+  return methodNames.map((methodName) => {
+    return {
+      name: methodName,
+      docs: parsedMethods[methodName].docs,
+      complexType: parsedMethods[methodName].complexType,
+      internal: isInternal(parsedMethods[methodName].docs)
+    };
+  });
+};
+
+// src/compiler/transformers/static-to-meta/props.ts
+var parseStaticProps = (staticMembers) => {
+  const parsedProps = getStaticValue(staticMembers, "properties");
+  if (!parsedProps) {
+    return [];
+  }
+  const propNames = Object.keys(parsedProps);
+  if (propNames.length === 0) {
+    return [];
+  }
+  return propNames.map((propName) => {
+    const val = parsedProps[propName];
+    return {
+      name: propName,
+      type: val.type,
+      attribute: val.attribute ? val.attribute.toLowerCase() : void 0,
+      reflect: typeof val.reflect === "boolean" ? val.reflect : false,
+      mutable: !!val.mutable,
+      required: !!val.required,
+      optional: !!val.optional,
+      defaultValue: val.defaultValue,
+      complexType: val.complexType,
+      docs: val.docs,
+      internal: isInternal(val.docs),
+      getter: !!val.getter,
+      setter: !!val.setter
+    };
+  });
+};
+
+// src/compiler/transformers/static-to-meta/states.ts
+var parseStaticStates = (staticMembers) => {
+  const parsedStates = getStaticValue(staticMembers, "states");
+  if (!parsedStates) {
+    return [];
+  }
+  const stateNames = Object.keys(parsedStates);
+  if (stateNames.length === 0) {
+    return [];
+  }
+  return stateNames.map((stateName) => {
+    return {
+      name: stateName
+    };
+  });
+};
+
 // src/compiler/transformers/static-to-meta/watchers.ts
 var parseStaticWatchers = (staticMembers) => {
   const parsedWatchers = getStaticValue(staticMembers, "watchers");
@@ -262289,6 +262393,188 @@ var parseStaticWatchers = (staticMembers) => {
   });
 };
 
+// src/compiler/transformers/static-to-meta/class-extension.ts
+var deDupeMembers = (dedupeMembers, staticMembers) => {
+  return dedupeMembers.filter(
+    (s) => !staticMembers.some((d) => {
+      if (d.methodName) {
+        return d.methodName === s.methodName;
+      }
+      return d.name === s.name;
+    })
+  );
+};
+function findClassWalk(node, name) {
+  var _a2;
+  if (!node) return void 0;
+  if (node && import_typescript59.default.isClassDeclaration(node) && (!name || ((_a2 = node.name) == null ? void 0 : _a2.text) === name)) {
+    return node;
+  }
+  let found2;
+  import_typescript59.default.forEachChild(node, (child) => {
+    if (found2) return;
+    const result2 = findClassWalk(child, name);
+    if (result2) found2 = result2;
+  });
+  return found2;
+}
+function matchesNamedDeclaration(name) {
+  return function(stmt) {
+    var _a2, _b;
+    if (import_typescript59.default.isClassDeclaration(stmt) && ((_a2 = stmt.name) == null ? void 0 : _a2.text) === name) {
+      return true;
+    }
+    if (import_typescript59.default.isFunctionDeclaration(stmt) && ((_b = stmt.name) == null ? void 0 : _b.text) === name) {
+      return true;
+    }
+    if (import_typescript59.default.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (import_typescript59.default.isIdentifier(decl.name) && decl.name.text === name) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+}
+function buildExtendsTree(compilerCtx, classDeclaration3, dependentClasses, typeChecker, buildCtx) {
+  const hasHeritageClauses = classDeclaration3.heritageClauses;
+  if (!(hasHeritageClauses == null ? void 0 : hasHeritageClauses.length)) return dependentClasses;
+  const extendsClause = hasHeritageClauses.find((clause) => clause.token === import_typescript59.default.SyntaxKind.ExtendsKeyword);
+  if (!extendsClause) return dependentClasses;
+  let classIdentifiers = [];
+  let foundClassDeclaration;
+  let keepLooking = true;
+  extendsClause.types.forEach((type) => {
+    if (import_typescript59.default.isExpressionWithTypeArguments(type) && import_typescript59.default.isCallExpression(type.expression) && type.expression.expression.getText() === "Mixin") {
+      classIdentifiers = type.expression.arguments.filter(import_typescript59.default.isIdentifier);
+    } else if (import_typescript59.default.isIdentifier(type.expression)) {
+      classIdentifiers = [type.expression];
+    }
+  });
+  classIdentifiers.forEach((extendee) => {
+    var _a2, _b, _c;
+    try {
+      const symbol = typeChecker.getSymbolAtLocation(extendee);
+      const aliasedSymbol = symbol ? typeChecker.getAliasedSymbol(symbol) : void 0;
+      foundClassDeclaration = (_a2 = aliasedSymbol == null ? void 0 : aliasedSymbol.declarations) == null ? void 0 : _a2.find(import_typescript59.default.isClassDeclaration);
+      if (!foundClassDeclaration) {
+        const node = (_b = aliasedSymbol == null ? void 0 : aliasedSymbol.declarations) == null ? void 0 : _b[0];
+        foundClassDeclaration = findClassWalk(node);
+        keepLooking = false;
+      }
+      if (foundClassDeclaration && !dependentClasses.some((dc) => dc.classNode === foundClassDeclaration)) {
+        const foundModule = compilerCtx.moduleMap.get(foundClassDeclaration.getSourceFile().fileName);
+        if (foundModule) {
+          const source = foundModule.staticSourceFile;
+          const sourceClass = findClassWalk(source, (_c = foundClassDeclaration.name) == null ? void 0 : _c.getText());
+          if (sourceClass) {
+            dependentClasses.push({ classNode: sourceClass, fileName: source.fileName });
+            if (keepLooking) {
+              buildExtendsTree(compilerCtx, foundClassDeclaration, dependentClasses, typeChecker, buildCtx);
+            }
+          }
+        }
+      }
+    } catch (_e) {
+      const currentSource = classDeclaration3.getSourceFile();
+      if (!currentSource) return;
+      const matchedStatement = currentSource.statements.find(matchesNamedDeclaration(extendee.getText()));
+      if (matchedStatement && import_typescript59.default.isClassDeclaration(matchedStatement)) {
+        foundClassDeclaration = matchedStatement;
+      } else if (matchedStatement) {
+        foundClassDeclaration = findClassWalk(matchedStatement);
+        keepLooking = false;
+      }
+      if (foundClassDeclaration && !dependentClasses.some((dc) => dc.classNode === foundClassDeclaration)) {
+        dependentClasses.push({ classNode: foundClassDeclaration, fileName: currentSource.fileName });
+        if (keepLooking) {
+          buildExtendsTree(compilerCtx, foundClassDeclaration, dependentClasses, typeChecker, buildCtx);
+        }
+        return;
+      }
+      const importStatements = currentSource.statements.filter(import_typescript59.default.isImportDeclaration);
+      importStatements.forEach((statement) => {
+        var _a3, _b2, _c2;
+        if (((_a3 = statement.importClause) == null ? void 0 : _a3.namedBindings) && import_typescript59.default.isNamedImports((_b2 = statement.importClause) == null ? void 0 : _b2.namedBindings)) {
+          (_c2 = statement.importClause) == null ? void 0 : _c2.namedBindings.elements.forEach((element) => {
+            var _a4;
+            if (element.name.getText() === extendee.getText()) {
+              const className = ((_a4 = element.propertyName) == null ? void 0 : _a4.getText()) || element.name.getText();
+              const foundFile = tsResolveModuleName(
+                buildCtx.config,
+                compilerCtx,
+                statement.moduleSpecifier.getText().replaceAll(/['"]/g, ""),
+                currentSource.fileName
+              );
+              if ((foundFile == null ? void 0 : foundFile.resolvedModule) && className) {
+                const foundModule = compilerCtx.moduleMap.get(foundFile.resolvedModule.resolvedFileName);
+                const matchedStatement2 = (foundModule == null ? void 0 : foundModule.staticSourceFile).statements.find(
+                  matchesNamedDeclaration(className)
+                );
+                foundClassDeclaration = matchedStatement2 ? import_typescript59.default.isClassDeclaration(matchedStatement2) ? matchedStatement2 : void 0 : void 0;
+                if (!foundClassDeclaration && matchedStatement2) {
+                  foundClassDeclaration = findClassWalk(matchedStatement2);
+                  keepLooking = false;
+                }
+                if (foundClassDeclaration && !dependentClasses.some((dc) => dc.classNode === foundClassDeclaration)) {
+                  dependentClasses.push({ classNode: foundClassDeclaration, fileName: currentSource.fileName });
+                  if (keepLooking) {
+                    buildExtendsTree(compilerCtx, foundClassDeclaration, dependentClasses, typeChecker, buildCtx);
+                  }
+                  return;
+                }
+              }
+            }
+          });
+        }
+      });
+    }
+  });
+  return dependentClasses;
+}
+function mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, staticMembers) {
+  const tree = buildExtendsTree(compilerCtx, cmpNode, [], typeChecker, buildCtx);
+  let hasMixin = false;
+  let doesExtend = false;
+  let properties = parseStaticProps(staticMembers);
+  let states = parseStaticStates(staticMembers);
+  let methods = parseStaticMethods(staticMembers);
+  let listeners = parseStaticListeners(staticMembers);
+  let events = parseStaticEvents(staticMembers);
+  let watchers = parseStaticWatchers(staticMembers);
+  let classMethods = cmpNode.members.filter(import_typescript59.default.isMethodDeclaration);
+  tree.forEach((extendedClass) => {
+    var _a2, _b, _c, _d, _e, _f, _g, _h;
+    const extendedStaticMembers = extendedClass.classNode.members.filter(isStaticGetter);
+    const mixinProps = (_a2 = parseStaticProps(extendedStaticMembers)) != null ? _a2 : [];
+    const mixinStates = (_b = parseStaticStates(extendedStaticMembers)) != null ? _b : [];
+    const mixinMethods = (_c = parseStaticMethods(extendedStaticMembers)) != null ? _c : [];
+    const isMixin = mixinProps.length > 0 || mixinStates.length > 0;
+    const module2 = compilerCtx.moduleMap.get(extendedClass.fileName);
+    if (!module2) return;
+    module2.isMixin = isMixin;
+    module2.isExtended = true;
+    doesExtend = true;
+    if (isMixin && !detectModernPropDeclarations(extendedClass.classNode)) {
+      const err2 = buildWarn(buildCtx.diagnostics);
+      const target = (_d = buildCtx.config.tsCompilerOptions) == null ? void 0 : _d.target;
+      err2.messageText = `Component classes can only extend from other Stencil decorated base classes when targetting more modern JavaScript (ES2022 and above).
+      ${target ? `Your current TypeScript configuration is set to target \`${import_typescript59.default.ScriptTarget[target]}\`.` : ""} Please amend your tsconfig.json.`;
+      if (!buildCtx.config._isTesting) augmentDiagnosticWithNode(err2, extendedClass.classNode);
+    }
+    properties = [...deDupeMembers(mixinProps, properties), ...properties];
+    states = [...deDupeMembers(mixinStates, states), ...states];
+    methods = [...deDupeMembers(mixinMethods, methods), ...methods];
+    listeners = [...deDupeMembers((_e = parseStaticListeners(extendedStaticMembers)) != null ? _e : [], listeners), ...listeners];
+    events = [...deDupeMembers((_f = parseStaticEvents(extendedStaticMembers)) != null ? _f : [], events), ...events];
+    watchers = [...deDupeMembers((_g = parseStaticWatchers(extendedStaticMembers)) != null ? _g : [], watchers), ...watchers];
+    classMethods = [...classMethods, ...(_h = extendedClass.classNode.members.filter(import_typescript59.default.isMethodDeclaration)) != null ? _h : []];
+    if (isMixin) hasMixin = true;
+  });
+  return { hasMixin, doesExtend, properties, states, methods, listeners, events, watchers, classMethods };
+}
+
 // src/compiler/transformers/static-to-meta/component.ts
 var BLACKLISTED_COMPONENT_METHODS = [
   /**
@@ -262297,7 +262583,7 @@ var BLACKLISTED_COMPONENT_METHODS = [
    */
   "shadowRoot"
 ];
-var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, transformOpts) => {
+var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, buildCtx, transformOpts) => {
   if (cmpNode.members == null) {
     return cmpNode;
   }
@@ -262306,6 +262592,13 @@ var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, t
   if (tagName == null) {
     return cmpNode;
   }
+  const { doesExtend, properties, states, methods, listeners, events, watchers, classMethods } = mergeExtendedClassMeta(
+    compilerCtx,
+    typeChecker,
+    buildCtx,
+    cmpNode,
+    staticMembers
+  );
   const symbol = typeChecker ? typeChecker.getSymbolAtLocation(cmpNode.name) : void 0;
   const docs = serializeSymbol(typeChecker, symbol);
   const isCollectionDependency = moduleFile.isCollectionDependency;
@@ -262320,13 +262613,14 @@ var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, t
     elementRef: parseStaticElementRef(staticMembers),
     encapsulation,
     shadowDelegatesFocus: !!parseStaticShadowDelegatesFocus(encapsulation, staticMembers),
-    properties: parseStaticProps(staticMembers),
+    properties,
     virtualProperties: parseVirtualProps(docs),
-    states: parseStaticStates(staticMembers),
-    methods: parseStaticMethods(staticMembers),
-    listeners: parseStaticListeners(staticMembers),
-    events: parseStaticEvents(staticMembers),
-    watchers: parseStaticWatchers(staticMembers),
+    states,
+    methods,
+    listeners,
+    events,
+    watchers,
+    doesExtend,
     styles: parseStaticStyles(compilerCtx, tagName, moduleFile.sourceFilePath, isCollectionDependency, staticMembers),
     internal: isInternal(docs),
     assetsDirs: parseAssetsDirs(staticMembers, moduleFile.jsFilePath),
@@ -262391,18 +262685,19 @@ var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, t
     directDependents: [],
     directDependencies: []
   };
-  const visitComponentChildNode = (node) => {
-    validateComponentMembers(node);
+  const visitComponentChildNode = (node, buildCtx2) => {
+    validateComponentMembers(node, buildCtx2);
     if (import_typescript60.default.isCallExpression(node)) {
       parseCallExpression(cmp, node);
     } else if (import_typescript60.default.isStringLiteral(node)) {
       parseStringLiteral(cmp, node);
     }
-    node.forEachChild(visitComponentChildNode);
+    node.forEachChild((child) => visitComponentChildNode(child, buildCtx2));
   };
-  visitComponentChildNode(cmpNode);
-  parseClassMethods(cmpNode, cmp);
-  detectModernPropDeclarations(cmpNode, cmp);
+  visitComponentChildNode(cmpNode, buildCtx);
+  parseClassMethods(classMethods, cmp);
+  const hasModernPropertyDecls = detectModernPropDeclarations(cmpNode);
+  cmp.hasModernPropertyDecls = hasModernPropertyDecls;
   cmp.htmlAttrNames = unique(cmp.htmlAttrNames);
   cmp.htmlTagNames = unique(cmp.htmlTagNames);
   cmp.potentialCmpRefs = unique(cmp.potentialCmpRefs);
@@ -262418,7 +262713,7 @@ var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, t
   compilerCtx.nodeMap.set(cmpNode, cmp);
   return cmpNode;
 };
-var validateComponentMembers = (node) => {
+var validateComponentMembers = (node, buildCtx) => {
   if (
     /**
      * the component has a getter called "shadowRoot"
@@ -262434,9 +262729,9 @@ var validateComponentMembers = (node) => {
       (prop) => import_typescript60.default.isPropertyAssignment(prop) && prop.name.getText() === "tag"
     )) {
       const componentName = node.parent.name.getText();
-      throw new Error(
-        `The component "${componentName}" has a getter called "${propName}". This getter is reserved for use by Stencil components and should not be defined by the user.`
-      );
+      const err2 = buildWarn(buildCtx.diagnostics);
+      err2.messageText = `The component "${componentName}" has a getter called "${propName}". This getter is reserved for use by Stencil components and should not be defined by the user.`;
+      augmentDiagnosticWithNode(err2, node);
     }
   }
 };
@@ -262694,7 +262989,7 @@ var updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileText,
   compilerCtx.changedModules.add(moduleFile.sourceFilePath);
   const visitNode = (node) => {
     if (import_typescript63.default.isClassDeclaration(node)) {
-      parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile);
+      parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile, buildCtx, void 0);
       return;
     } else if (import_typescript63.default.isImportDeclaration(node)) {
       parseModuleImport(config, compilerCtx, buildCtx, moduleFile, srcDirPath, node, true);
@@ -268436,7 +268731,7 @@ var convertStaticToMeta = (config, compilerCtx, buildCtx, typeChecker, collectio
     let moduleFile;
     const visitNode = (node) => {
       if (import_typescript68.default.isClassDeclaration(node)) {
-        return parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile, transformOpts);
+        return parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile, buildCtx, transformOpts);
       } else if (import_typescript68.default.isImportDeclaration(node)) {
         parseModuleImport(config, compilerCtx, buildCtx, moduleFile, dirPath, node, !transformOpts.isolatedModules);
       } else if (import_typescript68.default.isCallExpression(node)) {