@stencil/cli 5.0.0-alpha.1

package/dist/index.mjs

@@ -0,0 +1,1832 @@
+import { LOG_LEVELS } from "@stencil/core/compiler";
+import { buildError, catchError, hasError, isFunction, isOutputTargetDocs, isOutputTargetHydrate, isOutputTargetWww, isString, normalizePath, readOnlyArrayHasStringMember, result, shouldIgnoreError, toCamelCase, validateComponentTag } from "@stencil/core/compiler/utils";
+import { join, parse, relative } from "path";
+import { start } from "@stencil/dev-server";
+//#region src/config-flags.ts
+/**
+* All the Boolean options supported by the Stencil CLI
+*/
+const BOOLEAN_CLI_FLAGS = [
+	"build",
+	"cache",
+	"checkVersion",
+	"ci",
+	"compare",
+	"debug",
+	"dev",
+	"devtools",
+	"docs",
+	"e2e",
+	"es5",
+	"esm",
+	"help",
+	"log",
+	"open",
+	"prerender",
+	"prerenderExternal",
+	"prod",
+	"profile",
+	"serviceWorker",
+	"screenshot",
+	"serve",
+	"skipNodeCheck",
+	"spec",
+	"ssr",
+	"updateScreenshot",
+	"verbose",
+	"version",
+	"watch",
+	"all",
+	"automock",
+	"bail",
+	"changedFilesWithAncestor",
+	"clearCache",
+	"clearMocks",
+	"collectCoverage",
+	"color",
+	"colors",
+	"coverage",
+	"detectLeaks",
+	"detectOpenHandles",
+	"errorOnDeprecated",
+	"expand",
+	"findRelatedTests",
+	"forceExit",
+	"init",
+	"injectGlobals",
+	"json",
+	"lastCommit",
+	"listTests",
+	"logHeapUsage",
+	"noStackTrace",
+	"notify",
+	"onlyChanged",
+	"onlyFailures",
+	"passWithNoTests",
+	"resetMocks",
+	"resetModules",
+	"restoreMocks",
+	"runInBand",
+	"runTestsByPath",
+	"showConfig",
+	"silent",
+	"skipFilter",
+	"testLocationInResults",
+	"updateSnapshot",
+	"useStderr",
+	"watchAll",
+	"watchman"
+];
+/**
+* All the Number options supported by the Stencil CLI
+*/
+const NUMBER_CLI_FLAGS = [
+	"port",
+	"maxConcurrency",
+	"testTimeout"
+];
+/**
+* All the String options supported by the Stencil CLI
+*/
+const STRING_CLI_FLAGS = [
+	"address",
+	"config",
+	"docsApi",
+	"docsJson",
+	"emulate",
+	"root",
+	"screenshotConnector",
+	"cacheDirectory",
+	"changedSince",
+	"collectCoverageFrom",
+	"coverageDirectory",
+	"coverageThreshold",
+	"env",
+	"filter",
+	"globalSetup",
+	"globalTeardown",
+	"globals",
+	"haste",
+	"moduleNameMapper",
+	"notifyMode",
+	"outputFile",
+	"preset",
+	"prettierPath",
+	"resolver",
+	"rootDir",
+	"runner",
+	"testEnvironment",
+	"testEnvironmentOptions",
+	"testFailureExitCode",
+	"testNamePattern",
+	"testResultsProcessor",
+	"testRunner",
+	"testSequencer",
+	"testURL",
+	"timers",
+	"transform"
+];
+const STRING_ARRAY_CLI_FLAGS = [
+	"collectCoverageOnlyFrom",
+	"coveragePathIgnorePatterns",
+	"coverageReporters",
+	"moduleDirectories",
+	"moduleFileExtensions",
+	"modulePathIgnorePatterns",
+	"modulePaths",
+	"projects",
+	"reporters",
+	"roots",
+	"selectProjects",
+	"setupFiles",
+	"setupFilesAfterEnv",
+	"snapshotSerializers",
+	"testMatch",
+	"testPathIgnorePatterns",
+	"testPathPattern",
+	"testRegex",
+	"transformIgnorePatterns",
+	"unmockedModulePathPatterns",
+	"watchPathIgnorePatterns"
+];
+/**
+* All the CLI arguments which may have string or number values
+*
+* `maxWorkers` is an argument which is used both by Stencil _and_ by Jest,
+* which means that we need to support parsing both string and number values.
+*/
+const STRING_NUMBER_CLI_FLAGS = ["maxWorkers"];
+/**
+* All the CLI arguments which may have boolean or string values.
+*/
+const BOOLEAN_STRING_CLI_FLAGS = ["headless", "stats"];
+/**
+* All the LogLevel-type options supported by the Stencil CLI
+*
+* This is a bit silly since there's only one such argument atm,
+* but this approach lets us make sure that we're handling all
+* our arguments in a type-safe way.
+*/
+const LOG_LEVEL_CLI_FLAGS = ["logLevel"];
+/**
+* For a small subset of CLI options we support a short alias e.g. `'h'` for `'help'`
+*/
+const CLI_FLAG_ALIASES = {
+	c: "config",
+	h: "help",
+	p: "port",
+	v: "version",
+	b: "bail",
+	e: "expand",
+	f: "onlyFailures",
+	i: "runInBand",
+	o: "onlyChanged",
+	t: "testNamePattern",
+	u: "updateSnapshot",
+	w: "maxWorkers"
+};
+/**
+* A regular expression which can be used to match a CLI flag for one of our
+* short aliases.
+*/
+const CLI_FLAG_REGEX = new RegExp(`^-[chpvbewofitu]{1}$`);
+/**
+* Helper function for initializing a `ConfigFlags` object. Provide any overrides
+* for default values and off you go!
+*
+* @param init an object with any overrides for default values
+* @returns a complete CLI flag object
+*/
+const createConfigFlags = (init = {}) => {
+	return {
+		task: null,
+		args: [],
+		knownArgs: [],
+		unknownArgs: [],
+		...init
+	};
+};
+//#endregion
+//#region src/parse-flags.ts
+/**
+* Parse command line arguments into a structured `ConfigFlags` object
+*
+* @param args an array of CLI flags
+* @returns a structured ConfigFlags object
+*/
+const parseFlags = (args) => {
+	const flags = createConfigFlags();
+	flags.args = Array.isArray(args) ? args.slice() : [];
+	if (flags.args.length > 0 && flags.args[0] && !flags.args[0].startsWith("-")) {
+		flags.task = flags.args[0];
+		parseArgs(flags, args.slice(1));
+	} else parseArgs(flags, flags.args);
+	if (flags.task != null) {
+		const i = flags.args.indexOf(flags.task);
+		if (i > -1) flags.args.splice(i, 1);
+	}
+	return flags;
+};
+/**
+* Parse the supported command line flags which are enumerated in the
+* `config-flags` module. Handles leading dashes on arguments, aliases that are
+* defined for a small number of arguments, and parsing values for non-boolean
+* arguments (e.g. port number for the dev server).
+*
+* This parses the following grammar:
+*
+* CLIArguments    → ""
+*                 | CLITerm ( " " CLITerm )* ;
+* CLITerm         → EqualsArg
+*                 | AliasEqualsArg
+*                 | AliasArg
+*                 | NegativeDashArg
+*                 | NegativeArg
+*                 | SimpleArg ;
+* EqualsArg       → "--" ArgName "=" CLIValue ;
+* AliasEqualsArg  → "-" AliasName "=" CLIValue ;
+* AliasArg        → "-" AliasName ( " " CLIValue )? ;
+* NegativeDashArg → "--no-" ArgName ;
+* NegativeArg     → "--no" ArgName ;
+* SimpleArg       → "--" ArgName ( " " CLIValue )? ;
+* ArgName         → /^[a-zA-Z-]+$/ ;
+* AliasName       → /^[a-z]{1}$/ ;
+* CLIValue        → '"' /^[a-zA-Z0-9]+$/ '"'
+*                 | /^[a-zA-Z0-9]+$/ ;
+*
+* There are additional constraints (not shown in the grammar for brevity's sake)
+* on the type of `CLIValue` which will be associated with a particular argument.
+* We enforce this by declaring lists of boolean, string, etc arguments and
+* checking the types of values before setting them.
+*
+* We don't need to turn the list of CLI arg tokens into any kind of
+* intermediate representation since we aren't concerned with doing anything
+* other than setting the correct values on our ConfigFlags object. So we just
+* parse the array of string arguments using a recursive-descent approach
+* (which is not very deep since our grammar is pretty simple) and make the
+* modifications we need to make to the {@link ConfigFlags} object as we go.
+*
+* @param flags a ConfigFlags object to which parsed arguments will be added
+* @param args  an array of command-line arguments to parse
+*/
+const parseArgs = (flags, args) => {
+	const argsCopy = args.concat();
+	while (argsCopy.length > 0) parseCLITerm(flags, argsCopy);
+};
+/**
+* Given an array of CLI arguments, parse it and perform a series of side
+* effects (setting values on the provided `ConfigFlags` object).
+*
+* @param flags a {@link ConfigFlags} object which is updated as we parse the CLI
+* arguments
+* @param args a list of args to work through. This function (and some functions
+* it calls) calls `Array.prototype.shift` to get the next argument to look at,
+* so this parameter will be modified.
+*/
+const parseCLITerm = (flags, args) => {
+	const arg = args.shift();
+	if (arg === void 0) return;
+	const isNegatedBoolean = !readOnlyArrayHasStringMember(BOOLEAN_CLI_FLAGS, normalizeFlagName(arg)) && readOnlyArrayHasStringMember(BOOLEAN_CLI_FLAGS, normalizeNegativeFlagName(arg));
+	const isNegatedBooleanOrString = !readOnlyArrayHasStringMember(BOOLEAN_STRING_CLI_FLAGS, normalizeFlagName(arg)) && readOnlyArrayHasStringMember(BOOLEAN_STRING_CLI_FLAGS, normalizeNegativeFlagName(arg));
+	if (arg.startsWith("--") && arg.includes("=")) {
+		const [originalArg, value] = parseEqualsArg(arg);
+		setCLIArg(flags, arg.split("=")[0], normalizeFlagName(originalArg), value);
+	} else if (arg.startsWith("-") && arg.includes("=")) {
+		const [originalArg, value] = parseEqualsArg(arg);
+		setCLIArg(flags, desugarRawAlias(originalArg), normalizeFlagName(originalArg), value);
+	} else if (CLI_FLAG_REGEX.test(arg)) setCLIArg(flags, desugarRawAlias(arg), normalizeFlagName(arg), parseCLIValue(args));
+	else if (arg.startsWith("--no-") && arg.length > 5) setCLIArg(flags, arg, normalizeNegativeFlagName(arg), "");
+	else if (arg.startsWith("--no") && (isNegatedBoolean || isNegatedBooleanOrString)) setCLIArg(flags, arg, normalizeNegativeFlagName(arg), "");
+	else if (arg.startsWith("--") && arg.length > 2) setCLIArg(flags, arg, normalizeFlagName(arg), parseCLIValue(args));
+	else flags.unknownArgs.push(arg);
+};
+/**
+* Normalize a 'negative' flag name, just to do a little pre-processing before
+* we pass it to {@link setCLIArg}.
+*
+* @param flagName the flag name to normalize
+* @returns a normalized flag name
+*/
+const normalizeNegativeFlagName = (flagName) => {
+	const trimmed = flagName.replace(/^--no[-]?/, "");
+	return normalizeFlagName(trimmed.charAt(0).toLowerCase() + trimmed.slice(1));
+};
+/**
+* Normalize a flag name by:
+*
+* - replacing any leading dashes (`--foo` -> `foo`)
+* - converting `dash-case` to camelCase (if necessary)
+*
+* Normalizing in this context basically means converting the various
+* supported flag spelling variants to the variant defined in our lists of
+* supported arguments (e.g. BOOLEAN_CLI_FLAGS, etc). So, for instance,
+* `--log-level` should be converted to `logLevel`.
+*
+* @param flagName the flag name to normalize
+* @returns a normalized flag name
+*
+*/
+const normalizeFlagName = (flagName) => {
+	const trimmed = flagName.replace(/^-+/, "");
+	return trimmed.includes("-") ? toCamelCase(trimmed) : trimmed;
+};
+/**
+* Set a value on a provided {@link ConfigFlags} object, given an argument
+* name and a raw string value. This function dispatches to other functions
+* which make sure that the string value can be properly parsed into a JS
+* runtime value of the right type (e.g. number, string, etc).
+*
+* @throws if a value cannot be parsed to the right type for a given flag
+* @param flags a {@link ConfigFlags} object
+* @param rawArg the raw argument name matched by the parser
+* @param normalizedArg an argument with leading control characters (`--`,
+* `--no-`, etc) removed
+* @param value the raw value to be set onto the config flags object
+*/
+const setCLIArg = (flags, rawArg, normalizedArg, value) => {
+	normalizedArg = desugarAlias(normalizedArg);
+	if (readOnlyArrayHasStringMember(BOOLEAN_CLI_FLAGS, normalizedArg)) {
+		flags[normalizedArg] = typeof value === "string" ? value === "true" : true;
+		flags.knownArgs.push(rawArg);
+		if (typeof value === "string" && value !== "") flags.knownArgs.push(value);
+	} else if (readOnlyArrayHasStringMember(STRING_CLI_FLAGS, normalizedArg)) if (typeof value === "string") {
+		flags[normalizedArg] = value;
+		flags.knownArgs.push(rawArg);
+		flags.knownArgs.push(value);
+	} else throwCLIParsingError(rawArg, "expected a string argument but received nothing");
+	else if (readOnlyArrayHasStringMember(STRING_ARRAY_CLI_FLAGS, normalizedArg)) if (typeof value === "string") {
+		if (!Array.isArray(flags[normalizedArg])) flags[normalizedArg] = [];
+		const targetArray = flags[normalizedArg];
+		if (Array.isArray(targetArray)) {
+			targetArray.push(value);
+			flags.knownArgs.push(rawArg);
+			flags.knownArgs.push(value);
+		}
+	} else throwCLIParsingError(rawArg, "expected a string argument but received nothing");
+	else if (readOnlyArrayHasStringMember(NUMBER_CLI_FLAGS, normalizedArg)) if (typeof value === "string") {
+		const parsed = parseInt(value, 10);
+		if (isNaN(parsed)) throwNumberParsingError(rawArg, value);
+		else {
+			flags[normalizedArg] = parsed;
+			flags.knownArgs.push(rawArg);
+			flags.knownArgs.push(value);
+		}
+	} else throwCLIParsingError(rawArg, "expected a number argument but received nothing");
+	else if (readOnlyArrayHasStringMember(STRING_NUMBER_CLI_FLAGS, normalizedArg)) if (typeof value === "string") {
+		if (CLI_ARG_STRING_REGEX.test(value)) flags[normalizedArg] = value;
+		else {
+			const parsed = Number(value);
+			if (isNaN(parsed)) throwNumberParsingError(rawArg, value);
+			else flags[normalizedArg] = parsed;
+		}
+		flags.knownArgs.push(rawArg);
+		flags.knownArgs.push(value);
+	} else throwCLIParsingError(rawArg, "expected a string or a number but received nothing");
+	else if (readOnlyArrayHasStringMember(BOOLEAN_STRING_CLI_FLAGS, normalizedArg)) {
+		const derivedValue = typeof value === "string" ? value ? value : false : true;
+		flags[normalizedArg] = derivedValue;
+		flags.knownArgs.push(rawArg);
+		if (typeof derivedValue === "string" && derivedValue) flags.knownArgs.push(derivedValue);
+	} else if (readOnlyArrayHasStringMember(LOG_LEVEL_CLI_FLAGS, normalizedArg)) if (typeof value === "string") if (isLogLevel(value)) {
+		flags[normalizedArg] = value;
+		flags.knownArgs.push(rawArg);
+		flags.knownArgs.push(value);
+	} else throwCLIParsingError(rawArg, `expected to receive a valid log level but received "${String(value)}"`);
+	else throwCLIParsingError(rawArg, "expected to receive a valid log level but received nothing");
+	else {
+		flags.unknownArgs.push(rawArg);
+		if (typeof value === "string") flags.unknownArgs.push(value);
+	}
+};
+/**
+* We use this regular expression to detect CLI parameters which
+* should be parsed as string values (as opposed to numbers) for
+* the argument types for which we support both a string and a
+* number value.
+*
+* The regex tests for the presence of at least one character which is
+* _not_ a digit (`\d`), a period (`\.`), or one of the characters `"e"`,
+* `"E"`, `"+"`, or `"-"` (the latter four characters are necessary to
+* support the admittedly unlikely use of scientific notation, like `"4e+0"`
+* for `4`).
+*
+* Thus we'll match a string like `"50%"`, but not a string like `"50"` or
+* `"5.0"`. If it matches a given string we conclude that the string should
+* be parsed as a string literal, rather than using `Number` to convert it
+* to a number.
+*/
+const CLI_ARG_STRING_REGEX = /[^\d.Ee+-]+/g;
+const Empty = Symbol("Empty");
+/**
+* A little helper which tries to parse a CLI value (as opposed to a flag) off
+* of the argument array.
+*
+* We support a variety of different argument formats for flags (as opposed to
+* values), but all of them start with `-`, so we can check the first character
+* to test whether the next token in our array of CLI arguments is a flag name
+* or a value.
+*
+* @param args an array of CLI args
+* @returns either a string result or an Empty sentinel
+*/
+const parseCLIValue = (args) => {
+	if (args[0] === void 0) return Empty;
+	if (!args[0].startsWith("-")) {
+		const value = args.shift();
+		if (typeof value === "string") return value;
+	}
+	return Empty;
+};
+/**
+* Parse an 'equals' argument, which is a CLI argument-value pair in the
+* format `--foobar=12` (as opposed to a space-separated format like
+* `--foobar 12`).
+*
+* To parse this we split on the `=`, returning the first part as the argument
+* name and the second part as the value. We join the value on `"="` in case
+* there is another `"="` in the argument.
+*
+* This function is safe to call with any arg, and can therefore be used as
+* an argument 'normalizer'. If CLI argument is not an 'equals' argument then
+* the return value will be a tuple of the original argument and an empty
+* string `""` for the value.
+*
+* In code terms, if you do:
+*
+* ```ts
+* const [arg, value] = parseEqualsArg("--myArgument")
+* ```
+*
+* Then `arg` will be `"--myArgument"` and `value` will be `""`, whereas if
+* you do:
+*
+*
+* ```ts
+* const [arg, value] = parseEqualsArg("--myArgument=myValue")
+* ```
+*
+* Then `arg` will be `"--myArgument"` and `value` will be `"myValue"`.
+*
+* @param arg the arg in question
+* @returns a tuple containing the arg name and the value (if present)
+*/
+const parseEqualsArg = (arg) => {
+	const [originalArg, ...splitSections] = arg.split("=");
+	const value = splitSections.join("=");
+	return [originalArg, value === "" ? Empty : value];
+};
+/**
+* Small helper for getting type-system-level assurance that a `string` can be
+* narrowed to a `LogLevel`
+*
+* @param maybeLogLevel the string to check
+* @returns whether this is a `LogLevel`
+*/
+const isLogLevel = (maybeLogLevel) => readOnlyArrayHasStringMember(LOG_LEVELS, maybeLogLevel);
+/**
+* A little helper for constructing and throwing an error message with info
+* about what went wrong
+*
+* @param flag the flag which encountered the error
+* @param message a message specific to the error which was encountered
+*/
+const throwCLIParsingError = (flag, message) => {
+	throw new Error(`when parsing CLI flag "${flag}": ${message}`);
+};
+/**
+* Throw a specific error for the situation where we ran into an issue parsing
+* a number.
+*
+* @param flag the flag for which we encountered the issue
+* @param value what we were trying to parse
+*/
+const throwNumberParsingError = (flag, value) => {
+	throwCLIParsingError(flag, `expected a number but received "${value}"`);
+};
+/**
+* A little helper to 'desugar' a flag alias, meaning expand it to its full
+* name. For instance, the alias `"c"` will desugar to `"config"`.
+*
+* If no expansion is found for the possible alias we just return the passed
+* string unmodified.
+*
+* @param maybeAlias a string which _could_ be an alias to a full flag name
+* @returns the full aliased flag name, if found, or the passed string if not
+*/
+const desugarAlias = (maybeAlias) => {
+	const possiblyDesugared = CLI_FLAG_ALIASES[maybeAlias];
+	if (typeof possiblyDesugared === "string") return possiblyDesugared;
+	return maybeAlias;
+};
+/**
+* Desugar a 'raw' alias (with a leading dash) and return an equivalent,
+* desugared argument.
+*
+* For instance, passing `"-c` will return `"--config"`.
+*
+* The reason we'd like to do this is not so much for our own code, but so that
+* we can transform an alias like `"-u"` to `"--updateSnapshot"` in order to
+* pass it along to Jest.
+*
+* @param rawAlias a CLI flag alias as found on the command line (like `"-c"`)
+* @returns an equivalent full command (like `"--config"`)
+*/
+const desugarRawAlias = (rawAlias) => "--" + desugarAlias(normalizeFlagName(rawAlias));
+//#endregion
+//#region src/find-config.ts
+/**
+* Attempt to find a Stencil configuration file on the file system
+* @param opts the options needed to find the configuration file
+* @returns the results of attempting to find a configuration file on disk
+*/
+const findConfig = async (opts) => {
+	const sys = opts.sys;
+	const cwd = sys.getCurrentDirectory();
+	const rootDir = normalizePath(cwd);
+	let configPath = opts.configPath;
+	if (isString(configPath)) if (!sys.platformPath.isAbsolute(configPath)) configPath = normalizePath(sys.platformPath.join(cwd, configPath));
+	else configPath = normalizePath(configPath);
+	else configPath = rootDir;
+	const results = {
+		configPath,
+		rootDir: normalizePath(cwd)
+	};
+	const stat = await sys.stat(configPath);
+	if (stat.error) {
+		const diagnostics = [];
+		const diagnostic = buildError(diagnostics);
+		diagnostic.absFilePath = configPath;
+		diagnostic.header = `Invalid config path`;
+		diagnostic.messageText = `Config path "${configPath}" not found`;
+		return result.err(diagnostics);
+	}
+	if (stat.isFile) {
+		results.configPath = configPath;
+		results.rootDir = sys.platformPath.dirname(configPath);
+	} else if (stat.isDirectory) for (const configName of ["stencil.config.ts", "stencil.config.js"]) {
+		const testConfigFilePath = sys.platformPath.join(configPath, configName);
+		if ((await sys.stat(testConfigFilePath)).isFile) {
+			results.configPath = testConfigFilePath;
+			results.rootDir = sys.platformPath.dirname(testConfigFilePath);
+			break;
+		}
+	}
+	return result.ok(results);
+};
+//#endregion
+//#region src/load-compiler.ts
+const loadCoreCompiler = async (sys) => {
+	return await sys.dynamicImport(sys.getCompilerExecutingPath());
+};
+//#endregion
+//#region src/logs.ts
+/**
+* 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;
+	const isDevBuild = coreCompiler.version.includes("-dev.");
+	let startupMsg;
+	if (isDevBuild) startupMsg = logger.yellow(`[LOCAL DEV] v${coreCompiler.version}`);
+	else startupMsg = logger.cyan(`v${coreCompiler.version}`);
+	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 ? `${sysDetails.platform}, ${sysDetails.cpuModel}` : `Unknown Platform, Unknown CPU Model`;
+	const statsInfo = sysDetails ? `cpus: ${sys.hardwareConcurrency}, freemem: ${Math.round(sysDetails.freemem() / 1e6)}MB, totalmem: ${Math.round(sysDetails.totalmem / 1e6)}MB` : "Unknown CPU Core Count, Unknown Memory";
+	if (logger.getLevel() === "debug") {
+		logger.debug(runtimeInfo);
+		logger.debug(platformInfo);
+		logger.debug(statsInfo);
+		logger.debug(`compiler: ${sys.getCompilerExecutingPath()}`);
+		logger.debug(`build: ${coreCompiler.buildId}`);
+	} else if (flags.ci) {
+		logger.info(runtimeInfo);
+		logger.info(platformInfo);
+		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;
+	const { logger } = config;
+	const isDebug = logger.getLevel() === "debug";
+	const isPrerelease = coreCompiler.version.includes("-");
+	const isDevBuild = coreCompiler.version.includes("-dev.");
+	if (isPrerelease && !isDevBuild) logger.warn(logger.yellow(`This is a prerelease build, undocumented changes might happen at any time. Technical support is not available for prereleases, but any assistance testing is appreciated.`));
+	if (config.devMode && !isDebug) {
+		if (config.buildEs5) logger.warn(`Generating ES5 during development is a very task expensive, initial and incremental builds will be much slower. Drop the '--es5' flag and use a modern browser for development.`);
+		if (!config.enableCache) logger.warn(`Disabling cache during development will slow down incremental builds.`);
+	}
+};
+//#endregion
+//#region src/merge-flags.ts
+/**
+* Merge CLI flags into a Stencil configuration object.
+*
+* This function applies command-line flags to the config, with CLI flags
+* taking precedence over config file values. This is the canonical place
+* where flag values are translated into config properties.?
+*
+* @param config The config object (from stencil.config.ts or empty)
+* @param flags The parsed CLI flags
+* @returns The config with flags merged in
+*/
+const mergeFlags = (config, flags) => {
+	const merged = { ...config };
+	if (flags.prod === true) merged.devMode = false;
+	else if (flags.dev === true) merged.devMode = true;
+	if (flags.debug === true || flags.verbose === true) merged.logLevel = "debug";
+	else if (flags.logLevel) merged.logLevel = flags.logLevel;
+	if (typeof flags.watch === "boolean") merged.watch = flags.watch;
+	if (typeof flags.docs === "boolean") merged.buildDocs = flags.docs;
+	if (typeof flags.esm === "boolean") merged.buildDist = flags.esm;
+	if (typeof flags.profile === "boolean") merged.profile = flags.profile;
+	if (typeof flags.log === "boolean") merged.writeLog = flags.log;
+	if (typeof flags.cache === "boolean") merged.enableCache = flags.cache;
+	if (typeof flags.ci === "boolean") merged.ci = flags.ci;
+	if (typeof flags.ssr === "boolean") merged.ssr = flags.ssr;
+	if (typeof flags.prerender === "boolean") merged.prerender = flags.prerender;
+	if (typeof flags.docsJson === "string") merged.docsJsonPath = flags.docsJson;
+	if (flags.stats) merged.statsJsonPath = flags.stats;
+	if (typeof flags.serviceWorker === "boolean") merged.generateServiceWorker = flags.serviceWorker;
+	if (typeof flags.e2e === "boolean") merged.e2eTests = flags.e2e;
+	if (typeof flags.maxWorkers === "number") merged.maxConcurrentWorkers = flags.maxWorkers;
+	if (typeof flags.address === "string") merged.devServerAddress = flags.address;
+	if (typeof flags.port === "number") merged.devServerPort = flags.port;
+	if (typeof flags.open === "boolean") merged.devServerOpen = flags.open;
+	return merged;
+};
+//#endregion
+//#region src/check-version.ts
+/**
+* Retrieve a reference to the active `CompilerSystem`'s `checkVersion` function
+* @param config the Stencil configuration associated with the currently compiled project
+* @param currentVersion the Stencil compiler's version string
+* @param flags the CLI flags (owned by CLI, not part of core config)
+* @returns a reference to `checkVersion`, or `null` if one does not exist on the current `CompilerSystem`
+*/
+const startCheckVersion = async (config, currentVersion, flags) => {
+	if (config.devMode && !flags.ci && !currentVersion.includes("-dev.") && isFunction(config.sys.checkVersion)) return config.sys.checkVersion(config.logger, currentVersion);
+	return null;
+};
+/**
+* Print the results of running the provided `versionChecker`.
+*
+* Does not print if no `versionChecker` is provided.
+*
+* @param versionChecker the function to invoke.
+*/
+const printCheckVersionResults = async (versionChecker) => {
+	if (versionChecker) {
+		const checkVersionResults = await versionChecker;
+		if (isFunction(checkVersionResults)) checkVersionResults();
+	}
+};
+//#endregion
+//#region src/task-prerender.ts
+const taskPrerender = async (coreCompiler, config, flags) => {
+	startupCompilerLog(coreCompiler, config);
+	const hydrateAppFilePath = flags.unknownArgs[0];
+	if (typeof hydrateAppFilePath !== "string") {
+		config.logger.error(`Missing hydrate app script path`);
+		return config.sys.exit(1);
+	}
+	const srcIndexHtmlPath = config.srcIndexHtml;
+	const diagnostics = await runPrerenderTask(coreCompiler, config, hydrateAppFilePath, void 0, srcIndexHtmlPath);
+	config.logger.printDiagnostics(diagnostics);
+	if (diagnostics.some((d) => d.level === "error")) return config.sys.exit(1);
+};
+const runPrerenderTask = async (coreCompiler, config, hydrateAppFilePath, componentGraph, srcIndexHtmlPath) => {
+	const diagnostics = [];
+	try {
+		const results = await (await coreCompiler.createPrerenderer(config)).start({
+			hydrateAppFilePath,
+			componentGraph,
+			srcIndexHtmlPath
+		});
+		diagnostics.push(...results.diagnostics);
+	} catch (e) {
+		catchError(diagnostics, e);
+	}
+	return diagnostics;
+};
+//#endregion
+//#region src/task-watch.ts
+const taskWatch = async (coreCompiler, config, flags) => {
+	let devServer = null;
+	let exitCode = 0;
+	try {
+		startupCompilerLog(coreCompiler, config);
+		const versionChecker = startCheckVersion(config, coreCompiler.version, flags);
+		const compiler = await coreCompiler.createCompiler(config);
+		const watcher = await compiler.createWatcher();
+		if (!config.sys.onProcessInterrupt) throw new Error(`Environment doesn't provide required function: onProcessInterrupt`);
+		if (flags.serve) {
+			const { start } = await import("@stencil/dev-server");
+			devServer = await start(config.devServer, config.logger, watcher);
+		}
+		config.sys.onProcessInterrupt(() => {
+			config.logger.debug(`close watch`);
+			if (compiler) compiler.destroy();
+		});
+		const rmVersionCheckerLog = watcher.on("buildFinish", async () => {
+			rmVersionCheckerLog();
+			printCheckVersionResults(versionChecker);
+		});
+		if (devServer) {
+			const rmDevServerLog = watcher.on("buildFinish", () => {
+				rmDevServerLog();
+				const url = devServer?.browserUrl ?? "UNKNOWN URL";
+				config.logger.info(`${config.logger.cyan(url)}\n`);
+			});
+		}
+		const closeResults = await watcher.start();
+		if (closeResults.exitCode > 0) exitCode = closeResults.exitCode;
+	} catch (e) {
+		exitCode = 1;
+		config.logger.error(e);
+	}
+	if (devServer) await devServer.close();
+	if (exitCode > 0) return config.sys.exit(exitCode);
+};
+//#endregion
+//#region src/telemetry/helpers.ts
+const tryFn = async (fn, ...args) => {
+	try {
+		return await fn(...args);
+	} catch {}
+	return null;
+};
+const isInteractive = (sys, flags, object) => {
+	const terminalInfo = object || Object.freeze({
+		tty: sys.isTTY(),
+		ci: [
+			"CI",
+			"BUILD_ID",
+			"BUILD_NUMBER",
+			"BITBUCKET_COMMIT",
+			"CODEBUILD_BUILD_ARN"
+		].filter((v) => !!sys.getEnvironmentVar?.(v)).length > 0 || !!flags.ci
+	});
+	return terminalInfo.tty && !terminalInfo.ci;
+};
+const UUID_REGEX = /* @__PURE__ */ new RegExp(/^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i);
+function uuidv4() {
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = Math.random() * 16 | 0;
+		return (c == "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+/**
+* Reads and parses a JSON file from the given `path`
+* @param sys The system where the command is invoked
+* @param path the path on the file system to read and parse
+* @returns the parsed JSON
+*/
+async function readJson(sys, path) {
+	const file = await sys.readFile(path);
+	return file ? JSON.parse(file) : null;
+}
+/**
+* Does the command have the debug flag?
+* @param flags The configuration flags passed into the Stencil command
+* @returns true if --debug has been passed, otherwise false
+*/
+function hasDebug(flags) {
+	return !!flags.debug;
+}
+/**
+* Does the command have the verbose and debug flags?
+* @param flags The configuration flags passed into the Stencil command
+* @returns true if both --debug and --verbose have been passed, otherwise false
+*/
+function hasVerbose(flags) {
+	return !!flags.verbose && hasDebug(flags);
+}
+//#endregion
+//#region src/ionic-config.ts
+const isTest$1 = () => process.env.JEST_WORKER_ID !== void 0;
+const defaultConfig = (sys) => sys.resolvePath(`${sys.homeDir()}/.ionic/${isTest$1() ? "tmp-config.json" : "config.json"}`);
+const defaultConfigDirectory = (sys) => sys.resolvePath(`${sys.homeDir()}/.ionic`);
+/**
+* Reads an Ionic configuration file from disk, parses it, and performs any necessary corrections to it if certain
+* values are deemed to be malformed
+* @param sys The system where the command is invoked
+* @returns the config read from disk that has been potentially been updated
+*/
+async function readConfig(sys) {
+	let config = await readJson(sys, defaultConfig(sys));
+	if (!config) {
+		config = {
+			"tokens.telemetry": uuidv4(),
+			"telemetry.stencil": true
+		};
+		await writeConfig(sys, config);
+	} 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;
+	}
+	return config;
+}
+/**
+* Writes an Ionic configuration file to disk.
+* @param sys The system where the command is invoked
+* @param config The config passed into the Stencil command
+* @returns boolean If the command was successful
+*/
+async function writeConfig(sys, config) {
+	let result = false;
+	try {
+		await sys.createDir(defaultConfigDirectory(sys), { recursive: true });
+		await sys.writeFile(defaultConfig(sys), JSON.stringify(config, null, 2));
+		result = true;
+	} catch (error) {
+		console.error(`Stencil Telemetry: couldn't write configuration file to ${defaultConfig(sys)} - ${error}.`);
+	}
+	return result;
+}
+/**
+* Update a subset of the Ionic config.
+* @param sys The system where the command is invoked
+* @param newOptions The new options to save
+* @returns boolean If the command was successful
+*/
+async function updateConfig(sys, newOptions) {
+	const config = await readConfig(sys);
+	return await writeConfig(sys, Object.assign(config, newOptions));
+}
+//#endregion
+//#region src/telemetry/shouldTrack.ts
+/**
+* Used to determine if tracking should occur.
+* @param sys The system where the command is invoked
+* @param flags The CLI flags (owned by CLI, not part of core config)
+* @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(sys, flags, ci) {
+	return !ci && isInteractive(sys, flags) && await checkTelemetry(sys);
+}
+//#endregion
+//#region src/telemetry/telemetry.ts
+/**
+* Used to within taskBuild to provide the component_count property.
+*
+* @param sys The system where the command is invoked
+* @param config The config passed into the Stencil command
+* @param coreCompiler The compiler used to do builds
+* @param result The results of a compiler build.
+* @param flags The CLI flags (owned by CLI, not part of core config)
+*/
+async function telemetryBuildFinishedAction(sys, config, coreCompiler, result, flags) {
+	if (!await shouldTrack(sys, flags, !!flags.ci)) return;
+	const component_count = result.componentGraph ? Object.keys(result.componentGraph).length : void 0;
+	const data = await prepareData(coreCompiler, config, sys, flags, result.duration, component_count);
+	await sendMetric(sys, flags, "stencil_cli_command", data);
+	config.logger.debug(`${config.logger.blue("Telemetry")}: ${config.logger.gray(JSON.stringify(data))}`);
+}
+/**
+* A function to wrap a compiler task function around. Will send telemetry if, and only if, the machine allows.
+*
+* @param sys The system where the command is invoked
+* @param config The config passed into the Stencil command
+* @param coreCompiler The compiler used to do builds
+* @param flags The CLI flags (owned by CLI, not part of core config)
+* @param action A Promise-based function to call in order to get the duration of any given command.
+* @returns void
+*/
+async function telemetryAction(sys, config, coreCompiler, flags, action) {
+	const tracking = await shouldTrack(sys, flags, !!flags.ci);
+	let duration = void 0;
+	let error;
+	if (action) {
+		const start = /* @__PURE__ */ new Date();
+		try {
+			await action();
+		} catch (e) {
+			error = e;
+		}
+		duration = (/* @__PURE__ */ new Date()).getTime() - start.getTime();
+	}
+	if (!tracking || flags.task == "build" && !flags.args.includes("--watch")) return;
+	const data = await prepareData(coreCompiler, config, sys, flags, duration);
+	await sendMetric(sys, flags, "stencil_cli_command", data);
+	config.logger.debug(`${config.logger.blue("Telemetry")}: ${config.logger.gray(JSON.stringify(data))}`);
+	if (error) throw error;
+}
+/**
+* Helper function to determine if a Stencil configuration builds an application.
+*
+* This function is a rough approximation whether an application is generated as a part of a Stencil build, based on
+* contents of the project's `stencil.config.ts` file.
+*
+* @param config the configuration used by the Stencil project
+* @returns true if we believe the project generates an application, false otherwise
+*/
+function hasAppTarget(config) {
+	return config.outputTargets.some((target) => isOutputTargetWww(target) && (!!target.serviceWorker || !!target.baseUrl && target.baseUrl !== "/"));
+}
+function isUsingYarn(sys) {
+	return sys.getEnvironmentVar?.("npm_execpath")?.includes("yarn") || false;
+}
+/**
+* Build a list of the different types of output targets used in a Stencil configuration.
+*
+* Duplicate entries will not be returned from the list
+*
+* @param config the configuration used by the Stencil project
+* @returns a unique list of output target types found in the Stencil configuration
+*/
+function getActiveTargets(config) {
+	const result = config.outputTargets.map((t) => t.type);
+	return Array.from(new Set(result));
+}
+/**
+* Prepare data for telemetry
+*
+* @param coreCompiler the core compiler
+* @param config the current Stencil config
+* @param sys the compiler system instance in use
+* @param flags the CLI flags (owned by CLI, not part of core config)
+* @param duration_ms the duration of the action being tracked
+* @param component_count the number of components being built (optional)
+* @returns a Promise wrapping data for the telemetry endpoint
+*/
+const prepareData = async (coreCompiler, config, sys, flags, duration_ms, component_count = void 0) => {
+	const { typescript, rollup } = coreCompiler.versions || {
+		typescript: "unknown",
+		rollup: "unknown"
+	};
+	const { packages, packagesNoVersions } = await getInstalledPackages(sys, flags);
+	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 build = coreCompiler.buildId || "unknown";
+	const has_app_pwa_config = hasAppTarget(config);
+	const anonymizedConfig = anonymizeConfigForTelemetry(config);
+	return {
+		arguments: flags.args,
+		build,
+		component_count,
+		config: anonymizedConfig,
+		cpu_model,
+		duration_ms,
+		has_app_pwa_config,
+		os_name,
+		os_version,
+		packages,
+		packages_no_versions: packagesNoVersions,
+		rollup,
+		stencil,
+		system,
+		system_major: getMajorVersion(system),
+		targets,
+		task: flags.task,
+		typescript,
+		yarn
+	};
+};
+const OUTPUT_TARGET_KEYS_TO_KEEP = ["type"];
+const CONFIG_PROPS_TO_ANONYMIZE = [
+	"rootDir",
+	"fsNamespace",
+	"packageJsonFilePath",
+	"namespace",
+	"srcDir",
+	"srcIndexHtml",
+	"buildLogFilePath",
+	"cacheDir",
+	"configPath",
+	"tsconfig"
+];
+const CONFIG_PROPS_TO_DELETE = [
+	"commonjs",
+	"devServer",
+	"env",
+	"logger",
+	"rollupConfig",
+	"sys",
+	"testing",
+	"tsCompilerOptions"
+];
+/**
+* Anonymize the config for telemetry, replacing potentially revealing config props
+* with a placeholder string if they are present (this lets us still track how frequently
+* these config options are being used)
+*
+* @param config the config to anonymize
+* @returns an anonymized copy of the same config
+*/
+const anonymizeConfigForTelemetry = (config) => {
+	const anonymizedConfig = { ...config };
+	for (const prop of CONFIG_PROPS_TO_ANONYMIZE) if (anonymizedConfig[prop] !== void 0) anonymizedConfig[prop] = "omitted";
+	anonymizedConfig.outputTargets = config.outputTargets.map((target) => {
+		const anonymizedOT = JSON.parse(JSON.stringify(target, (key, value) => {
+			if (!(typeof value === "string")) return value;
+			if (OUTPUT_TARGET_KEYS_TO_KEEP.includes(key)) return value;
+			return "omitted";
+		}));
+		if (isOutputTargetHydrate(target) && target.external) anonymizedOT["external"] = target.external.concat();
+		return anonymizedOT;
+	});
+	for (const prop of CONFIG_PROPS_TO_DELETE) delete anonymizedConfig[prop];
+	return anonymizedConfig;
+};
+/**
+* Reads package-lock.json, yarn.lock, and package.json files in order to cross-reference
+* the dependencies and devDependencies properties. Pulls up the current installed version
+* of each package under the @stencil, @ionic, and @capacitor scopes.
+*
+* @param sys the system instance where telemetry is invoked
+* @param flags the CLI flags (owned by CLI, not part of core config)
+* @returns an object listing all dev and production dependencies under the aforementioned scopes
+*/
+async function getInstalledPackages(sys, flags) {
+	let packages = [];
+	let packagesNoVersions = [];
+	const yarn = isUsingYarn(sys);
+	try {
+		const appRootDir = sys.getCurrentDirectory();
+		const packageJson = await tryFn(readJson, sys, sys.resolvePath(appRootDir + "/package.json"));
+		if (!packageJson) return {
+			packages,
+			packagesNoVersions
+		};
+		const ionicPackages = Object.entries({
+			...packageJson.devDependencies,
+			...packageJson.dependencies
+		}).filter(([k]) => k.startsWith("@stencil/") || k.startsWith("@ionic/") || k.startsWith("@capacitor/"));
+		try {
+			packages = yarn ? await yarnPackages(sys, ionicPackages) : await npmPackages(sys, ionicPackages);
+		} catch {
+			packages = ionicPackages.map(([k, v]) => `${k}@${v.replace("^", "")}`);
+		}
+		packagesNoVersions = ionicPackages.map(([k]) => `${k}`);
+		return {
+			packages,
+			packagesNoVersions
+		};
+	} catch (err) {
+		if (hasDebug(flags)) console.error(err);
+		return {
+			packages,
+			packagesNoVersions
+		};
+	}
+}
+/**
+* Visits the npm lock file to find the exact versions that are installed
+* @param sys The system where the command is invoked
+* @param ionicPackages a list of the found packages matching `@stencil`, `@capacitor`, or `@ionic` from the package.json file.
+* @returns an array of strings of all the packages and their versions.
+*/
+async function npmPackages(sys, ionicPackages) {
+	const appRootDir = sys.getCurrentDirectory();
+	const packageLockJson = await tryFn(readJson, sys, sys.resolvePath(appRootDir + "/package-lock.json"));
+	return ionicPackages.map(([k, v]) => {
+		let version = packageLockJson?.dependencies[k]?.version ?? packageLockJson?.devDependencies[k]?.version ?? v;
+		version = version.includes("file:") ? sanitizeDeclaredVersion(v) : version;
+		return `${k}@${version}`;
+	});
+}
+/**
+* Visits the yarn lock file to find the exact versions that are installed
+* @param sys The system where the command is invoked
+* @param ionicPackages a list of the found packages matching `@stencil`, `@capacitor`, or `@ionic` from the package.json file.
+* @returns an array of strings of all the packages and their versions.
+*/
+async function yarnPackages(sys, ionicPackages) {
+	const appRootDir = sys.getCurrentDirectory();
+	const yarnLock = sys.readFileSync(sys.resolvePath(appRootDir + "/yarn.lock"));
+	const yarnLockYml = sys.parseYarnLockFile?.(yarnLock);
+	return ionicPackages.map(([k, v]) => {
+		const identifiedVersion = `${k}@${v}`;
+		let version = yarnLockYml?.object[identifiedVersion]?.version;
+		version = version && version.includes("undefined") ? sanitizeDeclaredVersion(identifiedVersion) : version;
+		return `${k}@${version}`;
+	});
+}
+/**
+* This function is used for fallback purposes, where an npm or yarn lock file doesn't exist in the consumers directory.
+* This will strip away '*', '^' and '~' from the declared package versions in a package.json.
+* @param version the raw semver pattern identifier version string
+* @returns a cleaned up representation without any qualifiers
+*/
+function sanitizeDeclaredVersion(version) {
+	return version.replace(/[*^~]/g, "");
+}
+/**
+* If telemetry is enabled, send a metric to an external data store
+*
+* @param sys the system instance where telemetry is invoked
+* @param flags the CLI flags (owned by CLI, not part of core config)
+* @param name the name of a trackable metric. Note this name is not necessarily a scalar value to track, like
+* "Stencil Version". For example, "stencil_cli_command" is a name that is used to track all CLI command information.
+* @param value the data to send to the external data store under the provided name argument
+*/
+async function sendMetric(sys, flags, name, value) {
+	const session_id = await getTelemetryToken(sys);
+	await sendTelemetry(sys, flags, {
+		name,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		source: "stencil_cli",
+		value,
+		session_id
+	});
+}
+/**
+* Used to read the config file's tokens.telemetry property.
+*
+* @param sys The system where the command is invoked
+* @returns string
+*/
+async function getTelemetryToken(sys) {
+	const config = await readConfig(sys);
+	if (config["tokens.telemetry"] === void 0) {
+		config["tokens.telemetry"] = uuidv4();
+		await writeConfig(sys, config);
+	}
+	return config["tokens.telemetry"];
+}
+/**
+* Issues a request to the telemetry server.
+* @param sys The system where the command is invoked
+* @param flags The CLI flags (owned by CLI, not part of core config)
+* @param data Data to be tracked
+*/
+async function sendTelemetry(sys, flags, data) {
+	try {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const body = {
+			metrics: [data],
+			sent_at: now
+		};
+		if (!sys.fetch) throw new Error("No fetch implementation available");
+		const response = await sys.fetch("https://api.ionicjs.com/events/metrics", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+		if (hasVerbose(flags)) console.debug("\nSent %O metric to events service (status: %O)", data.name, response.status, "\n");
+		if (response.status !== 204 && hasVerbose(flags)) console.debug("\nBad response from events service. Request body: %O", response.body.toString(), "\n");
+	} catch (e) {
+		if (hasVerbose(flags)) console.debug("Telemetry request failed:", e);
+	}
+}
+/**
+* Checks if telemetry is enabled on this machine
+* @param sys The system where the command is invoked
+* @returns true if telemetry is enabled, false otherwise
+*/
+async function checkTelemetry(sys) {
+	const config = await readConfig(sys);
+	if (config["telemetry.stencil"] === void 0) {
+		config["telemetry.stencil"] = true;
+		await writeConfig(sys, config);
+	}
+	return config["telemetry.stencil"];
+}
+/**
+* Writes to the config file, enabling telemetry for this machine.
+* @param sys The system where the command is invoked
+* @returns true if writing the file was successful, false otherwise
+*/
+async function enableTelemetry(sys) {
+	return await updateConfig(sys, { "telemetry.stencil": true });
+}
+/**
+* Writes to the config file, disabling telemetry for this machine.
+* @param sys The system where the command is invoked
+* @returns true if writing the file was successful, false otherwise
+*/
+async function disableTelemetry(sys) {
+	return await updateConfig(sys, { "telemetry.stencil": false });
+}
+/**
+* Takes in a semver string in order to return the major version.
+* @param version The fully qualified semver version
+* @returns a string of the major version
+*/
+function getMajorVersion(version) {
+	return version.split(".")[0];
+}
+//#endregion
+//#region src/task-build.ts
+const taskBuild = async (coreCompiler, config, flags) => {
+	if (flags.watch) {
+		await taskWatch(coreCompiler, config, flags);
+		return;
+	}
+	let exitCode = 0;
+	try {
+		startupCompilerLog(coreCompiler, config);
+		const versionChecker = startCheckVersion(config, coreCompiler.version, flags);
+		const compiler = await coreCompiler.createCompiler(config);
+		const results = await compiler.build();
+		await telemetryBuildFinishedAction(config.sys, config, coreCompiler, results, flags);
+		await compiler.destroy();
+		if (results.hasError) exitCode = 1;
+		else if (flags.prerender) {
+			const prerenderDiagnostics = await runPrerenderTask(coreCompiler, config, results.hydrateAppFilePath, results.componentGraph, void 0);
+			config.logger.printDiagnostics(prerenderDiagnostics);
+			if (prerenderDiagnostics.some((d) => d.level === "error")) exitCode = 1;
+		}
+		await printCheckVersionResults(versionChecker);
+	} catch (e) {
+		exitCode = 1;
+		config.logger.error(e);
+	}
+	if (exitCode > 0) return config.sys.exit(exitCode);
+};
+//#endregion
+//#region src/task-docs.ts
+const taskDocs = async (coreCompiler, config) => {
+	config.devServer = {};
+	config.outputTargets = config.outputTargets.filter(isOutputTargetDocs);
+	config.devMode = true;
+	startupCompilerLog(coreCompiler, config);
+	const compiler = await coreCompiler.createCompiler(config);
+	await compiler.build();
+	await compiler.destroy();
+};
+//#endregion
+//#region src/task-generate.ts
+/**
+* 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
+* being called in an inappropriate place, being asked to overwrite files that
+* already exist, etc.
+*
+* @param config the user-supplied config, which we need here to access `.sys`.
+* @param flags the CLI flags (owned by CLI, not part of core config)
+* @returns a void promise
+*/
+const taskGenerate = async (config, flags) => {
+	if (!config.configPath) {
+		config.logger.error("Please run this command in your root directory (i. e. the one containing stencil.config.ts).");
+		return config.sys.exit(1);
+	}
+	const absoluteSrcDir = config.srcDir;
+	if (!absoluteSrcDir) {
+		config.logger.error(`Stencil's srcDir was not specified.`);
+		return config.sys.exit(1);
+	}
+	const { prompt } = await import("prompts");
+	const input = flags.unknownArgs.find((arg) => !arg.startsWith("-")) || (await prompt({
+		name: "tagName",
+		type: "text",
+		message: "Component tag name (dash-case):"
+	})).tagName;
+	if (void 0 === input) return;
+	const { dir, base: componentName } = parse(input);
+	const tagError = validateComponentTag(componentName);
+	if (tagError) {
+		config.logger.error(tagError);
+		return config.sys.exit(1);
+	}
+	let cssExtension = "css";
+	if (config.plugins?.find((plugin) => plugin.name === "sass")) cssExtension = await chooseSassExtension();
+	else if (config.plugins?.find((plugin) => plugin.name === "less")) cssExtension = "less";
+	const filesToGenerateExt = await chooseFilesToGenerate(cssExtension);
+	if (!filesToGenerateExt) return;
+	const extensionsToGenerate = ["tsx", ...filesToGenerateExt];
+	const testFolder = extensionsToGenerate.some(isTest) ? "test" : "";
+	const outDir = join(absoluteSrcDir, "components", dir, componentName);
+	await config.sys.createDir(normalizePath(join(outDir, testFolder)), { recursive: true });
+	const filesToGenerate = extensionsToGenerate.map((extension) => ({
+		extension,
+		path: getFilepathForFile(outDir, componentName, extension)
+	}));
+	await checkForOverwrite(filesToGenerate, config);
+	const writtenFiles = await Promise.all(filesToGenerate.map((file) => getBoilerplateAndWriteFile(config, componentName, extensionsToGenerate.includes("css") || extensionsToGenerate.includes("sass") || extensionsToGenerate.includes("scss") || extensionsToGenerate.includes("less"), file, cssExtension))).catch((error) => config.logger.error(error));
+	if (!writtenFiles) return config.sys.exit(1);
+	console.log();
+	console.log(`${config.logger.gray("$")} stencil generate ${input}`);
+	console.log();
+	console.log(config.logger.bold("The following files have been generated:"));
+	const absoluteRootDir = config.rootDir;
+	writtenFiles.map((file) => console.log(`  - ${relative(absoluteRootDir, file)}`));
+};
+/**
+* Show a checkbox prompt to select the files to be generated.
+*
+* @param cssExtension the extension of the CSS file to be generated
+* @returns a read-only array of `GeneratableExtension`, the extensions that the user has decided
+* to generate
+*/
+const chooseFilesToGenerate = async (cssExtension) => {
+	const { prompt } = await import("prompts");
+	return (await prompt({
+		name: "filesToGenerate",
+		type: "multiselect",
+		message: "Which additional files do you want to generate?",
+		choices: [
+			{
+				value: cssExtension,
+				title: `Stylesheet (.${cssExtension})`,
+				selected: true
+			},
+			{
+				value: "spec.tsx",
+				title: "Spec Test  (.spec.tsx)",
+				selected: true
+			},
+			{
+				value: "e2e.ts",
+				title: "E2E Test (.e2e.ts)",
+				selected: true
+			}
+		]
+	})).filesToGenerate;
+};
+const chooseSassExtension = async () => {
+	const { prompt } = await import("prompts");
+	return (await prompt({
+		name: "sassFormat",
+		type: "select",
+		message: "Which Sass format would you like to use? (More info: https://sass-lang.com/documentation/syntax/#the-indented-syntax)",
+		choices: [{
+			value: "sass",
+			title: `*.sass Format`,
+			selected: true
+		}, {
+			value: "scss",
+			title: "*.scss Format"
+		}]
+	})).sassFormat;
+};
+/**
+* Get a filepath for a file we want to generate!
+*
+* The filepath for a given file depends on the path, the user-supplied
+* component name, the extension, and whether we're inside of a test directory.
+*
+* @param filePath      path to where we're going to generate the component
+* @param componentName the user-supplied name for the generated component
+* @param extension     the file extension
+* @returns the full filepath to the component (with a possible `test` directory
+* added)
+*/
+const getFilepathForFile = (filePath, componentName, extension) => isTest(extension) ? normalizePath(join(filePath, "test", `${componentName}.${extension}`)) : normalizePath(join(filePath, `${componentName}.${extension}`));
+/**
+* Get the boilerplate for a file and write it to disk
+*
+* @param config        the current config, needed for file operations
+* @param componentName the component name (user-supplied)
+* @param withCss       are we generating CSS?
+* @param file          the file we want to write
+* @param styleExtension extension used for styles
+* @returns a `Promise<string>` which holds the full filepath we've written to,
+* used to print out a little summary of our activity to the user.
+*/
+const getBoilerplateAndWriteFile = async (config, componentName, withCss, file, styleExtension) => {
+	const boilerplate = getBoilerplateByExtension(componentName, file.extension, withCss, styleExtension);
+	await config.sys.writeFile(normalizePath(file.path), boilerplate);
+	return file.path;
+};
+/**
+* Check to see if any of the files we plan to write already exist and would
+* therefore be overwritten if we proceed, because we'd like to not overwrite
+* people's code!
+*
+* This function will check all the filepaths and if it finds any files log an
+* error and exit with an error code. If it doesn't find anything it will just
+* peacefully return `Promise<void>`.
+*
+* @param files  the files we want to check
+* @param config the Config object, used here to get access to `sys.readFile`
+*/
+const checkForOverwrite = async (files, config) => {
+	const alreadyPresent = [];
+	await Promise.all(files.map(async ({ path }) => {
+		if (await config.sys.readFile(path) !== void 0) alreadyPresent.push(path);
+	}));
+	if (alreadyPresent.length > 0) {
+		config.logger.error("Generating code would overwrite the following files:", ...alreadyPresent.map((path) => "	" + normalizePath(path)));
+		await config.sys.exit(1);
+	}
+};
+/**
+* Check if an extension is for a test
+*
+* @param extension the extension we want to check
+* @returns a boolean indicating whether or not its a test
+*/
+const isTest = (extension) => {
+	return extension === "e2e.ts" || extension === "spec.tsx";
+};
+/**
+* Get the boilerplate for a file by its extension.
+*
+* @param tagName the name of the component we're generating
+* @param extension the file extension we want boilerplate for (.css, tsx, etc)
+* @param withCss a boolean indicating whether we're generating a CSS file
+* @param styleExtension extension used for styles
+* @returns a string container the file boilerplate for the supplied extension
+*/
+const getBoilerplateByExtension = (tagName, extension, withCss, styleExtension) => {
+	switch (extension) {
+		case "tsx": return getComponentBoilerplate(tagName, withCss, styleExtension);
+		case "css":
+		case "less":
+		case "sass":
+		case "scss": return getStyleUrlBoilerplate(styleExtension);
+		case "spec.tsx": return getSpecTestBoilerplate(tagName);
+		case "e2e.ts": return getE2eTestBoilerplate(tagName);
+		default: throw new Error(`Unkown extension "${extension}".`);
+	}
+};
+/**
+* Get the boilerplate for a file containing the definition of a component
+* @param tagName the name of the tag to give the component
+* @param hasStyle designates if the component has an external stylesheet or not
+* @param styleExtension extension used for styles
+* @returns the contents of a file that defines a component
+*/
+const getComponentBoilerplate = (tagName, hasStyle, styleExtension) => {
+	const decorator = [`{`];
+	decorator.push(`  tag: '${tagName}',`);
+	if (hasStyle) decorator.push(`  styleUrl: '${tagName}.${styleExtension}',`);
+	decorator.push(`  shadow: true,`);
+	decorator.push(`}`);
+	return `import { Component, Host, h } from '@stencil/core';
+
+@Component(${decorator.join("\n")})
+export class ${toPascalCase(tagName)} {
+  render() {
+    return (
+      <Host>
+        <slot></slot>
+      </Host>
+    );
+  }
+}
+`;
+};
+/**
+* Get the boilerplate for style for a generated component
+* @param ext extension used for styles
+* @returns a boilerplate CSS block
+*/
+const getStyleUrlBoilerplate = (ext) => ext === "sass" ? `:host
+  display: block
+` : `:host {
+  display: block;
+}
+`;
+/**
+* Get the boilerplate for a file containing a spec (unit) test for a component
+* @param tagName the name of the tag associated with the component under test
+* @returns the contents of a file that unit tests a component
+*/
+const getSpecTestBoilerplate = (tagName) => `import { newSpecPage } from '@stencil/core/testing';
+import { ${toPascalCase(tagName)} } from '../${tagName}';
+
+describe('${tagName}', () => {
+  it('renders', async () => {
+    const page = await newSpecPage({
+      components: [${toPascalCase(tagName)}],
+      html: \`<${tagName}></${tagName}>\`,
+    });
+    expect(page.root).toEqualHtml(\`
+      <${tagName}>
+        <mock:shadow-root>
+          <slot></slot>
+        </mock:shadow-root>
+      </${tagName}>
+    \`);
+  });
+});
+`;
+/**
+* Get the boilerplate for a file containing an end-to-end (E2E) test for a component
+* @param tagName the name of the tag associated with the component under test
+* @returns the contents of a file that E2E tests a component
+*/
+const getE2eTestBoilerplate = (tagName) => `import { newE2EPage } from '@stencil/core/testing';
+
+describe('${tagName}', () => {
+  it('renders', async () => {
+    const page = await newE2EPage();
+    await page.setContent('<${tagName}></${tagName}>');
+
+    const element = await page.find('${tagName}');
+    expect(element).toHaveClass('hydrated');
+  });
+});
+`;
+/**
+* Convert a dash case string to pascal case.
+* @param str the string to convert
+* @returns the converted input as pascal case
+*/
+const toPascalCase = (str) => str.split("-").reduce((res, part) => res + part[0].toUpperCase() + part.slice(1), "");
+//#endregion
+//#region src/task-telemetry.ts
+/**
+* Entrypoint for the Telemetry task
+* @param flags configuration flags provided to Stencil when a task was called (either this task or a task that invokes
+* telemetry)
+* @param sys the abstraction for interfacing with the operating system
+* @param logger a logging implementation to log the results out to the user
+*/
+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 out of telemetry. Information about the data we collect is available on our website: ${logger.bold("https://stenciljs.com/telemetry")}`;
+	const ENABLED_MESSAGE = `${logger.green("Enabled")}. Thank you for helping to make Stencil better! 💖\n\n`;
+	const DISABLED_MESSAGE = `${logger.red("Disabled")}\n\n`;
+	const hasTelemetry = await checkTelemetry(sys);
+	if (isEnabling) {
+		if (await enableTelemetry(sys)) console.log(`\n  ${logger.bold("Telemetry is now ") + ENABLED_MESSAGE}`);
+		else console.log(`Something went wrong when enabling Telemetry.`);
+		return;
+	}
+	if (isDisabling) {
+		if (await disableTelemetry(sys)) console.log(`\n  ${logger.bold("Telemetry is now ") + DISABLED_MESSAGE}`);
+		else console.log(`Something went wrong when disabling Telemetry.`);
+		return;
+	}
+	console.log(`  ${logger.bold("Telemetry:")} ${logger.dim(INFORMATION)}`);
+	console.log(`\n  ${logger.bold("Status")}: ${hasTelemetry ? ENABLED_MESSAGE : DISABLED_MESSAGE}`);
+	console.log(`    ${prompt} ${logger.green("stencil telemetry [off|on]")}
+
+        ${logger.cyan("off")} ${logger.dim(".............")} Disable sharing anonymous usage data
+        ${logger.cyan("on")} ${logger.dim("..............")} Enable sharing anonymous usage data
+  `);
+};
+//#endregion
+//#region src/task-help.ts
+/**
+* Entrypoint for the Help task, providing Stencil usage context to the user
+* @param flags configuration flags provided to Stencil when a task was call (either this task or a task that invokes
+* telemetry)
+* @param logger a logging implementation to log the results out to the user
+* @param sys the abstraction for interfacing with the operating system
+*/
+const taskHelp = async (flags, logger, sys) => {
+	const prompt = logger.dim(sys.details?.platform === "windows" ? ">" : "$");
+	console.log(`
+  ${logger.bold("Build:")} ${logger.dim("Build components for development or production.")}
+
+    ${prompt} ${logger.green("stencil build [--dev] [--watch] [--prerender] [--debug]")}
+
+      ${logger.cyan("--dev")} ${logger.dim(".............")} Development build
+      ${logger.cyan("--watch")} ${logger.dim("...........")} Rebuild when files update
+      ${logger.cyan("--serve")} ${logger.dim("...........")} Start the dev-server
+      ${logger.cyan("--prerender")} ${logger.dim(".......")} Prerender the application
+      ${logger.cyan("--docs")} ${logger.dim("............")} Generate component readme.md docs
+      ${logger.cyan("--config")} ${logger.dim("..........")} Set stencil config file
+      ${logger.cyan("--stats")} ${logger.dim("...........")} Write stats, optional file path (default: stencil-stats.json)
+      ${logger.cyan("--log")} ${logger.dim(".............")} Write stencil-build.log file
+      ${logger.cyan("--debug")} ${logger.dim("...........")} Set the log level to debug
+
+
+  ${logger.bold("Test:")} ${logger.dim("Run unit and end-to-end tests.")}
+
+    ${prompt} ${logger.green("stencil test [--spec] [--e2e]")}
+
+      ${logger.cyan("--spec")} ${logger.dim("............")} Run unit tests with Jest
+      ${logger.cyan("--e2e")} ${logger.dim(".............")} Run e2e tests with Puppeteer
+
+
+  ${logger.bold("Generate:")} ${logger.dim("Bootstrap components.")}
+
+    ${prompt} ${logger.green("stencil generate")} or ${logger.green("stencil g")}
+
+`);
+	await taskTelemetry(flags, sys, logger);
+	console.log(`
+  ${logger.bold("Examples:")}
+
+  ${prompt} ${logger.green("stencil build --dev --watch --serve")}
+  ${prompt} ${logger.green("stencil build --prerender")}
+  ${prompt} ${logger.green("stencil test --spec --e2e")}
+  ${prompt} ${logger.green("stencil telemetry on")}
+  ${prompt} ${logger.green("stencil generate")}
+  ${prompt} ${logger.green("stencil g my-component")}
+`);
+};
+//#endregion
+//#region src/task-info.ts
+/**
+* Generate the output for Stencils 'info' task, and log that output - `npx stencil info`
+* @param coreCompiler the compiler instance to derive certain version information from
+* @param sys the compiler system instance that provides details about the system Stencil is running on
+* @param logger the logger instance to use to log information out to
+*/
+const taskInfo = (coreCompiler, sys, logger) => {
+	const details = sys.details;
+	const versions = coreCompiler.versions;
+	console.log(``);
+	console.log(`${logger.cyan("      System:")} ${sys.name} ${sys.version}`);
+	if (details) {
+		console.log(`${logger.cyan("    Platform:")} ${details.platform} (${details.release})`);
+		console.log(`${logger.cyan("   CPU Model:")} ${details.cpuModel} (${sys.hardwareConcurrency} cpu${sys.hardwareConcurrency !== 1 ? "s" : ""})`);
+	}
+	console.log(`${logger.cyan("    Compiler:")} ${sys.getCompilerExecutingPath()}`);
+	console.log(`${logger.cyan("       Build:")} ${coreCompiler.buildId}`);
+	console.log(`${logger.cyan("     Stencil:")} ${coreCompiler.version}${logger.emoji(" " + coreCompiler.vermoji)}`);
+	console.log(`${logger.cyan("  TypeScript:")} ${versions.typescript}`);
+	console.log(`${logger.cyan("      Rollup:")} ${versions.rollup}`);
+	console.log(`${logger.cyan("      Terser:")} ${versions.terser}`);
+	console.log(``);
+};
+//#endregion
+//#region src/task-serve.ts
+const taskServe = async (config, flags) => {
+	config.suppressLogs = true;
+	if (typeof flags.open === "boolean") config.devServer.openBrowser = flags.open;
+	config.devServer.reloadStrategy = null;
+	config.devServer.initialLoadUrl = "/";
+	config.devServer.websocket = false;
+	config.maxConcurrentWorkers = 1;
+	config.devServer.root = isString(flags.root) ? flags.root : config.sys.getCurrentDirectory();
+	if (!config.sys.onProcessInterrupt) throw new Error(`Environment doesn't provide required function: onProcessInterrupt`);
+	const devServer = await start(config.devServer, config.logger);
+	console.log(`${config.logger.cyan("     Root:")} ${devServer.root}`);
+	console.log(`${config.logger.cyan("  Address:")} ${devServer.address}`);
+	console.log(`${config.logger.cyan("     Port:")} ${devServer.port}`);
+	console.log(`${config.logger.cyan("   Server:")} ${devServer.browserUrl}`);
+	console.log(``);
+	config.sys.onProcessInterrupt(() => {
+		if (devServer) {
+			config.logger.debug(`dev server close: ${devServer.browserUrl}`);
+			devServer.close();
+		}
+	});
+};
+//#endregion
+//#region src/run.ts
+/**
+* Main entry point for the Stencil CLI
+*
+* Take care of parsing CLI arguments, initializing various components needed
+* by the rest of the program, and kicking off the correct task (build, test,
+* etc).
+*
+* @param init initial CLI options
+* @returns an empty promise
+*/
+const run = async (init) => {
+	const { args, logger, sys } = init;
+	try {
+		const flags = parseFlags(args);
+		const task = flags.task;
+		if (flags.debug || flags.verbose) logger.setLevel("debug");
+		if (flags.ci) logger.enableColors(false);
+		if (isFunction(sys.applyGlobalPatch)) sys.applyGlobalPatch(sys.getCurrentDirectory());
+		if (task && task === "version" || flags.version) {
+			const coreCompiler = await loadCoreCompiler(sys);
+			console.log(coreCompiler.version);
+			return;
+		}
+		if (!task || task === "help" || flags.help) {
+			await taskHelp(createConfigFlags({
+				task: "help",
+				args
+			}), logger, sys);
+			return;
+		}
+		startupLog(logger, task);
+		const findConfigResults = await findConfig({
+			sys,
+			configPath: flags.config
+		});
+		if (findConfigResults.isErr) {
+			logger.printDiagnostics(findConfigResults.value);
+			return sys.exit(1);
+		}
+		const coreCompiler = await loadCoreCompiler(sys);
+		startupLogVersion(logger, task, coreCompiler);
+		loadedCompilerLog(sys, logger, flags, coreCompiler);
+		if (task === "info") {
+			taskInfo(coreCompiler, sys, logger);
+			return;
+		}
+		const foundConfig = result.unwrap(findConfigResults);
+		const configWithFlags = mergeFlags({}, flags);
+		const validated = await coreCompiler.loadConfig({
+			config: configWithFlags,
+			configPath: foundConfig.configPath,
+			logger,
+			sys
+		});
+		if (validated.diagnostics.length > 0) {
+			logger.printDiagnostics(validated.diagnostics);
+			if (hasError(validated.diagnostics)) return sys.exit(1);
+		}
+		if (isFunction(sys.applyGlobalPatch)) sys.applyGlobalPatch(validated.config.rootDir);
+		await telemetryAction(sys, validated.config, coreCompiler, flags, async () => {
+			await runTask(coreCompiler, validated.config, task, sys, flags);
+		});
+	} catch (e) {
+		if (!shouldIgnoreError(e)) {
+			const details = `${logger.getLevel() === "debug" && e instanceof Error ? e.stack : ""}`;
+			logger.error(`uncaught cli error: ${e}${details}`);
+			return sys.exit(1);
+		}
+	}
+};
+/**
+* Run a specified task
+*
+* @param coreCompiler an instance of a minimal, bootstrap compiler for running the specified task
+* @param config a configuration for the Stencil project to apply to the task run
+* @param task the task to run
+* @param sys the {@link d.CompilerSystem} for interacting with the operating system
+* @param flags the parsed CLI flags (owned by CLI, not passed to Core)
+* @public
+* @returns a void promise
+*/
+const runTask = async (coreCompiler, config, task, sys, flags) => {
+	const resolvedFlags = flags ?? createConfigFlags({ task });
+	const configWithFlags = mergeFlags(config, resolvedFlags);
+	if (!configWithFlags.sys) configWithFlags.sys = sys;
+	const strictConfig = coreCompiler.validateConfig(configWithFlags, {}).config;
+	switch (task) {
+		case "build":
+			await taskBuild(coreCompiler, strictConfig, resolvedFlags);
+			break;
+		case "docs":
+			await taskDocs(coreCompiler, strictConfig);
+			break;
+		case "generate":
+		case "g":
+			await taskGenerate(strictConfig, resolvedFlags);
+			break;
+		case "help":
+			await taskHelp(resolvedFlags, strictConfig.logger, sys);
+			break;
+		case "prerender":
+			await taskPrerender(coreCompiler, strictConfig, resolvedFlags);
+			break;
+		case "serve":
+			await taskServe(strictConfig, resolvedFlags);
+			break;
+		case "telemetry":
+			await taskTelemetry(resolvedFlags, sys, strictConfig.logger);
+			break;
+		case "version":
+			console.log(coreCompiler.version);
+			break;
+		default:
+			strictConfig.logger.error(`${strictConfig.logger.emoji("❌ ")}Invalid stencil command, please see the options below:`);
+			await taskHelp(resolvedFlags, strictConfig.logger, sys);
+			return configWithFlags.sys.exit(1);
+	}
+};
+//#endregion
+export { BOOLEAN_CLI_FLAGS, createConfigFlags, parseFlags, run, runTask };