@stencil/core 4.36.3-dev.1757653330.0456db1 → 4.37.0-dev.1757912532.d7ee800

package/compiler/stencil.js

@@ -1,5 +1,5 @@
 /*!
- Stencil Compiler v4.36.3-dev.1757653330.0456db1 | MIT Licensed | https://stenciljs.com
+ Stencil Compiler v4.37.0-dev.1757912532.d7ee800 | 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 ts70 = {};
+    var ts71 = {};
     ((module3) => {
       "use strict";
       var _a2;
@@ -77616,10 +77616,10 @@ ${lanes.join("\n")}
           const baseClassType = classType && getBaseTypes(classType)[0];
           return baseClassType && getTypeOfPropertyOfType(baseClassType, property3.escapedName);
         }
-        function isPropertyInClassDerivedFrom(prop, baseClass) {
+        function isPropertyInClassDerivedFrom(prop, baseClass2) {
           return forEachProperty2(prop, (sp) => {
             const sourceClass = getDeclaringClass(sp);
-            return sourceClass ? hasBaseType(sourceClass, baseClass) : false;
+            return sourceClass ? hasBaseType(sourceClass, baseClass2) : false;
           });
         }
         function isValidOverrideOf(sourceProp, targetProp) {
@@ -207851,9 +207851,9 @@ ${e.message}`;
         };
       }
     })({ get exports() {
-      return ts70;
+      return ts71;
     }, set exports(v) {
-      ts70 = v;
+      ts71 = 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_typescript69.default,
+  ts: () => import_typescript70.default,
   validateConfig: () => validateConfig,
   vermoji: () => vermoji,
   version: () => version,
   versions: () => versions
 });
 module.exports = __toCommonJS(index_exports);
-var import_typescript69 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript70 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/version.ts
-var buildId = "1757653330";
+var buildId = "1757912532";
 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{1F350}";
-var version = "4.36.3-dev.1757653330.0456db1";
+var vermoji = "\u{1F416}";
+var version = "4.37.0-dev.1757912532.d7ee800";
 var versions = {
   stencil: version,
   parse5: parse5Version,
@@ -234255,6 +234255,11 @@ var scopeCss = (cssText, scopeId, commentOriginalSelector) => {
 var CAPTURE_EVENT_SUFFIX = "Capture";
 var CAPTURE_EVENT_REGEX = new RegExp(CAPTURE_EVENT_SUFFIX + "$");
 
+// src/runtime/mixin.ts
+var baseClass = BUILD.lazyLoad ? class {
+} : globalThis.HTMLElement || class {
+};
+
 // src/utils/sourcemaps.ts
 function rollupToStencilSourceMap(rollupSourceMap) {
   if (!rollupSourceMap || !rollupSourceMap.file) {
@@ -234458,7 +234463,7 @@ var validateComponentTag = (tag) => {
 };
 
 // src/compiler/compiler.ts
-var import_typescript65 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript66 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/build/compiler-ctx.ts
 var import_path4 = require("path");
@@ -254185,7 +254190,8 @@ var KEEP_IMPORTS = /* @__PURE__ */ new Set([
   "forceUpdate",
   "getRenderingRef",
   "forceModeUpdate",
-  "setErrorHandler"
+  "setErrorHandler",
+  "Mixin"
 ]);
 
 // src/compiler/app-core/app-data.ts
