@stencil/core 4.43.5 → 5.0.0-alpha.10

package/dist/node--akYC-sG.mjs

@@ -0,0 +1,1937 @@
+import { n as __require } from "./chunk-z9aeyW2b.mjs";
+import "./client-aTQ7xHxx.mjs";
+import { h as noop, i as flatOne, l as isFunction, p as isString } from "./regular-expression-CFVJOTUh.mjs";
+import { St as isGlob, _t as catchError, bt as shouldIgnoreError, it as normalizePath, mt as buildError, pt as TASK_CANCELED_MSG } from "./validation-ByxKj8bC.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import path$1 from "path";
+import * as cp from "child_process";
+import chalk from "chalk";
+import { createHash } from "node:crypto";
+import * as os from "node:os";
+import { cpus, freemem, platform, release, tmpdir, totalmem } from "node:os";
+import * as parcelWatcher from "@parcel/watcher";
+import { glob } from "tinyglobby";
+import { copyFile, mkdir, readdir, stat } from "node:fs/promises";
+import semverLte from "semver/functions/lte.js";
+import major from "semver/functions/major.js";
+import satisfies from "semver/functions/satisfies.js";
+import { cpus as cpus$1, tmpdir as tmpdir$1 } from "os";
+import semverLt from "semver/functions/lt.js";
+import { EventEmitter } from "events";
+//#region src/compiler/events.ts
+const buildEvents = () => {
+	const evCallbacks = [];
+	const off = (callback) => {
+		const index = evCallbacks.findIndex((ev) => ev.callback === callback);
+		if (index > -1) {
+			evCallbacks.splice(index, 1);
+			return true;
+		}
+		return false;
+	};
+	const on = (arg0, arg1) => {
+		if (typeof arg0 === "function") {
+			const eventName = null;
+			const callback = arg0;
+			evCallbacks.push({
+				eventName,
+				callback
+			});
+			return () => off(callback);
+		} else if (typeof arg0 === "string" && typeof arg1 === "function") {
+			const eventName = arg0.toLowerCase().trim();
+			const callback = arg1;
+			evCallbacks.push({
+				eventName,
+				callback
+			});
+			return () => off(callback);
+		}
+		return () => false;
+	};
+	const emit = (eventName, data) => {
+		const normalizedEventName = eventName.toLowerCase().trim();
+		const callbacks = evCallbacks.slice();
+		for (const ev of callbacks) if (ev.eventName == null) try {
+			ev.callback(eventName, data);
+		} catch (e) {
+			console.error(e);
+		}
+		else if (ev.eventName === normalizedEventName) try {
+			ev.callback(data);
+		} catch (e) {
+			console.error(e);
+		}
+	};
+	const unsubscribeAll = () => {
+		evCallbacks.length = 0;
+	};
+	return {
+		emit,
+		on,
+		unsubscribeAll
+	};
+};
+//#endregion
+//#region src/declarations/stencil-public-compiler.ts
+/**
+* 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"
+];
+/**
+* The collection of valid export behaviors.
+* Used to generate a type for typed configs as well as output target validation
+* for the `standalone` output target.
+*
+* Adding a value to this const array will automatically add it as a valid option on the
+* output target configuration for `customElementsExportBehavior`.
+*
+* - `default`: No additional export or definition behavior will happen.
+* - `auto-define-custom-elements`: Enables the auto-definition of a component and its children (recursively) in the custom elements registry. This
+* functionality allows consumers to bypass the explicit call to define a component, its children, its children's
+* children, etc. Users of this flag should be aware that enabling this functionality may increase bundle size.
+* - `bundle`: A `defineCustomElements` function will be exported from the distribution directory.
+* - `single-export-module`: All components will be re-exported from the specified directory's root `index.js` file.
+*/
+const CustomElementsExportBehaviorOptions = [
+	"default",
+	"auto-define-custom-elements",
+	"bundle",
+	"single-export-module"
+];
+//#endregion
+//#region src/sys/node/logger/terminal-logger.ts
+const { bgRed, blue, bold, cyan, dim, gray, green, magenta, red, yellow } = chalk;
+/**
+* Map of color names to chalk functions for dynamic access
+*/
+const chalkColors = {
+	yellow: chalk.yellow,
+	red: chalk.red,
+	magenta: chalk.magenta,
+	green: chalk.green,
+	gray: chalk.gray,
+	cyan: chalk.cyan,
+	blue: chalk.blue,
+	bold: chalk.bold,
+	dim: chalk.dim
+};
+/**
+* Create a logger for outputting information to a terminal environment
+* @param loggerSys an underlying logger system entity used to create the terminal logger
+* @returns the created logger
+*/
+const createTerminalLogger = (loggerSys) => {
+	let currentLogLevel = "info";
+	let logFilePath = null;
+	const writeLogQueue = [];
+	const setLevel = (l) => currentLogLevel = l;
+	const getLevel = () => currentLogLevel;
+	const setLogFilePath = (p) => logFilePath = p;
+	const info = (...msg) => {
+		if (shouldLog(currentLogLevel, "info")) {
+			const lines = wordWrap(msg, loggerSys.getColumns());
+			infoPrefix(lines);
+			console.log(lines.join("\n"));
+		}
+		queueWriteLog("I", msg);
+	};
+	const infoPrefix = (lines) => {
+		if (lines.length > 0) {
+			const prefix = formatPrefixTimestamp();
+			lines[0] = dim(prefix) + lines[0].slice(prefix.length);
+		}
+	};
+	const warn = (...msg) => {
+		if (shouldLog(currentLogLevel, "warn")) {
+			const lines = wordWrap(msg, loggerSys.getColumns());
+			warnPrefix(lines);
+			console.warn("\n" + lines.join("\n") + "\n");
+		}
+		queueWriteLog("W", msg);
+	};
+	const warnPrefix = (lines) => {
+		if (lines.length) lines[0] = bold(yellow("[ WARN  ]")) + lines[0].slice(9);
+	};
+	const error = (...msg) => {
+		for (let i = 0; i < msg.length; i++) if (msg[i] instanceof Error) {
+			const err = msg[i];
+			msg[i] = err.message;
+			if (err.stack) msg[i] += "\n" + err.stack;
+		}
+		if (shouldLog(currentLogLevel, "error")) {
+			const lines = wordWrap(msg, loggerSys.getColumns());
+			errorPrefix(lines);
+			console.error("\n" + lines.join("\n") + "\n");
+		}
+		queueWriteLog("E", msg);
+	};
+	const errorPrefix = (lines) => {
+		if (lines.length) lines[0] = bold(red("[ ERROR ]")) + lines[0].slice(9);
+	};
+	const debug = (...msg) => {
+		if (shouldLog(currentLogLevel, "debug")) {
+			formatMemoryUsage(msg);
+			const lines = wordWrap(msg, loggerSys.getColumns());
+			debugPrefix(lines);
+			console.log(lines.join("\n"));
+		}
+		queueWriteLog("D", msg);
+	};
+	const debugPrefix = (lines) => {
+		if (lines.length) {
+			const prefix = formatPrefixTimestamp();
+			lines[0] = cyan(prefix) + lines[0].slice(prefix.length);
+		}
+	};
+	const timespanStart = (startMsg, isDebug, appendTo) => {
+		const msg = [`${startMsg} ${dim("...")}`];
+		if (isDebug) {
+			if (shouldLog(currentLogLevel, "debug")) {
+				formatMemoryUsage(msg);
+				const lines = wordWrap(msg, loggerSys.getColumns());
+				debugPrefix(lines);
+				console.log(lines.join("\n"));
+				queueWriteLog("D", [`${startMsg} ...`]);
+			}
+		} else {
+			const lines = wordWrap(msg, loggerSys.getColumns());
+			infoPrefix(lines);
+			console.log(lines.join("\n"));
+			queueWriteLog("I", [`${startMsg} ...`]);
+			if (appendTo) appendTo.push(`${startMsg} ...`);
+		}
+	};
+	/**
+	* A little helper to (conditionally) format and add the current memory usage
+	*
+	* @param message an array to which the memory usage will be added
+	*/
+	const formatMemoryUsage = (message) => {
+		const mem = loggerSys.memoryUsage();
+		if (mem > 0) message.push(dim(` MEM: ${(mem / 1e6).toFixed(1)}MB`));
+	};
+	const timespanFinish = (finishMsg, timeSuffix, colorName, textBold, newLineSuffix, isDebug, appendTo) => {
+		let msg = finishMsg;
+		if (colorName && chalkColors[colorName]) msg = chalkColors[colorName](finishMsg);
+		if (textBold) msg = bold(msg);
+		msg += " " + dim(timeSuffix);
+		if (isDebug) {
+			if (shouldLog(currentLogLevel, "debug")) {
+				const m = [msg];
+				formatMemoryUsage(m);
+				const lines = wordWrap(m, loggerSys.getColumns());
+				debugPrefix(lines);
+				console.log(lines.join("\n"));
+			}
+			queueWriteLog("D", [`${finishMsg} ${timeSuffix}`]);
+		} else {
+			const lines = wordWrap([msg], loggerSys.getColumns());
+			infoPrefix(lines);
+			console.log(lines.join("\n"));
+			queueWriteLog("I", [`${finishMsg} ${timeSuffix}`]);
+			if (appendTo) appendTo.push(`${finishMsg} ${timeSuffix}`);
+		}
+		if (newLineSuffix) console.log("");
+	};
+	const createTimeSpan = (startMsg, isDebug = false, appendTo) => {
+		const start = Date.now();
+		const duration = () => Date.now() - start;
+		const timeSpan = {
+			duration,
+			finish: (finishMsg, colorName, textBold, newLineSuffix) => {
+				const dur = duration();
+				let time;
+				if (dur > 1e3) time = "in " + (dur / 1e3).toFixed(2) + " s";
+				else if (parseFloat(dur.toFixed(3)) > 0) time = "in " + dur + " ms";
+				else time = "in less than 1 ms";
+				timespanFinish(finishMsg, time, colorName, !!textBold, !!newLineSuffix, isDebug, appendTo);
+				return dur;
+			}
+		};
+		timespanStart(startMsg, isDebug, appendTo);
+		return timeSpan;
+	};
+	const queueWriteLog = (prefix, msg) => {
+		if (logFilePath) {
+			const d = /* @__PURE__ */ new Date();
+			const log = "" + ("0" + d.getHours()).slice(-2) + ":" + ("0" + d.getMinutes()).slice(-2) + ":" + ("0" + d.getSeconds()).slice(-2) + "." + ("0" + Math.floor(d.getMilliseconds() / 1e3 * 10)) + "  " + ("000" + (loggerSys.memoryUsage() / 1e6).toFixed(1)).slice(-6) + "MB  " + prefix + "  " + msg.join(", ");
+			writeLogQueue.push(log);
+		}
+	};
+	const writeLogs = (append) => {
+		if (logFilePath) try {
+			queueWriteLog("F", ["--------------------------------------"]);
+			loggerSys.writeLogs(logFilePath, writeLogQueue.join("\n"), append);
+		} catch {}
+		writeLogQueue.length = 0;
+	};
+	/**
+	* Callback to enable / disable colored output in logs
+	* @param useColors whether to enable colors (chalk.level = 3) or disable (chalk.level = 0)
+	*/
+	const enableColors = (useColors) => {
+		chalk.level = useColors ? 3 : 0;
+	};
+	/**
+	* Print all diagnostics to the console
+	* @param diagnostics the diagnostics to print
+	* @param cwd the current working directory
+	*/
+	const printDiagnostics = (diagnostics, cwd) => {
+		if (!diagnostics || diagnostics.length === 0) return;
+		let outputLines = [""];
+		diagnostics.forEach((d) => {
+			outputLines = outputLines.concat(printDiagnostic(d, cwd));
+		});
+		console.log(outputLines.join("\n"));
+	};
+	/**
+	* Formats a single diagnostic to be printed
+	* @param diagnostic the diagnostic to prepare for printing
+	* @param cwd the current working directory
+	* @returns the message from the diagnostic, formatted and split into multiple lines
+	*/
+	const printDiagnostic = (diagnostic, cwd) => {
+		const outputLines = wordWrap([diagnostic.messageText], loggerSys.getColumns());
+		let header = "";
+		if (diagnostic.header && diagnostic.header !== "Build Error") header += diagnostic.header;
+		if (typeof diagnostic.absFilePath === "string" && typeof diagnostic.relFilePath !== "string") {
+			if (typeof cwd !== "string") cwd = loggerSys.cwd();
+			diagnostic.relFilePath = loggerSys.relativePath(cwd, diagnostic.absFilePath);
+			if (!diagnostic.relFilePath.includes("/")) diagnostic.relFilePath = "./" + diagnostic.relFilePath;
+		}
+		let filePath = diagnostic.relFilePath;
+		if (typeof filePath !== "string") filePath = diagnostic.absFilePath;
+		if (typeof filePath === "string") {
+			if (header.length > 0) header += ": ";
+			header += cyan(filePath);
+			if (typeof diagnostic.lineNumber === "number" && diagnostic.lineNumber > -1) {
+				header += dim(`:`);
+				header += yellow(`${diagnostic.lineNumber}`);
+				if (typeof diagnostic.columnNumber === "number" && diagnostic.columnNumber > -1) {
+					header += dim(`:`);
+					header += yellow(`${diagnostic.columnNumber}`);
+				}
+			}
+		}
+		if (header.length > 0) outputLines.unshift(INDENT$1 + header);
+		outputLines.push("");
+		if (diagnostic.lines && diagnostic.lines.length) {
+			removeLeadingWhitespace(diagnostic.lines).forEach((l) => {
+				if (!isMeaningfulLine(l.text)) return;
+				let msg = ``;
+				if (l.lineNumber > -1) msg = `L${l.lineNumber}:  `;
+				while (msg.length < INDENT$1.length) msg = " " + msg;
+				let text = l.text;
+				if (l.errorCharStart > -1) text = highlightError(text, l.errorCharStart, l.errorLength);
+				msg = dim(msg);
+				if (diagnostic.language === "typescript" || diagnostic.language === "javascript") msg += javaScriptSyntaxHighlight(text);
+				else if (diagnostic.language === "scss" || diagnostic.language === "css") msg += cssSyntaxHighlight(text);
+				else msg += text;
+				outputLines.push(msg);
+			});
+			outputLines.push("");
+		}
+		if (diagnostic.level === "error") errorPrefix(outputLines);
+		else if (diagnostic.level === "warn") warnPrefix(outputLines);
+		else if (diagnostic.level === "debug") debugPrefix(outputLines);
+		else infoPrefix(outputLines);
+		if (diagnostic.debugText != null && currentLogLevel === "debug") {
+			outputLines.push(diagnostic.debugText);
+			debugPrefix(wordWrap([diagnostic.debugText], loggerSys.getColumns()));
+		}
+		return outputLines;
+	};
+	/**
+	* Highlights an error
+	* @param errorLine the line containing the error
+	* @param errorCharStart the character at which the error starts
+	* @param errorLength the length of the error, how many characters should be highlighted
+	* @returns the highlighted error
+	*/
+	const highlightError = (errorLine, errorCharStart, errorLength = 0) => {
+		let rightSideChars = errorLine.length - errorCharStart + errorLength - 1;
+		while (errorLine.length + INDENT$1.length > loggerSys.getColumns()) if (errorCharStart > errorLine.length - errorCharStart + errorLength && errorCharStart > 5) {
+			errorLine = errorLine.slice(1);
+			errorCharStart--;
+		} else if (rightSideChars > 1) {
+			errorLine = errorLine.slice(0, -1);
+			rightSideChars--;
+		} else break;
+		const lineChars = [];
+		const lineLength = Math.max(errorLine.length, errorCharStart + errorLength);
+		for (let i = 0; i < lineLength; i++) {
+			let chr = errorLine.charAt(i);
+			if (i >= errorCharStart && i < errorCharStart + errorLength) chr = bgRed(chr === "" ? " " : chr);
+			lineChars.push(chr);
+		}
+		return lineChars.join("");
+	};
+	/**
+	* Highlights JavaScript/TypeScript syntax, taking in text and selectively highlighting keywords from the language
+	* @param text the text to highlight
+	* @returns the text with highlighted JS/TS
+	*/
+	const javaScriptSyntaxHighlight = (text) => {
+		if (text.trim().startsWith("//")) return dim(text);
+		return text.split(" ").map((word) => {
+			if (JS_KEYWORDS.indexOf(word) > -1) return cyan(word);
+			return word;
+		}).join(" ");
+	};
+	/**
+	* Highlights CSS syntax, taking in text and selectively highlighting keywords from the language
+	* @param text the text to highlight
+	* @returns the text with highlighted CSS
+	*/
+	const cssSyntaxHighlight = (text) => {
+		let cssProp = true;
+		const safeChars = "abcdefghijklmnopqrstuvwxyz-_";
+		const notProp = ".#,:}@$[]/*";
+		const chars = [];
+		for (let i = 0; i < text.length; i++) {
+			const c = text.charAt(i);
+			if (c === ";" || c === "{") cssProp = true;
+			else if (notProp.indexOf(c) > -1) cssProp = false;
+			if (cssProp && safeChars.indexOf(c.toLowerCase()) > -1) {
+				chars.push(cyan(c));
+				continue;
+			}
+			chars.push(c);
+		}
+		return chars.join("");
+	};
+	return {
+		createLineUpdater: loggerSys.createLineUpdater,
+		createTimeSpan,
+		debug,
+		emoji: loggerSys.emoji,
+		enableColors,
+		error,
+		getLevel,
+		info,
+		printDiagnostics,
+		setLevel,
+		setLogFilePath,
+		warn,
+		writeLogs,
+		bgRed,
+		blue,
+		bold,
+		cyan,
+		dim,
+		gray,
+		green,
+		magenta,
+		red,
+		yellow
+	};
+};
+/**
+* Helper function to determine, based on the current log level setting, whether
+* a message at a given log level should be logged or not.
+*
+* @param currentSetting the current log level setting
+* @param messageLevel the log level to check
+* @returns whether we should log or not!
+*/
+const shouldLog = (currentSetting, messageLevel) => LOG_LEVELS.indexOf(messageLevel) >= LOG_LEVELS.indexOf(currentSetting);
+/**
+* Format a simple timestamp string for log prefixes
+*
+* @returns a formatted timestamp
+*/
+const formatPrefixTimestamp = () => {
+	const currentTime = /* @__PURE__ */ new Date();
+	return `[${clampTwoDigits(currentTime.getMinutes())}:${clampTwoDigits(currentTime.getSeconds())}.${Math.floor(currentTime.getMilliseconds() / 1e3 * 10)}]`;
+};
+/**
+* Format a number as a string and clamp it to exactly
+* two digits, e.g.
+*
+* ```ts
+* clampTwoDigits(3) // '03'
+* clampTwoDigits(14) // '14'
+* clampTwoDigits(104) // '04'
+* ```
+*
+* @param n the number to clamp
+* @returns a formatted string
+*/
+const clampTwoDigits = (n) => ("0" + n.toString()).slice(-2);
+/**
+* Helper function for word wrapping
+* @param msg the message to wrap
+* @param columns the maximum number of columns to occupy per line
+* @returns the wrapped message
+*/
+const wordWrap = (msg, columns) => {
+	const lines = [];
+	const words = [];
+	msg.forEach((m) => {
+		if (m === null) words.push("null");
+		else if (typeof m === "undefined") words.push("undefined");
+		else if (typeof m === "string") m.replace(/\s/gm, " ").split(" ").forEach((strWord) => {
+			if (strWord.trim().length) words.push(strWord.trim());
+		});
+		else if (typeof m === "number" || typeof m === "boolean" || typeof m === "function") words.push(m.toString());
+		else if (Array.isArray(m)) words.push(() => {
+			return m.toString();
+		});
+		else if (Object(m) === m) words.push(() => {
+			return m.toString();
+		});
+		else words.push(m.toString());
+	});
+	let line = INDENT$1;
+	words.forEach((word) => {
+		if (lines.length > 25) return;
+		if (typeof word === "function") {
+			if (line.trim().length) lines.push(line);
+			lines.push(word());
+			line = INDENT$1;
+		} else if (INDENT$1.length + word.length > columns - 1) {
+			if (line.trim().length) lines.push(line);
+			lines.push(INDENT$1 + word);
+			line = INDENT$1;
+		} else if (word.length + line.length > columns - 1) {
+			lines.push(line);
+			line = INDENT$1 + word + " ";
+		} else line += word + " ";
+	});
+	if (line.trim().length) lines.push(line);
+	return lines.map((l) => {
+		return l.trimRight();
+	});
+};
+/**
+* Prepare the code associated with the error/warning to be logged by stripping variable length, leading whitespace
+* @param orgLines the lines of code to log
+* @returns the code, with leading whitespace stripped
+*/
+const removeLeadingWhitespace = (orgLines) => {
+	const numberOfTries = 100;
+	const lines = JSON.parse(JSON.stringify(orgLines));
+	for (let i = 0; i < numberOfTries; i++) {
+		if (!eachLineHasLeadingWhitespace(lines)) return lines;
+		for (let j = 0; j < lines.length; j++) {
+			lines[j].text = lines[j].text.slice(1);
+			lines[j].errorCharStart--;
+			if (!lines[j].text.length) return lines;
+		}
+	}
+	return lines;
+};
+/**
+* Determine if any of the provided lines begin with whitespace or not
+* @param lines the lines to check for whitespace
+* @returns true if each of the provided `lines` has some leading whitespace, false otherwise
+*/
+const eachLineHasLeadingWhitespace = (lines) => {
+	if (!lines.length) return false;
+	for (let i = 0; i < lines.length; i++) {
+		if (!lines[i].text || lines[i].text.length < 1) return false;
+		const firstChar = lines[i].text.charAt(0);
+		if (firstChar !== " " && firstChar !== "	") return false;
+	}
+	return true;
+};
+/**
+* Verify that a given line has more than just whitespace
+* @param line the line to check
+* @returns true if a line has characters other than whitespace in it, false otherwise
+*/
+const isMeaningfulLine = (line) => {
+	if (line) {
+		line = line.trim();
+		return line.length > 0;
+	}
+	return false;
+};
+const JS_KEYWORDS = [
+	"abstract",
+	"any",
+	"as",
+	"break",
+	"boolean",
+	"case",
+	"catch",
+	"class",
+	"console",
+	"const",
+	"continue",
+	"debugger",
+	"declare",
+	"default",
+	"delete",
+	"do",
+	"else",
+	"enum",
+	"export",
+	"extends",
+	"false",
+	"finally",
+	"for",
+	"from",
+	"function",
+	"get",
+	"if",
+	"import",
+	"in",
+	"implements",
+	"Infinity",
+	"instanceof",
+	"let",
+	"module",
+	"namespace",
+	"NaN",
+	"new",
+	"number",
+	"null",
+	"public",
+	"private",
+	"protected",
+	"require",
+	"return",
+	"static",
+	"set",
+	"string",
+	"super",
+	"switch",
+	"this",
+	"throw",
+	"try",
+	"true",
+	"type",
+	"typeof",
+	"undefined",
+	"var",
+	"void",
+	"with",
+	"while",
+	"yield"
+];
+/**
+* This is used to prefix lines with whitespace which is then
+* replaced by various prefixes like [ WARN ] and so on
+*/
+const INDENT$1 = "           ";
+//#endregion
+//#region src/sys/node/logger/index.ts
+/**
+* Create a logger to run in a Node environment
+*
+* @returns the created logger
+*/
+const createNodeLogger = () => {
+	return createTerminalLogger(createNodeLoggerSys());
+};
+/**
+* Create a logger sys object for use in a Node.js environment
+*
+* The `TerminalLoggerSys` interface basically abstracts away some
+* environment-specific details so that the terminal logger can deal with
+* things in a (potentially) platform-agnostic way.
+*
+* @returns a configured logger sys object
+*/
+function createNodeLoggerSys() {
+	const cwd = () => process.cwd();
+	const emoji = (e) => process.platform !== "win32" ? e : "";
+	/**
+	* Get the number of columns for the terminal to use when printing
+	* @returns the number of columns to use
+	*/
+	const getColumns = () => {
+		const min_columns = 60;
+		const max_columns = 120;
+		const terminalWidth = process?.stdout?.columns ?? 80;
+		return Math.max(Math.min(terminalWidth, max_columns), min_columns);
+	};
+	const memoryUsage = () => process.memoryUsage().rss;
+	const relativePath = (from, to) => path$1.relative(from, to);
+	const writeLogs = (logFilePath, log, append) => {
+		if (append) try {
+			fs.accessSync(logFilePath);
+		} catch {
+			append = false;
+		}
+		if (append) fs.appendFileSync(logFilePath, log);
+		else fs.writeFileSync(logFilePath, log);
+	};
+	const createLineUpdater = async () => {
+		const readline = await import("readline");
+		let promise = Promise.resolve();
+		const update = (text) => {
+			text = text.substring(0, process.stdout.columns - 5) + "\x1B[0m";
+			return promise = promise.then(() => {
+				return new Promise((resolve) => {
+					readline.clearLine(process.stdout, 0);
+					readline.cursorTo(process.stdout, 0, void 0);
+					process.stdout.write(text, resolve);
+				});
+			});
+		};
+		const stop = () => {
+			return update("\x1B[?25h");
+		};
+		process.stdout.write("\x1B[?25l");
+		return {
+			update,
+			stop
+		};
+	};
+	return {
+		cwd,
+		emoji,
+		getColumns,
+		memoryUsage,
+		relativePath,
+		writeLogs,
+		createLineUpdater
+	};
+}
+//#endregion
+//#region src/sys/node/node-setup-process.ts
+function setupNodeProcess(c) {
+	c.process.on(`unhandledRejection`, (e) => {
+		if (!shouldIgnoreError(e)) {
+			let msg = "unhandledRejection";
+			if (e != null) {
+				if (typeof e === "string") msg += ": " + e;
+				else if (e.stack) msg += ": " + e.stack;
+				else if (e.message) msg += ": " + e.message;
+			}
+			c.logger.error(msg);
+		}
+	});
+}
+//#endregion
+//#region src/sys/node/node-copy-tasks.ts
+/**
+* Copy a file with retry logic for transient Windows errors (EBUSY, EPERM, EACCES).
+* These errors commonly occur on Windows CI when antivirus or indexing services
+* temporarily lock files.
+*
+* @param src - The source file path to copy from
+* @param dest - The destination file path to copy to
+* @param maxRetries - Maximum number of retry attempts (default: 3)
+* @returns A promise that resolves when the file is successfully copied
+* @throws The original error if all retry attempts fail or the error is not retryable
+*/
+async function copyFileWithRetry(src, dest, maxRetries = 3) {
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		await copyFile(src, dest);
+		return;
+	} catch (err) {
+		if (![
+			"EBUSY",
+			"EPERM",
+			"EACCES"
+		].includes(err.code) || attempt === maxRetries) throw err;
+		await new Promise((resolve) => setTimeout(resolve, 100 * Math.pow(2, attempt)));
+	}
+}
+async function nodeCopyTasks(copyTasks, srcDir) {
+	const results = {
+		diagnostics: [],
+		dirPaths: [],
+		filePaths: []
+	};
+	try {
+		copyTasks = flatOne(await Promise.all(copyTasks.map((task) => processGlobs(task, srcDir))));
+		const allCopyTasks = [];
+		while (copyTasks.length > 0) {
+			const tasks = copyTasks.splice(0, 100);
+			await Promise.all(tasks.map((copyTask) => processCopyTask(results, allCopyTasks, copyTask)));
+		}
+		const mkDirs = ensureDirs(allCopyTasks);
+		try {
+			await Promise.all(mkDirs.map((dir) => mkdir(dir, { recursive: true })));
+		} catch {}
+		while (allCopyTasks.length > 0) {
+			const tasks = allCopyTasks.splice(0, 100);
+			await Promise.all(tasks.map((copyTask) => copyFileWithRetry(copyTask.src, copyTask.dest)));
+		}
+	} catch (e) {
+		catchError(results.diagnostics, e);
+	}
+	return results;
+}
+async function processGlobs(copyTask, srcDir) {
+	return isGlob(copyTask.src) ? await processGlobTask(copyTask, srcDir) : [{
+		src: getSrcAbsPath(srcDir, copyTask.src),
+		dest: copyTask.keepDirStructure ? path$1.join(copyTask.dest, copyTask.src) : copyTask.dest,
+		warn: copyTask.warn,
+		ignore: copyTask.ignore,
+		keepDirStructure: copyTask.keepDirStructure
+	}];
+}
+function getSrcAbsPath(srcDir, src) {
+	if (path$1.isAbsolute(src)) return src;
+	return path$1.join(srcDir, src);
+}
+async function processGlobTask(copyTask, srcDir) {
+	return (await asyncGlob(copyTask.src, {
+		cwd: srcDir,
+		nodir: true,
+		ignore: copyTask.ignore
+	})).map((globRelPath) => createGlobCopyTask(copyTask, srcDir, globRelPath));
+}
+function createGlobCopyTask(copyTask, srcDir, globRelPath) {
+	const dest = path$1.join(copyTask.dest, copyTask.keepDirStructure ? globRelPath : path$1.basename(globRelPath));
+	return {
+		src: path$1.join(srcDir, globRelPath),
+		dest,
+		ignore: copyTask.ignore,
+		warn: copyTask.warn,
+		keepDirStructure: copyTask.keepDirStructure
+	};
+}
+async function processCopyTask(results, allCopyTasks, copyTask) {
+	try {
+		copyTask.src = normalizePath(copyTask.src);
+		copyTask.dest = normalizePath(copyTask.dest);
+		if ((await stat(copyTask.src)).isDirectory()) {
+			if (!results.dirPaths.includes(copyTask.dest)) results.dirPaths.push(copyTask.dest);
+			await processCopyTaskDirectory(results, allCopyTasks, copyTask);
+		} else if (!shouldIgnore(copyTask)) {
+			if (!results.filePaths.includes(copyTask.dest)) results.filePaths.push(copyTask.dest);
+			allCopyTasks.push(copyTask);
+		}
+	} catch (e) {
+		if (copyTask.warn !== false) {
+			const err = buildError(results.diagnostics);
+			if (e instanceof Error) err.messageText = e.message;
+		}
+	}
+}
+async function processCopyTaskDirectory(results, allCopyTasks, copyTask) {
+	try {
+		const dirItems = await readdir(copyTask.src);
+		await Promise.all(dirItems.map(async (dirItem) => {
+			await processCopyTask(results, allCopyTasks, {
+				src: path$1.join(copyTask.src, dirItem),
+				dest: path$1.join(copyTask.dest, dirItem),
+				warn: copyTask.warn
+			});
+		}));
+	} catch (e) {
+		catchError(results.diagnostics, e);
+	}
+}
+function ensureDirs(copyTasks) {
+	const mkDirs = [];
+	copyTasks.forEach((copyTask) => {
+		addMkDir(mkDirs, path$1.dirname(copyTask.dest));
+	});
+	mkDirs.sort((a, b) => {
+		const partsA = a.split("/").length;
+		const partsB = b.split("/").length;
+		if (partsA < partsB) return -1;
+		if (partsA > partsB) return 1;
+		if (a < b) return -1;
+		if (a > b) return 1;
+		return 0;
+	});
+	return mkDirs;
+}
+function addMkDir(mkDirs, destDir) {
+	destDir = normalizePath(destDir);
+	if (destDir === ROOT_DIR || destDir + "/" === ROOT_DIR || destDir === "") return;
+	if (!mkDirs.includes(destDir)) mkDirs.push(destDir);
+}
+const ROOT_DIR = normalizePath(path$1.resolve("/"));
+function shouldIgnore({ src, ignore = [] }) {
+	const filePath = src.trim().toLowerCase();
+	return ignore.some((ignoreFile) => filePath.endsWith(ignoreFile));
+}
+function asyncGlob(pattern, opts = {}) {
+	const { nodir, ...rest } = opts;
+	return glob(pattern, {
+		...rest,
+		onlyFiles: nodir ?? true
+	});
+}
+//#endregion
+//#region src/sys/node/node-lazy-require.ts
+/**
+* Lazy requirer for Node, with functionality for specifying version ranges and
+* returning diagnostic errors if requirements aren't met.
+*/
+var NodeLazyRequire = class {
+	nodeResolveModule;
+	lazyDependencies;
+	ensured = /* @__PURE__ */ new Set();
+	/**
+	* Create a NodeLazyRequire instance
+	*
+	* @param nodeResolveModule an object which wraps up module resolution functionality
+	* @param lazyDependencies the dependency requirements we want to enforce here
+	*/
+	constructor(nodeResolveModule, lazyDependencies) {
+		this.nodeResolveModule = nodeResolveModule;
+		this.lazyDependencies = lazyDependencies;
+	}
+	/**
+	* Ensure that a dependency within our supported range is installed in the
+	* current environment. This function will check all the dependency
+	* requirements passed in when the class is instantiated and return
+	* diagnostics if there are any issues.
+	*
+	* @param fromDir the directory from which we'll attempt to resolve the
+	* dependencies, typically this will be project's root directory.
+	* @param ensureModuleIds an array of module names whose versions we're going
+	* to check
+	* @returns a Promise holding diagnostics if any of the dependencies either
+	* were not resolved _or_ did not meet our version requirements.
+	*/
+	async ensure(fromDir, ensureModuleIds) {
+		const diagnostics = [];
+		const problemDeps = [];
+		ensureModuleIds.forEach((ensureModuleId) => {
+			if (!this.ensured.has(ensureModuleId)) {
+				const { minVersion, recommendedVersion, maxVersion } = this.lazyDependencies[ensureModuleId];
+				try {
+					const pkgJsonPath = this.nodeResolveModule.resolveModule(fromDir, ensureModuleId);
+					const installedPkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+					if (maxVersion ? satisfies(installedPkgJson.version, `${minVersion} - ${major(maxVersion)}.x`) : semverLte(minVersion, installedPkgJson.version)) {
+						this.ensured.add(ensureModuleId);
+						return;
+					}
+				} catch {}
+				problemDeps.push(`${ensureModuleId}@${recommendedVersion}`);
+			}
+		});
+		if (problemDeps.length > 0) {
+			const err = buildError(diagnostics);
+			err.header = `Please install supported versions of dev dependencies with either npm or yarn.`;
+			err.messageText = `npm install --save-dev ${problemDeps.join(" ")}`;
+		}
+		return diagnostics;
+	}
+	require(fromDir, moduleId) {
+		return __require(this.getModulePath(fromDir, moduleId));
+	}
+	getModulePath(fromDir, moduleId) {
+		const modulePath = this.nodeResolveModule.resolveModule(fromDir, moduleId);
+		return path$1.dirname(modulePath);
+	}
+};
+//#endregion
+//#region src/sys/node/node-resolve-module.ts
+var NodeResolveModule = class {
+	resolveModuleCache = /* @__PURE__ */ new Map();
+	resolveModule(fromDir, moduleId, opts) {
+		const cacheKey = `${fromDir}:${moduleId}`;
+		const cachedPath = this.resolveModuleCache.get(cacheKey);
+		if (cachedPath) return cachedPath;
+		if (opts && opts.manuallyResolve) return this.resolveModuleManually(fromDir, moduleId, cacheKey);
+		if (moduleId.startsWith("@types/")) return this.resolveTypesModule(fromDir, moduleId, cacheKey);
+		const Module = __require("module");
+		fromDir = path$1.resolve(fromDir);
+		const fromFile = path$1.join(fromDir, "noop.js");
+		let dir = normalizePath(Module._resolveFilename(moduleId, {
+			id: fromFile,
+			filename: fromFile,
+			paths: Module._nodeModulePaths(fromDir)
+		}));
+		const root = normalizePath(path$1.parse(fromDir).root);
+		let packageJsonFilePath;
+		while (dir !== root) {
+			dir = normalizePath(path$1.dirname(dir));
+			packageJsonFilePath = path$1.join(dir, "package.json");
+			if (!fs.existsSync(packageJsonFilePath)) continue;
+			this.resolveModuleCache.set(cacheKey, packageJsonFilePath);
+			return packageJsonFilePath;
+		}
+		throw new Error(`error loading "${moduleId}" from "${fromDir}"`);
+	}
+	resolveTypesModule(fromDir, moduleId, cacheKey) {
+		const moduleSplt = moduleId.split("/");
+		const root = normalizePath(path$1.parse(fromDir).root);
+		let dir = normalizePath(path$1.join(fromDir, "noop.js"));
+		let typesPackageJsonFilePath;
+		while (dir !== root) {
+			dir = normalizePath(path$1.dirname(dir));
+			typesPackageJsonFilePath = path$1.join(dir, "node_modules", moduleSplt[0], moduleSplt[1], "package.json");
+			if (!fs.existsSync(typesPackageJsonFilePath)) continue;
+			this.resolveModuleCache.set(cacheKey, typesPackageJsonFilePath);
+			return typesPackageJsonFilePath;
+		}
+		throw new Error(`error loading "${moduleId}" from "${fromDir}"`);
+	}
+	resolveModuleManually(fromDir, moduleId, cacheKey) {
+		const root = normalizePath(path$1.parse(fromDir).root);
+		let dir = normalizePath(path$1.join(fromDir, "noop.js"));
+		let packageJsonFilePath;
+		while (dir !== root) {
+			dir = normalizePath(path$1.dirname(dir));
+			packageJsonFilePath = path$1.join(dir, "node_modules", moduleId, "package.json");
+			if (!fs.existsSync(packageJsonFilePath)) continue;
+			this.resolveModuleCache.set(cacheKey, packageJsonFilePath);
+			return packageJsonFilePath;
+		}
+		throw new Error(`error loading "${moduleId}" from "${fromDir}"`);
+	}
+};
+//#endregion
+//#region src/sys/node/node-stencil-version-checker.ts
+const REGISTRY_URL = `https://registry.npmjs.org/@stencil/core`;
+const CHECK_INTERVAL = 1e3 * 60 * 60 * 24 * 7;
+const CHANGELOG = `https://github.com/stenciljs/core/blob/main/CHANGELOG.md`;
+async function checkVersion(logger, currentVersion) {
+	try {
+		const latestVersion = await getLatestCompilerVersion(logger);
+		if (latestVersion != null) return () => {
+			if (semverLt(currentVersion, latestVersion)) printUpdateMessage(logger, currentVersion, latestVersion);
+			else console.debug(`${logger.cyan("@stencil/core")} version ${logger.green(currentVersion)} is the latest version`);
+		};
+	} catch (e) {
+		logger.debug(`unable to load latest compiler version: ${e}`);
+	}
+	return noop;
+}
+async function getLatestCompilerVersion(logger) {
+	try {
+		const lastCheck = await getLastCheck();
+		if (lastCheck == null) {
+			setLastCheck();
+			return null;
+		}
+		if (!requiresCheck(Date.now(), lastCheck, CHECK_INTERVAL)) return null;
+		const setPromise = setLastCheck();
+		const body = await requestUrl(REGISTRY_URL);
+		const data = JSON.parse(body);
+		await setPromise;
+		return data["dist-tags"].latest;
+	} catch (e) {
+		logger.debug(`getLatestCompilerVersion error: ${e}`);
+	}
+	return null;
+}
+async function requestUrl(url) {
+	const https = await import("https");
+	return new Promise((resolve, reject) => {
+		const req = https.request(url, (res) => {
+			if (res.statusCode > 299) {
+				reject(`url: ${url}, staus: ${res.statusCode}`);
+				return;
+			}
+			res.once("error", reject);
+			const ret = [];
+			res.once("end", () => {
+				resolve(ret.join(""));
+			});
+			res.on("data", (data) => {
+				ret.push(data);
+			});
+		});
+		req.once("error", reject);
+		req.end();
+	});
+}
+function requiresCheck(now, lastCheck, checkInterval) {
+	return lastCheck + checkInterval < now;
+}
+function getLastCheck() {
+	return new Promise((resolve) => {
+		fs.readFile(getLastCheckStoragePath(), "utf8", (err, data) => {
+			if (!err && isString(data)) try {
+				resolve(JSON.parse(data));
+			} catch {}
+			resolve(null);
+		});
+	});
+}
+function setLastCheck() {
+	return new Promise((resolve) => {
+		const now = JSON.stringify(Date.now());
+		fs.writeFile(getLastCheckStoragePath(), now, () => {
+			resolve();
+		});
+	});
+}
+function getLastCheckStoragePath() {
+	return path$1.join(tmpdir$1(), "stencil_last_version_node.json");
+}
+function printUpdateMessage(logger, currentVersion, latestVersion) {
+	const installMessage = `npm install @stencil/core`;
+	const msg = [
+		`Update available: ${currentVersion} ${ARROW} ${latestVersion}`,
+		`To get the latest, please run:`,
+		installMessage,
+		CHANGELOG
+	];
+	const lineLength = msg.reduce((longest, line) => line.length > longest ? line.length : longest, 0);
+	const o = [];
+	let top = BOX_TOP_LEFT;
+	while (top.length <= lineLength + PADDING * 2) top += BOX_HORIZONTAL;
+	top += BOX_TOP_RIGHT;
+	o.push(top);
+	msg.forEach((m) => {
+		let line = BOX_VERTICAL;
+		for (let i = 0; i < PADDING; i++) line += ` `;
+		line += m;
+		while (line.length <= lineLength + PADDING * 2) line += ` `;
+		line += BOX_VERTICAL;
+		o.push(line);
+	});
+	let bottom = BOX_BOTTOM_LEFT;
+	while (bottom.length <= lineLength + PADDING * 2) bottom += BOX_HORIZONTAL;
+	bottom += BOX_BOTTOM_RIGHT;
+	o.push(bottom);
+	let output = `${INDENT}${o.join(`\n${INDENT}`)}\n`;
+	output = output.replace(currentVersion, logger.red(currentVersion));
+	output = output.replace(latestVersion, logger.green(latestVersion));
+	output = output.replace(installMessage, logger.cyan(installMessage));
+	output = output.replace(CHANGELOG, logger.dim(CHANGELOG));
+	console.log(output);
+}
+const ARROW = `→`;
+const BOX_TOP_LEFT = `╭`;
+const BOX_TOP_RIGHT = `╮`;
+const BOX_BOTTOM_LEFT = `╰`;
+const BOX_BOTTOM_RIGHT = `╯`;
+const BOX_VERTICAL = `│`;
+const BOX_HORIZONTAL = `─`;
+const PADDING = 2;
+const INDENT = `   `;
+//#endregion
+//#region src/sys/node/node-worker-main.ts
+/**
+* A class that holds a reference to a node worker sub-process within the main
+* thread so that messages may be passed to it.
+*/
+var NodeWorkerMain = class extends EventEmitter {
+	id;
+	/**
+	* A handle for the OS process that is running our worker code
+	*/
+	childProcess;
+	tasks = /* @__PURE__ */ new Map();
+	exitCode = null;
+	processQueue = true;
+	sendQueue = [];
+	stopped = false;
+	successfulMessage = false;
+	totalTasksAssigned = 0;
+	/**
+	* Create an object for holding and interacting with a reference to a worker
+	* child-process.
+	*
+	* @param id a unique ID
+	* @param forkModulePath the path to the module which should be run by the
+	* child process
+	*/
+	constructor(id, forkModulePath) {
+		super();
+		this.id = id;
+		this.fork(forkModulePath);
+	}
+	fork(forkModulePath) {
+		const options = {
+			execArgv: process.execArgv.filter((v) => !/^--(debug|inspect)/.test(v)),
+			env: process.env,
+			cwd: process.cwd(),
+			silent: true
+		};
+		this.childProcess = cp.fork(forkModulePath, [], options);
+		this.childProcess.stdout.setEncoding("utf8");
+		this.childProcess.stdout.on("data", (data) => {
+			console.log(data);
+		});
+		this.childProcess.stderr.setEncoding("utf8");
+		this.childProcess.stderr.on("data", (data) => {
+			console.error(data);
+		});
+		this.childProcess.on("message", this.receiveFromWorker.bind(this));
+		this.childProcess.on("error", (err) => {
+			this.emit("error", err);
+		});
+		this.childProcess.once("exit", (code) => {
+			this.exitCode = code;
+			this.emit("exit", code);
+		});
+	}
+	run(task) {
+		this.totalTasksAssigned++;
+		this.tasks.set(task.stencilId, task);
+		const [method, ...args] = task.inputArgs;
+		this.sendToWorker({
+			stencilId: task.stencilId,
+			method,
+			args
+		});
+	}
+	sendToWorker(msg) {
+		if (!this.processQueue) {
+			this.sendQueue.push(msg);
+			return;
+		}
+		if (!this.childProcess.send(msg, (error) => {
+			if (error && error instanceof Error) return;
+			this.processQueue = true;
+			if (this.sendQueue.length > 0) {
+				const queueCopy = this.sendQueue.slice();
+				this.sendQueue = [];
+				queueCopy.forEach((d) => this.sendToWorker(d));
+			}
+		}) || process.platform.startsWith("win")) this.processQueue = false;
+	}
+	receiveFromWorker(msgFromWorker) {
+		this.successfulMessage = true;
+		if (this.stopped) return;
+		const task = this.tasks.get(msgFromWorker.stencilId);
+		if (!task) {
+			if (msgFromWorker.stencilRtnError != null) this.emit("error", msgFromWorker.stencilRtnError);
+			return;
+		}
+		if (msgFromWorker.stencilRtnError != null) task.reject(msgFromWorker.stencilRtnError);
+		else task.resolve(msgFromWorker.stencilRtnValue);
+		this.tasks.delete(msgFromWorker.stencilId);
+		this.emit("response", msgFromWorker);
+	}
+	stop() {
+		this.stopped = true;
+		this.tasks.forEach((t) => t.reject(TASK_CANCELED_MSG));
+		this.tasks.clear();
+		if (this.successfulMessage) {
+			this.childProcess.send({ exit: true });
+			setTimeout(() => {
+				if (this.exitCode === null) this.childProcess.kill("SIGKILL");
+			}, 100);
+		} else this.childProcess.kill("SIGKILL");
+	}
+};
+//#endregion
+//#region src/sys/node/node-worker-controller.ts
+/**
+* A custom EventEmitter which provides centralizes dispatching and control for
+* node.js workers ({@link NodeWorkerMain} instances)
+*/
+var NodeWorkerController = class extends EventEmitter {
+	forkModulePath;
+	workerIds = 0;
+	stencilId = 0;
+	isEnding = false;
+	taskQueue = [];
+	workers = [];
+	maxWorkers;
+	useForkedWorkers;
+	mainThreadRunner;
+	/**
+	* Create a node.js-specific worker controller, which controls and
+	* coordinates distributing tasks to a series of child processes (tracked by
+	* {@link NodeWorkerMain} instances). These child processes are node
+	* processes executing a special worker script (`src/sys/node/worker.ts`)
+	* which listens for {@link d.MsgToWorker} messages and runs certain tasks in
+	* response.
+	*
+	* @param forkModulePath the path to the module which k
+	* @param maxConcurrentWorkers the max number of worker threads to spin up
+	*/
+	constructor(forkModulePath, maxConcurrentWorkers) {
+		super();
+		this.forkModulePath = forkModulePath;
+		const osCpus = cpus$1().length;
+		this.useForkedWorkers = maxConcurrentWorkers > 0;
+		this.maxWorkers = Math.max(Math.min(maxConcurrentWorkers, osCpus), 2) - 1;
+		if (this.useForkedWorkers) this.startWorkers();
+		else this.mainThreadRunner = __require(forkModulePath);
+	}
+	onError(err, workerId) {
+		if (err.code === "ERR_IPC_CHANNEL_CLOSED") return this.stopWorker(workerId);
+		if (err.code !== "EPIPE") console.error(err);
+	}
+	onExit(workerId) {
+		setTimeout(() => {
+			let doQueue = false;
+			const worker = this.workers.find((w) => w.id === workerId);
+			if (worker) {
+				worker.tasks.forEach((t) => {
+					t.retries++;
+					this.taskQueue.unshift(t);
+					doQueue = true;
+				});
+				worker.tasks.clear();
+			}
+			this.stopWorker(workerId);
+			if (doQueue) this.processTaskQueue();
+		}, 10);
+	}
+	startWorkers() {
+		while (this.workers.length < this.maxWorkers) this.startWorker();
+	}
+	startWorker() {
+		const workerId = this.workerIds++;
+		const worker = new NodeWorkerMain(workerId, this.forkModulePath);
+		worker.on("response", this.processTaskQueue.bind(this));
+		worker.once("exit", () => {
+			this.onExit(workerId);
+		});
+		worker.on("error", (err) => {
+			this.onError(err, workerId);
+		});
+		this.workers.push(worker);
+	}
+	stopWorker(workerId) {
+		const worker = this.workers.find((w) => w.id === workerId);
+		if (worker) {
+			worker.stop();
+			const index = this.workers.indexOf(worker);
+			if (index > -1) this.workers.splice(index, 1);
+		}
+	}
+	processTaskQueue() {
+		if (this.isEnding) return;
+		if (this.useForkedWorkers) this.startWorkers();
+		while (this.taskQueue.length > 0) {
+			const worker = getNextWorker(this.workers);
+			if (!worker) break;
+			worker.run(this.taskQueue.shift());
+		}
+	}
+	send(...args) {
+		if (this.isEnding) return Promise.reject(TASK_CANCELED_MSG);
+		if (this.useForkedWorkers) return new Promise((resolve, reject) => {
+			const task = {
+				stencilId: this.stencilId++,
+				inputArgs: args,
+				retries: 0,
+				resolve,
+				reject
+			};
+			this.taskQueue.push(task);
+			this.processTaskQueue();
+		});
+		return this.mainThreadRunner[args[0]].apply(null, args.slice(1));
+	}
+	handler(name) {
+		return (...args) => {
+			return this.send(name, ...args);
+		};
+	}
+	cancelTasks() {
+		for (const worker of this.workers) {
+			worker.tasks.forEach((t) => t.reject(TASK_CANCELED_MSG));
+			worker.tasks.clear();
+		}
+		this.taskQueue.length = 0;
+	}
+	destroy() {
+		if (!this.isEnding) {
+			this.isEnding = true;
+			for (const task of this.taskQueue) task.reject(TASK_CANCELED_MSG);
+			this.taskQueue.length = 0;
+			const workerIds = this.workers.map((w) => w.id);
+			for (const workerId of workerIds) this.stopWorker(workerId);
+		}
+	}
+};
+function getNextWorker(workers) {
+	const availableWorkers = workers.filter((w) => {
+		if (w.stopped) return false;
+		return true;
+	});
+	if (availableWorkers.length === 0) return null;
+	return availableWorkers.sort((a, b) => {
+		if (a.tasks.size < b.tasks.size) return -1;
+		if (a.tasks.size > b.tasks.size) return 1;
+		if (a.totalTasksAssigned < b.totalTasksAssigned) return -1;
+		if (a.totalTasksAssigned > b.totalTasksAssigned) return 1;
+		return 0;
+	})[0];
+}
+//#endregion
+//#region src/sys/node/node-sys.ts
+const __dirname = import.meta.dirname;
+/**
+* Create a node.js-specific {@link CompilerSystem} to be used when Stencil is
+* run from the CLI or via the public API in a node context.
+*
+* This takes an optional param supplying a `process` object to be used.
+*
+* @param c an optional object wrapping `process` and `logger` objects
+* @returns a node.js `CompilerSystem` object
+*/
+function createNodeSys(c = {}) {
+	const prcs = c?.process ?? global.process;
+	const logger = c?.logger;
+	const destroys = /* @__PURE__ */ new Set();
+	const onInterruptsCallbacks = [];
+	const sysCpus = cpus();
+	const hardwareConcurrency = sysCpus.length;
+	const osPlatform = platform();
+	const compilerExecutingPath = path.join(__dirname, "compiler", "index.mjs");
+	const runInterruptsCallbacks = () => {
+		const returnValues = [];
+		let cb;
+		while (isFunction(cb = onInterruptsCallbacks.pop())) try {
+			const rtn = cb();
+			returnValues.push(rtn);
+		} catch {}
+		return Promise.all(returnValues).then(() => {});
+	};
+	const sys = {
+		name: "node",
+		version: prcs.versions.node,
+		access(p) {
+			return new Promise((resolve) => {
+				fs.access(p, (err) => resolve(!err));
+			});
+		},
+		accessSync(p) {
+			let hasAccess = false;
+			try {
+				fs.accessSync(p);
+				hasAccess = true;
+			} catch {}
+			return hasAccess;
+		},
+		addDestroy(cb) {
+			destroys.add(cb);
+		},
+		removeDestroy(cb) {
+			destroys.delete(cb);
+		},
+		applyPrerenderGlobalPatch(opts) {
+			opts.window.fetch = global.fetch;
+			opts.window.Headers = global.Headers;
+			opts.window.Request = global.Request;
+			opts.window.Response = global.Response;
+		},
+		fetch: global.fetch,
+		checkVersion,
+		copyFile(src, dst) {
+			return new Promise((resolve) => {
+				fs.copyFile(src, dst, (err) => {
+					resolve(!err);
+				});
+			});
+		},
+		createDir(p, opts) {
+			return new Promise((resolve) => {
+				if (opts) fs.mkdir(p, opts, (err) => {
+					resolve({
+						basename: path.basename(p),
+						dirname: path.dirname(p),
+						path: p,
+						newDirs: [],
+						error: err
+					});
+				});
+				else fs.mkdir(p, (err) => {
+					resolve({
+						basename: path.basename(p),
+						dirname: path.dirname(p),
+						path: p,
+						newDirs: [],
+						error: err
+					});
+				});
+			});
+		},
+		createDirSync(p, opts) {
+			const results = {
+				basename: path.basename(p),
+				dirname: path.dirname(p),
+				path: p,
+				newDirs: [],
+				error: null
+			};
+			try {
+				fs.mkdirSync(p, opts);
+			} catch (e) {
+				results.error = e;
+			}
+			return results;
+		},
+		createWorkerController(maxConcurrentWorkers) {
+			return new NodeWorkerController(path.join(__dirname, "sys", "node", "worker.mjs"), maxConcurrentWorkers);
+		},
+		async destroy() {
+			const waits = [];
+			destroys.forEach((cb) => {
+				try {
+					const rtn = cb();
+					if (rtn && typeof rtn.then === "function") waits.push(rtn);
+				} catch (e) {
+					console.error(`node sys destroy: ${e}`);
+				}
+			});
+			if (waits.length > 0) await Promise.all(waits);
+			destroys.clear();
+		},
+		dynamicImport(p) {
+			return import(pathToFileURL(p).href);
+		},
+		encodeToBase64(str) {
+			return Buffer.from(str).toString("base64");
+		},
+		exit: async (exitCode) => {
+			await runInterruptsCallbacks();
+			process.exitCode = exitCode;
+		},
+		getCurrentDirectory() {
+			return normalizePath(prcs.cwd());
+		},
+		getCompilerExecutingPath() {
+			return compilerExecutingPath;
+		},
+		getEnvironmentVar(key) {
+			return process.env[key];
+		},
+		getLocalModulePath() {
+			return null;
+		},
+		getRemoteModuleUrl() {
+			return null;
+		},
+		glob: asyncGlob,
+		hardwareConcurrency,
+		isSymbolicLink(p) {
+			return new Promise((resolve) => {
+				try {
+					fs.lstat(p, (err, stats) => {
+						if (err) resolve(false);
+						else resolve(stats.isSymbolicLink());
+					});
+				} catch {
+					resolve(false);
+				}
+			});
+		},
+		nextTick: prcs.nextTick,
+		normalizePath,
+		onProcessInterrupt: (cb) => {
+			if (!onInterruptsCallbacks.includes(cb)) onInterruptsCallbacks.push(cb);
+		},
+		platformPath: path,
+		readDir(p) {
+			return new Promise((resolve) => {
+				fs.readdir(p, (err, files) => {
+					if (err) resolve([]);
+					else resolve(files.map((f) => {
+						return normalizePath(path.join(p, f));
+					}));
+				});
+			});
+		},
+		isTTY() {
+			return !!process?.stdout?.isTTY;
+		},
+		readDirSync(p) {
+			try {
+				return fs.readdirSync(p).map((f) => {
+					return normalizePath(path.join(p, f));
+				});
+			} catch {}
+			return [];
+		},
+		readFile(p, encoding) {
+			if (encoding === "binary") return new Promise((resolve) => {
+				fs.readFile(p, (_, data) => {
+					resolve(data);
+				});
+			});
+			return new Promise((resolve) => {
+				fs.readFile(p, "utf8", (_, data) => {
+					resolve(data);
+				});
+			});
+		},
+		readFileSync(p) {
+			try {
+				return fs.readFileSync(p, "utf8");
+			} catch {}
+		},
+		homeDir() {
+			try {
+				return os.homedir();
+			} catch {}
+		},
+		realpath(p) {
+			return new Promise((resolve) => {
+				fs.realpath(p, "utf8", (e, data) => {
+					resolve({
+						path: data,
+						error: e
+					});
+				});
+			});
+		},
+		realpathSync(p) {
+			const results = {
+				path: void 0,
+				error: null
+			};
+			try {
+				results.path = fs.realpathSync(p, "utf8");
+			} catch (e) {
+				results.error = e;
+			}
+			return results;
+		},
+		rename(oldPath, newPath) {
+			return new Promise((resolve) => {
+				fs.rename(oldPath, newPath, (error) => {
+					resolve({
+						oldPath,
+						newPath,
+						error,
+						oldDirs: [],
+						oldFiles: [],
+						newDirs: [],
+						newFiles: [],
+						renamed: [],
+						isFile: false,
+						isDirectory: false
+					});
+				});
+			});
+		},
+		resolvePath(p) {
+			return normalizePath(p);
+		},
+		removeDir(p, opts) {
+			return new Promise((resolve) => {
+				if (!!(opts && opts.recursive)) fs.rm(p, {
+					recursive: true,
+					force: true
+				}, (err) => {
+					resolve({
+						basename: path.basename(p),
+						dirname: path.dirname(p),
+						path: p,
+						removedDirs: [],
+						removedFiles: [],
+						error: err
+					});
+				});
+				else fs.rmdir(p, (err) => {
+					resolve({
+						basename: path.basename(p),
+						dirname: path.dirname(p),
+						path: p,
+						removedDirs: [],
+						removedFiles: [],
+						error: err
+					});
+				});
+			});
+		},
+		removeDirSync(p, opts) {
+			try {
+				if (!!(opts && opts.recursive)) fs.rmSync(p, {
+					recursive: true,
+					force: true
+				});
+				else fs.rmdirSync(p);
+				return {
+					basename: path.basename(p),
+					dirname: path.dirname(p),
+					path: p,
+					removedDirs: [],
+					removedFiles: [],
+					error: null
+				};
+			} catch (e) {
+				return {
+					basename: path.basename(p),
+					dirname: path.dirname(p),
+					path: p,
+					removedDirs: [],
+					removedFiles: [],
+					error: e
+				};
+			}
+		},
+		removeFile(p) {
+			return new Promise((resolve) => {
+				fs.unlink(p, (err) => {
+					resolve({
+						basename: path.basename(p),
+						dirname: path.dirname(p),
+						path: p,
+						error: err
+					});
+				});
+			});
+		},
+		removeFileSync(p) {
+			const results = {
+				basename: path.basename(p),
+				dirname: path.dirname(p),
+				path: p,
+				error: null
+			};
+			try {
+				fs.unlinkSync(p);
+			} catch (e) {
+				results.error = e;
+			}
+			return results;
+		},
+		setupCompiler(_c) {
+			sys.watchTimeout = 80;
+			sys.events = buildEvents();
+			const activeSubscriptions = /* @__PURE__ */ new Map();
+			/**
+			* Watch a directory for changes using @parcel/watcher.
+			* Uses native file system events (FSEvents on macOS, inotify on Linux, ReadDirectoryChangesW on Windows)
+			* for efficient, low-latency change detection.
+			*
+			* @param p - the directory path to watch
+			* @param callback - the callback function when changes occur
+			* @param _recursive - unused recursive flag
+			* @returns a file watcher with a close method
+			*/
+			sys.watchDirectory = (p, callback, _recursive) => {
+				logger?.debug(`NODE_SYS_DEBUG::watchDir ${p}`);
+				const subscriptionPromise = parcelWatcher.subscribe(p, (err, events) => {
+					if (err) {
+						logger?.error(`Watch error for ${p}: ${err.message}`);
+						return;
+					}
+					for (const event of events) {
+						const fileName = normalizePath(event.path);
+						logger?.debug(`NODE_SYS_DEBUG::watchDir:callback dir=${p} changedPath=${fileName} type=${event.type}`);
+						if (event.type === "create") callback(fileName, "fileAdd");
+						else if (event.type === "update") callback(fileName, "fileUpdate");
+						else if (event.type === "delete") callback(fileName, "fileDelete");
+					}
+				}, { ignore: [
+					".git",
+					"node_modules",
+					".stencil",
+					"dist",
+					"www",
+					".cache"
+				] }).catch((err) => {
+					logger?.debug(`Watch subscribe failed for ${p}: ${err.message}`);
+					return null;
+				});
+				activeSubscriptions.set(p, subscriptionPromise);
+				const close = () => {
+					const sub = activeSubscriptions.get(p);
+					if (sub) {
+						activeSubscriptions.delete(p);
+						sub.then((s) => s?.unsubscribe()).catch(() => {});
+					}
+				};
+				sys.addDestroy(close);
+				return { close() {
+					sys.removeDestroy(close);
+					close();
+				} };
+			};
+			/**
+			* Watch an individual file for changes using @parcel/watcher.
+			* Watches the parent directory and filters events for the specific file.
+			*
+			* @param filePath - the file path to watch
+			* @param callback - the callback function when the file changes
+			* @returns a file watcher with a close method
+			*/
+			sys.watchFile = (filePath, callback) => {
+				logger?.debug(`NODE_SYS_DEBUG::watchFile ${filePath}`);
+				const normalizedPath = normalizePath(filePath);
+				const dirPath = path.dirname(filePath);
+				const subscriptionPromise = parcelWatcher.subscribe(dirPath, (err, events) => {
+					if (err) {
+						logger?.error(`Watch error for ${filePath}: ${err.message}`);
+						return;
+					}
+					for (const event of events) {
+						const eventPath = normalizePath(event.path);
+						if (eventPath === normalizedPath) {
+							logger?.debug(`NODE_SYS_DEBUG::watchFile:callback file=${filePath} type=${event.type}`);
+							if (event.type === "create") {
+								callback(eventPath, "fileAdd");
+								sys.events.emit("fileAdd", eventPath);
+							} else if (event.type === "update") {
+								callback(eventPath, "fileUpdate");
+								sys.events.emit("fileUpdate", eventPath);
+							} else if (event.type === "delete") {
+								callback(eventPath, "fileDelete");
+								sys.events.emit("fileDelete", eventPath);
+							}
+						}
+					}
+				}, { ignore: [".git", "node_modules"] }).catch((err) => {
+					logger?.debug(`Watch subscribe failed for ${filePath}: ${err.message}`);
+					return null;
+				});
+				const subscriptionKey = `file:${filePath}`;
+				activeSubscriptions.set(subscriptionKey, subscriptionPromise);
+				const close = () => {
+					const sub = activeSubscriptions.get(subscriptionKey);
+					if (sub) {
+						activeSubscriptions.delete(subscriptionKey);
+						sub.then((s) => s?.unsubscribe()).catch(() => {});
+					}
+				};
+				sys.addDestroy(close);
+				return { close() {
+					sys.removeDestroy(close);
+					close();
+				} };
+			};
+		},
+		stat(p) {
+			return new Promise((resolve) => {
+				fs.stat(p, (err, fsStat) => {
+					if (err) resolve({
+						isDirectory: false,
+						isFile: false,
+						isSymbolicLink: false,
+						size: 0,
+						mtimeMs: 0,
+						error: err
+					});
+					else resolve({
+						isDirectory: fsStat.isDirectory(),
+						isFile: fsStat.isFile(),
+						isSymbolicLink: fsStat.isSymbolicLink(),
+						size: fsStat.size,
+						mtimeMs: fsStat.mtimeMs,
+						error: null
+					});
+				});
+			});
+		},
+		statSync(p) {
+			try {
+				const fsStat = fs.statSync(p);
+				return {
+					isDirectory: fsStat.isDirectory(),
+					isFile: fsStat.isFile(),
+					isSymbolicLink: fsStat.isSymbolicLink(),
+					size: fsStat.size,
+					mtimeMs: fsStat.mtimeMs,
+					error: null
+				};
+			} catch (e) {
+				return {
+					isDirectory: false,
+					isFile: false,
+					isSymbolicLink: false,
+					size: 0,
+					mtimeMs: 0,
+					error: e
+				};
+			}
+		},
+		tmpDirSync() {
+			return tmpdir();
+		},
+		writeFile(p, content) {
+			return new Promise((resolve) => {
+				fs.writeFile(p, content, (err) => {
+					resolve({
+						path: p,
+						error: err
+					});
+				});
+			});
+		},
+		writeFileSync(p, content) {
+			const results = {
+				path: p,
+				error: null
+			};
+			try {
+				fs.writeFileSync(p, content);
+			} catch (e) {
+				results.error = e;
+			}
+			return results;
+		},
+		generateContentHash(content, length) {
+			let hash = createHash("sha1").update(content).digest("hex").toLowerCase();
+			if (typeof length === "number") hash = hash.slice(0, length);
+			return Promise.resolve(hash);
+		},
+		generateFileHash(filePath, length) {
+			return new Promise((resolve, reject) => {
+				const h = createHash("sha1");
+				fs.createReadStream(filePath).on("error", (err) => reject(err)).on("data", (data) => h.update(data)).on("end", () => {
+					let hash = h.digest("hex").toLowerCase();
+					if (typeof length === "number") hash = hash.slice(0, length);
+					resolve(hash);
+				});
+			});
+		},
+		copy: nodeCopyTasks,
+		details: {
+			cpuModel: (Array.isArray(sysCpus) && sysCpus.length > 0 ? sysCpus[0] && sysCpus[0].model : "") || "",
+			freemem() {
+				return freemem();
+			},
+			platform: osPlatform === "darwin" || osPlatform === "linux" ? osPlatform : osPlatform === "win32" ? "windows" : "",
+			release: release(),
+			totalmem: totalmem()
+		}
+	};
+	sys.lazyRequire = new NodeLazyRequire(new NodeResolveModule(), {
+		"@types/jest": {
+			minVersion: "24.9.1",
+			recommendedVersion: "29",
+			maxVersion: "29.0.0"
+		},
+		jest: {
+			minVersion: "24.9.0",
+			recommendedVersion: "29",
+			maxVersion: "29.0.0"
+		},
+		"jest-cli": {
+			minVersion: "24.9.0",
+			recommendedVersion: "29",
+			maxVersion: "29.0.0"
+		},
+		puppeteer: {
+			minVersion: "10.0.0",
+			recommendedVersion: "20"
+		},
+		"puppeteer-core": {
+			minVersion: "10.0.0",
+			recommendedVersion: "20"
+		},
+		"workbox-build": {
+			minVersion: "4.3.1",
+			recommendedVersion: "4.3.1"
+		}
+	});
+	prcs.on("SIGINT", runInterruptsCallbacks);
+	prcs.on("exit", runInterruptsCallbacks);
+	return sys;
+}
+//#endregion
+export { LOG_LEVELS as a, CustomElementsExportBehaviorOptions as i, setupNodeProcess as n, buildEvents as o, createNodeLogger as r, createNodeSys as t };