@stencil/core 2.19.1-0 → 2.19.2-0

package/compiler/stencil.js

@@ -1,5 +1,5 @@
 /*!
- Stencil Compiler v2.19.1-0 | MIT Licensed | https://stenciljs.com
+ Stencil Compiler v2.19.2-0 | MIT Licensed | https://stenciljs.com
  */
 (function(exports) {
 'use strict';
@@ -2039,7 +2039,7 @@ const process$3 = /*#__PURE__*/Object.assign(/*#__PURE__*/Object.create(null), p
   'default': process_1
 });
 
-const buildId = '20221025200049';
+const buildId = '20221027170342';
 const minfyJsId = 'terser5.6.1_7';
 const optimizeCssId = 'autoprefixer10.4.12_postcss8.4.18_7';
 const parse5Version = '7.1.1';
@@ -2047,8 +2047,8 @@ const rollupVersion = '2.42.3';
 const sizzleVersion = '2.42.3';
 const terserVersion = '5.6.1';
 const typescriptVersion = '4.7.4';
-const vermoji = '🐺';
-const version$3 = '2.19.1-0';
+const vermoji = '🌵';
+const version$3 = '2.19.2-0';
 const versions = {
   stencil: version$3,
   parse5: parse5Version,
@@ -9449,6 +9449,9 @@ const nodeRequire = (id) => {
           sourceText = sourceText.replace(/export\s+\w+\s+(\w+)/gm, 'exports.$1');
         }
         try {
+          // we need to coerce because of the requirements for the arguments to
+          // this function. It's safe enough since it's already wrapped in a
+          // `try { } catch`.
           module._compile(sourceText, fileName);
         }
         catch (e) {
@@ -52212,7 +52215,7 @@ const removeCollectionImports = (compilerCtx) => {
         }
       }
       if (madeUpdates) {
-        return t.updateSourceFileNode(tsSourceFile, statements);
+        return t.factory.updateSourceFile(tsSourceFile, statements);
       }
       return tsSourceFile;
     };
@@ -52535,201 +52538,8 @@ const getHydratedFlagHead = (h) => {
   return initial + hydrated;
 };
 
-/**
- * A new BuildCtx object is created for every build
- * and rebuild.
- */
-class BuildContext {
-  constructor(config, compilerCtx) {
-    this.buildId = -1;
-    this.buildMessages = [];
-    this.buildResults = null;
-    this.bundleBuildCount = 0;
-    this.collections = [];
-    this.completedTasks = [];
-    this.components = [];
-    this.componentGraph = new Map();
-    this.data = {};
-    this.buildStats = undefined;
-    this.diagnostics = [];
-    this.dirsAdded = [];
-    this.dirsDeleted = [];
-    this.entryModules = [];
-    this.filesAdded = [];
-    this.filesChanged = [];
-    this.filesDeleted = [];
-    this.filesUpdated = [];
-    this.filesWritten = [];
-    this.globalStyle = undefined;
-    this.hasConfigChanges = false;
-    this.hasFinished = false;
-    this.hasHtmlChanges = false;
-    this.hasPrintedResults = false;
-    this.hasServiceWorkerChanges = false;
-    this.hasScriptChanges = true;
-    this.hasStyleChanges = true;
-    this.hydrateAppFilePath = null;
-    this.indexBuildCount = 0;
-    this.indexDoc = undefined;
-    this.isRebuild = false;
-    this.moduleFiles = [];
-    this.outputs = [];
-    this.packageJson = {};
-    this.packageJsonFilePath = null;
-    this.pendingCopyTasks = [];
-    this.requiresFullBuild = true;
-    this.scriptsAdded = [];
-    this.scriptsDeleted = [];
-    this.startTime = Date.now();
-    this.styleBuildCount = 0;
-    this.stylesPromise = null;
-    this.stylesUpdated = [];
-    this.timeSpan = null;
-    this.transpileBuildCount = 0;
-    this.config = config;
-    this.compilerCtx = compilerCtx;
-    this.buildId = ++this.compilerCtx.activeBuildId;
-    this.debug = config.logger.debug.bind(config.logger);
-  }
-  start() {
-    // get the build id from the incremented activeBuildId
-    // print out a good message
-    const msg = `${this.isRebuild ? 'rebuild' : 'build'}, ${this.config.fsNamespace}, ${this.config.devMode ? 'dev' : 'prod'} mode, started`;
-    const buildLog = {
-      buildId: this.buildId,
-      messages: [],
-      progress: 0,
-    };
-    this.compilerCtx.events.emit('buildLog', buildLog);
-    // create a timespan for this build
-    this.timeSpan = this.createTimeSpan(msg);
-    // create a build timestamp for this build
-    this.timestamp = getBuildTimestamp();
-    // debug log our new build
-    this.debug(`start build, ${this.timestamp}`);
-    const buildStart = {
-      buildId: this.buildId,
-      timestamp: this.timestamp,
-    };
-    this.compilerCtx.events.emit('buildStart', buildStart);
-  }
-  createTimeSpan(msg, debug) {
-    if (!this.hasFinished || debug) {
-      if (debug) {
-        if (this.config.watch) {
-          msg = `${this.config.logger.cyan('[' + this.buildId + ']')} ${msg}`;
-        }
-      }
-      const timeSpan = this.config.logger.createTimeSpan(msg, debug, this.buildMessages);
-      if (!debug && this.compilerCtx.events) {
-        const buildLog = {
-          buildId: this.buildId,
-          messages: this.buildMessages,
-          progress: getProgress(this.completedTasks),
-        };
-        this.compilerCtx.events.emit('buildLog', buildLog);
-      }
-      return {
-        duration: () => {
-          return timeSpan.duration();
-        },
-        finish: (finishedMsg, color, bold, newLineSuffix) => {
-          if (!this.hasFinished || debug) {
-            if (debug) {
-              if (this.config.watch) {
-                finishedMsg = `${this.config.logger.cyan('[' + this.buildId + ']')} ${finishedMsg}`;
-              }
-            }
-            timeSpan.finish(finishedMsg, color, bold, newLineSuffix);
-            if (!debug) {
-              const buildLog = {
-                buildId: this.buildId,
-                messages: this.buildMessages.slice(),
-                progress: getProgress(this.completedTasks),
-              };
-              this.compilerCtx.events.emit('buildLog', buildLog);
-            }
-          }
-          return timeSpan.duration();
-        },
-      };
-    }
-    return {
-      duration() {
-        return 0;
-      },
-      finish() {
-        return 0;
-      },
-    };
-  }
-  debug(msg) {
-    this.config.logger.debug(msg);
-  }
-  get hasError() {
-    return hasError(this.diagnostics);
-  }
-  get hasWarning() {
-    return hasWarning(this.diagnostics);
-  }
-  progress(t) {
-    this.completedTasks.push(t);
-  }
-  async validateTypesBuild() {
-    if (this.hasError) {
-      // no need to wait on this one since
-      // we already aborted this build
-      return;
-    }
-    if (!this.validateTypesPromise) {
-      // there is no pending validate types promise
-      // so it probably already finished
-      // so no need to wait on anything
-      return;
-    }
-    if (!this.config.watch) {
-      // this is not a watch build, so we need to make
-      // sure that the type validation has finished
-      this.debug(`build, non-watch, waiting on validateTypes`);
-      await this.validateTypesPromise;
-      this.debug(`build, non-watch, finished waiting on validateTypes`);
-    }
-  }
-}
-/**
- * Generate a timestamp of the format `YYYY-MM-DDThh:mm:ss`, using the number of seconds that have elapsed since
- * January 01, 1970, and the time this function was called
- * @returns the generated timestamp
- */
-const getBuildTimestamp = () => {
-  const d = new Date();
-  // YYYY-MM-DDThh:mm:ss
-  let timestamp = d.getUTCFullYear() + '-';
-  timestamp += ('0' + (d.getUTCMonth() + 1)).slice(-2) + '-';
-  timestamp += ('0' + d.getUTCDate()).slice(-2) + 'T';
-  timestamp += ('0' + d.getUTCHours()).slice(-2) + ':';
-  timestamp += ('0' + d.getUTCMinutes()).slice(-2) + ':';
-  timestamp += ('0' + d.getUTCSeconds()).slice(-2);
-  return timestamp;
-};
-const getProgress = (completedTasks) => {
-  let progressIndex = 0;
-  const taskKeys = Object.keys(ProgressTask);
-  taskKeys.forEach((taskKey, index) => {
-    if (completedTasks.includes(ProgressTask[taskKey])) {
-      progressIndex = index;
-    }
-  });
-  return (progressIndex + 1) / taskKeys.length;
-};
-const ProgressTask = {
-  emptyOutputTargets: {},
-  transpileApp: {},
-  generateStyles: {},
-  generateOutputTargets: {},
-  validateTypesBuild: {},
-  writeBuildFiles: {},
-};
+const DEV_MODULE_CACHE_BUSTER = 0;
+const DEV_MODULE_DIR = `~dev-module`;
 
 const devNodeModuleResolveId = async (config, inMemoryFs, resolvedId, importee) => {
   if (!shouldCheckDevModule(resolvedId, importee)) {
@@ -52756,6 +52566,14 @@ const devNodeModuleResolveId = async (config, inMemoryFs, resolvedId, importee)
   resolvedId.external = true;
   return resolvedId;
 };
+const shouldCheckDevModule = (resolvedId, importee) => resolvedId &&
+  importee &&
+  resolvedId.id &&
+  resolvedId.id.includes('node_modules') &&
+  (resolvedId.id.endsWith('.js') || resolvedId.id.endsWith('.mjs')) &&
+  !resolvedId.external &&
+  !importee.startsWith('.') &&
+  !importee.startsWith('/');
 const getPackageJsonPath = (resolvedPath, importee) => {
   let currentPath = resolvedPath;
   for (let i = 0; i < 10; i++) {
@@ -52769,130 +52587,6 @@ const getPackageJsonPath = (resolvedPath, importee) => {
   }
   return null;
 };
-const compilerRequest = async (config, compilerCtx, data) => {
-  const results = {
-    path: data.path,
-    nodeModuleId: null,
-    nodeModuleVersion: null,
-    nodeResolvedPath: null,
-    cachePath: null,
-    cacheHit: false,
-    content: '',
-    status: 404,
-  };
-  try {
-    const parsedUrl = parseDevModuleUrl(config, data.path);
-    Object.assign(results, parsedUrl);
-    if (parsedUrl.nodeModuleId) {
-      if (!parsedUrl.nodeModuleVersion) {
-        results.content = `/* invalid module version */`;
-        results.status = 400;
-        return results;
-      }
-      if (!parsedUrl.nodeResolvedPath) {
-        results.content = `/* invalid resolved path */`;
-        results.status = 400;
-        return results;
-      }
-      const useCache = await useDevModuleCache(config, parsedUrl.nodeResolvedPath);
-      let cachePath = null;
-      if (useCache) {
-        cachePath = getDevModuleCachePath(config, parsedUrl);
-        const cachedContent = await config.sys.readFile(cachePath);
-        if (typeof cachedContent === 'string') {
-          results.content = cachedContent;
-          results.cachePath = cachePath;
-          results.cacheHit = true;
-          results.status = 200;
-          return results;
-        }
-      }
-      await bundleDevModule(config, compilerCtx, parsedUrl, results);
-      if (results.status === 200 && useCache) {
-        results.cachePath = cachePath;
-        writeCachedFile(config, results);
-      }
-    }
-    else {
-      results.content = `/* invalid dev module */`;
-      results.status = 400;
-      return results;
-    }
-  }
-  catch (e) {
-    if (e) {
-      if (e instanceof Error && e.stack) {
-        results.content = `/*\n${e.stack}\n*/`;
-      }
-      else {
-        results.content = `/*\n${e}\n*/`;
-      }
-    }
-    results.status = 500;
-  }
-  return results;
-};
-const bundleDevModule = async (config, compilerCtx, parsedUrl, results) => {
-  const buildCtx = new BuildContext(config, compilerCtx);
-  try {
-    const inputOpts = getRollupOptions(config, compilerCtx, buildCtx, {
-      id: parsedUrl.nodeModuleId,
-      platform: 'client',
-      inputs: {
-        index: parsedUrl.nodeResolvedPath,
-      },
-    });
-    const rollupBuild = await rollup(inputOpts);
-    const outputOpts = {
-      banner: generatePreamble(config),
-      format: 'es',
-    };
-    if (parsedUrl.nodeModuleId) {
-      const commentPath = relative$1(config.rootDir, parsedUrl.nodeResolvedPath);
-      outputOpts.intro = `/**\n * Dev Node Module: ${parsedUrl.nodeModuleId}, v${parsedUrl.nodeModuleVersion}\n * Entry: ${commentPath}\n * DEVELOPMENT PURPOSES ONLY!!\n */`;
-      inputOpts.input = parsedUrl.nodeResolvedPath;
-    }
-    const r = await rollupBuild.generate(outputOpts);
-    if (buildCtx.hasError) {
-      results.status = 500;
-      results.content = `console.error(${JSON.stringify(buildCtx.diagnostics)})`;
-    }
-    else if (r && r.output && r.output.length > 0) {
-      results.content = r.output[0].code;
-      results.status = 200;
-    }
-  }
-  catch (e) {
-    results.status = 500;
-    const errorMsg = e instanceof Error ? e.stack : e + '';
-    results.content = `console.error(${JSON.stringify(errorMsg)})`;
-  }
-};
-const useDevModuleCache = async (config, p) => {
-  if (config.enableCache) {
-    for (let i = 0; i < 10; i++) {
-      const n = basename(p);
-      if (n === 'node_modules') {
-        return true;
-      }
-      const isSymbolicLink = await config.sys.isSymbolicLink(p);
-      if (isSymbolicLink) {
-        return false;
-      }
-      p = dirname(p);
-    }
-  }
-  return false;
-};
-const writeCachedFile = async (config, results) => {
-  try {
-    await config.sys.createDir(config.cacheDir);
-    config.sys.writeFile(results.cachePath, results.content);
-  }
-  catch (e) {
-    console.error(e);
-  }
-};
 const serializeDevNodeModuleUrl = (config, moduleId, moduleVersion, resolvedPath) => {
   resolvedPath = relative$1(config.rootDir, resolvedPath);
   let id = `/${DEV_MODULE_DIR}/`;
@@ -52901,42 +52595,6 @@ const serializeDevNodeModuleUrl = (config, moduleId, moduleVersion, resolvedPath
   id += '?p=' + encodeURIComponent(resolvedPath);
   return id;
 };
-const parseDevModuleUrl = (config, u) => {
-  const parsedUrl = {
-    nodeModuleId: null,
-    nodeModuleVersion: null,
-    nodeResolvedPath: null,
-  };
-  if (u && u.includes(DEV_MODULE_DIR) && u.endsWith('.js')) {
-    const url = new URL(u, 'https://stenciljs.com');
-    let reqPath = basename(url.pathname);
-    reqPath = reqPath.substring(0, reqPath.length - 3);
-    const splt = reqPath.split('@');
-    if (splt.length === 2) {
-      parsedUrl.nodeModuleId = decodeURIComponent(splt[0]);
-      parsedUrl.nodeModuleVersion = decodeURIComponent(splt[1]);
-      parsedUrl.nodeResolvedPath = url.searchParams.get('p');
-      if (parsedUrl.nodeResolvedPath) {
-        parsedUrl.nodeResolvedPath = decodeURIComponent(parsedUrl.nodeResolvedPath);
-        parsedUrl.nodeResolvedPath = join(config.rootDir, parsedUrl.nodeResolvedPath);
-      }
-    }
-  }
-  return parsedUrl;
-};
-const getDevModuleCachePath = (config, parsedUrl) => {
-  return join(config.cacheDir, `dev_module_${parsedUrl.nodeModuleId}_${parsedUrl.nodeModuleVersion}_${DEV_MODULE_CACHE_BUSTER}.log`);
-};
-const DEV_MODULE_CACHE_BUSTER = 0;
-const DEV_MODULE_DIR = `~dev-module`;
-const shouldCheckDevModule = (resolvedId, importee) => resolvedId &&
-  importee &&
-  resolvedId.id &&
-  resolvedId.id.includes('node_modules') &&
-  (resolvedId.id.endsWith('.js') || resolvedId.id.endsWith('.mjs')) &&
-  !resolvedId.external &&
-  !importee.startsWith('.') &&
-  !importee.startsWith('/');
 
 const extFormatPlugin = (config) => {
   return {
@@ -54950,7 +54608,21 @@ const convertValueToLiteral = (val, refs = null) => {
     }
     return objectToObjectLiteral(val, refs);
   }
-  return t.createLiteral(val);
+  // the remainder of the implementation of this function was derived from the deprecated `createLiteral` function
+  // found in typescript@4.8.4
+  if (typeof val === 'number') {
+    return t.factory.createNumericLiteral(val);
+  }
+  if (typeof val === 'object' && 'base10Value' in val) {
+    return t.factory.createBigIntLiteral(val);
+  }
+  if (typeof val === 'boolean') {
+    return val ? t.factory.createTrue() : t.factory.createFalse();
+  }
+  if (typeof val === 'string') {
+    return t.factory.createStringLiteral(val, undefined);
+  }
+  return t.factory.createStringLiteralFromNode(val);
 };
 /**
  * Convert a JavaScript Array instance to TypeScript's Intermediate
@@ -54968,7 +54640,7 @@ const arrayToArrayLiteral = (list, refs) => {
   const newList = list.map((l) => {
     return convertValueToLiteral(l, refs);
   });
-  return t.createArrayLiteral(newList);
+  return t.factory.createArrayLiteralExpression(newList);
 };
 /**
  * Convert a JavaScript object (i.e. an object existing at runtime) to the
@@ -54991,7 +54663,7 @@ const objectToObjectLiteral = (obj, refs) => {
   }
   refs.add(obj);
   const newProperties = Object.keys(obj).map((key) => {
-    const prop = t.factory.createPropertyAssignment(t.createLiteral(key), convertValueToLiteral(obj[key], refs));
+    const prop = t.factory.createPropertyAssignment(t.factory.createStringLiteral(key), convertValueToLiteral(obj[key], refs));
     return prop;
   });
   return t.factory.createObjectLiteralExpression(newProperties, true);
@@ -55433,12 +55105,12 @@ const createImportStatement = (importFnNames, importPath) => {
       ? t.factory.createIdentifier(importFnName)
       : undefined, t.factory.createIdentifier(importAs));
   });
-  return t.createImportDeclaration(undefined, undefined, t.createImportClause(undefined, t.createNamedImports(importSpecifiers)), t.createLiteral(importPath));
+  return t.factory.createImportDeclaration(undefined, undefined, t.factory.createImportClause(false, undefined, t.factory.createNamedImports(importSpecifiers)), t.factory.createStringLiteral(importPath));
 };
 const createRequireStatement = (importFnNames, importPath) => {
   // CommonJS require()
   // const { a, b, c } = require(importPath);
-  const importBinding = t.createObjectBindingPattern(importFnNames.map((importKey) => {
+  const importBinding = t.factory.createObjectBindingPattern(importFnNames.map((importKey) => {
     const splt = importKey.split(' as ');
     let importAs = importKey;
     let importFnName = importKey;
@@ -55446,10 +55118,10 @@ const createRequireStatement = (importFnNames, importPath) => {
       importAs = splt[1];
       importFnName = splt[0];
     }
-    return t.createBindingElement(undefined, importFnName, importAs);
+    return t.factory.createBindingElement(undefined, importFnName, importAs);
   }));
-  return t.createVariableStatement(undefined, t.createVariableDeclarationList([
-    t.createVariableDeclaration(importBinding, undefined, t.factory.createCallExpression(t.factory.createIdentifier('require'), [], [t.createLiteral(importPath)])),
+  return t.factory.createVariableStatement(undefined, t.factory.createVariableDeclarationList([
+    t.factory.createVariableDeclaration(importBinding, undefined, undefined, t.factory.createCallExpression(t.factory.createIdentifier('require'), [], [t.factory.createStringLiteral(importPath)])),
   ], t.NodeFlags.Const));
 };
 
@@ -55628,10 +55300,10 @@ const addModuleMetadataProxies = (tsSourceFile, moduleFile) => {
   const statements = tsSourceFile.statements.slice();
   addCoreRuntimeApi(moduleFile, RUNTIME_APIS.proxyCustomElement);
   statements.push(...moduleFile.cmps.map(addComponentMetadataProxy));
-  return t.updateSourceFileNode(tsSourceFile, statements);
+  return t.factory.updateSourceFile(tsSourceFile, statements);
 };
 const addComponentMetadataProxy = (compilerMeta) => {
-  return t.createStatement(createComponentMetadataProxy(compilerMeta));
+  return t.factory.createExpressionStatement(createComponentMetadataProxy(compilerMeta));
 };
 /**
  * Create a call expression for wrapping a component in a proxy. This call expression takes a form:
@@ -55684,13 +55356,13 @@ const addImports = (transformOpts, tsSourceFile, importFnNames, importPath) => {
     const newRequire = createRequireStatement(importFnNames, importPath);
     const statements = tsSourceFile.statements.slice();
     statements.splice(2, 0, newRequire);
-    return t.updateSourceFileNode(tsSourceFile, statements);
+    return t.factory.updateSourceFile(tsSourceFile, statements);
   }
   // ESM Imports
   const newImport = createImportStatement(importFnNames, importPath);
   const statements = tsSourceFile.statements.slice();
   statements.unshift(newImport);
-  return t.updateSourceFileNode(tsSourceFile, statements);
+  return t.factory.updateSourceFile(tsSourceFile, statements);
 };
 
 /**
@@ -55767,18 +55439,21 @@ const defineCustomElement = (tsSourceFile, moduleFile, transformOpts) => {
     // remove commonjs exports keyword from component classes
     statements = removeComponentCjsExport(statements, moduleFile);
   }
-  return t.updateSourceFileNode(tsSourceFile, statements);
+  return t.factory.updateSourceFile(tsSourceFile, statements);
 };
 const addDefineCustomElement = (moduleFile, compilerMeta) => {
   if (compilerMeta.isPlain) {
     // add customElements.define('cmp-a', CmpClass);
-    return t.createStatement(t.factory.createCallExpression(t.factory.createPropertyAccessExpression(t.factory.createIdentifier('customElements'), t.factory.createIdentifier('define')), [], [t.createLiteral(compilerMeta.tagName), t.factory.createIdentifier(compilerMeta.componentClassName)]));
+    return t.factory.createExpressionStatement(t.factory.createCallExpression(t.factory.createPropertyAccessExpression(t.factory.createIdentifier('customElements'), t.factory.createIdentifier('define')), [], [
+      t.factory.createStringLiteral(compilerMeta.tagName),
+      t.factory.createIdentifier(compilerMeta.componentClassName),
+    ]));
   }
   addCoreRuntimeApi(moduleFile, RUNTIME_APIS.defineCustomElement);
   const compactMeta = formatComponentRuntimeMeta(compilerMeta, true);
   const liternalCmpClassName = t.factory.createIdentifier(compilerMeta.componentClassName);
   const liternalMeta = convertValueToLiteral(compactMeta);
-  return t.createStatement(t.factory.createCallExpression(t.factory.createIdentifier(DEFINE_CUSTOM_ELEMENT), [], [liternalCmpClassName, liternalMeta]));
+  return t.factory.createExpressionStatement(t.factory.createCallExpression(t.factory.createIdentifier(DEFINE_CUSTOM_ELEMENT), [], [liternalCmpClassName, liternalMeta]));
 };
 const removeComponentCjsExport = (statements, moduleFile) => {
   const cmpClassNames = new Set(moduleFile.cmps.map((cmp) => cmp.componentClassName));
@@ -55838,7 +55513,7 @@ const updateEsmStyleImports = (transformOpts, tsSourceFile, moduleFile) => {
       }
     }
     statements.splice(lastImportIndex + 1, 0, ...styleImports);
-    return t.updateSourceFileNode(tsSourceFile, statements);
+    return t.factory.updateSourceFile(tsSourceFile, statements);
   }
   return tsSourceFile;
 };
@@ -55859,7 +55534,7 @@ const updateEsmStyleImportPath = (transformOpts, tsSourceFile, statements, cmp,
 const createEsmStyleImport = (transformOpts, tsSourceFile, cmp, style) => {
   const importName = t.factory.createIdentifier(style.styleIdentifier);
   const importPath = getStyleImportPath(transformOpts, tsSourceFile, cmp, style, style.externalStyles[0].absolutePath);
-  return t.createImportDeclaration(undefined, undefined, t.createImportClause(importName, undefined), t.createLiteral(importPath));
+  return t.factory.createImportDeclaration(undefined, undefined, t.factory.createImportClause(false, importName, undefined), t.factory.createStringLiteral(importPath));
 };
 const updateCjsStyleRequires = (transformOpts, tsSourceFile, moduleFile) => {
   const styleRequires = [];
@@ -55872,15 +55547,15 @@ const updateCjsStyleRequires = (transformOpts, tsSourceFile, moduleFile) => {
     });
   });
   if (styleRequires.length > 0) {
-    return t.updateSourceFileNode(tsSourceFile, [...styleRequires, ...tsSourceFile.statements]);
+    return t.factory.updateSourceFile(tsSourceFile, [...styleRequires, ...tsSourceFile.statements]);
   }
   return tsSourceFile;
 };
 const createCjsStyleRequire = (transformOpts, tsSourceFile, cmp, style) => {
   const importName = t.factory.createIdentifier(style.styleIdentifier);
   const importPath = getStyleImportPath(transformOpts, tsSourceFile, cmp, style, style.externalStyles[0].absolutePath);
-  return t.createVariableStatement(undefined, t.createVariableDeclarationList([
-    t.createVariableDeclaration(importName, undefined, t.factory.createCallExpression(t.factory.createIdentifier('require'), [], [t.createLiteral(importPath)])),
+  return t.factory.createVariableStatement(undefined, t.factory.createVariableDeclarationList([
+    t.factory.createVariableDeclaration(importName, undefined, undefined, t.factory.createCallExpression(t.factory.createIdentifier('require'), [], [t.factory.createStringLiteral(importPath)])),
   ], t.NodeFlags.Const));
 };
 const getStyleImportPath = (transformOpts, tsSourceFile, cmp, style, importPath) => {
@@ -55900,7 +55575,7 @@ const transformHostData = (classElements, moduleFile) => {
     const renderIndex = classElements.findIndex((e) => t.isMethodDeclaration(e) && e.name.escapedText === 'render');
     if (renderIndex >= 0) {
       const renderMethod = classElements[renderIndex];
-      classElements[renderIndex] = t.updateMethod(renderMethod, renderMethod.decorators, renderMethod.modifiers, renderMethod.asteriskToken, t.factory.createIdentifier(INTERNAL_RENDER), renderMethod.questionToken, renderMethod.typeParameters, renderMethod.parameters, renderMethod.type, renderMethod.body);
+      classElements[renderIndex] = t.factory.updateMethodDeclaration(renderMethod, renderMethod.decorators, renderMethod.modifiers, renderMethod.asteriskToken, t.factory.createIdentifier(INTERNAL_RENDER), renderMethod.questionToken, renderMethod.typeParameters, renderMethod.parameters, renderMethod.type, renderMethod.body);
     }
     classElements.push(syntheticRender(moduleFile, renderIndex >= 0));
   }
@@ -55925,7 +55600,7 @@ const syntheticRender = (moduleFile, hasRender) => {
    * }
    */
   return t.factory.createMethodDeclaration(undefined, undefined, undefined, 'render', undefined, undefined, undefined, undefined, t.factory.createBlock([
-    t.createReturn(t.factory.createCallExpression(t.factory.createIdentifier(H), undefined, hArguments)),
+    t.factory.createReturnStatement(t.factory.createCallExpression(t.factory.createIdentifier(H), undefined, hArguments)),
   ]));
 };
 const INTERNAL_RENDER = '__stencil_render';
@@ -55976,7 +55651,7 @@ const updateComponentClass = (transformOpts, classNode, heritageClauses, members
         return m.kind !== t.SyntaxKind.ExportKeyword;
       });
     }
-    return t.updateClassDeclaration(classNode, classNode.decorators, classModifiers, classNode.name, classNode.typeParameters, heritageClauses, members);
+    return t.factory.updateClassDeclaration(classNode, classNode.decorators, classModifiers, classNode.name, classNode.typeParameters, heritageClauses, members);
   }
   // ESM with export
   return createConstClass(transformOpts, classNode, heritageClauses, members);
