@stencil/core 2.10.0 → 2.11.0-0

package/compiler/stencil.js

@@ -1,5 +1,5 @@
 /*!
- Stencil Compiler v2.10.0 | MIT Licensed | https://stenciljs.com
+ Stencil Compiler v2.11.0-0 | MIT Licensed | https://stenciljs.com
  */
 (function(exports) {
 'use strict';
@@ -1645,6 +1645,11 @@ const parseJson = (jsonStr, filePath) => {
 const SKIP_DEPS = ['@stencil/core'];
 
 // MODULE: utils/validation.js
+/**
+ * Validates that a component tag meets required naming conventions to be used for a web component
+ * @param tag the tag to validate
+ * @returns an error message if the tag has an invalid name, undefined if the tag name passes all checks
+ */
 const validateComponentTag = (tag) => {
   if (tag !== tag.trim()) {
     return `Tag can not contain white spaces`;
@@ -3967,7 +3972,7 @@ const createCustomResolverAsync = (sys, inMemoryFs, exts) => {
 };
 
 // MODULE: version.js
-const buildId = '20211101165355';
+const buildId = '20211109214411';
 const minfyJsId = 'terser5.6.1_7';
 const optimizeCssId = 'autoprefixer10.2.5_postcss8.2.8_7';
 const parse5Version = '6.0.1';
@@ -3975,8 +3980,8 @@ const rollupVersion = '2.42.3';
 const sizzleVersion = '2.42.3';
 const terserVersion = '5.6.1';
 const typescriptVersion = '4.3.5';
-const vermoji = '🦁';
-const version$3 = '2.10.0';
+const vermoji = '🚟';
+const version$3 = '2.11.0-0';
 const versions = {
   stencil: version$3,
   parse5: parse5Version,
@@ -11091,6 +11096,7 @@ const extractCommentsWithHash = (input) => {
 };
 const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
 const _curlyRe = /([{}])/g;
+const _selectorPartsRe = /(^.*?[^\\])??((:+)(.*)|$)/;
 const OPEN_CURLY = '{';
 const CLOSE_CURLY = '}';
 const BLOCK_PLACEHOLDER = '%BLOCK%';
@@ -11243,17 +11249,18 @@ const selectorNeedsScoping = (selector, scopeSelector) => {
   const re = makeScopeMatcher(scopeSelector);
   return !re.test(selector);
 };
+const injectScopingSelector = (selector, scopingSelector) => {
+  return selector.replace(_selectorPartsRe, (_, before = '', _colonGroup, colon = '', after = '') => {
+    return before + scopingSelector + colon + after;
+  });
+};
 const applySimpleSelectorScope = (selector, scopeSelector, hostSelector) => {
   // In Android browser, the lastIndex is not reset when the regex is used in String.replace()
   _polyfillHostRe.lastIndex = 0;
   if (_polyfillHostRe.test(selector)) {
     const replaceBy = `.${hostSelector}`;
     return selector
-      .replace(_polyfillHostNoCombinatorRe, (_, selector) => {
-      return selector.replace(/([^:]*)(:*)(.*)/, (_, before, colon, after) => {
-        return before + replaceBy + colon + after;
-      });
-    })
+      .replace(_polyfillHostNoCombinatorRe, (_, selector) => injectScopingSelector(selector, replaceBy))
       .replace(_polyfillHostRe, replaceBy + ' ');
   }
   return scopeSelector + ' ' + selector;
@@ -11274,10 +11281,7 @@ const applyStrictSelectorScope = (selector, scopeSelector, hostSelector) => {
       // remove :host since it should be unnecessary
       const t = p.replace(_polyfillHostRe, '');
       if (t.length > 0) {
-        const matches = t.match(/([^:]*)(:*)(.*)/);
-        if (matches) {
-          scopedP = matches[1] + className + matches[2] + matches[3];
-        }
+        scopedP = injectScopingSelector(t, className);
       }
     }
     return scopedP;
@@ -54999,11 +55003,11 @@ const updateNativeHostComponentHeritageClauses = (classNode, moduleFile) => {
   if (classNode.heritageClauses != null && classNode.heritageClauses.length > 0) {
     return classNode.heritageClauses;
   }
-  if (moduleFile.cmps.length > 1) {
+  if (moduleFile.cmps.length >= 1) {
     addCoreRuntimeApi(moduleFile, RUNTIME_APIS.HTMLElement);
   }
-  const heritageClause = t.createHeritageClause(t.SyntaxKind.ExtendsKeyword, [
-    t.createExpressionWithTypeArguments([], t.createIdentifier(HTML_ELEMENT)),
+  const heritageClause = t.factory.createHeritageClause(t.SyntaxKind.ExtendsKeyword, [
+    t.factory.createExpressionWithTypeArguments(t.factory.createIdentifier(HTML_ELEMENT), []),
   ]);
   return [heritageClause];
 };
@@ -55241,6 +55245,9 @@ const createCustomElementsDefineCase = (tagName, actionExpression) => {
  * Add the main `defineCustomElement` function e.g.
  * ```javascript
  * function defineCustomElement() {
+ *  if (typeof customElements === 'undefined') {
+ *  return;
+ *  }
  *  const components = ['my-component'];
  *   components.forEach(tagName => {
  *   switch (tagName) {
@@ -55261,6 +55268,7 @@ const createCustomElementsDefineCase = (tagName, actionExpression) => {
  */
 const addDefineCustomElementFunction = (tagNames, newStatements, caseStatements) => {
   const newExpression = t.factory.createFunctionDeclaration(undefined, [t.factory.createModifier(t.SyntaxKind.ExportKeyword)], undefined, t.factory.createIdentifier('defineCustomElement'), undefined, undefined, undefined, t.factory.createBlock([
+    t.factory.createIfStatement(t.factory.createStrictEquality(t.factory.createTypeOfExpression(t.factory.createIdentifier('customElements')), t.factory.createStringLiteral('undefined')), t.factory.createBlock([t.factory.createReturnStatement()])),
     t.factory.createVariableStatement(undefined, t.factory.createVariableDeclarationList([
       t.factory.createVariableDeclaration('components', undefined, undefined, t.factory.createArrayLiteralExpression(tagNames.map((tagName) => t.factory.createStringLiteral(tagName)))),
     ], t.NodeFlags.Const)),
@@ -57155,195 +57163,6 @@ const outputHydrateScript = async (config, compilerCtx, buildCtx) => {
   }
 };
 
-// MODULE: compiler/html/used-components.js
-const getUsedComponents = (doc, cmps) => {
-  const tags = new Set(cmps.map((cmp) => cmp.tagName.toUpperCase()));
-  const found = [];
-  const searchComponents = (el) => {
-    if (tags.has(el.tagName)) {
-      found.push(el.tagName.toLowerCase());
-    }
-    for (let i = 0; i < el.childElementCount; i++) {
-      searchComponents(el.children[i]);
-    }
-  };
-  searchComponents(doc.documentElement);
-  return found;
-};
-
-// MODULE: compiler/entries/default-bundles.js
-function getDefaultBundles(config, buildCtx, cmps) {
-  const userConfigEntryPoints = getUserConfigBundles(config, buildCtx, cmps);
-  if (userConfigEntryPoints.length > 0) {
-    return userConfigEntryPoints;
-  }
-  let entryPointsHints = config.entryComponentsHint;
-  if (!entryPointsHints && buildCtx.indexDoc) {
-    entryPointsHints = getUsedComponents(buildCtx.indexDoc, cmps);
-  }
-  if (!entryPointsHints) {
-    return [];
-  }
-  const mainBundle = unique([
-    ...entryPointsHints,
-    ...flatOne(entryPointsHints.map(resolveTag).map((cmp) => cmp.dependencies)),
-  ]).map(resolveTag);
-  function resolveTag(tag) {
-    return cmps.find((cmp) => cmp.tagName === tag);
-  }
-  return [mainBundle];
-}
-function getUserConfigBundles(config, buildCtx, cmps) {
-  const definedTags = new Set();
-  const entryTags = config.bundles.map((b) => {
-    return b.components
-      .map((tag) => {
-      const tagError = validateComponentTag(tag);
-      if (tagError) {
-        const err = buildError(buildCtx.diagnostics);
-        err.header = `Stencil Config`;
-        err.messageText = tagError;
-      }
-      const component = cmps.find((cmp) => cmp.tagName === tag);
-      if (!component) {
-        const warn = buildWarn(buildCtx.diagnostics);
-        warn.header = `Stencil Config`;
-        warn.messageText = `Component tag "${tag}" is defined in a bundle but no matching component was found within this app or its collections.`;
-      }
-      if (definedTags.has(tag)) {
-        const warn = buildWarn(buildCtx.diagnostics);
-        warn.header = `Stencil Config`;
-        warn.messageText = `Component tag "${tag}" has been defined multiple times in the "bundles" config.`;
-      }
-      definedTags.add(tag);
-      return component;
-    })
-      .sort();
-  });
-  return entryTags;
-}
-
-// MODULE: compiler/entries/component-bundles.js
-function computeUsedComponents(config, defaultBundles, allCmps) {
-  if (!config.excludeUnusedDependencies) {
-    return new Set(allCmps.map((c) => c.tagName));
-  }
-  const usedComponents = new Set();
-  // All components
-  defaultBundles.forEach((entry) => {
-    entry.forEach((cmp) => usedComponents.add(cmp.tagName));
-  });
-  allCmps.forEach((cmp) => {
-    if (!cmp.isCollectionDependency) {
-      usedComponents.add(cmp.tagName);
-    }
-  });
-  allCmps.forEach((cmp) => {
-    if (cmp.isCollectionDependency) {
-      if (cmp.dependents.some((dep) => usedComponents.has(dep))) {
-        usedComponents.add(cmp.tagName);
-      }
-    }
-  });
-  return usedComponents;
-}
-function generateComponentBundles(config, buildCtx) {
-  const cmps = sortBy(buildCtx.components, (cmp) => cmp.dependents.length);
-  const defaultBundles = getDefaultBundles(config, buildCtx, cmps);
-  const usedComponents = computeUsedComponents(config, defaultBundles, cmps);
-  if (config.devMode) {
-    return cmps.filter((c) => usedComponents.has(c.tagName)).map((cmp) => [cmp]);
-  }
-  // Visit components that are already in one of the default bundlers
-  const alreadyBundled = new Set();
-  defaultBundles.forEach((entry) => {
-    entry.forEach((cmp) => alreadyBundled.add(cmp));
-  });
-  const bundlers = cmps
-    .filter((cmp) => usedComponents.has(cmp.tagName) && !alreadyBundled.has(cmp))
-    .map((c) => [c]);
-  return [...defaultBundles, ...optimizeBundlers(bundlers, 0.6)].filter((b) => b.length > 0);
-}
-function optimizeBundlers(bundles, threshold) {
-  const cmpIndexMap = new Map();
-  bundles.forEach((entry, index) => {
-    entry.forEach((cmp) => {
-      cmpIndexMap.set(cmp.tagName, index);
-    });
-  });
-  const visited = new Uint8Array(bundles.length);
-  const matrix = bundles.map((entry) => {
-    const vector = new Uint8Array(bundles.length);
-    entry.forEach((cmp) => {
-      cmp.dependents.forEach((tag) => {
-        const index = cmpIndexMap.get(tag);
-        if (index !== undefined) {
-          vector[index] = 1;
-        }
-      });
-    });
-    entry.forEach((cmp) => {
-      const index = cmpIndexMap.get(cmp.tagName);
-      if (index !== undefined) {
-        vector[index] = 0;
-      }
-    });
-    return vector;
-  });
-  // resolve similar components
-  const newBundles = [];
-  for (let i = 0; i < matrix.length; i++) {
-    // check if bundle is visited (0 means it's not)
-    if (visited[i] === 0) {
-      const bundle = [...bundles[i]];
-      visited[i] = 1;
-      for (let j = i + 1; j < matrix.length; j++) {
-        if (visited[j] === 0 && computeScore(matrix[i], matrix[j]) >= threshold) {
-          bundle.push(...bundles[j]);
-          visited[j] = 1;
-        }
-      }
-      newBundles.push(bundle);
-    }
-  }
-  return newBundles;
-}
-function computeScore(m0, m1) {
-  let total = 0;
-  let match = 0;
-  for (let i = 0; i < m0.length; i++) {
-    if (m0[i] === 1 || m1[i] === 1) {
-      total++;
-      if (m0[i] === m1[i]) {
-        match++;
-      }
-    }
-  }
-  return match / total;
-}
-
-// MODULE: compiler/entries/entry-modules.js
-function generateEntryModules(config, buildCtx) {
-  // figure out how modules and components connect
-  try {
-    const bundles = generateComponentBundles(config, buildCtx);
-    buildCtx.entryModules = bundles.map(createEntryModule);
-  }
-  catch (e) {
-    catchError(buildCtx.diagnostics, e);
-  }
-  buildCtx.debug(`generateEntryModules, ${buildCtx.entryModules.length} entryModules`);
-}
-function createEntryModule(cmps) {
-  // generate a unique entry key based on the components within this entry module
-  cmps = sortBy(cmps, (c) => c.tagName);
-  const entryKey = cmps.map((c) => c.tagName).join('.') + '.entry';
-  return {
-    cmps,
-    entryKey,
-  };
-}
-
 // MODULE: compiler/output-targets/dist-lazy/lazy-build-conditionals.js
 const getLazyBuildConditionals = (config, cmps) => {
   const build = getBuildFeatures(cmps);
@@ -57882,6 +57701,258 @@ const generateModuleGraph = (cmps, bundleModules) => {
   return cmpMap;
 };
 
+// MODULE: compiler/html/used-components.js
+/**
+ * Scan the provided `doc` for any known Stencil components
+ * @param doc the Document to scan
+ * @param cmps the compiler metadata of known Stencil components
+ * @returns a list of all tags that were identified as known Stencil components
+ */
+const getUsedComponents = (doc, cmps) => {
+  const tags = new Set(cmps.map((cmp) => cmp.tagName.toUpperCase()));
+  const found = [];
+  const searchComponents = (el) => {
+    if (tags.has(el.tagName)) {
+      found.push(el.tagName.toLowerCase());
+    }
+    for (let i = 0; i < el.childElementCount; i++) {
+      searchComponents(el.children[i]);
+    }
+  };
+  searchComponents(doc.documentElement);
+  return found;
+};
+
+// MODULE: compiler/entries/default-bundles.js
+/**
+ * Retrieve the component bundle groupings to be used when generating output
+ * @param config the Stencil configuration used for the build
+ * @param buildCtx the current build context
+ * @param cmps the components that have been registered & defined for the current build
+ * @returns the component bundling data
+ */
+function getDefaultBundles(config, buildCtx, cmps) {
+  // get all of the user defined bundles in the Stencil config file
+  const userConfigEntryPoints = getUserConfigBundles(config, buildCtx, cmps);
+  if (userConfigEntryPoints.length > 0) {
+    // prefer user defined entry points over anything else Stencil may derive
+    return userConfigEntryPoints;
+  }
+  let entryPointsHints = config.entryComponentsHint;
+  if (!entryPointsHints && buildCtx.indexDoc) {
+    // attempt to scan an HTML file for known Stencil components
+    entryPointsHints = getUsedComponents(buildCtx.indexDoc, cmps);
+  }
+  if (!entryPointsHints) {
+    return [];
+  }
+  const mainBundle = unique([
+    ...entryPointsHints,
+    ...flatOne(entryPointsHints.map(resolveTag).map((cmp) => cmp.dependencies)),
+  ]).map(resolveTag);
+  function resolveTag(tag) {
+    return cmps.find((cmp) => cmp.tagName === tag);
+  }
+  return [mainBundle];
+}
+/**
+ * Retrieve and validate the `bundles` field on a project's Stencil configuration file
+ * @param config the configuration file with a `bundles` field to inspect
+ * @param buildCtx the current build context
+ * @param cmps the components that have been registered & defined for the current build
+ * @returns a three dimensional array with the compiler metadata for each component used
+ */
+function getUserConfigBundles(config, buildCtx, cmps) {
+  const definedTags = new Set();
+  const entryTags = config.bundles.map((b) => {
+    return b.components
+      .map((tag) => {
+      const tagError = validateComponentTag(tag);
+      if (tagError) {
+        const err = buildError(buildCtx.diagnostics);
+        err.header = `Stencil Config`;
+        err.messageText = tagError;
+      }
+      const component = cmps.find((cmp) => cmp.tagName === tag);
+      if (!component) {
+        const warn = buildWarn(buildCtx.diagnostics);
+        warn.header = `Stencil Config`;
+        warn.messageText = `Component tag "${tag}" is defined in a bundle but no matching component was found within this app or its collections.`;
+      }
+      if (definedTags.has(tag)) {
+        const warn = buildWarn(buildCtx.diagnostics);
+        warn.header = `Stencil Config`;
+        warn.messageText = `Component tag "${tag}" has been defined multiple times in the "bundles" config.`;
+      }
+      definedTags.add(tag);
+      return component;
+    })
+      .sort();
+  });
+  return entryTags;
+}
+
+// MODULE: compiler/entries/component-bundles.js
+/**
+ * Generate a list of all component tags that will be used by the output
+ * @param config the Stencil configuration used for the build
+ * @param defaultBundles metadata of the assumed components being used/bundled
+ * @param allCmps all known components
+ * @returns a set of all component tags that are used
+ */
+function computeUsedComponents(config, defaultBundles, allCmps) {
+  if (!config.excludeUnusedDependencies) {
+    // the user/config has specified that Stencil should use all the dependencies it's found, return the set of all
+    // known tags
+    return new Set(allCmps.map((c) => c.tagName));
+  }
+  const usedComponents = new Set();
+  // All components
+  defaultBundles.forEach((entry) => {
+    entry.forEach((cmp) => usedComponents.add(cmp.tagName));
+  });
+  allCmps.forEach((cmp) => {
+    if (!cmp.isCollectionDependency) {
+      usedComponents.add(cmp.tagName);
+    }
+  });
+  allCmps.forEach((cmp) => {
+    if (cmp.isCollectionDependency) {
+      if (cmp.dependents.some((dep) => usedComponents.has(dep))) {
+        usedComponents.add(cmp.tagName);
+      }
+    }
+  });
+  return usedComponents;
+}
+/**
+ * Generate the bundles that will be used during the bundling process
+ * @param config the Stencil configuration used for the build
+ * @param buildCtx the current build context
+ * @returns the bundles to be used during the bundling process
+ */
+function generateComponentBundles(config, buildCtx) {
+  const cmps = sortBy(buildCtx.components, (cmp) => cmp.dependents.length);
+  const defaultBundles = getDefaultBundles(config, buildCtx, cmps);
+  const usedComponents = computeUsedComponents(config, defaultBundles, cmps);
+  if (config.devMode) {
+    return cmps
+      .filter((c) => usedComponents.has(c.tagName))
+      .map((cmp) => [cmp]);
+  }
+  // Visit components that are already in one of the default bundlers
+  const alreadyBundled = new Set();
+  defaultBundles.forEach((entry) => {
+    entry.forEach((cmp) => alreadyBundled.add(cmp));
+  });
+  const bundlers = cmps
+    .filter((cmp) => usedComponents.has(cmp.tagName) && !alreadyBundled.has(cmp))
+    .map((c) => [c]);
+  return [...defaultBundles, ...optimizeBundlers(bundlers, 0.6)].filter((b) => b.length > 0);
+}
+/**
+ * Calculate and reorganize bundles based on a calculated similarity score between bundle entries
+ * @param bundles the bundles to reorganize
+ * @param threshold a numeric value used to determine whether or not bundles should be reorganized
+ * @returns the reorganized bundles
+ */
+function optimizeBundlers(bundles, threshold) {
+  /**
+   * build a mapping of component tag names in each `bundles` entry to the index where that entry occurs in `bundles`:
+   * ```ts
+   * bundles = [
+   *   [
+   *   {
+   *     tagName: 'my-foo', ...<other_fields>,
+   *   },
+   *   ],
+   *   [
+   *   {
+   *     tagName: 'my-bar', ...<other_fields>,
+   *   },
+   *   {
+   *     tagName: 'my-baz', ...<other_fields>,
+   *   },
+   *   ],
+   * ];
+   * // yields
+   * {
+   *   'my-foo': 0,
+   *   'my-bar': 1,
+   *   'my-baz': 1,
+   * }
+   * ```
+   * note that in the event of a component being found >1 time, store the index of the last entry in which it's found
+   */
+  const cmpIndexMap = new Map();
+  bundles.forEach((entry, index) => {
+    entry.forEach((cmp) => {
+      cmpIndexMap.set(cmp.tagName, index);
+    });
+  });
+  // build a record of components
+  const matrix = bundles.map((entry) => {
+    const vector = new Uint8Array(bundles.length);
+    entry.forEach((cmp) => {
+      // for each dependent of a component, check to see if the dependent has been seen already when the `cmpIndexMap`
+      // was originally built. If so, mark it with a '1'
+      cmp.dependents.forEach((tag) => {
+        const index = cmpIndexMap.get(tag);
+        if (index !== undefined) {
+          vector[index] = 1;
+        }
+      });
+    });
+    entry.forEach((cmp) => {
+      // for each entry, check to see if the component has been seen already when the `cmpIndexMap` was originally
+      // built. If so, mark it with a '0', potentially overriding a previously set value on the vector.
+      const index = cmpIndexMap.get(cmp.tagName);
+      if (index !== undefined) {
+        vector[index] = 0;
+      }
+    });
+    return vector;
+  });
+  // resolve similar components
+  const newBundles = [];
+  const visited = new Uint8Array(bundles.length);
+  for (let i = 0; i < matrix.length; i++) {
+    // check if bundle is visited (0 means it's not)
+    if (visited[i] === 0) {
+      const bundle = [...bundles[i]];
+      visited[i] = 1;
+      for (let j = i + 1; j < matrix.length; j++) {
+        if (visited[j] === 0 && computeScore(matrix[i], matrix[j]) >= threshold) {
+          bundle.push(...bundles[j]);
+          visited[j] = 1;
+        }
+      }
+      newBundles.push(bundle);
+    }
+  }
+  return newBundles;
+}
+/**
+ * Computes a 'score' between two arrays, that is defined as the number of times that the value at a given index is the
+ * same in both arrays divided by the number of times the value in either array is high at the given index.
+ * @param m0 the first array to calculate sameness with
+ * @param m1 the second array to calculate sameness with
+ * @returns the calculated score
+ */
+function computeScore(m0, m1) {
+  let total = 0;
+  let match = 0;
+  for (let i = 0; i < m0.length; i++) {
+    if (m0[i] === 1 || m1[i] === 1) {
+      total++;
+      if (m0[i] === m1[i]) {
+        match++;
+      }
+    }
+  }
+  return match / total;
+}
+
 // MODULE: compiler/output-targets/dist-lazy/lazy-output.js
 const outputLazy = async (config, compilerCtx, buildCtx) => {
   const outputTargets = config.outputTargets.filter(isOutputTargetDistLazy);
@@ -57964,6 +58035,36 @@ const getLazyCustomTransformer = (config, compilerCtx) => {
     removeCollectionImports(compilerCtx),
   ];
 };
+/**
+ * Generate entry modules to be used by the build process by determining how modules and components are connected
+ * @param config the Stencil configuration file that was provided as a part of the build step
+ * @param buildCtx the current build context
+ */
+function generateEntryModules(config, buildCtx) {
+  // figure out how modules and components connect
+  try {
+    const bundles = generateComponentBundles(config, buildCtx);
+    buildCtx.entryModules = bundles.map(createEntryModule);
+  }
+  catch (e) {
+    catchError(buildCtx.diagnostics, e);
+  }
+  buildCtx.debug(`generateEntryModules, ${buildCtx.entryModules.length} entryModules`);
+}
+/**
+ * Generates an entry module to be used during the bundling process
+ * @param cmps the component metadata to create a single entry module from
+ * @returns the entry module generated
+ */
+function createEntryModule(cmps) {
+  // generate a unique entry key based on the components within this entry module
+  cmps = sortBy(cmps, (c) => c.tagName);
+  const entryKey = cmps.map((c) => c.tagName).join('.') + '.entry';
+  return {
+    cmps,
+    entryKey,
+  };
+}
 const getLazyEntry = (isBrowser) => {
   const s = new MagicString$2(``);
   s.append(`import { bootstrapLazy } from '${STENCIL_CORE_ID}';\n`);
@@ -58604,7 +58705,39 @@ const generateIndexHtml = async (config, compilerCtx, buildCtx, criticalPath, ou
 };
 const MAX_CSS_INLINE_SIZE = 3 * 1024;
 
-// MODULE: compiler/output-targets/output-collection.js
+// MODULE: compiler/output-targets/dist-collection/index.js
+const outputCollection = async (config, compilerCtx, buildCtx, changedModuleFiles) => {
+  const outputTargets = config.outputTargets.filter(isOutputTargetDistCollection);
+  if (outputTargets.length === 0) {
+    return;
+  }
+  const bundlingEventMessage = `generate collections${config.sourceMap ? ' + source maps' : ''}`;
+  const timespan = buildCtx.createTimeSpan(`${bundlingEventMessage} started`, true);
+  try {
+    await Promise.all(changedModuleFiles.map(async (mod) => {
+      let code = mod.staticSourceFileText;
+      if (config.preamble) {
+        code = `${generatePreamble(config)}\n${code}`;
+      }
+      const mapCode = mod.sourceMapFileText;
+      await Promise.all(outputTargets.map(async (o) => {
+        const relPath = relative$1(config.srcDir, mod.jsFilePath);
+        const filePath = join(o.collectionDir, relPath);
+        await compilerCtx.fs.writeFile(filePath, code, { outputTargetType: o.type });
+        if (mod.sourceMapPath) {
+          const relativeSourceMapPath = relative$1(config.srcDir, mod.sourceMapPath);
+          const sourceMapOutputFilePath = join(o.collectionDir, relativeSourceMapPath);
+          await compilerCtx.fs.writeFile(sourceMapOutputFilePath, mapCode, { outputTargetType: o.type });
+        }
+      }));
+    }));
+    await writeCollectionManifests(config, compilerCtx, buildCtx, outputTargets);
+  }
+  catch (e) {
+    catchError(buildCtx.diagnostics, e);
+  }
+  timespan.finish(`${bundlingEventMessage} finished`);
+};
 const writeCollectionManifests = async (config, compilerCtx, buildCtx, outputTargets) => {
   const collectionData = JSON.stringify(serializeCollectionManifest(config, compilerCtx, buildCtx), null, 2);
   return Promise.all(outputTargets.map((o) => writeCollectionManifest(compilerCtx, collectionData, o)));
@@ -58656,40 +58789,6 @@ const serializeCollectionDependencies = (compilerCtx) => {
   return sortBy(collectionDeps, (item) => item.name);
 };
 
-// MODULE: compiler/output-targets/dist-collection/index.js
-const outputCollection = async (config, compilerCtx, buildCtx, changedModuleFiles) => {
-  const outputTargets = config.outputTargets.filter(isOutputTargetDistCollection);
-  if (outputTargets.length === 0) {
-    return;
-  }
-  const bundlingEventMessage = `generate collections${config.sourceMap ? ' + source maps' : ''}`;
-  const timespan = buildCtx.createTimeSpan(`${bundlingEventMessage} started`, true);
-  try {
-    await Promise.all(changedModuleFiles.map(async (mod) => {
-      let code = mod.staticSourceFileText;
-      if (config.preamble) {
-        code = `${generatePreamble(config)}\n${code}`;
-      }
-      const mapCode = mod.sourceMapFileText;
-      await Promise.all(outputTargets.map(async (o) => {
-        const relPath = relative$1(config.srcDir, mod.jsFilePath);
-        const filePath = join(o.collectionDir, relPath);
-        await compilerCtx.fs.writeFile(filePath, code, { outputTargetType: o.type });
-        if (mod.sourceMapPath) {
-          const relativeSourceMapPath = relative$1(config.srcDir, mod.sourceMapPath);
-          const sourceMapOutputFilePath = join(o.collectionDir, relativeSourceMapPath);
-          await compilerCtx.fs.writeFile(sourceMapOutputFilePath, mapCode, { outputTargetType: o.type });
-        }
-      }));
-    }));
-    await writeCollectionManifests(config, compilerCtx, buildCtx, outputTargets);
-  }
-  catch (e) {
-    catchError(buildCtx.diagnostics, e);
-  }
-  timespan.finish(`${bundlingEventMessage} finished`);
-};
-
 // MODULE: compiler/types/stencil-types.js
 const updateStencilTypesImports = (typesDir, dtsFilePath, dtsContent) => {
   const dir = dirname(dtsFilePath);
@@ -63818,7 +63917,7 @@ const getComponentPathContent = (componentGraph, outputTarget) => {
 const dependencies = [
 	{
 		name: "@stencil/core",
-		version: "2.10.0",
+		version: "2.11.0-0",
 		main: "compiler/stencil.js",
 		resources: [
 			"package.json",