@@ -254332,6 +254338,7 @@ var getCustomElementsBuildConditionals = (config, cmps) => {
   build2.hydrateServerSide = false;
   build2.asyncQueue = config.taskQueue === "congestionAsync";
   build2.taskQueue = config.taskQueue !== "immediate";
+  build2.initializeNextTick = config.extras.initializeNextTick;
   updateBuildConditionals(config, build2);
   build2.devTools = false;
   return build2;
@@ -261863,7 +261870,7 @@ var filterDecorators = (decorators, excludeList) => {
 
 // src/compiler/transformers/static-to-meta/parse-static.ts
 var import_path51 = require("path");
-var import_typescript62 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript63 = __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());
@@ -261984,7 +261991,7 @@ var visitCallExpressionArg = (m, arg) => {
 
 // src/compiler/transformers/static-to-meta/component.ts
 var import_path47 = require("path");
-var import_typescript59 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript60 = __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());
@@ -262058,24 +262065,24 @@ var setComponentBuildConditionals = (cmpMeta) => {
 
 // src/compiler/transformers/detect-modern-prop-decls.ts
 var import_typescript58 = __toESM(require_typescript_5_5_4_bundle_cache_min());
-var detectModernPropDeclarations = (classNode, cmp) => {
+var detectModernPropDeclarations = (classNode) => {
   const parsedProps = getStaticValue(classNode.members, "properties");
   const parsedStates = getStaticValue(classNode.members, "states");
   if (!parsedProps && !parsedStates) {
-    cmp.hasModernPropertyDecls = false;
     return false;
   }
   const members = [...Object.entries(parsedProps || {}), ...Object.entries(parsedStates || {})];
+  let hasModernPropertyDecls = false;
   for (const [propName, meta] of members) {
     const dynamicPropName = meta.ogPropName || "";
     const prop = classNode.members.find((m) => {
       return import_typescript58.default.isPropertyDeclaration(m) && (import_typescript58.default.isComputedPropertyName(m.name) && m.name.expression.getText() === dynamicPropName || m.name.getText() === propName);
     });
     if (!prop) continue;
-    cmp.hasModernPropertyDecls = true;
+    hasModernPropertyDecls = true;
     break;
   }
-  return cmp.hasModernPropertyDecls;
+  return hasModernPropertyDecls;
 };
 
 // src/compiler/transformers/static-to-meta/attach-internals.ts
@@ -262137,116 +262144,12 @@ var parseStaticShadowDelegatesFocus = (encapsulation, staticMembers) => {
   return null;
 };
 
-// src/compiler/transformers/static-to-meta/events.ts
-var parseStaticEvents = (staticMembers) => {
-  const parsedEvents = getStaticValue(staticMembers, "events");
-  if (!parsedEvents || parsedEvents.length === 0) {
-    return [];
-  }
-  return parsedEvents.map((parsedEvent) => {
-    return {
-      name: parsedEvent.name,
-      method: parsedEvent.method,
-      bubbles: parsedEvent.bubbles,
-      cancelable: parsedEvent.cancelable,
-      composed: parsedEvent.composed,
-      docs: parsedEvent.docs,
-      complexType: parsedEvent.complexType,
-      internal: isInternal(parsedEvent.docs)
-    };
-  });
-};
-
 // src/compiler/transformers/static-to-meta/form-associated.ts
 var parseFormAssociated = (staticMembers) => {
   const isFormAssociated = getStaticValue(staticMembers, "formAssociated");
   return typeof isFormAssociated === "boolean" && isFormAssociated;
 };
 
-// src/compiler/transformers/static-to-meta/listeners.ts
-var parseStaticListeners = (staticMembers) => {
-  const parsedListeners = getStaticValue(staticMembers, "listeners");
-  if (!parsedListeners || parsedListeners.length === 0) {
-    return [];
-  }
-  return parsedListeners.map((parsedListener) => {
-    return {
-      name: parsedListener.name,
-      method: parsedListener.method,
-      capture: !!parsedListener.capture,
-      passive: !!parsedListener.passive,
-      target: parsedListener.target
-    };
-  });
-};
-
-// src/compiler/transformers/static-to-meta/methods.ts
-var parseStaticMethods = (staticMembers) => {
-  const parsedMethods = getStaticValue(staticMembers, "methods");
-  if (!parsedMethods) {
-    return [];
-  }
-  const methodNames = Object.keys(parsedMethods);
-  if (methodNames.length === 0) {
-    return [];
-  }
-  return methodNames.map((methodName) => {
-    return {
-      name: methodName,
-      docs: parsedMethods[methodName].docs,
-      complexType: parsedMethods[methodName].complexType,
-      internal: isInternal(parsedMethods[methodName].docs)
-    };
-  });
-};
-
-// src/compiler/transformers/static-to-meta/props.ts
-var parseStaticProps = (staticMembers) => {
-  const parsedProps = getStaticValue(staticMembers, "properties");
-  if (!parsedProps) {
-    return [];
-  }
-  const propNames = Object.keys(parsedProps);
-  if (propNames.length === 0) {
-    return [];
-  }
-  return propNames.map((propName) => {
-    const val = parsedProps[propName];
-    return {
-      name: propName,
-      type: val.type,
-      attribute: val.attribute ? val.attribute.toLowerCase() : void 0,
-      reflect: typeof val.reflect === "boolean" ? val.reflect : false,
-      mutable: !!val.mutable,
-      required: !!val.required,
-      optional: !!val.optional,
-      defaultValue: val.defaultValue,
-      complexType: val.complexType,
-      docs: val.docs,
-      internal: isInternal(val.docs),
-      getter: !!val.getter,
-      setter: !!val.setter
-    };
-  });
-};
-
-// src/compiler/transformers/static-to-meta/states.ts
-var parseStaticStates = (staticMembers) => {
-  const parsedStates = getStaticValue(staticMembers, "states");
-  if (!parsedStates) {
-    return [];
-  }
-  const stateNames = Object.keys(parsedStates);
-  if (stateNames.length === 0) {
-    return [];
-  }
-  return stateNames.map((stateName) => {
-    return {
-      name: stateName
-    };
-  });
-};
-
 // src/compiler/transformers/static-to-meta/string-literal.ts
 var parseStringLiteral = (m, node) => {
   if (typeof node.text === "string" && node.text.includes("</")) {
@@ -262369,6 +262272,113 @@ var parseStyleIdentifier = (parsedStyle, modeName) => {
   return style;
 };
 
+// src/compiler/transformers/static-to-meta/class-extension.ts
+var import_typescript59 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+
+// src/compiler/transformers/static-to-meta/events.ts
+var parseStaticEvents = (staticMembers) => {
+  const parsedEvents = getStaticValue(staticMembers, "events");
+  if (!parsedEvents || parsedEvents.length === 0) {
+    return [];
+  }
+  return parsedEvents.map((parsedEvent) => {
+    return {
+      name: parsedEvent.name,
+      method: parsedEvent.method,
+      bubbles: parsedEvent.bubbles,
+      cancelable: parsedEvent.cancelable,
+      composed: parsedEvent.composed,
+      docs: parsedEvent.docs,
+      complexType: parsedEvent.complexType,
+      internal: isInternal(parsedEvent.docs)
+    };
+  });
+};
+
+// src/compiler/transformers/static-to-meta/listeners.ts
+var parseStaticListeners = (staticMembers) => {
+  const parsedListeners = getStaticValue(staticMembers, "listeners");
+  if (!parsedListeners || parsedListeners.length === 0) {
+    return [];
+  }
+  return parsedListeners.map((parsedListener) => {
+    return {
+      name: parsedListener.name,
+      method: parsedListener.method,
+      capture: !!parsedListener.capture,
+      passive: !!parsedListener.passive,
+      target: parsedListener.target
+    };
+  });
+};
+
+// src/compiler/transformers/static-to-meta/methods.ts
+var parseStaticMethods = (staticMembers) => {
+  const parsedMethods = getStaticValue(staticMembers, "methods");
+  if (!parsedMethods) {
+    return [];
+  }
+  const methodNames = Object.keys(parsedMethods);
+  if (methodNames.length === 0) {
+    return [];
+  }
+  return methodNames.map((methodName) => {
+    return {
+      name: methodName,
+      docs: parsedMethods[methodName].docs,
+      complexType: parsedMethods[methodName].complexType,
+      internal: isInternal(parsedMethods[methodName].docs)
+    };
+  });
+};
+
+// src/compiler/transformers/static-to-meta/props.ts
+var parseStaticProps = (staticMembers) => {
+  const parsedProps = getStaticValue(staticMembers, "properties");
+  if (!parsedProps) {
+    return [];
+  }
+  const propNames = Object.keys(parsedProps);
+  if (propNames.length === 0) {
+    return [];
+  }
+  return propNames.map((propName) => {
+    const val = parsedProps[propName];
+    return {
+      name: propName,
+      type: val.type,
+      attribute: val.attribute ? val.attribute.toLowerCase() : void 0,
+      reflect: typeof val.reflect === "boolean" ? val.reflect : false,
+      mutable: !!val.mutable,
+      required: !!val.required,
+      optional: !!val.optional,
+      defaultValue: val.defaultValue,
+      complexType: val.complexType,
+      docs: val.docs,
+      internal: isInternal(val.docs),
+      getter: !!val.getter,
+      setter: !!val.setter
+    };
+  });
+};
+
+// src/compiler/transformers/static-to-meta/states.ts
+var parseStaticStates = (staticMembers) => {
+  const parsedStates = getStaticValue(staticMembers, "states");
+  if (!parsedStates) {
+    return [];
+  }
+  const stateNames = Object.keys(parsedStates);
+  if (stateNames.length === 0) {
+    return [];
+  }
+  return stateNames.map((stateName) => {
+    return {
+      name: stateName
+    };
+  });
+};
+
 // src/compiler/transformers/static-to-meta/watchers.ts
 var parseStaticWatchers = (staticMembers) => {
   const parsedWatchers = getStaticValue(staticMembers, "watchers");
@@ -262383,62 +262393,113 @@ var parseStaticWatchers = (staticMembers) => {
   });
 };
 
-// src/compiler/transformers/static-to-meta/component.ts
-var BLACKLISTED_COMPONENT_METHODS = [
-  /**
-   * If someone would define a getter called "shadowRoot" on a component
-   * this would cause issues when Stencil tries to hydrate the component.
-   */
-  "shadowRoot"
-];
-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
+// src/compiler/transformers/static-to-meta/class-extension.ts
+var deDupeMembers = (dedupeMembers, staticMembers) => {
+  return dedupeMembers.filter(
+    (s) => !staticMembers.some((d) => {
+      if (d.methodName) {
+        return d.methodName === s.methodName;
+      }
+      return d.name === s.name;
+    })
   );
-  if (!extendsClause) {
-    return dependentClasses;
+};
+function findClassWalk(node, name) {
+  var _a2;
+  if (!node) return void 0;
+  if (node && import_typescript59.default.isClassDeclaration(node) && (!name || ((_a2 = node.name) == null ? void 0 : _a2.text) === name)) {
+    return node;
   }
+  let found2;
+  import_typescript59.default.forEachChild(node, (child) => {
+    if (found2) return;
+    const result2 = findClassWalk(child, name);
+    if (result2) found2 = result2;
+  });
+  return found2;
+}
+function matchesNamedDeclaration(name) {
+  return function(stmt) {
+    var _a2, _b;
+    if (import_typescript59.default.isClassDeclaration(stmt) && ((_a2 = stmt.name) == null ? void 0 : _a2.text) === name) {
+      return true;
+    }
+    if (import_typescript59.default.isFunctionDeclaration(stmt) && ((_b = stmt.name) == null ? void 0 : _b.text) === name) {
+      return true;
+    }
+    if (import_typescript59.default.isVariableStatement(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (import_typescript59.default.isIdentifier(decl.name) && decl.name.text === name) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+}
+function buildExtendsTree(compilerCtx, classDeclaration3, dependentClasses, typeChecker, buildCtx) {
+  const hasHeritageClauses = classDeclaration3.heritageClauses;
+  if (!(hasHeritageClauses == null ? void 0 : hasHeritageClauses.length)) return dependentClasses;
+  const extendsClause = hasHeritageClauses.find((clause) => clause.token === import_typescript59.default.SyntaxKind.ExtendsKeyword);
+  if (!extendsClause) return dependentClasses;
+  let classIdentifiers = [];
+  let foundClassDeclaration;
+  let keepLooking = true;
   extendsClause.types.forEach((type) => {
-    var _a2;
+    if (import_typescript59.default.isExpressionWithTypeArguments(type) && import_typescript59.default.isCallExpression(type.expression) && type.expression.expression.getText() === "Mixin") {
+      classIdentifiers = type.expression.arguments.filter(import_typescript59.default.isIdentifier);
+    } else if (import_typescript59.default.isIdentifier(type.expression)) {
+      classIdentifiers = [type.expression];
+    }
+  });
+  classIdentifiers.forEach((extendee) => {
+    var _a2, _b, _c;
     try {
-      const 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);
+      const symbol = typeChecker.getSymbolAtLocation(extendee);
+      const aliasedSymbol = symbol ? typeChecker.getAliasedSymbol(symbol) : void 0;
+      foundClassDeclaration = (_a2 = aliasedSymbol == null ? void 0 : aliasedSymbol.declarations) == null ? void 0 : _a2.find(import_typescript59.default.isClassDeclaration);
+      if (!foundClassDeclaration) {
+        const node = (_b = aliasedSymbol == null ? void 0 : aliasedSymbol.declarations) == null ? void 0 : _b[0];
+        foundClassDeclaration = findClassWalk(node);
+        keepLooking = false;
+      }
+      if (foundClassDeclaration && !dependentClasses.some((dc) => dc.classNode === foundClassDeclaration)) {
+        const foundModule = compilerCtx.moduleMap.get(foundClassDeclaration.getSourceFile().fileName);
         if (foundModule) {
           const source = foundModule.staticSourceFile;
-          source.statements.forEach((statement) => {
-            if (import_typescript59.default.isClassDeclaration(statement)) {
-              dependentClasses.push({ classNode: statement, fileName: source.fileName });
-              buildExtendsTree(compilerCtx, statement, dependentClasses, typeChecker, buildCtx);
+          const sourceClass = findClassWalk(source, (_c = foundClassDeclaration.name) == null ? void 0 : _c.getText());
+          if (sourceClass) {
+            dependentClasses.push({ classNode: sourceClass, fileName: source.fileName });
+            if (keepLooking) {
+              buildExtendsTree(compilerCtx, foundClassDeclaration, dependentClasses, typeChecker, buildCtx);
             }
-          });
+          }
         }
       }
-    } catch (e) {
+    } 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 (!currentSource) return;
+      const matchedStatement = currentSource.statements.find(matchesNamedDeclaration(extendee.getText()));
+      if (matchedStatement && import_typescript59.default.isClassDeclaration(matchedStatement)) {
+        foundClassDeclaration = matchedStatement;
+      } else if (matchedStatement) {
+        foundClassDeclaration = findClassWalk(matchedStatement);
+        keepLooking = false;
+      }
+      if (foundClassDeclaration && !dependentClasses.some((dc) => dc.classNode === foundClassDeclaration)) {
+        dependentClasses.push({ classNode: foundClassDeclaration, fileName: currentSource.fileName });
+        if (keepLooking) {
+          buildExtendsTree(compilerCtx, foundClassDeclaration, dependentClasses, typeChecker, buildCtx);
+        }
+        return;
       }
-      if (found2) return;
+      const importStatements = currentSource.statements.filter(import_typescript59.default.isImportDeclaration);
       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 _a3, _b2, _c2;
+        if (((_a3 = statement.importClause) == null ? void 0 : _a3.namedBindings) && import_typescript59.default.isNamedImports((_b2 = statement.importClause) == null ? void 0 : _b2.namedBindings)) {
+          (_c2 = statement.importClause) == null ? void 0 : _c2.namedBindings.elements.forEach((element) => {
             var _a4;
-            if (element.name.getText() === type.expression.getText()) {
+            if (element.name.getText() === extendee.getText()) {
               const className = ((_a4 = element.propertyName) == null ? void 0 : _a4.getText()) || element.name.getText();
               const foundFile = tsResolveModuleName(
                 buildCtx.config,
@@ -262446,15 +262507,23 @@ var buildExtendsTree = (compilerCtx, classDeclaration3, dependentClasses, typeCh
                 statement.moduleSpecifier.getText().replaceAll(/['"]/g, ""),
                 currentSource.fileName
               );
-              if (foundFile) {
+              if ((foundFile == null ? void 0 : foundFile.resolvedModule) && className) {
                 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);
+                const matchedStatement2 = (foundModule == null ? void 0 : foundModule.staticSourceFile).statements.find(
+                  matchesNamedDeclaration(className)
+                );
+                foundClassDeclaration = matchedStatement2 ? import_typescript59.default.isClassDeclaration(matchedStatement2) ? matchedStatement2 : void 0 : void 0;
+                if (!foundClassDeclaration && matchedStatement2) {
+                  foundClassDeclaration = findClassWalk(matchedStatement2);
+                  keepLooking = false;
+                }
+                if (foundClassDeclaration && !dependentClasses.some((dc) => dc.classNode === foundClassDeclaration)) {
+                  dependentClasses.push({ classNode: foundClassDeclaration, fileName: currentSource.fileName });
+                  if (keepLooking) {
+                    buildExtendsTree(compilerCtx, foundClassDeclaration, dependentClasses, typeChecker, buildCtx);
                   }
-                });
+                  return;
+                }
               }
             }
           });
@@ -262463,58 +262532,73 @@ var buildExtendsTree = (compilerCtx, classDeclaration3, dependentClasses, typeCh
     }
   });
   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;
-  }
-  const staticMembers = cmpNode.members.filter(isStaticGetter);
-  const tagName = getComponentTagName(staticMembers);
-  if (tagName == null) {
-    return cmpNode;
-  }
+}
+function mergeExtendedClassMeta(compilerCtx, typeChecker, buildCtx, cmpNode, staticMembers) {
+  const tree = buildExtendsTree(compilerCtx, cmpNode, [], typeChecker, buildCtx);
+  let hasMixin = false;
+  let doesExtend = false;
   let properties = parseStaticProps(staticMembers);
   let states = parseStaticStates(staticMembers);
   let methods = parseStaticMethods(staticMembers);
   let listeners = parseStaticListeners(staticMembers);
   let events = parseStaticEvents(staticMembers);
   let watchers = parseStaticWatchers(staticMembers);
-  let 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;
+  tree.forEach((extendedClass) => {
+    var _a2, _b, _c, _d, _e, _f, _g, _h;
     const extendedStaticMembers = extendedClass.classNode.members.filter(isStaticGetter);
-    const mixinProps = (_a3 = parseStaticProps(extendedStaticMembers)) != null ? _a3 : [];
+    const mixinProps = (_a2 = parseStaticProps(extendedStaticMembers)) != null ? _a2 : [];
     const mixinStates = (_b = parseStaticStates(extendedStaticMembers)) != null ? _b : [];
+    const mixinMethods = (_c = parseStaticMethods(extendedStaticMembers)) != null ? _c : [];
     const isMixin = mixinProps.length > 0 || mixinStates.length > 0;
     const module2 = compilerCtx.moduleMap.get(extendedClass.fileName);
+    if (!module2) return;
     module2.isMixin = isMixin;
     module2.isExtended = true;
     doesExtend = true;
+    if (isMixin && !detectModernPropDeclarations(extendedClass.classNode)) {
+      const err2 = buildWarn(buildCtx.diagnostics);
+      const target = (_d = buildCtx.config.tsCompilerOptions) == null ? void 0 : _d.target;
+      err2.messageText = `Component classes can only extend from other Stencil decorated base classes when targetting more modern JavaScript (ES2022 and above).
+      ${target ? `Your current TypeScript configuration is set to target \`${import_typescript59.default.ScriptTarget[target]}\`.` : ""} Please amend your tsconfig.json.`;
+      if (!buildCtx.config._isTesting) augmentDiagnosticWithNode(err2, extendedClass.classNode);
+    }
     properties = [...deDupeMembers(mixinProps, properties), ...properties];
     states = [...deDupeMembers(mixinStates, states), ...states];
-    methods = [...deDupeMembers((_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;
-    }
+    methods = [...deDupeMembers(mixinMethods, methods), ...methods];
+    listeners = [...deDupeMembers((_e = parseStaticListeners(extendedStaticMembers)) != null ? _e : [], listeners), ...listeners];
+    events = [...deDupeMembers((_f = parseStaticEvents(extendedStaticMembers)) != null ? _f : [], events), ...events];
+    watchers = [...deDupeMembers((_g = parseStaticWatchers(extendedStaticMembers)) != null ? _g : [], watchers), ...watchers];
+    classMethods = [...classMethods, ...(_h = extendedClass.classNode.members.filter(import_typescript59.default.isMethodDeclaration)) != null ? _h : []];
+    if (isMixin) hasMixin = true;
   });
+  return { hasMixin, doesExtend, properties, states, methods, listeners, events, watchers, classMethods };
+}
+
+// src/compiler/transformers/static-to-meta/component.ts
+var BLACKLISTED_COMPONENT_METHODS = [
+  /**
+   * If someone would define a getter called "shadowRoot" on a component
+   * this would cause issues when Stencil tries to hydrate the component.
+   */
+  "shadowRoot"
+];
+var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, buildCtx, transformOpts) => {
+  if (cmpNode.members == null) {
+    return cmpNode;
+  }
+  const staticMembers = cmpNode.members.filter(isStaticGetter);
+  const tagName = getComponentTagName(staticMembers);
+  if (tagName == null) {
+    return cmpNode;
+  }
+  const { doesExtend, properties, states, methods, listeners, events, watchers, classMethods } = mergeExtendedClassMeta(
+    compilerCtx,
+    typeChecker,
+    buildCtx,
+    cmpNode,
+    staticMembers
+  );
   const symbol = typeChecker ? typeChecker.getSymbolAtLocation(cmpNode.name) : void 0;
   const docs = serializeSymbol(typeChecker, symbol);
   const isCollectionDependency = moduleFile.isCollectionDependency;
@@ -262603,23 +262687,17 @@ var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, b
   };
   const visitComponentChildNode = (node, buildCtx2) => {
     validateComponentMembers(node, buildCtx2);
-    if (import_typescript59.default.isCallExpression(node)) {
+    if (import_typescript60.default.isCallExpression(node)) {
       parseCallExpression(cmp, node);
-    } else if (import_typescript59.default.isStringLiteral(node)) {
+    } else if (import_typescript60.default.isStringLiteral(node)) {
       parseStringLiteral(cmp, node);
     }
     node.forEachChild((child) => visitComponentChildNode(child, buildCtx2));
   };
   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);
-  }
+  const hasModernPropertyDecls = detectModernPropDeclarations(cmpNode);
+  cmp.hasModernPropertyDecls = hasModernPropertyDecls;
   cmp.htmlAttrNames = unique(cmp.htmlAttrNames);
   cmp.htmlTagNames = unique(cmp.htmlTagNames);
   cmp.potentialCmpRefs = unique(cmp.potentialCmpRefs);
@@ -262640,15 +262718,15 @@ var validateComponentMembers = (node, buildCtx) => {
     /**
      * the component has a getter called "shadowRoot"
      */
-    import_typescript59.default.isGetAccessorDeclaration(node) && import_typescript59.default.isIdentifier(node.name) && typeof node.name.escapedText === "string" && BLACKLISTED_COMPONENT_METHODS.includes(node.name.escapedText) && /**
+    import_typescript60.default.isGetAccessorDeclaration(node) && import_typescript60.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_typescript59.default.isClassDeclaration(node.parent)
+    node.parent && import_typescript60.default.isClassDeclaration(node.parent)
   ) {
     const propName = node.name.escapedText;
-    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 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 componentName = node.parent.name.getText();
       const err2 = buildWarn(buildCtx.diagnostics);
@@ -262694,7 +262772,7 @@ var parseAssetsDirs = (staticMembers, componentFilePath) => {
 
 // src/compiler/transformers/static-to-meta/import.ts
 var import_path50 = require("path");
-var import_typescript61 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript62 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/collections/add-external-import.ts
 var import_path49 = require("path");
@@ -262703,7 +262781,7 @@ var import_path49 = require("path");
 var import_path48 = require("path");
 
 // src/compiler/transformers/collections/parse-collection-components.ts
-var import_typescript60 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript61 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var parseCollectionComponents = (config, compilerCtx, buildCtx, collectionDir, collectionManifest, collection) => {
   if (collectionManifest.entries) {
     collectionManifest.entries.forEach((entryPath) => {
@@ -262714,7 +262792,7 @@ var parseCollectionComponents = (config, compilerCtx, buildCtx, collectionDir, c
 };
 var transpileCollectionModule = (config, compilerCtx, buildCtx, collection, inputFileName) => {
   const sourceText = compilerCtx.fs.readFileSync(inputFileName);
-  const sourceFile = import_typescript60.default.createSourceFile(inputFileName, sourceText, import_typescript60.default.ScriptTarget.ES2017, true, import_typescript60.default.ScriptKind.JS);
+  const sourceFile = import_typescript61.default.createSourceFile(inputFileName, sourceText, import_typescript61.default.ScriptTarget.ES2017, true, import_typescript61.default.ScriptKind.JS);
   return updateModule(config, compilerCtx, buildCtx, sourceFile, sourceText, inputFileName, void 0, collection);
 };
 
@@ -262862,7 +262940,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_typescript61.default.isStringLiteral(importNode.moduleSpecifier)) {
+  if (importNode.moduleSpecifier && import_typescript62.default.isStringLiteral(importNode.moduleSpecifier)) {
     let importPath = importNode.moduleSpecifier.text;
     if (!moduleFile.originalImports.includes(importPath)) {
       moduleFile.originalImports.push(importPath);
@@ -262910,15 +262988,15 @@ var updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileText,
   compilerCtx.moduleMap.set(moduleFileKey, moduleFile);
   compilerCtx.changedModules.add(moduleFile.sourceFilePath);
   const visitNode = (node) => {
-    if (import_typescript62.default.isClassDeclaration(node)) {
+    if (import_typescript63.default.isClassDeclaration(node)) {
       parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile, buildCtx, void 0);
       return;
-    } else if (import_typescript62.default.isImportDeclaration(node)) {
+    } else if (import_typescript63.default.isImportDeclaration(node)) {
       parseModuleImport(config, compilerCtx, buildCtx, moduleFile, srcDirPath, node, true);
       return;
-    } else if (import_typescript62.default.isCallExpression(node)) {
+    } else if (import_typescript63.default.isCallExpression(node)) {
       parseCallExpression(moduleFile, node);
-    } else if (import_typescript62.default.isStringLiteral(node)) {
+    } else if (import_typescript63.default.isStringLiteral(node)) {
       parseStringLiteral(moduleFile, node);
     }
     node.forEachChild(visitNode);
@@ -262930,12 +263008,12 @@ var updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileText,
   }
   visitNode(tsSourceFile);
   if (moduleFile.cmps.length > 0) {
-    moduleFile.staticSourceFile = import_typescript62.default.createSourceFile(
+    moduleFile.staticSourceFile = import_typescript63.default.createSourceFile(
       sourceFilePath,
       sourceFileText,
       tsSourceFile.languageVersion,
       true,
-      import_typescript62.default.ScriptKind.JS
+      import_typescript63.default.ScriptKind.JS
     );
   }
   return moduleFile;
@@ -264179,14 +264257,14 @@ var isWatchIgnorePath = (config, path7) => {
 };
 
 // src/compiler/transpile/create-watch-program.ts
-var import_typescript63 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript64 = __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_typescript63.default.sys,
+    ...import_typescript64.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
@@ -264214,7 +264292,7 @@ var createTsWatchProgram = async (config, buildCallback) => {
     }
   };
   config.sys.addDestroy(() => tsWatchSys.clearTimeout(timeoutId));
-  const tsWatchHost = import_typescript63.default.createWatchCompilerHost(
+  const tsWatchHost = import_typescript64.default.createWatchCompilerHost(
     // Use the TS config from the Stencil project
     config.tsconfig,
     optionsToExtend,
@@ -264222,7 +264300,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_typescript63.default.createEmitAndSemanticDiagnosticsBuilderProgram,
+    import_typescript64.default.createEmitAndSemanticDiagnosticsBuilderProgram,
     // Add a callback to log out diagnostics as the program runs
     (reportDiagnostic) => {
       config.logger.debug("watch reportDiagnostic:" + reportDiagnostic.messageText);
@@ -264249,7 +264327,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_typescript63.default.createWatchProgram(tsWatchHost),
+    program: import_typescript64.default.createWatchProgram(tsWatchHost),
     // This will be called via a callback on the watch build whenever a file
     // change is detected
     rebuild: () => {
@@ -266306,7 +266384,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_typescript64 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript65 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var nodeRequire = (id) => {
   const results = {
     module: void 0,
@@ -266321,13 +266399,13 @@ var nodeRequire = (id) => {
     require.extensions[".ts"] = (module2, fileName) => {
       let sourceText = fs2.readFileSync(fileName, "utf8");
       if (fileName.endsWith(".ts")) {
-        const tsResults = import_typescript64.default.transpileModule(sourceText, {
+        const tsResults = import_typescript65.default.transpileModule(sourceText, {
           fileName,
           compilerOptions: {
-            module: import_typescript64.default.ModuleKind.CommonJS,
-            moduleResolution: import_typescript64.default.ModuleResolutionKind.NodeJs,
+            module: import_typescript65.default.ModuleKind.CommonJS,
+            moduleResolution: import_typescript65.default.ModuleResolutionKind.NodeJs,
             esModuleInterop: true,
-            target: import_typescript64.default.ScriptTarget.ES2017,
+            target: import_typescript65.default.ScriptTarget.ES2017,
             allowJs: true
           }
         });
@@ -267129,7 +267207,7 @@ var createCompiler = async (userConfig) => {
   const sys = config.sys;
   const compilerCtx = new CompilerContext();
   if (isFunction(config.sys.setupCompiler)) {
-    config.sys.setupCompiler({ ts: import_typescript65.default });
+    config.sys.setupCompiler({ ts: import_typescript66.default });
   }
   compilerCtx.fs = createInMemoryFs(sys);
   compilerCtx.cache = new Cache(config, createInMemoryFs(sys));
@@ -267163,7 +267241,7 @@ var import_path63 = require("path");
 
 // src/compiler/sys/typescript/typescript-config.ts
 var import_path62 = require("path");
-var import_typescript66 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript67 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var validateTsConfig = async (config, sys, init) => {
   var _a2;
   const tsconfig = {
@@ -267185,7 +267263,7 @@ var validateTsConfig = async (config, sys, init) => {
     } else {
       tsconfig.path = readTsConfig.path;
       const host = {
-        ...import_typescript66.default.sys,
+        ...import_typescript67.default.sys,
         readFile: (p) => {
           if (p === tsconfig.path) {
             return readTsConfig.content;
@@ -267196,7 +267274,7 @@ var validateTsConfig = async (config, sys, init) => {
         fileExists: (p) => sys.accessSync(p),
         onUnRecoverableConfigFileDiagnostic: (e) => console.error(e)
       };
-      const results = import_typescript66.default.getParsedCommandLineOfConfigFile(tsconfig.path, {}, host);
+      const results = import_typescript67.default.getParsedCommandLineOfConfigFile(tsconfig.path, {}, host);
       if (results === void 0) {
         throw "Encountered an error reading tsconfig!";
       }
@@ -267240,12 +267318,12 @@ var validateTsConfig = async (config, sys, init) => {
         }
         if (results.options) {
           tsconfig.compilerOptions = results.options;
-          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 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 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_typescript66.default.ModuleKind.ESNext && !config._isTesting) {
+          if (tsconfig.compilerOptions.module !== import_typescript67.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.`;
           }
@@ -268642,26 +268720,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_typescript68 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript69 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/static-to-meta/visitor.ts
 var import_path67 = require("path");
-var import_typescript67 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript68 = __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_typescript67.default.isClassDeclaration(node)) {
+      if (import_typescript68.default.isClassDeclaration(node)) {
         return parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile, buildCtx, transformOpts);
-      } else if (import_typescript67.default.isImportDeclaration(node)) {
+      } else if (import_typescript68.default.isImportDeclaration(node)) {
         parseModuleImport(config, compilerCtx, buildCtx, moduleFile, dirPath, node, !transformOpts.isolatedModules);
-      } else if (import_typescript67.default.isCallExpression(node)) {
+      } else if (import_typescript68.default.isCallExpression(node)) {
         parseCallExpression(moduleFile, node);
-      } else if (import_typescript67.default.isStringLiteral(node)) {
+      } else if (import_typescript68.default.isStringLiteral(node)) {
         parseStringLiteral(moduleFile, node);
       }
-      return import_typescript67.default.visitEachChild(node, visitNode, transformCtx);
+      return import_typescript68.default.visitEachChild(node, visitNode, transformCtx);
     };
     return (tsSourceFile) => {
       dirPath = (0, import_path67.dirname)(tsSourceFile.fileName);
@@ -268707,13 +268785,13 @@ var transpileModule = (config, input, transformOpts) => {
     moduleFile: null
   };
   if (transformOpts.module === "cjs") {
-    tsCompilerOptions.module = import_typescript68.default.ModuleKind.CommonJS;
+    tsCompilerOptions.module = import_typescript69.default.ModuleKind.CommonJS;
   } else {
-    tsCompilerOptions.module = import_typescript68.default.ModuleKind.ESNext;
+    tsCompilerOptions.module = import_typescript69.default.ModuleKind.ESNext;
   }
   tsCompilerOptions.target = getScriptTargetKind(transformOpts);
   if ((sourceFilePath.endsWith(".tsx") || sourceFilePath.endsWith(".jsx")) && tsCompilerOptions.jsx == null) {
-    tsCompilerOptions.jsx = import_typescript68.default.JsxEmit.React;
+    tsCompilerOptions.jsx = import_typescript69.default.JsxEmit.React;
   }
   if (tsCompilerOptions.jsx != null && !isString(tsCompilerOptions.jsxFactory)) {
     tsCompilerOptions.jsxFactory = "h";
@@ -268724,7 +268802,7 @@ var transpileModule = (config, input, transformOpts) => {
   if (tsCompilerOptions.paths && !isString(tsCompilerOptions.baseUrl)) {
     tsCompilerOptions.baseUrl = ".";
   }
-  const sourceFile = import_typescript68.default.createSourceFile(sourceFilePath, input, tsCompilerOptions.target);
+  const sourceFile = import_typescript69.default.createSourceFile(sourceFilePath, input, tsCompilerOptions.target);
   const compilerHost = {
     getSourceFile: (fileName) => {
       return normalizePath(fileName) === normalizePath(sourceFilePath) ? sourceFile : void 0;
@@ -268740,13 +268818,13 @@ var transpileModule = (config, input, transformOpts) => {
     useCaseSensitiveFileNames: () => false,
     getCanonicalFileName: (fileName) => fileName,
     getCurrentDirectory: () => transformOpts.currentDirectory || process.cwd(),
-    getNewLine: () => import_typescript68.default.sys.newLine || "\n",
+    getNewLine: () => import_typescript69.default.sys.newLine || "\n",
     fileExists: (fileName) => normalizePath(fileName) === normalizePath(sourceFilePath),
     readFile: () => "",
     directoryExists: () => true,
     getDirectories: () => []
   };
-  const program3 = import_typescript68.default.createProgram([sourceFilePath], tsCompilerOptions, compilerHost);
+  const program3 = import_typescript69.default.createProgram([sourceFilePath], tsCompilerOptions, compilerHost);
   const typeChecker = program3.getTypeChecker();
   const transformers = {
     before: [
@@ -268778,10 +268856,10 @@ var transpileModule = (config, input, transformOpts) => {
 };
 var getScriptTargetKind = (transformOpts) => {
   const target = transformOpts.target && transformOpts.target.toUpperCase();
-  if (isNumber(import_typescript68.default.ScriptTarget[target])) {
-    return import_typescript68.default.ScriptTarget[target];
+  if (isNumber(import_typescript69.default.ScriptTarget[target])) {
+    return import_typescript69.default.ScriptTarget[target];
   }
-  return import_typescript68.default.ScriptTarget.Latest;
+  return import_typescript69.default.ScriptTarget.Latest;
 };
 
 // src/compiler/transpile.ts