@stencil/core 4.36.3-dev.1756357315.1a20bb5 → 4.36.3-dev.1756702916.0456db1

package/compiler/stencil.js

@@ -1,5 +1,5 @@
 /*!
- Stencil Compiler v4.36.3-dev.1756357315.1a20bb5 | MIT Licensed | https://stenciljs.com
+ Stencil Compiler v4.36.3-dev.1756702916.0456db1 | MIT Licensed | https://stenciljs.com
  */
 "use strict";
 var __create = Object.create;
@@ -2330,7 +2330,7 @@ var require_typescript_5_5_4_bundle_cache_min = __commonJS({
     See the Apache Version 2.0 License for specific language governing permissions
     and limitations under the License.
     ***************************************************************************** */
-    var ts71 = {};
+    var ts70 = {};
     ((module3) => {
       "use strict";
       var _a2;
@@ -207851,9 +207851,9 @@ ${e.message}`;
         };
       }
     })({ get exports() {
-      return ts71;
+      return ts70;
     }, set exports(v) {
-      ts71 = v;
+      ts70 = v;
       if (typeof module2 !== "undefined" && module2.exports) {
         module2.exports = v;
       }
@@ -232664,17 +232664,17 @@ __export(index_exports, {
   optimizeJs: () => optimizeJs,
   transpile: () => transpile,
   transpileSync: () => transpileSync,
-  ts: () => import_typescript70.default,
+  ts: () => import_typescript69.default,
   validateConfig: () => validateConfig,
   vermoji: () => vermoji,
   version: () => version,
   versions: () => versions
 });
 module.exports = __toCommonJS(index_exports);
-var import_typescript70 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript69 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/version.ts
-var buildId = "1756357315";
+var buildId = "1756702916";
 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{1F6E9}";
-var version = "4.36.3-dev.1756357315.1a20bb5";
+var vermoji = "\u{1F60E}";
+var version = "4.36.3-dev.1756702916.0456db1";
 var versions = {
   stencil: version,
   parse5: parse5Version,
@@ -234458,7 +234458,7 @@ var validateComponentTag = (tag) => {
 };
 
 // src/compiler/compiler.ts
-var import_typescript66 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript65 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/build/compiler-ctx.ts
 var import_path4 = require("path");
@@ -234585,6 +234585,8 @@ var getModuleLegacy = (compilerCtx, sourceFilePath) => {
       sourceFilePath,
       jsFilePath,
       cmps: [],
+      isExtended: false,
+      isMixin: false,
       coreRuntimeApis: [],
       outputTargetCoreRuntimeApis: {},
       collectionName: null,
@@ -236260,17 +236262,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 +236541,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 +236556,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 +236595,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 +236605,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 +236622,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 +236646,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 +236661,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 +236729,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 +236806,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 +236849,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 +236871,7 @@ var arrayLiteralToArray = (arr) => {
           val = Boolean;
         }
         break;
-      case import_typescript4.default.SyntaxKind.PropertyAccessExpression:
+      case import_typescript9.default.SyntaxKind.PropertyAccessExpression:
       default:
         val = element;
     }
@@ -236582,29 +236884,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 +236922,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 +236940,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 +236962,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 +236971,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 +236988,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 +236996,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 +237023,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 +237070,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 +237107,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 +237124,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 +237135,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 +237148,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 +237159,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 +237181,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 +237208,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 +237258,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 +237296,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 +237328,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 +237357,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 +242007,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 +242018,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 +242032,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 +242115,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 +243539,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 +243626,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 +243662,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 +243677,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 +243721,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 +243762,8 @@ var createModule = (staticSourceFile, staticSourceFileText, emitFilepath) => ({
   staticSourceFile,
   staticSourceFileText,
   cmps: [],
+  isExtended: false,
+  isMixin: false,
   coreRuntimeApis: [],
   outputTargetCoreRuntimeApis: {},
   collectionName: null,
@@ -243505,8 +243831,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 +243892,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 +252512,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 +253094,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 +253105,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 +253122,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 +253135,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 +253225,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 +253258,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 +253271,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 +253289,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 +253345,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 +253359,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 +253392,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 +253414,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 +253440,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 +253473,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 +253520,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 +253536,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 +253570,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 +253581,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 +253596,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 +253618,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 +253643,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 +253656,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 +253665,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 +253701,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 +253719,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 +253750,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 +253781,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 +253794,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 +253818,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 +253840,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 +253863,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 +253887,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 +253910,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 +253928,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 +253990,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 +254025,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 +254049,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 +254064,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 +254112,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 +254122,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 +254155,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,
@@ -254330,133 +254526,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 +254615,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 +255288,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 +255351,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 +255371,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 +255392,7 @@ var generateLazyModules = async (config, compilerCtx, buildCtx, outputTargetType
         destinations,
         sourceTarget,
         shouldMinify,
-        isBrowserBuild,
-        sufix
+        isBrowserBuild
       );
     })
   );
@@ -255419,9 +255481,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 +255494,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 +255637,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 +255695,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 +255713,7 @@ var generateCjs = async (config, compilerCtx, buildCtx, rollupBuild, outputTarge
         destinations,
         results,
         "es2017",
-        false,
-        ".cjs"
+        false
       );
       await generateShortcuts(compilerCtx, results, cjsOutputs);
     }
@@ -255646,7 +255745,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 +255760,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 +255771,7 @@ var generateEsm = async (config, compilerCtx, buildCtx, rollupBuild, outputTarge
         es5destinations,
         output,
         "es5",
-        false,
-        ""
+        false
       );
       if (config.buildEs5) {
         await copyPolyfills(config, compilerCtx, esmOutputs);
@@ -255725,7 +255823,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 +255837,7 @@ var generateEsmBrowser = async (config, compilerCtx, buildCtx, rollupBuild, outp
         es2017destinations,
         output,
         "es2017",
-        true,
-        ""
+        true
       );
     }
   }
@@ -255778,7 +255876,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 +255890,7 @@ var generateSystem = async (config, compilerCtx, buildCtx, rollupBuild, outputTa
         destinations,
         results,
         "es5",
-        true,
-        ".system"
+        true
       );
       await generateSystemLoaders(config, compilerCtx, results, systemOutputs);
     }
@@ -260435,14 +260533,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 +261711,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,
@@ -261764,7 +261863,7 @@ var filterDecorators = (decorators, excludeList) => {
 
 // src/compiler/transformers/static-to-meta/parse-static.ts
 var import_path51 = require("path");
-var import_typescript63 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript62 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/static-to-meta/call-expression.ts
 var import_typescript56 = __toESM(require_typescript_5_5_4_bundle_cache_min());
@@ -261885,7 +261984,7 @@ var visitCallExpressionArg = (m, arg) => {
 
 // src/compiler/transformers/static-to-meta/component.ts
 var import_path47 = require("path");
-var import_typescript60 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript59 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/add-component-meta-static.ts
 var import_typescript57 = __toESM(require_typescript_5_5_4_bundle_cache_min());
@@ -261964,7 +262063,7 @@ var detectModernPropDeclarations = (classNode, cmp) => {
   const parsedStates = getStaticValue(classNode.members, "states");
   if (!parsedProps && !parsedStates) {
     cmp.hasModernPropertyDecls = false;
-    return;
+    return false;
   }
   const members = [...Object.entries(parsedProps || {}), ...Object.entries(parsedStates || {})];
   for (const [propName, meta] of members) {
@@ -261976,6 +262075,7 @@ var detectModernPropDeclarations = (classNode, cmp) => {
     cmp.hasModernPropertyDecls = true;
     break;
   }
+  return cmp.hasModernPropertyDecls;
 };
 
 // src/compiler/transformers/static-to-meta/attach-internals.ts
@@ -261989,14 +262089,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"));
@@ -262297,7 +262391,91 @@ var BLACKLISTED_COMPONENT_METHODS = [
    */
   "shadowRoot"
 ];
-var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, transformOpts) => {
+var buildExtendsTree = (compilerCtx, classDeclaration3, dependentClasses, typeChecker, buildCtx) => {
+  const hasHeritageClauses = classDeclaration3.heritageClauses && classDeclaration3.heritageClauses.length > 0;
+  if (!hasHeritageClauses) return dependentClasses;
+  const extendsClause = classDeclaration3.heritageClauses.find(
+    (clause) => clause.token === import_typescript59.default.SyntaxKind.ExtendsKeyword
+  );
+  if (!extendsClause) {
+    return dependentClasses;
+  }
+  extendsClause.types.forEach((type) => {
+    var _a2;
+    try {
+      const aliasedSymbol = typeChecker.getAliasedSymbol(typeChecker.getSymbolAtLocation(type.expression));
+      classDeclaration3 = (_a2 = aliasedSymbol == null ? void 0 : aliasedSymbol.declarations) == null ? void 0 : _a2.find(import_typescript59.default.isClassDeclaration);
+      if (classDeclaration3 && !dependentClasses.some((dc) => dc.classNode === classDeclaration3)) {
+        const foundModule = compilerCtx.moduleMap.get(classDeclaration3.getSourceFile().fileName);
+        if (foundModule) {
+          const source = foundModule.staticSourceFile;
+          source.statements.forEach((statement) => {
+            if (import_typescript59.default.isClassDeclaration(statement)) {
+              dependentClasses.push({ classNode: statement, fileName: source.fileName });
+              buildExtendsTree(compilerCtx, statement, dependentClasses, typeChecker, buildCtx);
+            }
+          });
+        }
+      }
+    } catch (e) {
+      const currentSource = classDeclaration3.getSourceFile();
+      const importStatements = currentSource.statements.filter(import_typescript59.default.isImportDeclaration);
+      const classDeclarations = currentSource.statements.filter(import_typescript59.default.isClassDeclaration);
+      let found2 = false;
+      if (classDeclarations.length > 1) {
+        classDeclarations.forEach((statement) => {
+          var _a3;
+          if (((_a3 = statement.name) == null ? void 0 : _a3.getText()) === type.expression.getText() && !dependentClasses.some((dc) => dc.classNode === statement)) {
+            found2 = true;
+            dependentClasses.push({ classNode: statement, fileName: currentSource.fileName });
+            buildExtendsTree(compilerCtx, statement, dependentClasses, typeChecker, buildCtx);
+          }
+        });
+      }
+      if (found2) return;
+      importStatements.forEach((statement) => {
+        var _a3, _b;
+        if (import_typescript59.default.isNamedImports((_a3 = statement.importClause) == null ? void 0 : _a3.namedBindings)) {
+          (_b = statement.importClause) == null ? void 0 : _b.namedBindings.elements.forEach((element) => {
+            var _a4;
+            if (element.name.getText() === type.expression.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) {
+                const foundModule = compilerCtx.moduleMap.get(foundFile.resolvedModule.resolvedFileName);
+                (foundModule == null ? void 0 : foundModule.staticSourceFile).statements.forEach((statement2) => {
+                  var _a5;
+                  if (import_typescript59.default.isClassDeclaration(statement2) && ((_a5 = statement2.name) == null ? void 0 : _a5.getText()) === className && !dependentClasses.some((dc) => dc.classNode === statement2)) {
+                    dependentClasses.push({ classNode: statement2, fileName: foundModule.staticSourceFile.fileName });
+                    buildExtendsTree(compilerCtx, statement2, dependentClasses, typeChecker, buildCtx);
+                  }
+                });
+              }
+            }
+          });
+        }
+      });
+    }
+  });
+  return dependentClasses;
+};
+var deDupeMembers = (dedupeMembers, staticMembers) => {
+  return dedupeMembers.filter(
+    (s) => !staticMembers.some((d) => {
+      if (d.methodName) {
+        return d.methodName === s.methodName;
+      }
+      return d.name === s.name;
+    })
+  );
+};
+var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, buildCtx, transformOpts) => {
+  var _a2;
   if (cmpNode.members == null) {
     return cmpNode;
   }
@@ -262306,6 +262484,37 @@ var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, t
   if (tagName == null) {
     return cmpNode;
   }
+  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 hasMixin = false;
+  let classMethods = cmpNode.members.filter(import_typescript59.default.isMethodDeclaration);
+  let doesExtend = false;
+  const tree = buildExtendsTree(compilerCtx, cmpNode, [], typeChecker, buildCtx);
+  tree.map((extendedClass) => {
+    var _a3, _b, _c, _d, _e, _f, _g;
+    const extendedStaticMembers = extendedClass.classNode.members.filter(isStaticGetter);
+    const mixinProps = (_a3 = parseStaticProps(extendedStaticMembers)) != null ? _a3 : [];
+    const mixinStates = (_b = parseStaticStates(extendedStaticMembers)) != null ? _b : [];
+    const isMixin = mixinProps.length > 0 || mixinStates.length > 0;
+    const module2 = compilerCtx.moduleMap.get(extendedClass.fileName);
+    module2.isMixin = isMixin;
+    module2.isExtended = true;
+    doesExtend = true;
+    properties = [...deDupeMembers(mixinProps, properties), ...properties];
+    states = [...deDupeMembers(mixinStates, states), ...states];
+    methods = [...deDupeMembers((_c = parseStaticMethods(extendedStaticMembers)) != null ? _c : [], methods), ...methods];
+    listeners = [...deDupeMembers((_d = parseStaticListeners(extendedStaticMembers)) != null ? _d : [], listeners), ...listeners];
+    events = [...deDupeMembers((_e = parseStaticEvents(extendedStaticMembers)) != null ? _e : [], events), ...events];
+    watchers = [...deDupeMembers((_f = parseStaticWatchers(extendedStaticMembers)) != null ? _f : [], watchers), ...watchers];
+    classMethods = [...classMethods, ...(_g = extendedClass.classNode.members.filter(import_typescript59.default.isMethodDeclaration)) != null ? _g : []];
+    if (isMixin) {
+      hasMixin = true;
+    }
+  });
   const symbol = typeChecker ? typeChecker.getSymbolAtLocation(cmpNode.name) : void 0;
   const docs = serializeSymbol(typeChecker, symbol);
   const isCollectionDependency = moduleFile.isCollectionDependency;
@@ -262320,13 +262529,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 +262601,25 @@ var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, t
     directDependents: [],
     directDependencies: []
   };
-  const visitComponentChildNode = (node) => {
-    validateComponentMembers(node);
-    if (import_typescript60.default.isCallExpression(node)) {
+  const visitComponentChildNode = (node, buildCtx2) => {
+    validateComponentMembers(node, buildCtx2);
+    if (import_typescript59.default.isCallExpression(node)) {
       parseCallExpression(cmp, node);
-    } else if (import_typescript60.default.isStringLiteral(node)) {
+    } else if (import_typescript59.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);
+  if (!hasModernPropertyDecls && hasMixin) {
+    const err2 = buildWarn(buildCtx.diagnostics);
+    const target = (_a2 = buildCtx.config.tsCompilerOptions) == null ? void 0 : _a2.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, cmpNode);
+  }
   cmp.htmlAttrNames = unique(cmp.htmlAttrNames);
   cmp.htmlTagNames = unique(cmp.htmlTagNames);
   cmp.potentialCmpRefs = unique(cmp.potentialCmpRefs);
@@ -262418,25 +262635,25 @@ 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"
      */
-    import_typescript60.default.isGetAccessorDeclaration(node) && import_typescript60.default.isIdentifier(node.name) && typeof node.name.escapedText === "string" && BLACKLISTED_COMPONENT_METHODS.includes(node.name.escapedText) && /**
+    import_typescript59.default.isGetAccessorDeclaration(node) && import_typescript59.default.isIdentifier(node.name) && typeof node.name.escapedText === "string" && BLACKLISTED_COMPONENT_METHODS.includes(node.name.escapedText) && /**
      * the parent node is a class declaration
      */
-    node.parent && import_typescript60.default.isClassDeclaration(node.parent)
+    node.parent && import_typescript59.default.isClassDeclaration(node.parent)
   ) {
     const propName = node.name.escapedText;
-    const decorator3 = import_typescript60.default.getDecorators(node.parent)[0];
-    if (import_typescript60.default.isCallExpression(decorator3.expression) && decorator3.expression.arguments.length === 1 && import_typescript60.default.isObjectLiteralExpression(decorator3.expression.arguments[0]) && decorator3.expression.arguments[0].properties.some(
-      (prop) => import_typescript60.default.isPropertyAssignment(prop) && prop.name.getText() === "tag"
+    const decorator3 = import_typescript59.default.getDecorators(node.parent)[0];
+    if (import_typescript59.default.isCallExpression(decorator3.expression) && decorator3.expression.arguments.length === 1 && import_typescript59.default.isObjectLiteralExpression(decorator3.expression.arguments[0]) && decorator3.expression.arguments[0].properties.some(
+      (prop) => import_typescript59.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);
     }
   }
 };
@@ -262477,7 +262694,7 @@ var parseAssetsDirs = (staticMembers, componentFilePath) => {
 
 // src/compiler/transformers/static-to-meta/import.ts
 var import_path50 = require("path");
-var import_typescript62 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript61 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/collections/add-external-import.ts
 var import_path49 = require("path");
@@ -262486,7 +262703,7 @@ var import_path49 = require("path");
 var import_path48 = require("path");
 
 // src/compiler/transformers/collections/parse-collection-components.ts
-var import_typescript61 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript60 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var parseCollectionComponents = (config, compilerCtx, buildCtx, collectionDir, collectionManifest, collection) => {
   if (collectionManifest.entries) {
     collectionManifest.entries.forEach((entryPath) => {
@@ -262497,7 +262714,7 @@ var parseCollectionComponents = (config, compilerCtx, buildCtx, collectionDir, c
 };
 var transpileCollectionModule = (config, compilerCtx, buildCtx, collection, inputFileName) => {
   const sourceText = compilerCtx.fs.readFileSync(inputFileName);
-  const sourceFile = import_typescript61.default.createSourceFile(inputFileName, sourceText, import_typescript61.default.ScriptTarget.ES2017, true, import_typescript61.default.ScriptKind.JS);
+  const sourceFile = import_typescript60.default.createSourceFile(inputFileName, sourceText, import_typescript60.default.ScriptTarget.ES2017, true, import_typescript60.default.ScriptKind.JS);
   return updateModule(config, compilerCtx, buildCtx, sourceFile, sourceText, inputFileName, void 0, collection);
 };
 
@@ -262645,7 +262862,7 @@ var addExternalImport = (config, compilerCtx, buildCtx, moduleFile, containingFi
 
 // src/compiler/transformers/static-to-meta/import.ts
 var parseModuleImport = (config, compilerCtx, buildCtx, moduleFile, dirPath, importNode, resolveCollections) => {
-  if (importNode.moduleSpecifier && import_typescript62.default.isStringLiteral(importNode.moduleSpecifier)) {
+  if (importNode.moduleSpecifier && import_typescript61.default.isStringLiteral(importNode.moduleSpecifier)) {
     let importPath = importNode.moduleSpecifier.text;
     if (!moduleFile.originalImports.includes(importPath)) {
       moduleFile.originalImports.push(importPath);
@@ -262693,15 +262910,15 @@ var updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileText,
   compilerCtx.moduleMap.set(moduleFileKey, moduleFile);
   compilerCtx.changedModules.add(moduleFile.sourceFilePath);
   const visitNode = (node) => {
-    if (import_typescript63.default.isClassDeclaration(node)) {
-      parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile);
+    if (import_typescript62.default.isClassDeclaration(node)) {
+      parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile, buildCtx, void 0);
       return;
-    } else if (import_typescript63.default.isImportDeclaration(node)) {
+    } else if (import_typescript62.default.isImportDeclaration(node)) {
       parseModuleImport(config, compilerCtx, buildCtx, moduleFile, srcDirPath, node, true);
       return;
-    } else if (import_typescript63.default.isCallExpression(node)) {
+    } else if (import_typescript62.default.isCallExpression(node)) {
       parseCallExpression(moduleFile, node);
-    } else if (import_typescript63.default.isStringLiteral(node)) {
+    } else if (import_typescript62.default.isStringLiteral(node)) {
       parseStringLiteral(moduleFile, node);
     }
     node.forEachChild(visitNode);
@@ -262713,12 +262930,12 @@ var updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileText,
   }
   visitNode(tsSourceFile);
   if (moduleFile.cmps.length > 0) {
-    moduleFile.staticSourceFile = import_typescript63.default.createSourceFile(
+    moduleFile.staticSourceFile = import_typescript62.default.createSourceFile(
       sourceFilePath,
       sourceFileText,
       tsSourceFile.languageVersion,
       true,
-      import_typescript63.default.ScriptKind.JS
+      import_typescript62.default.ScriptKind.JS
     );
   }
   return moduleFile;
@@ -263962,14 +264179,14 @@ var isWatchIgnorePath = (config, path7) => {
 };
 
 // src/compiler/transpile/create-watch-program.ts
-var import_typescript64 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript63 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var createTsWatchProgram = async (config, buildCallback) => {
   let isRunning = false;
   let lastTsBuilder;
   let timeoutId;
   const optionsToExtend = getTsOptionsToExtend(config);
   const tsWatchSys = {
-    ...import_typescript64.default.sys,
+    ...import_typescript63.default.sys,
     /**
      * Override the default `setTimeout` implementation in the {@link ts.System}. The reasoning
      * behind this change is not explicitly clear, but this appears to be related to debouncing
@@ -263997,7 +264214,7 @@ var createTsWatchProgram = async (config, buildCallback) => {
     }
   };
   config.sys.addDestroy(() => tsWatchSys.clearTimeout(timeoutId));
-  const tsWatchHost = import_typescript64.default.createWatchCompilerHost(
+  const tsWatchHost = import_typescript63.default.createWatchCompilerHost(
     // Use the TS config from the Stencil project
     config.tsconfig,
     optionsToExtend,
@@ -264005,7 +264222,7 @@ var createTsWatchProgram = async (config, buildCallback) => {
     // We use the `createEmitAndSemanticDiagnosticsBuilderProgram` as opposed to the
     // `createSemanticDiagnosticsBuilderProgram` because we need our program to emit
     // output files in addition to checking for errors
-    import_typescript64.default.createEmitAndSemanticDiagnosticsBuilderProgram,
+    import_typescript63.default.createEmitAndSemanticDiagnosticsBuilderProgram,
     // Add a callback to log out diagnostics as the program runs
     (reportDiagnostic) => {
       config.logger.debug("watch reportDiagnostic:" + reportDiagnostic.messageText);
@@ -264032,7 +264249,7 @@ var createTsWatchProgram = async (config, buildCallback) => {
     // Create the watch builder program instance and make it available on the
     // returned object. This provides us an easy way to teardown the program
     // down-the-road.
-    program: import_typescript64.default.createWatchProgram(tsWatchHost),
+    program: import_typescript63.default.createWatchProgram(tsWatchHost),
     // This will be called via a callback on the watch build whenever a file
     // change is detected
     rebuild: () => {
@@ -266089,7 +266306,7 @@ var extname9 = (str) => {
 var SKIP_EXT = /* @__PURE__ */ new Set(["zip", "rar", "tar", "gz", "bz2", "png", "jpeg", "jpg", "gif", "pdf", "tiff", "psd"]);
 
 // src/compiler/sys/node-require.ts
-var import_typescript65 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript64 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var nodeRequire = (id) => {
   const results = {
     module: void 0,
@@ -266104,13 +266321,13 @@ var nodeRequire = (id) => {
     require.extensions[".ts"] = (module2, fileName) => {
       let sourceText = fs2.readFileSync(fileName, "utf8");
       if (fileName.endsWith(".ts")) {
-        const tsResults = import_typescript65.default.transpileModule(sourceText, {
+        const tsResults = import_typescript64.default.transpileModule(sourceText, {
           fileName,
           compilerOptions: {
-            module: import_typescript65.default.ModuleKind.CommonJS,
-            moduleResolution: import_typescript65.default.ModuleResolutionKind.NodeJs,
+            module: import_typescript64.default.ModuleKind.CommonJS,
+            moduleResolution: import_typescript64.default.ModuleResolutionKind.NodeJs,
             esModuleInterop: true,
-            target: import_typescript65.default.ScriptTarget.ES2017,
+            target: import_typescript64.default.ScriptTarget.ES2017,
             allowJs: true
           }
         });
@@ -266912,7 +267129,7 @@ var createCompiler = async (userConfig) => {
   const sys = config.sys;
   const compilerCtx = new CompilerContext();
   if (isFunction(config.sys.setupCompiler)) {
-    config.sys.setupCompiler({ ts: import_typescript66.default });
+    config.sys.setupCompiler({ ts: import_typescript65.default });
   }
   compilerCtx.fs = createInMemoryFs(sys);
   compilerCtx.cache = new Cache(config, createInMemoryFs(sys));
@@ -266946,7 +267163,7 @@ var import_path63 = require("path");
 
 // src/compiler/sys/typescript/typescript-config.ts
 var import_path62 = require("path");
-var import_typescript67 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript66 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var validateTsConfig = async (config, sys, init) => {
   var _a2;
   const tsconfig = {
@@ -266968,7 +267185,7 @@ var validateTsConfig = async (config, sys, init) => {
     } else {
       tsconfig.path = readTsConfig.path;
       const host = {
-        ...import_typescript67.default.sys,
+        ...import_typescript66.default.sys,
         readFile: (p) => {
           if (p === tsconfig.path) {
             return readTsConfig.content;
@@ -266979,7 +267196,7 @@ var validateTsConfig = async (config, sys, init) => {
         fileExists: (p) => sys.accessSync(p),
         onUnRecoverableConfigFileDiagnostic: (e) => console.error(e)
       };
-      const results = import_typescript67.default.getParsedCommandLineOfConfigFile(tsconfig.path, {}, host);
+      const results = import_typescript66.default.getParsedCommandLineOfConfigFile(tsconfig.path, {}, host);
       if (results === void 0) {
         throw "Encountered an error reading tsconfig!";
       }
@@ -267023,12 +267240,12 @@ var validateTsConfig = async (config, sys, init) => {
         }
         if (results.options) {
           tsconfig.compilerOptions = results.options;
-          const target = (_a2 = tsconfig.compilerOptions.target) != null ? _a2 : import_typescript67.default.ScriptTarget.ES5;
-          if ([import_typescript67.default.ScriptTarget.ES3, import_typescript67.default.ScriptTarget.ES5, import_typescript67.default.ScriptTarget.ES2015, import_typescript67.default.ScriptTarget.ES2016].includes(target)) {
+          const target = (_a2 = tsconfig.compilerOptions.target) != null ? _a2 : import_typescript66.default.ScriptTarget.ES5;
+          if ([import_typescript66.default.ScriptTarget.ES3, import_typescript66.default.ScriptTarget.ES5, import_typescript66.default.ScriptTarget.ES2015, import_typescript66.default.ScriptTarget.ES2016].includes(target)) {
             const warn = buildWarn(tsconfig.diagnostics);
             warn.messageText = `To improve bundling, it is always recommended to set the tsconfig.json \u201Ctarget\u201D setting to "es2017". Note that the compiler will automatically handle transpilation for ES5-only browsers.`;
           }
-          if (tsconfig.compilerOptions.module !== import_typescript67.default.ModuleKind.ESNext && !config._isTesting) {
+          if (tsconfig.compilerOptions.module !== import_typescript66.default.ModuleKind.ESNext && !config._isTesting) {
             const warn = buildWarn(tsconfig.diagnostics);
             warn.messageText = `To improve bundling, it is always recommended to set the tsconfig.json \u201Cmodule\u201D setting to \u201Cesnext\u201D. Note that the compiler will automatically handle bundling both modern and legacy builds.`;
           }
@@ -268425,26 +268642,26 @@ var VALID_TARGET = /* @__PURE__ */ new Set(["latest", "esnext", "es2020", "es201
 
 // src/compiler/transpile/transpile-module.ts
 var import_sys_api_node5 = require("../sys/node/index.js");
-var import_typescript69 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript68 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/static-to-meta/visitor.ts
 var import_path67 = require("path");
-var import_typescript68 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript67 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var convertStaticToMeta = (config, compilerCtx, buildCtx, typeChecker, collection, transformOpts) => {
   return (transformCtx) => {
     let dirPath;
     let moduleFile;
     const visitNode = (node) => {
-      if (import_typescript68.default.isClassDeclaration(node)) {
-        return parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile, transformOpts);
-      } else if (import_typescript68.default.isImportDeclaration(node)) {
+      if (import_typescript67.default.isClassDeclaration(node)) {
+        return parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile, buildCtx, transformOpts);
+      } else if (import_typescript67.default.isImportDeclaration(node)) {
         parseModuleImport(config, compilerCtx, buildCtx, moduleFile, dirPath, node, !transformOpts.isolatedModules);
-      } else if (import_typescript68.default.isCallExpression(node)) {
+      } else if (import_typescript67.default.isCallExpression(node)) {
         parseCallExpression(moduleFile, node);
-      } else if (import_typescript68.default.isStringLiteral(node)) {
+      } else if (import_typescript67.default.isStringLiteral(node)) {
         parseStringLiteral(moduleFile, node);
       }
-      return import_typescript68.default.visitEachChild(node, visitNode, transformCtx);
+      return import_typescript67.default.visitEachChild(node, visitNode, transformCtx);
     };
     return (tsSourceFile) => {
       dirPath = (0, import_path67.dirname)(tsSourceFile.fileName);
@@ -268490,13 +268707,13 @@ var transpileModule = (config, input, transformOpts) => {
     moduleFile: null
   };
   if (transformOpts.module === "cjs") {
-    tsCompilerOptions.module = import_typescript69.default.ModuleKind.CommonJS;
+    tsCompilerOptions.module = import_typescript68.default.ModuleKind.CommonJS;
   } else {
-    tsCompilerOptions.module = import_typescript69.default.ModuleKind.ESNext;
+    tsCompilerOptions.module = import_typescript68.default.ModuleKind.ESNext;
   }
   tsCompilerOptions.target = getScriptTargetKind(transformOpts);
   if ((sourceFilePath.endsWith(".tsx") || sourceFilePath.endsWith(".jsx")) && tsCompilerOptions.jsx == null) {
-    tsCompilerOptions.jsx = import_typescript69.default.JsxEmit.React;
+    tsCompilerOptions.jsx = import_typescript68.default.JsxEmit.React;
   }
   if (tsCompilerOptions.jsx != null && !isString(tsCompilerOptions.jsxFactory)) {
     tsCompilerOptions.jsxFactory = "h";
@@ -268507,7 +268724,7 @@ var transpileModule = (config, input, transformOpts) => {
   if (tsCompilerOptions.paths && !isString(tsCompilerOptions.baseUrl)) {
     tsCompilerOptions.baseUrl = ".";
   }
-  const sourceFile = import_typescript69.default.createSourceFile(sourceFilePath, input, tsCompilerOptions.target);
+  const sourceFile = import_typescript68.default.createSourceFile(sourceFilePath, input, tsCompilerOptions.target);
   const compilerHost = {
     getSourceFile: (fileName) => {
       return normalizePath(fileName) === normalizePath(sourceFilePath) ? sourceFile : void 0;
@@ -268523,13 +268740,13 @@ var transpileModule = (config, input, transformOpts) => {
     useCaseSensitiveFileNames: () => false,
     getCanonicalFileName: (fileName) => fileName,
     getCurrentDirectory: () => transformOpts.currentDirectory || process.cwd(),
-    getNewLine: () => import_typescript69.default.sys.newLine || "\n",
+    getNewLine: () => import_typescript68.default.sys.newLine || "\n",
     fileExists: (fileName) => normalizePath(fileName) === normalizePath(sourceFilePath),
     readFile: () => "",
     directoryExists: () => true,
     getDirectories: () => []
   };
-  const program3 = import_typescript69.default.createProgram([sourceFilePath], tsCompilerOptions, compilerHost);
+  const program3 = import_typescript68.default.createProgram([sourceFilePath], tsCompilerOptions, compilerHost);
   const typeChecker = program3.getTypeChecker();
   const transformers = {
     before: [
@@ -268561,10 +268778,10 @@ var transpileModule = (config, input, transformOpts) => {
 };
 var getScriptTargetKind = (transformOpts) => {
   const target = transformOpts.target && transformOpts.target.toUpperCase();
-  if (isNumber(import_typescript69.default.ScriptTarget[target])) {
-    return import_typescript69.default.ScriptTarget[target];
+  if (isNumber(import_typescript68.default.ScriptTarget[target])) {
+    return import_typescript68.default.ScriptTarget[target];
   }
-  return import_typescript69.default.ScriptTarget.Latest;
+  return import_typescript68.default.ScriptTarget.Latest;
 };
 
 // src/compiler/transpile.ts