@stencil/core 2.17.4 → 2.18.1

package/cli/index.cjs

@@ -1,5 +1,5 @@
 /*!
- Stencil CLI (CommonJS) v2.17.4 | MIT Licensed | https://stenciljs.com
+ Stencil CLI (CommonJS) v2.18.1 | MIT Licensed | https://stenciljs.com
  */
 'use strict';
 
@@ -25,29 +25,6 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
-/**
- * This sets the log level hierarchy for our terminal logger, ranging from
- * most to least verbose.
- *
- * Ordering the levels like this lets us easily check whether we should log a
- * message at a given time. For instance, if the log level is set to `'warn'`,
- * then anything passed to the logger with level `'warn'` or `'error'` should
- * be logged, but we should _not_ log anything with level `'info'` or `'debug'`.
- *
- * If we have a current log level `currentLevel` and a message with level
- * `msgLevel` is passed to the logger, we can determine whether or not we should
- * log it by checking if the log level on the message is further up or at the
- * same level in the hierarchy than `currentLevel`, like so:
- *
- * ```ts
- * LOG_LEVELS.indexOf(msgLevel) >= LOG_LEVELS.indexOf(currentLevel)
- * ```
- *
- * NOTE: for the reasons described above, do not change the order of the entries
- * in this array without good reason!
- */
-const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
-
 /**
  * Convert a string from PascalCase to dash-case
  *
@@ -223,18 +200,18 @@ const getEncodedRootLength = (path) => {
         return 0;
     const ch0 = path.charCodeAt(0);
     // POSIX or UNC
-    if (ch0 === 47 /* slash */ || ch0 === 92 /* backslash */) {
+    if (ch0 === 47 /* CharacterCodes.slash */ || ch0 === 92 /* CharacterCodes.backslash */) {
         if (path.charCodeAt(1) !== ch0)
             return 1; // POSIX: "/" (or non-normalized "\")
-        const p1 = path.indexOf(ch0 === 47 /* slash */ ? '/' : altDirectorySeparator, 2);
+        const p1 = path.indexOf(ch0 === 47 /* CharacterCodes.slash */ ? '/' : altDirectorySeparator, 2);
         if (p1 < 0)
             return path.length; // UNC: "//server" or "\\server"
         return p1 + 1; // UNC: "//server/" or "\\server\"
     }
     // DOS
-    if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58 /* colon */) {
+    if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58 /* CharacterCodes.colon */) {
         const ch2 = path.charCodeAt(2);
-        if (ch2 === 47 /* slash */ || ch2 === 92 /* backslash */)
+        if (ch2 === 47 /* CharacterCodes.slash */ || ch2 === 92 /* CharacterCodes.backslash */)
             return 3; // DOS: "c:/" or "c:\"
         if (path.length === 2)
             return 2; // DOS: "c:" (but not "c:d")
@@ -256,7 +233,7 @@ const getEncodedRootLength = (path) => {
                 isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
                 const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
                 if (volumeSeparatorEnd !== -1) {
-                    if (path.charCodeAt(volumeSeparatorEnd) === 47 /* slash */) {
+                    if (path.charCodeAt(volumeSeparatorEnd) === 47 /* CharacterCodes.slash */) {
                         // URL: "file:///c:/", "file://localhost/c:/", "file:///c%3a/", "file://localhost/c%3a/"
                         return ~(volumeSeparatorEnd + 1);
                     }
@@ -274,15 +251,15 @@ const getEncodedRootLength = (path) => {
     // relative
     return 0;
 };
-const isVolumeCharacter = (charCode) => (charCode >= 97 /* a */ && charCode <= 122 /* z */) ||
-    (charCode >= 65 /* A */ && charCode <= 90 /* Z */);
+const isVolumeCharacter = (charCode) => (charCode >= 97 /* CharacterCodes.a */ && charCode <= 122 /* CharacterCodes.z */) ||
+    (charCode >= 65 /* CharacterCodes.A */ && charCode <= 90 /* CharacterCodes.Z */);
 const getFileUrlVolumeSeparatorEnd = (url, start) => {
     const ch0 = url.charCodeAt(start);
-    if (ch0 === 58 /* colon */)
+    if (ch0 === 58 /* CharacterCodes.colon */)
         return start + 1;
-    if (ch0 === 37 /* percent */ && url.charCodeAt(start + 1) === 51 /* _3 */) {
+    if (ch0 === 37 /* CharacterCodes.percent */ && url.charCodeAt(start + 1) === 51 /* CharacterCodes._3 */) {
         const ch2 = url.charCodeAt(start + 2);
-        if (ch2 === 97 /* a */ || ch2 === 65 /* A */)
+        if (ch2 === 97 /* CharacterCodes.a */ || ch2 === 65 /* CharacterCodes.A */)
             return start + 3;
     }
     return -1;
@@ -297,6 +274,22 @@ const pathComponents = (path, rootLength) => {
     return [root, ...rest];
 };
 
+/**
+ * Check whether a string is a member of a ReadonlyArray<string>
+ *
+ * We need a little helper for this because unfortunately `includes` is typed
+ * on `ReadonlyArray<T>` as `(el: T): boolean` so a `string` cannot be passed
+ * to `includes` on a `ReadonlyArray` 😢 thus we have a little helper function
+ * where we do the type coercion just once.
+ *
+ * see microsoft/TypeScript#31018 for some discussion of this
+ *
+ * @param readOnlyArray the array we're checking
+ * @param maybeMember a value which is possibly a member of the array
+ * @returns whether the array contains the member or not
+ */
+const readOnlyArrayHasStringMember = (readOnlyArray, maybeMember) => readOnlyArray.includes(maybeMember);
+
 /**
  * Validates that a component tag meets required naming conventions to be used for a web component
  * @param tag the tag to validate
@@ -341,6 +334,29 @@ const validateComponentTag = (tag) => {
     return undefined;
 };
 
+/**
+ * This sets the log level hierarchy for our terminal logger, ranging from
+ * most to least verbose.
+ *
+ * Ordering the levels like this lets us easily check whether we should log a
+ * message at a given time. For instance, if the log level is set to `'warn'`,
+ * then anything passed to the logger with level `'warn'` or `'error'` should
+ * be logged, but we should _not_ log anything with level `'info'` or `'debug'`.
+ *
+ * If we have a current log level `currentLevel` and a message with level
+ * `msgLevel` is passed to the logger, we can determine whether or not we should
+ * log it by checking if the log level on the message is further up or at the
+ * same level in the hierarchy than `currentLevel`, like so:
+ *
+ * ```ts
+ * LOG_LEVELS.indexOf(msgLevel) >= LOG_LEVELS.indexOf(currentLevel)
+ * ```
+ *
+ * NOTE: for the reasons described above, do not change the order of the entries
+ * in this array without good reason!
+ */
+const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+
 /**
  * All the Boolean options supported by the Stencil CLI
  */
@@ -818,18 +834,12 @@ const parseEqualsArg = (arg) => {
  * @param maybeLogLevel the string to check
  * @returns whether this is a `LogLevel`
  */
-const isLogLevel = (maybeLogLevel) => 
-// unfortunately `includes` is typed on `ReadonlyArray<T>` as `(el: T):
-// boolean` so a `string` cannot be passed to `includes` on a
-// `ReadonlyArray` 😢 thus we `as any`
-//
-// see microsoft/TypeScript#31018 for some discussion of this
-LOG_LEVELS.includes(maybeLogLevel);
+const isLogLevel = (maybeLogLevel) => readOnlyArrayHasStringMember(LOG_LEVELS, maybeLogLevel);
 
 const dependencies = [
 	{
 		name: "@stencil/core",
-		version: "2.17.4",
+		version: "2.18.1",
 		main: "compiler/stencil.js",
 		resources: [
 			"package.json",
@@ -871,8 +881,10 @@ const dependencies = [
 			"compiler/lib.es2019.symbol.d.ts",
 			"compiler/lib.es2020.bigint.d.ts",
 			"compiler/lib.es2020.d.ts",
+			"compiler/lib.es2020.date.d.ts",
 			"compiler/lib.es2020.full.d.ts",
 			"compiler/lib.es2020.intl.d.ts",
+			"compiler/lib.es2020.number.d.ts",
 			"compiler/lib.es2020.promise.d.ts",
 			"compiler/lib.es2020.sharedmemory.d.ts",
 			"compiler/lib.es2020.string.d.ts",
@@ -883,6 +895,13 @@ const dependencies = [
 			"compiler/lib.es2021.promise.d.ts",
 			"compiler/lib.es2021.string.d.ts",
 			"compiler/lib.es2021.weakref.d.ts",
+			"compiler/lib.es2022.array.d.ts",
+			"compiler/lib.es2022.d.ts",
+			"compiler/lib.es2022.error.d.ts",
+			"compiler/lib.es2022.full.d.ts",
+			"compiler/lib.es2022.intl.d.ts",
+			"compiler/lib.es2022.object.d.ts",
+			"compiler/lib.es2022.string.d.ts",
 			"compiler/lib.es5.d.ts",
 			"compiler/lib.es6.d.ts",
 			"compiler/lib.esnext.d.ts",
@@ -932,11 +951,107 @@ const dependencies = [
 	},
 	{
 		name: "typescript",
-		version: "4.5.4",
+		version: "4.7.4",
 		main: "lib/typescript.js"
 	}
 ];
 
+const IS_NODE_ENV = typeof global !== 'undefined' &&
+    typeof require === 'function' &&
+    !!global.process &&
+    typeof __filename === 'string' &&
+    (!global.origin || typeof global.origin !== 'string');
+const IS_BROWSER_ENV = typeof location !== 'undefined' && typeof navigator !== 'undefined' && typeof XMLHttpRequest !== 'undefined';
+
+/**
+ * Creates an instance of a logger
+ * @returns the new logger instance
+ */
+const createLogger = () => {
+    let useColors = IS_BROWSER_ENV;
+    let level = 'info';
+    return {
+        enableColors: (uc) => (useColors = uc),
+        getLevel: () => level,
+        setLevel: (l) => (level = l),
+        emoji: (e) => e,
+        info: console.log.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+        debug: console.debug.bind(console),
+        red: (msg) => msg,
+        green: (msg) => msg,
+        yellow: (msg) => msg,
+        blue: (msg) => msg,
+        magenta: (msg) => msg,
+        cyan: (msg) => msg,
+        gray: (msg) => msg,
+        bold: (msg) => msg,
+        dim: (msg) => msg,
+        bgRed: (msg) => msg,
+        createTimeSpan: (_startMsg, _debug = false) => ({
+            duration: () => 0,
+            finish: () => 0,
+        }),
+        printDiagnostics(diagnostics) {
+            diagnostics.forEach((diagnostic) => logDiagnostic(diagnostic, useColors));
+        },
+    };
+};
+const logDiagnostic = (diagnostic, useColors) => {
+    let color = BLUE;
+    let prefix = 'Build';
+    let msg = '';
+    if (diagnostic.level === 'error') {
+        color = RED;
+        prefix = 'Error';
+    }
+    else if (diagnostic.level === 'warn') {
+        color = YELLOW;
+        prefix = 'Warning';
+    }
+    if (diagnostic.header) {
+        prefix = diagnostic.header;
+    }
+    const filePath = diagnostic.relFilePath || diagnostic.absFilePath;
+    if (filePath) {
+        msg += filePath;
+        if (typeof diagnostic.lineNumber === 'number' && diagnostic.lineNumber > 0) {
+            msg += ', line ' + diagnostic.lineNumber;
+            if (typeof diagnostic.columnNumber === 'number' && diagnostic.columnNumber > 0) {
+                msg += ', column ' + diagnostic.columnNumber;
+            }
+        }
+        msg += '\n';
+    }
+    msg += diagnostic.messageText;
+    if (diagnostic.lines && diagnostic.lines.length > 0) {
+        diagnostic.lines.forEach((l) => {
+            msg += '\n' + l.lineNumber + ':  ' + l.text;
+        });
+        msg += '\n';
+    }
+    if (useColors) {
+        const styledPrefix = [
+            '%c' + prefix,
+            `background: ${color}; color: white; padding: 2px 3px; border-radius: 2px; font-size: 0.8em;`,
+        ];
+        console.log(...styledPrefix, msg);
+    }
+    else if (diagnostic.level === 'error') {
+        console.error(msg);
+    }
+    else if (diagnostic.level === 'warn') {
+        console.warn(msg);
+    }
+    else {
+        console.log(msg);
+    }
+};
+const YELLOW = `#f39c12`;
+const RED = `#c0392b`;
+const BLUE = `#3498db`;
+
 /**
  * Attempt to find a Stencil configuration file on the file system
  * @param opts the options needed to find the configuration file
@@ -945,11 +1060,7 @@ const dependencies = [
 const findConfig = async (opts) => {
     const sys = opts.sys;
     const cwd = sys.getCurrentDirectory();
-    const results = {
-        configPath: null,
-        rootDir: normalizePath(cwd),
-        diagnostics: [],
-    };
+    const rootDir = normalizePath(cwd);
     let configPath = opts.configPath;
     if (isString(configPath)) {
         if (!sys.platformPath.isAbsolute(configPath)) {
@@ -964,8 +1075,13 @@ const findConfig = async (opts) => {
     }
     else {
         // nothing was passed in, use the current working directory
-        configPath = results.rootDir;
+        configPath = rootDir;
     }
+    const results = {
+        configPath,
+        rootDir: normalizePath(cwd),
+        diagnostics: [],
+    };
     const stat = await sys.stat(configPath);
     if (stat.error) {
         const diagnostic = buildError(results.diagnostics);
@@ -998,12 +1114,33 @@ const loadCoreCompiler = async (sys) => {
     return globalThis.stencil;
 };
 
+/**
+ * Log the name of this package (`@stencil/core`) to an output stream
+ *
+ * The output stream is determined by the {@link Logger} instance that is provided as an argument to this function
+ *
+ * The name of the package may not be logged, by design, for certain `task` types and logging levels
+ *
+ * @param logger the logging entity to use to output the name of the package
+ * @param task the current task
+ */
 const startupLog = (logger, task) => {
     if (task === 'info' || task === 'serve' || task === 'version') {
         return;
     }
     logger.info(logger.cyan(`@stencil/core`));
 };
+/**
+ * Log this package's version to an output stream
+ *
+ * The output stream is determined by the {@link Logger} instance that is provided as an argument to this function
+ *
+ * The package version may not be logged, by design, for certain `task` types and logging levels
+ *
+ * @param logger the logging entity to use for output
+ * @param task the current task
+ * @param coreCompiler the compiler instance to derive version information from
+ */
 const startupLogVersion = (logger, task, coreCompiler) => {
     if (task === 'info' || task === 'serve' || task === 'version') {
         return;
@@ -1019,11 +1156,25 @@ const startupLogVersion = (logger, task, coreCompiler) => {
     startupMsg += logger.emoji(' ' + coreCompiler.vermoji);
     logger.info(startupMsg);
 };
+/**
+ * Log details from a {@link CompilerSystem} used by Stencil to an output stream
+ *
+ * The output stream is determined by the {@link Logger} instance that is provided as an argument to this function
+ *
+ * @param sys the `CompilerSystem` to report details on
+ * @param logger the logging entity to use for output
+ * @param flags user set flags for the current invocation of Stencil
+ * @param coreCompiler the compiler instance being used for this invocation of Stencil
+ */
 const loadedCompilerLog = (sys, logger, flags, coreCompiler) => {
     const sysDetails = sys.details;
     const runtimeInfo = `${sys.name} ${sys.version}`;
-    const platformInfo = `${sysDetails.platform}, ${sysDetails.cpuModel}`;
-    const statsInfo = `cpus: ${sys.hardwareConcurrency}, freemem: ${Math.round(sysDetails.freemem() / 1000000)}MB, totalmem: ${Math.round(sysDetails.totalmem / 1000000)}MB`;
+    const platformInfo = sysDetails
+        ? `${sysDetails.platform}, ${sysDetails.cpuModel}`
+        : `Unknown Platform, Unknown CPU Model`;
+    const statsInfo = sysDetails
+        ? `cpus: ${sys.hardwareConcurrency}, freemem: ${Math.round(sysDetails.freemem() / 1000000)}MB, totalmem: ${Math.round(sysDetails.totalmem / 1000000)}MB`
+        : 'Unknown CPU Core Count, Unknown Memory';
     if (logger.getLevel() === 'debug') {
         logger.debug(runtimeInfo);
         logger.debug(platformInfo);
@@ -1037,6 +1188,14 @@ const loadedCompilerLog = (sys, logger, flags, coreCompiler) => {
         logger.info(statsInfo);
     }
 };
+/**
+ * Log various warnings to an output stream
+ *
+ * The output stream is determined by the {@link Logger} instance attached to the `config` argument to this function
+ *
+ * @param coreCompiler the compiler instance being used for this invocation of Stencil
+ * @param config a validated configuration object to be used for this run of Stencil
+ */
 const startupCompilerLog = (coreCompiler, config) => {
     if (config.suppressLogs === true) {
         return;
@@ -1058,6 +1217,21 @@ const startupCompilerLog = (coreCompiler, config) => {
     }
 };
 
+const startCheckVersion = async (config, currentVersion) => {
+    if (config.devMode && !config.flags.ci && !currentVersion.includes('-dev.') && isFunction(config.sys.checkVersion)) {
+        return config.sys.checkVersion(config.logger, currentVersion);
+    }
+    return null;
+};
+const printCheckVersionResults = async (versionChecker) => {
+    if (versionChecker) {
+        const checkVersionResults = await versionChecker;
+        if (isFunction(checkVersionResults)) {
+            checkVersionResults();
+        }
+    }
+};
+
 const taskPrerender = async (coreCompiler, config) => {
     startupCompilerLog(coreCompiler, config);
     const hydrateAppFilePath = config.flags.unknownArgs[0];
@@ -1089,21 +1263,6 @@ const runPrerenderTask = async (coreCompiler, config, hydrateAppFilePath, compon
     return diagnostics;
 };
 
-const startCheckVersion = async (config, currentVersion) => {
-    if (config.devMode && !config.flags.ci && !currentVersion.includes('-dev.') && isFunction(config.sys.checkVersion)) {
-        return config.sys.checkVersion(config.logger, currentVersion);
-    }
-    return null;
-};
-const printCheckVersionResults = async (versionChecker) => {
-    if (versionChecker) {
-        const checkVersionResults = await versionChecker;
-        if (isFunction(checkVersionResults)) {
-            checkVersionResults();
-        }
-    }
-};
-
 const taskWatch = async (coreCompiler, config) => {
     let devServer = null;
     let exitCode = 0;
@@ -1150,6 +1309,15 @@ const taskWatch = async (coreCompiler, config) => {
     }
 };
 
+const isOutputTargetHydrate = (o) => o.type === DIST_HYDRATE_SCRIPT;
+const isOutputTargetDocs = (o) => o.type === DOCS_README || o.type === DOCS_JSON || o.type === DOCS_CUSTOM || o.type === DOCS_VSCODE;
+const DIST_HYDRATE_SCRIPT = 'dist-hydrate-script';
+const DOCS_CUSTOM = 'docs-custom';
+const DOCS_JSON = 'docs-json';
+const DOCS_README = 'docs-readme';
+const DOCS_VSCODE = 'docs-vscode';
+const WWW = 'www';
+
 const tryFn = async (fn, ...args) => {
     try {
         return await fn(...args);
@@ -1163,7 +1331,7 @@ const isInteractive = (sys, flags, object) => {
     const terminalInfo = object ||
         Object.freeze({
             tty: sys.isTTY() ? true : false,
-            ci: ['CI', 'BUILD_ID', 'BUILD_NUMBER', 'BITBUCKET_COMMIT', 'CODEBUILD_BUILD_ARN'].filter((v) => !!sys.getEnvironmentVar(v)).length > 0 || !!flags.ci,
+            ci: ['CI', 'BUILD_ID', 'BUILD_NUMBER', 'BITBUCKET_COMMIT', 'CODEBUILD_BUILD_ARN'].filter((v) => { var _a; return !!((_a = sys.getEnvironmentVar) === null || _a === void 0 ? void 0 : _a.call(sys, v)); }).length > 0 || !!flags.ci,
         });
     return terminalInfo.tty && !terminalInfo.ci;
 };
@@ -1192,7 +1360,7 @@ async function readJson(sys, path) {
  * @returns true if --debug has been passed, otherwise false
  */
 function hasDebug(flags) {
-    return flags.debug;
+    return !!flags.debug;
 }
 /**
  * Does the command have the verbose and debug flags?
@@ -1200,18 +1368,7 @@ function hasDebug(flags) {
  * @returns true if both --debug and --verbose have been passed, otherwise false
  */
 function hasVerbose(flags) {
-    return flags.verbose && hasDebug(flags);
-}
-
-/**
- * Used to determine if tracking should occur.
- * @param config The config passed into the Stencil command
- * @param sys The system where the command is invoked
- * @param ci whether or not the process is running in a Continuous Integration (CI) environment
- * @returns true if telemetry should be sent, false otherwise
- */
-async function shouldTrack(config, sys, ci) {
-    return !ci && isInteractive(sys, config.flags) && (await checkTelemetry(sys));
+    return !!flags.verbose && hasDebug(flags);
 }
 
 const isTest$1 = () => process.env.JEST_WORKER_ID !== undefined;
@@ -1232,7 +1389,7 @@ async function readConfig(sys) {
         };
         await writeConfig(sys, config);
     }
-    else if (!UUID_REGEX.test(config['tokens.telemetry'])) {
+    else if (!config['tokens.telemetry'] || !UUID_REGEX.test(config['tokens.telemetry'])) {
         const newUuid = uuidv4();
         await writeConfig(sys, { ...config, 'tokens.telemetry': newUuid });
         config['tokens.telemetry'] = newUuid;
@@ -1268,14 +1425,16 @@ async function updateConfig(sys, newOptions) {
     return await writeConfig(sys, Object.assign(config, newOptions));
 }
 
-const isOutputTargetHydrate = (o) => o.type === DIST_HYDRATE_SCRIPT;
-const isOutputTargetDocs = (o) => o.type === DOCS_README || o.type === DOCS_JSON || o.type === DOCS_CUSTOM || o.type === DOCS_VSCODE;
-const DIST_HYDRATE_SCRIPT = 'dist-hydrate-script';
-const DOCS_CUSTOM = 'docs-custom';
-const DOCS_JSON = 'docs-json';
-const DOCS_README = 'docs-readme';
-const DOCS_VSCODE = 'docs-vscode';
-const WWW = 'www';
+/**
+ * Used to determine if tracking should occur.
+ * @param config The config passed into the Stencil command
+ * @param sys The system where the command is invoked
+ * @param ci whether or not the process is running in a Continuous Integration (CI) environment
+ * @returns true if telemetry should be sent, false otherwise
+ */
+async function shouldTrack(config, sys, ci) {
+    return !ci && isInteractive(sys, config.flags) && (await checkTelemetry(sys));
+}
 
 /**
  * Used to within taskBuild to provide the component_count property.
@@ -1286,11 +1445,11 @@ const WWW = 'www';
  * @param result The results of a compiler build.
  */
 async function telemetryBuildFinishedAction(sys, config, coreCompiler, result) {
-    const tracking = await shouldTrack(config, sys, config.flags.ci);
+    const tracking = await shouldTrack(config, sys, !!config.flags.ci);
     if (!tracking) {
         return;
     }
-    const component_count = Object.keys(result.componentGraph).length;
+    const component_count = result.componentGraph ? Object.keys(result.componentGraph).length : undefined;
     const data = await prepareData(coreCompiler, config, sys, result.duration, component_count);
     await sendMetric(sys, config, 'stencil_cli_command', data);
     config.logger.debug(`${config.logger.blue('Telemetry')}: ${config.logger.gray(JSON.stringify(data))}`);
@@ -1369,15 +1528,16 @@ function getActiveTargets(config) {
  * @returns a Promise wrapping data for the telemetry endpoint
  */
 const prepareData = async (coreCompiler, config, sys, duration_ms, component_count = undefined) => {
+    var _a, _b, _c;
     const { typescript, rollup } = coreCompiler.versions || { typescript: 'unknown', rollup: 'unknown' };
     const { packages, packagesNoVersions } = await getInstalledPackages(sys, config);
     const targets = getActiveTargets(config);
     const yarn = isUsingYarn(sys);
     const stencil = coreCompiler.version || 'unknown';
     const system = `${sys.name} ${sys.version}`;
-    const os_name = sys.details.platform;
-    const os_version = sys.details.release;
-    const cpu_model = sys.details.cpuModel;
+    const os_name = (_a = sys.details) === null || _a === void 0 ? void 0 : _a.platform;
+    const os_version = (_b = sys.details) === null || _b === void 0 ? void 0 : _b.release;
+    const cpu_model = (_c = sys.details) === null || _c === void 0 ? void 0 : _c.cpuModel;
     const build = coreCompiler.buildId || 'unknown';
     const has_app_pwa_config = hasAppTarget(config);
     const anonymizedConfig = anonymizeConfigForTelemetry(config);
@@ -1707,13 +1867,6 @@ const taskDocs = async (coreCompiler, config) => {
     await compiler.destroy();
 };
 
-const IS_NODE_ENV = typeof global !== 'undefined' &&
-    typeof require === 'function' &&
-    !!global.process &&
-    typeof __filename === 'string' &&
-    (!global.origin || typeof global.origin !== 'string');
-const IS_BROWSER_ENV = typeof location !== 'undefined' && typeof navigator !== 'undefined' && typeof XMLHttpRequest !== 'undefined';
-
 /**
  * Task to generate component boilerplate and write it to disk. This task can
  * cause the program to exit with an error under various circumstances, such as
@@ -1974,7 +2127,7 @@ const taskTelemetry = async (flags, sys, logger) => {
     const prompt = logger.dim(sys.details.platform === 'windows' ? '>' : '$');
     const isEnabling = flags.args.includes('on');
     const isDisabling = flags.args.includes('off');
-    const INFORMATION = `Opt in or our of telemetry. Information about the data we collect is available on our website: ${logger.bold('https://stenciljs.com/telemetry')}`;
+    const INFORMATION = `Opt in or out of telemetry. Information about the data we collect is available on our website: ${logger.bold('https://stenciljs.com/telemetry')}`;
     const THANK_YOU = `Thank you for helping to make Stencil better! 💖`;
     const ENABLED_MESSAGE = `${logger.green('Enabled')}. ${THANK_YOU}\n\n`;
     const DISABLED_MESSAGE = `${logger.red('Disabled')}\n\n`;
@@ -2105,32 +2258,32 @@ const taskTest = async (config) => {
         config.logger.error(`"test" command is currently only implemented for a NodeJS environment`);
         return config.sys.exit(1);
     }
-    try {
-        config.buildDocs = false;
-        const testingRunOpts = {
-            e2e: !!config.flags.e2e,
-            screenshot: !!config.flags.screenshot,
-            spec: !!config.flags.spec,
-            updateScreenshot: !!config.flags.updateScreenshot,
-        };
-        // always ensure we have jest modules installed
-        const ensureModuleIds = ['@types/jest', 'jest', 'jest-cli'];
-        if (testingRunOpts.e2e) {
-            // if it's an e2e test, also make sure we're got
-            // puppeteer modules installed and if browserExecutablePath is provided don't download Chromium use only puppeteer-core instead
-            const puppeteer = config.testing.browserExecutablePath ? 'puppeteer-core' : 'puppeteer';
-            ensureModuleIds.push(puppeteer);
-            if (testingRunOpts.screenshot) {
-                // ensure we've got pixelmatch for screenshots
-                config.logger.warn(config.logger.yellow(`EXPERIMENTAL: screenshot visual diff testing is currently under heavy development and has not reached a stable status. However, any assistance testing would be appreciated.`));
-            }
-        }
-        // ensure we've got the required modules installed
-        const diagnostics = await config.sys.lazyRequire.ensure(config.rootDir, ensureModuleIds);
-        if (diagnostics.length > 0) {
-            config.logger.printDiagnostics(diagnostics);
-            return config.sys.exit(1);
+    config.buildDocs = false;
+    const testingRunOpts = {
+        e2e: !!config.flags.e2e,
+        screenshot: !!config.flags.screenshot,
+        spec: !!config.flags.spec,
+        updateScreenshot: !!config.flags.updateScreenshot,
+    };
+    // always ensure we have jest modules installed
+    const ensureModuleIds = ['@types/jest', 'jest', 'jest-cli'];
+    if (testingRunOpts.e2e) {
+        // if it's an e2e test, also make sure we're got
+        // puppeteer modules installed and if browserExecutablePath is provided don't download Chromium use only puppeteer-core instead
+        const puppeteer = config.testing.browserExecutablePath ? 'puppeteer-core' : 'puppeteer';
+        ensureModuleIds.push(puppeteer);
+        if (testingRunOpts.screenshot) {
+            // ensure we've got pixelmatch for screenshots
+            config.logger.warn(config.logger.yellow(`EXPERIMENTAL: screenshot visual diff testing is currently under heavy development and has not reached a stable status. However, any assistance testing would be appreciated.`));
         }
+    }
+    // ensure we've got the required modules installed
+    const diagnostics = await config.sys.lazyRequire.ensure(config.rootDir, ensureModuleIds);
+    if (diagnostics.length > 0) {
+        config.logger.printDiagnostics(diagnostics);
+        return config.sys.exit(1);
+    }
+    try {
         // let's test!
         const { createTesting } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('../testing/index.js')); });
         const testing = await createTesting(config);
@@ -2146,95 +2299,6 @@ const taskTest = async (config) => {
     }
 };
 
-/**
- * Creates an instance of a logger
- * @returns the new logger instance
- */
-const createLogger = () => {
-    let useColors = IS_BROWSER_ENV;
-    let level = 'info';
-    return {
-        enableColors: (uc) => (useColors = uc),
-        getLevel: () => level,
-        setLevel: (l) => (level = l),
-        emoji: (e) => e,
-        info: console.log.bind(console),
-        warn: console.warn.bind(console),
-        error: console.error.bind(console),
-        debug: console.debug.bind(console),
-        red: (msg) => msg,
-        green: (msg) => msg,
-        yellow: (msg) => msg,
-        blue: (msg) => msg,
-        magenta: (msg) => msg,
-        cyan: (msg) => msg,
-        gray: (msg) => msg,
-        bold: (msg) => msg,
-        dim: (msg) => msg,
-        bgRed: (msg) => msg,
-        createTimeSpan: (_startMsg, _debug = false) => ({
-            duration: () => 0,
-            finish: () => 0,
-        }),
-        printDiagnostics(diagnostics) {
-            diagnostics.forEach((diagnostic) => logDiagnostic(diagnostic, useColors));
-        },
-    };
-};
-const logDiagnostic = (diagnostic, useColors) => {
-    let color = BLUE;
-    let prefix = 'Build';
-    let msg = '';
-    if (diagnostic.level === 'error') {
-        color = RED;
-        prefix = 'Error';
-    }
-    else if (diagnostic.level === 'warn') {
-        color = YELLOW;
-        prefix = 'Warning';
-    }
-    if (diagnostic.header) {
-        prefix = diagnostic.header;
-    }
-    const filePath = diagnostic.relFilePath || diagnostic.absFilePath;
-    if (filePath) {
-        msg += filePath;
-        if (typeof diagnostic.lineNumber === 'number' && diagnostic.lineNumber > 0) {
-            msg += ', line ' + diagnostic.lineNumber;
-            if (typeof diagnostic.columnNumber === 'number' && diagnostic.columnNumber > 0) {
-                msg += ', column ' + diagnostic.columnNumber;
-            }
-        }
-        msg += '\n';
-    }
-    msg += diagnostic.messageText;
-    if (diagnostic.lines && diagnostic.lines.length > 0) {
-        diagnostic.lines.forEach((l) => {
-            msg += '\n' + l.lineNumber + ':  ' + l.text;
-        });
-        msg += '\n';
-    }
-    if (useColors) {
-        const styledPrefix = [
-            '%c' + prefix,
-            `background: ${color}; color: white; padding: 2px 3px; border-radius: 2px; font-size: 0.8em;`,
-        ];
-        console.log(...styledPrefix, msg);
-    }
-    else if (diagnostic.level === 'error') {
-        console.error(msg);
-    }
-    else if (diagnostic.level === 'warn') {
-        console.warn(msg);
-    }
-    else {
-        console.log(msg);
-    }
-};
-const YELLOW = `#f39c12`;
-const RED = `#c0392b`;
-const BLUE = `#3498db`;
-
 const run = async (init) => {
     const { args, logger, sys } = init;
     try {
@@ -2249,7 +2313,7 @@ const run = async (init) => {
         if (isFunction(sys.applyGlobalPatch)) {
             sys.applyGlobalPatch(sys.getCurrentDirectory());
         }
-        if (task === 'help' || flags.help) {
+        if (!task || task === 'help' || flags.help) {
             await taskHelp(createConfigFlags({ task: 'help', args }), logger, sys);
             return;
         }
@@ -2318,15 +2382,16 @@ const run = async (init) => {
  * @public
  */
 const runTask = async (coreCompiler, config, task, sys) => {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
     const logger = (_a = config.logger) !== null && _a !== void 0 ? _a : createLogger();
     const strictConfig = {
         ...config,
         flags: createConfigFlags((_b = config.flags) !== null && _b !== void 0 ? _b : { task }),
         logger,
         outputTargets: (_c = config.outputTargets) !== null && _c !== void 0 ? _c : [],
-        sys: (_d = sys !== null && sys !== void 0 ? sys : config.sys) !== null && _d !== void 0 ? _d : coreCompiler.createSystem({ logger }),
-        testing: (_e = config.testing) !== null && _e !== void 0 ? _e : {},
+        rootDir: (_d = config.rootDir) !== null && _d !== void 0 ? _d : '/',
+        sys: (_e = sys !== null && sys !== void 0 ? sys : config.sys) !== null && _e !== void 0 ? _e : coreCompiler.createSystem({ logger }),
+        testing: (_f = config.testing) !== null && _f !== void 0 ? _f : {},
     };
     switch (task) {
         case 'build':