@@ -55989,10 +55664,10 @@ const createConstClass = (transformOpts, classNode, heritageClauses, members) =>
   });
   const constModifiers = [];
   if (transformOpts.componentExport !== 'customelement') {
-    constModifiers.push(t.createModifier(t.SyntaxKind.ExportKeyword));
+    constModifiers.push(t.factory.createModifier(t.SyntaxKind.ExportKeyword));
   }
-  return t.createVariableStatement(constModifiers, t.createVariableDeclarationList([
-    t.createVariableDeclaration(className, undefined, t.createClassExpression(classModifiers, undefined, classNode.typeParameters, heritageClauses, members)),
+  return t.factory.createVariableStatement(constModifiers, t.factory.createVariableDeclarationList([
+    t.factory.createVariableDeclaration(className, undefined, undefined, t.factory.createClassExpression(undefined, classModifiers, undefined, classNode.typeParameters, heritageClauses, members)),
   ], t.NodeFlags.Const));
 };
 
@@ -56032,10 +55707,10 @@ const addNativeConnectedCallback = (classMembers, cmp) => {
 const addCreateEvents = (moduleFile, cmp) => {
   return cmp.events.map((ev) => {
     addCoreRuntimeApi(moduleFile, RUNTIME_APIS.createEvent);
-    return t.createStatement(t.factory.createAssignment(t.factory.createPropertyAccessExpression(t.factory.createThis(), t.factory.createIdentifier(ev.method)), t.factory.createCallExpression(t.factory.createIdentifier(CREATE_EVENT), undefined, [
+    return t.factory.createExpressionStatement(t.factory.createAssignment(t.factory.createPropertyAccessExpression(t.factory.createThis(), t.factory.createIdentifier(ev.method)), t.factory.createCallExpression(t.factory.createIdentifier(CREATE_EVENT), undefined, [
       t.factory.createThis(),
-      t.createLiteral(ev.name),
-      t.createLiteral(computeFlags(ev)),
+      t.factory.createStringLiteral(ev.name),
+      t.factory.createNumericLiteral(computeFlags(ev)),
     ])));
   });
 };
@@ -56068,7 +55743,7 @@ const addLegacyProps = (moduleFile, cmp) => {
 const getStatement = (propName, method, arg) => {
   return t.factory.createExpressionStatement(t.factory.createAssignment(t.factory.createPropertyAccessExpression(t.factory.createThis(), propName), t.factory.createCallExpression(t.factory.createIdentifier(method), undefined, [
     t.factory.createThis(),
-    t.createLiteral(arg),
+    t.factory.createStringLiteral(arg),
   ])));
 };
 
@@ -56092,7 +55767,7 @@ const updateNativeConstructor = (classMembers, moduleFile, cmp, ensureSuper) =>
         statements = [createNativeConstructorSuper(), ...statements];
       }
     }
-    classMembers[cstrMethodIndex] = t.updateConstructor(cstrMethod, cstrMethod.decorators, cstrMethod.modifiers, cstrMethod.parameters, t.updateBlock(cstrMethod.body, statements));
+    classMembers[cstrMethodIndex] = t.factory.updateConstructorDeclaration(cstrMethod, cstrMethod.decorators, cstrMethod.modifiers, cstrMethod.parameters, t.factory.updateBlock(cstrMethod.body, statements));
   }
   else {
     // create a constructor()
@@ -56104,7 +55779,7 @@ const updateNativeConstructor = (classMembers, moduleFile, cmp, ensureSuper) =>
     if (ensureSuper) {
       statements = [createNativeConstructorSuper(), ...statements];
     }
-    const cstrMethod = t.createConstructor(undefined, undefined, undefined, t.factory.createBlock(statements, true));
+    const cstrMethod = t.factory.createConstructorDeclaration(undefined, undefined, undefined, t.factory.createBlock(statements, true));
     classMembers.unshift(cstrMethod);
   }
 };
@@ -56122,7 +55797,7 @@ const nativeInit = (moduleFile, cmp) => {
   return initStatements;
 };
 const nativeRegisterHostStatement = () => {
-  return t.createStatement(t.factory.createCallExpression(t.factory.createPropertyAccessExpression(t.factory.createThis(), t.factory.createIdentifier('__registerHost')), undefined, undefined));
+  return t.factory.createExpressionStatement(t.factory.createCallExpression(t.factory.createPropertyAccessExpression(t.factory.createThis(), t.factory.createIdentifier('__registerHost')), undefined, undefined));
 };
 /**
  * Generates an expression statement for attaching a shadow DOM tree to an element.
@@ -56143,7 +55818,7 @@ const addNativeElementGetter = (classMembers, cmp) => {
   // is transformed into:
   // get element() { return this; }
   if (cmp.elementRef) {
-    classMembers.push(t.createGetAccessor(undefined, undefined, cmp.elementRef, [], undefined, t.factory.createBlock([t.createReturn(t.factory.createThis())])));
+    classMembers.push(t.factory.createGetAccessorDeclaration(undefined, undefined, cmp.elementRef, [], undefined, t.factory.createBlock([t.factory.createReturnStatement(t.factory.createThis())])));
   }
 };
 
@@ -56331,7 +56006,7 @@ const updateStencilCoreImports = (updatedCoreImportPath) => {
         newStatements.push(s);
       });
       if (madeChanges) {
-        return t.updateSourceFileNode(tsSourceFile, newStatements, tsSourceFile.isDeclarationFile, tsSourceFile.referencedFiles, tsSourceFile.typeReferenceDirectives, tsSourceFile.hasNoDefaultLib, tsSourceFile.libReferenceDirectives);
+        return t.factory.updateSourceFile(tsSourceFile, newStatements, tsSourceFile.isDeclarationFile, tsSourceFile.referencedFiles, tsSourceFile.typeReferenceDirectives, tsSourceFile.hasNoDefaultLib, tsSourceFile.libReferenceDirectives);
       }
       return tsSourceFile;
     };
@@ -56859,23 +56534,23 @@ const getCustomElementBundleCustomTransformer = (config, compilerCtx) => {
 
 const updateLazyComponentConstructor = (classMembers, moduleFile, cmp) => {
   const cstrMethodArgs = [
-    t.createParameter(undefined, undefined, undefined, t.factory.createIdentifier(HOST_REF_ARG)),
+    t.factory.createParameterDeclaration(undefined, undefined, undefined, t.factory.createIdentifier(HOST_REF_ARG)),
   ];
   const cstrMethodIndex = classMembers.findIndex((m) => m.kind === t.SyntaxKind.Constructor);
   if (cstrMethodIndex >= 0) {
     // add to the existing constructor()
     const cstrMethod = classMembers[cstrMethodIndex];
-    const body = t.updateBlock(cstrMethod.body, [
+    const body = t.factory.updateBlock(cstrMethod.body, [
       registerInstanceStatement(moduleFile),
       ...addCreateEvents(moduleFile, cmp),
       ...cstrMethod.body.statements,
       ...addLegacyProps(moduleFile, cmp),
     ]);
-    classMembers[cstrMethodIndex] = t.updateConstructor(cstrMethod, cstrMethod.decorators, cstrMethod.modifiers, cstrMethodArgs, body);
+    classMembers[cstrMethodIndex] = t.factory.updateConstructorDeclaration(cstrMethod, cstrMethod.decorators, cstrMethod.modifiers, cstrMethodArgs, body);
   }
   else {
     // create a constructor()
-    const cstrMethod = t.createConstructor(undefined, undefined, cstrMethodArgs, t.factory.createBlock([
+    const cstrMethod = t.factory.createConstructorDeclaration(undefined, undefined, cstrMethodArgs, t.factory.createBlock([
       registerInstanceStatement(moduleFile),
       ...addCreateEvents(moduleFile, cmp),
       ...addLegacyProps(moduleFile, cmp),
@@ -56885,7 +56560,7 @@ const updateLazyComponentConstructor = (classMembers, moduleFile, cmp) => {
 };
 const registerInstanceStatement = (moduleFile) => {
   addCoreRuntimeApi(moduleFile, RUNTIME_APIS.registerInstance);
-  return t.createStatement(t.factory.createCallExpression(t.factory.createIdentifier(REGISTER_INSTANCE), undefined, [
+  return t.factory.createExpressionStatement(t.factory.createCallExpression(t.factory.createIdentifier(REGISTER_INSTANCE), undefined, [
     t.factory.createThis(),
     t.factory.createIdentifier(HOST_REF_ARG),
   ]));
@@ -56898,8 +56573,8 @@ const addLazyElementGetter = (classMembers, moduleFile, cmp) => {
   // get element() { return __stencil_getElement(this); }
   if (cmp.elementRef) {
     addCoreRuntimeApi(moduleFile, RUNTIME_APIS.getElement);
-    classMembers.push(t.createGetAccessor(undefined, undefined, cmp.elementRef, [], undefined, t.factory.createBlock([
-      t.createReturn(t.factory.createCallExpression(t.factory.createIdentifier(GET_ELEMENT), undefined, [
+    classMembers.push(t.factory.createGetAccessorDeclaration(undefined, undefined, cmp.elementRef, [], undefined, t.factory.createBlock([
+      t.factory.createReturnStatement(t.factory.createCallExpression(t.factory.createIdentifier(GET_ELEMENT), undefined, [
         t.factory.createThis(),
       ])),
     ])));
@@ -57055,7 +56730,7 @@ const getHydrateAttrsToReflect = (cmp) => {
 };
 
 const updateHydrateComponentClass = (classNode, moduleFile, cmp) => {
-  return t.updateClassDeclaration(classNode, classNode.decorators, classNode.modifiers, classNode.name, classNode.typeParameters, classNode.heritageClauses, updateHydrateHostComponentMembers(classNode, moduleFile, cmp));
+  return t.factory.updateClassDeclaration(classNode, classNode.decorators, classNode.modifiers, classNode.name, classNode.typeParameters, classNode.heritageClauses, updateHydrateHostComponentMembers(classNode, moduleFile, cmp));
 };
 const updateHydrateHostComponentMembers = (classNode, moduleFile, cmp) => {
   const classMembers = removeStaticMetaProperties(classNode);
@@ -57807,7 +57482,7 @@ const lazyComponentTransform = (compilerCtx, transformOpts) => {
       }
       tsSourceFile = addImports(transformOpts, tsSourceFile, moduleFile.coreRuntimeApis, transformOpts.coreImportPath);
       if (styleStatements.length > 0) {
-        tsSourceFile = t.updateSourceFileNode(tsSourceFile, [...tsSourceFile.statements, ...styleStatements]);
+        tsSourceFile = t.factory.updateSourceFile(tsSourceFile, [...tsSourceFile.statements, ...styleStatements]);
       }
       return tsSourceFile;
     };
@@ -58703,6 +58378,202 @@ const generateCustomDocs = async (config, docsData, outputTargets) => {
   }));
 };
 
+/**
+ * A new BuildCtx object is created for every build
+ * and rebuild.
+ */
+class BuildContext {
+  constructor(config, compilerCtx) {
+    this.buildId = -1;
+    this.buildMessages = [];
+    this.buildResults = null;
+    this.bundleBuildCount = 0;
+    this.collections = [];
+    this.completedTasks = [];
+    this.components = [];
+    this.componentGraph = new Map();
+    this.data = {};
+    this.buildStats = undefined;
+    this.diagnostics = [];
+    this.dirsAdded = [];
+    this.dirsDeleted = [];
+    this.entryModules = [];
+    this.filesAdded = [];
+    this.filesChanged = [];
+    this.filesDeleted = [];
+    this.filesUpdated = [];
+    this.filesWritten = [];
+    this.globalStyle = undefined;
+    this.hasConfigChanges = false;
+    this.hasFinished = false;
+    this.hasHtmlChanges = false;
+    this.hasPrintedResults = false;
+    this.hasServiceWorkerChanges = false;
+    this.hasScriptChanges = true;
+    this.hasStyleChanges = true;
+    this.hydrateAppFilePath = null;
+    this.indexBuildCount = 0;
+    this.indexDoc = undefined;
+    this.isRebuild = false;
+    this.moduleFiles = [];
+    this.outputs = [];
+    this.packageJson = {};
+    this.packageJsonFilePath = null;
+    this.pendingCopyTasks = [];
+    this.requiresFullBuild = true;
+    this.scriptsAdded = [];
+    this.scriptsDeleted = [];
+    this.startTime = Date.now();
+    this.styleBuildCount = 0;
+    this.stylesPromise = null;
+    this.stylesUpdated = [];
+    this.timeSpan = null;
+    this.transpileBuildCount = 0;
+    this.config = config;
+    this.compilerCtx = compilerCtx;
+    this.buildId = ++this.compilerCtx.activeBuildId;
+    this.debug = config.logger.debug.bind(config.logger);
+  }
+  start() {
+    // get the build id from the incremented activeBuildId
+    // print out a good message
+    const msg = `${this.isRebuild ? 'rebuild' : 'build'}, ${this.config.fsNamespace}, ${this.config.devMode ? 'dev' : 'prod'} mode, started`;
+    const buildLog = {
+      buildId: this.buildId,
+      messages: [],
+      progress: 0,
+    };
+    this.compilerCtx.events.emit('buildLog', buildLog);
+    // create a timespan for this build
+    this.timeSpan = this.createTimeSpan(msg);
+    // create a build timestamp for this build
+    this.timestamp = getBuildTimestamp();
+    // debug log our new build
+    this.debug(`start build, ${this.timestamp}`);
+    const buildStart = {
+      buildId: this.buildId,
+      timestamp: this.timestamp,
+    };
+    this.compilerCtx.events.emit('buildStart', buildStart);
+  }
+  createTimeSpan(msg, debug) {
+    if (!this.hasFinished || debug) {
+      if (debug) {
+        if (this.config.watch) {
+          msg = `${this.config.logger.cyan('[' + this.buildId + ']')} ${msg}`;
+        }
+      }
+      const timeSpan = this.config.logger.createTimeSpan(msg, debug, this.buildMessages);
+      if (!debug && this.compilerCtx.events) {
+        const buildLog = {
+          buildId: this.buildId,
+          messages: this.buildMessages,
+          progress: getProgress(this.completedTasks),
+        };
+        this.compilerCtx.events.emit('buildLog', buildLog);
+      }
+      return {
+        duration: () => {
+          return timeSpan.duration();
+        },
+        finish: (finishedMsg, color, bold, newLineSuffix) => {
+          if (!this.hasFinished || debug) {
+            if (debug) {
+              if (this.config.watch) {
+                finishedMsg = `${this.config.logger.cyan('[' + this.buildId + ']')} ${finishedMsg}`;
+              }
+            }
+            timeSpan.finish(finishedMsg, color, bold, newLineSuffix);
+            if (!debug) {
+              const buildLog = {
+                buildId: this.buildId,
+                messages: this.buildMessages.slice(),
+                progress: getProgress(this.completedTasks),
+              };
+              this.compilerCtx.events.emit('buildLog', buildLog);
+            }
+          }
+          return timeSpan.duration();
+        },
+      };
+    }
+    return {
+      duration() {
+        return 0;
+      },
+      finish() {
+        return 0;
+      },
+    };
+  }
+  debug(msg) {
+    this.config.logger.debug(msg);
+  }
+  get hasError() {
+    return hasError(this.diagnostics);
+  }
+  get hasWarning() {
+    return hasWarning(this.diagnostics);
+  }
+  progress(t) {
+    this.completedTasks.push(t);
+  }
+  async validateTypesBuild() {
+    if (this.hasError) {
+      // no need to wait on this one since
+      // we already aborted this build
+      return;
+    }
+    if (!this.validateTypesPromise) {
+      // there is no pending validate types promise
+      // so it probably already finished
+      // so no need to wait on anything
+      return;
+    }
+    if (!this.config.watch) {
+      // this is not a watch build, so we need to make
+      // sure that the type validation has finished
+      this.debug(`build, non-watch, waiting on validateTypes`);
+      await this.validateTypesPromise;
+      this.debug(`build, non-watch, finished waiting on validateTypes`);
+    }
+  }
+}
+/**
+ * Generate a timestamp of the format `YYYY-MM-DDThh:mm:ss`, using the number of seconds that have elapsed since
+ * January 01, 1970, and the time this function was called
+ * @returns the generated timestamp
+ */
+const getBuildTimestamp = () => {
+  const d = new Date();
+  // YYYY-MM-DDThh:mm:ss
+  let timestamp = d.getUTCFullYear() + '-';
+  timestamp += ('0' + (d.getUTCMonth() + 1)).slice(-2) + '-';
+  timestamp += ('0' + d.getUTCDate()).slice(-2) + 'T';
+  timestamp += ('0' + d.getUTCHours()).slice(-2) + ':';
+  timestamp += ('0' + d.getUTCMinutes()).slice(-2) + ':';
+  timestamp += ('0' + d.getUTCSeconds()).slice(-2);
+  return timestamp;
+};
+const getProgress = (completedTasks) => {
+  let progressIndex = 0;
+  const taskKeys = Object.keys(ProgressTask);
+  taskKeys.forEach((taskKey, index) => {
+    if (completedTasks.includes(ProgressTask[taskKey])) {
+      progressIndex = index;
+    }
+  });
+  return (progressIndex + 1) / taskKeys.length;
+};
+const ProgressTask = {
+  emptyOutputTargets: {},
+  transpileApp: {},
+  generateStyles: {},
+  generateOutputTargets: {},
+  validateTypesBuild: {},
+  writeBuildFiles: {},
+};
+
 const AUTO_GENERATE_COMMENT = `<!-- Auto Generated Below -->`;
 const NOTE = `*Built with [StencilJS](https://stenciljs.com/)*`;
 
@@ -61391,7 +61262,7 @@ const styleToStatic = (newMembers, componentOptions) => {
       // @Component({
       //   styles: ":host {...}"
       // })
-      newMembers.push(createStaticGetter('styles', t.createLiteral(styles)));
+      newMembers.push(createStaticGetter('styles', t.factory.createStringLiteral(styles)));
     }
   }
   else if (componentOptions.styles) {
@@ -61568,7 +61439,7 @@ const elementDecoratorsToStatic = (diagnostics, decoratedMembers, typeChecker, n
     .map((prop) => parseElementDecorator(diagnostics, typeChecker, prop))
     .filter((element) => !!element);
   if (elementRefs.length > 0) {
-    newMembers.push(createStaticGetter('elementRef', t.createLiteral(elementRefs[0])));
+    newMembers.push(createStaticGetter('elementRef', t.factory.createStringLiteral(elementRefs[0])));
     if (elementRefs.length > 1) {
       const error = buildError(diagnostics);
       error.messageText = `It's not valid to add more than one Element() decorator`;
@@ -62380,7 +62251,7 @@ const parseMethodDecorator = (config, diagnostics, tsSourceFile, typeChecker, me
     },
   };
   validateReferences(diagnostics, methodMeta.complexType.references, method.type || method.name);
-  const staticProp = t.factory.createPropertyAssignment(t.createLiteral(methodName), convertValueToLiteral(methodMeta));
+  const staticProp = t.factory.createPropertyAssignment(t.factory.createStringLiteral(methodName), convertValueToLiteral(methodMeta));
   return staticProp;
 };
 const isTypePromise = (typeStr) => {
@@ -62471,7 +62342,7 @@ const parsePropDecorator = (diagnostics, typeChecker, prop, watchable) => {
   if (initializer) {
     propMeta.defaultValue = initializer.getText();
   }
-  const staticProp = t.factory.createPropertyAssignment(t.createLiteral(propName), convertValueToLiteral(propMeta));
+  const staticProp = t.factory.createPropertyAssignment(t.factory.createStringLiteral(propName), convertValueToLiteral(propMeta));
   watchable.add(propName);
   return staticProp;
 };
@@ -62729,7 +62600,7 @@ const visitClassDeclaration = (config, diagnostics, typeChecker, classNode) => {
   // class' constructor which instantiate them there instead.
   const updatedClassFields = handleClassFields(classNode, filteredMethodsAndFields);
   validateMethods(diagnostics, classMembers);
-  return t.updateClassDeclaration(classNode, filterDecorators(classNode, CLASS_DECORATORS_TO_REMOVE), classNode.modifiers, classNode.name, classNode.typeParameters, classNode.heritageClauses, updatedClassFields);
+  return t.factory.updateClassDeclaration(classNode, filterDecorators(classNode, CLASS_DECORATORS_TO_REMOVE), classNode.modifiers, classNode.name, classNode.typeParameters, classNode.heritageClauses, updatedClassFields);
 };
 /**
  * Take a list of `ClassElement` AST nodes and remove any decorators from
@@ -62753,7 +62624,7 @@ const removeStencilMethodDecorators = (classMembers, diagnostics) => {
     const newDecorators = filterDecorators(member, MEMBER_DECORATORS_TO_REMOVE);
     if (currentDecorators !== newDecorators) {
       if (t.isMethodDeclaration(member)) {
-        return t.updateMethod(member, newDecorators, member.modifiers, member.asteriskToken, member.name, member.questionToken, member.typeParameters, member.parameters, member.type, member.body);
+        return t.factory.updateMethodDeclaration(member, newDecorators, member.modifiers, member.asteriskToken, member.name, member.questionToken, member.typeParameters, member.parameters, member.type, member.body);
       }
       else if (t.isPropertyDeclaration(member)) {
         if (shouldInitializeInConstructor(member)) {
@@ -62766,7 +62637,7 @@ const removeStencilMethodDecorators = (classMembers, diagnostics) => {
         }
         else {
           // update the property to remove decorators
-          return t.updateProperty(member, newDecorators, member.modifiers, member.name, member.questionToken, member.type, member.initializer);
+          return t.factory.updatePropertyDeclaration(member, newDecorators, member.modifiers, member.name, member.questionToken, member.type, member.initializer);
         }
       }
       else {
@@ -62965,14 +62836,29 @@ function handleClassFields(classNode, classMembers) {
  * @returns a list of updated class elements
  */
 const updateConstructor = (classNode, classMembers, statements) => {
+  var _a, _b, _c;
   const constructorIndex = classMembers.findIndex((m) => m.kind === t.SyntaxKind.Constructor);
   const constructorMethod = classMembers[constructorIndex];
   if (constructorIndex >= 0 && t.isConstructorDeclaration(constructorMethod)) {
-    const hasSuper = constructorMethod.body.statements.some((s) => s.kind === t.SyntaxKind.SuperKeyword);
+    const constructorBodyStatements = (_b = (_a = constructorMethod.body) === null || _a === void 0 ? void 0 : _a.statements) !== null && _b !== void 0 ? _b : t.factory.createNodeArray();
+    const hasSuper = constructorBodyStatements.some((s) => s.kind === t.SyntaxKind.SuperKeyword);
     if (!hasSuper && needsSuper(classNode)) {
-      statements = [createConstructorBodyWithSuper(), ...statements];
+      // if there is no super and it needs one the statements comprising the
+      // body of the constructor should be:
+      //
+      // 1. the `super()` call
+      // 2. the new statements we've created to initialize fields
+      // 3. the statements currently comprising the body of the constructor
+      statements = [createConstructorBodyWithSuper(), ...statements, ...constructorBodyStatements];
     }
-    classMembers[constructorIndex] = t.factory.updateConstructorDeclaration(constructorMethod, constructorMethod.decorators, constructorMethod.modifiers, constructorMethod.parameters, t.factory.updateBlock(constructorMethod.body, statements));
+    else {
+      // if no super is needed then the body of the constructor should be:
+      //
+      // 1. the new statements we've created to initialize fields
+      // 2. the statements currently comprising the body of the constructor
+      statements = [...statements, ...constructorBodyStatements];
+    }
+    classMembers[constructorIndex] = t.factory.updateConstructorDeclaration(constructorMethod, constructorMethod.decorators, constructorMethod.modifiers, constructorMethod.parameters, t.factory.updateBlock((_c = constructorMethod === null || constructorMethod === void 0 ? void 0 : constructorMethod.body) !== null && _c !== void 0 ? _c : t.factory.createBlock([]), statements));
   }
   else {
     // we don't seem to have a constructor, so let's create one and stick it
@@ -62981,7 +62867,7 @@ const updateConstructor = (classNode, classMembers, statements) => {
       statements = [createConstructorBodyWithSuper(), ...statements];
     }
     classMembers = [
-      t.factory.createConstructorDeclaration(undefined, undefined, undefined, t.factory.createBlock(statements, true)),
+      t.factory.createConstructorDeclaration(undefined, undefined, [], t.factory.createBlock(statements, true)),
       ...classMembers,
     ];
   }
@@ -63175,7 +63061,7 @@ const addComponentMetaStatic = (cmpNode, cmpMeta) => {
   const publicCompilerMeta = getPublicCompilerMeta(cmpMeta);
   const cmpMetaStaticProp = createStaticGetter('COMPILER_META', convertValueToLiteral(publicCompilerMeta));
   const classMembers = [...cmpNode.members, cmpMetaStaticProp];
-  return t.updateClassDeclaration(cmpNode, cmpNode.decorators, cmpNode.modifiers, cmpNode.name, cmpNode.typeParameters, cmpNode.heritageClauses, classMembers);
+  return t.factory.updateClassDeclaration(cmpNode, cmpNode.decorators, cmpNode.modifiers, cmpNode.name, cmpNode.typeParameters, cmpNode.heritageClauses, classMembers);
 };
 const getPublicCompilerMeta = (cmpMeta) => {
   const publicCompilerMeta = Object.assign({}, cmpMeta);
@@ -65081,6 +64967,157 @@ const createFullBuild = async (config, compilerCtx) => {
   });
 };
 
+const compilerRequest = async (config, compilerCtx, data) => {
+  const results = {
+    path: data.path,
+    nodeModuleId: null,
+    nodeModuleVersion: null,
+    nodeResolvedPath: null,
+    cachePath: null,
+    cacheHit: false,
+    content: '',
+    status: 404,
+  };
+  try {
+    const parsedUrl = parseDevModuleUrl(config, data.path);
+    Object.assign(results, parsedUrl);
+    if (parsedUrl.nodeModuleId) {
+      if (!parsedUrl.nodeModuleVersion) {
+        results.content = `/* invalid module version */`;
+        results.status = 400;
+        return results;
+      }
+      if (!parsedUrl.nodeResolvedPath) {
+        results.content = `/* invalid resolved path */`;
+        results.status = 400;
+        return results;
+      }
+      const useCache = await useDevModuleCache(config, parsedUrl.nodeResolvedPath);
+      let cachePath = null;
+      if (useCache) {
+        cachePath = getDevModuleCachePath(config, parsedUrl);
+        const cachedContent = await config.sys.readFile(cachePath);
+        if (typeof cachedContent === 'string') {
+          results.content = cachedContent;
+          results.cachePath = cachePath;
+          results.cacheHit = true;
+          results.status = 200;
+          return results;
+        }
+      }
+      await bundleDevModule(config, compilerCtx, parsedUrl, results);
+      if (results.status === 200 && useCache) {
+        results.cachePath = cachePath;
+        writeCachedFile(config, results);
+      }
+    }
+    else {
+      results.content = `/* invalid dev module */`;
+      results.status = 400;
+      return results;
+    }
+  }
+  catch (e) {
+    if (e) {
+      if (e instanceof Error && e.stack) {
+        results.content = `/*\n${e.stack}\n*/`;
+      }
+      else {
+        results.content = `/*\n${e}\n*/`;
+      }
+    }
+    results.status = 500;
+  }
+  return results;
+};
+const bundleDevModule = async (config, compilerCtx, parsedUrl, results) => {
+  const buildCtx = new BuildContext(config, compilerCtx);
+  try {
+    const inputOpts = getRollupOptions(config, compilerCtx, buildCtx, {
+      id: parsedUrl.nodeModuleId,
+      platform: 'client',
+      inputs: {
+        index: parsedUrl.nodeResolvedPath,
+      },
+    });
+    const rollupBuild = await rollup(inputOpts);
+    const outputOpts = {
+      banner: generatePreamble(config),
+      format: 'es',
+    };
+    if (parsedUrl.nodeModuleId) {
+      const commentPath = relative$1(config.rootDir, parsedUrl.nodeResolvedPath);
+      outputOpts.intro = `/**\n * Dev Node Module: ${parsedUrl.nodeModuleId}, v${parsedUrl.nodeModuleVersion}\n * Entry: ${commentPath}\n * DEVELOPMENT PURPOSES ONLY!!\n */`;
+      inputOpts.input = parsedUrl.nodeResolvedPath;
+    }
+    const r = await rollupBuild.generate(outputOpts);
+    if (buildCtx.hasError) {
+      results.status = 500;
+      results.content = `console.error(${JSON.stringify(buildCtx.diagnostics)})`;
+    }
+    else if (r && r.output && r.output.length > 0) {
+      results.content = r.output[0].code;
+      results.status = 200;
+    }
+  }
+  catch (e) {
+    results.status = 500;
+    const errorMsg = e instanceof Error ? e.stack : e + '';
+    results.content = `console.error(${JSON.stringify(errorMsg)})`;
+  }
+};
+const useDevModuleCache = async (config, p) => {
+  if (config.enableCache) {
+    for (let i = 0; i < 10; i++) {
+      const n = basename(p);
+      if (n === 'node_modules') {
+        return true;
+      }
+      const isSymbolicLink = await config.sys.isSymbolicLink(p);
+      if (isSymbolicLink) {
+        return false;
+      }
+      p = dirname(p);
+    }
+  }
+  return false;
+};
+const writeCachedFile = async (config, results) => {
+  try {
+    await config.sys.createDir(config.cacheDir);
+    config.sys.writeFile(results.cachePath, results.content);
+  }
+  catch (e) {
+    console.error(e);
+  }
+};
+const parseDevModuleUrl = (config, u) => {
+  const parsedUrl = {
+    nodeModuleId: null,
+    nodeModuleVersion: null,
+    nodeResolvedPath: null,
+  };
+  if (u && u.includes(DEV_MODULE_DIR) && u.endsWith('.js')) {
+    const url = new URL(u, 'https://stenciljs.com');
+    let reqPath = basename(url.pathname);
+    reqPath = reqPath.substring(0, reqPath.length - 3);
+    const splt = reqPath.split('@');
+    if (splt.length === 2) {
+      parsedUrl.nodeModuleId = decodeURIComponent(splt[0]);
+      parsedUrl.nodeModuleVersion = decodeURIComponent(splt[1]);
+      parsedUrl.nodeResolvedPath = url.searchParams.get('p');
+      if (parsedUrl.nodeResolvedPath) {
+        parsedUrl.nodeResolvedPath = decodeURIComponent(parsedUrl.nodeResolvedPath);
+        parsedUrl.nodeResolvedPath = join(config.rootDir, parsedUrl.nodeResolvedPath);
+      }
+    }
+  }
+  return parsedUrl;
+};
+const getDevModuleCachePath = (config, parsedUrl) => {
+  return join(config.cacheDir, `dev_module_${parsedUrl.nodeModuleId}_${parsedUrl.nodeModuleVersion}_${DEV_MODULE_CACHE_BUSTER}.log`);
+};
+
 const filesChanged = (buildCtx) => {
   // files changed include updated, added and deleted
   return unique([...buildCtx.filesUpdated, ...buildCtx.filesAdded, ...buildCtx.filesDeleted]).sort();
@@ -68017,7 +68054,7 @@ const validateTesting = (config, diagnostics) => {
       return join(testing.rootDir, ignorePattern);
     });
     ((_a = config.outputTargets) !== null && _a !== void 0 ? _a : [])
-      .filter((o) => (isOutputTargetDist(o) || isOutputTargetWww(o)) && o.dir)
+      .filter((o) => (isOutputTargetDist(o) || isOutputTargetWww(o)) && !!o.dir)
       .forEach((outputTarget) => {
       var _a;
       (_a = testing.testPathIgnorePatterns) === null || _a === void 0 ? void 0 : _a.push(outputTarget.dir);
@@ -69089,7 +69126,7 @@ const getComponentPathContent = (componentGraph, outputTarget) => {
 const dependencies = [
 	{
 		name: "@stencil/core",
-		version: "2.19.1-0",
+		version: "2.19.2-0",
 		main: "compiler/stencil.js",
 		resources: [
 			"package.json",