@stencil/core 4.43.3 → 5.0.0-alpha.2

package/dist/validation-BR7tMYEv.mjs

@@ -0,0 +1,1441 @@
+import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
+import { A as CUSTOM, B as DOCS_CUSTOM, C as toDashCase, D as CMP_FLAGS, F as DIST_GLOBAL_STYLES, H as DOCS_JSON, I as DIST_HYDRATE_SCRIPT, K as GENERATED_DTS, L as DIST_LAZY, M as DIST, N as DIST_COLLECTION, P as DIST_CUSTOM_ELEMENTS, R as DIST_LAZY_LOADER, U as DOCS_README, V as DOCS_CUSTOM_ELEMENTS_MANIFEST, W as DOCS_VSCODE, X as MEMBER_FLAGS, Y as LISTENER_FLAGS, _ as isString, c as flatOne, it as VALID_CONFIG_OUTPUT_TARGETS, k as COPY, m as isIterable, o as dashToPascalCase, ot as WATCH_FLAGS, s as escapeWithPattern, tt as STATS, w as toTitleCase, x as sortBy, z as DIST_TYPES } from "./serialize-o-Sj1lvg.mjs";
+import path, { basename, dirname, relative } from "node:path";
+import { minimatch } from "minimatch";
+//#region src/utils/byte-size.ts
+/**
+* Used to learn the size of a string in bytes.
+*
+* @param str The string to measure
+* @returns number
+*/
+const byteSize = (str) => Buffer.byteLength(str, "utf8");
+//#endregion
+//#region src/utils/format-component-runtime-meta.ts
+const formatLazyBundleRuntimeMeta = (bundleId, cmps) => {
+	return [bundleId, cmps.map((cmp) => formatComponentRuntimeMeta(cmp, true))];
+};
+/**
+* Transform metadata about a component from the compiler to a compact form for
+* use at runtime.
+*
+* @param compilerMeta component metadata gathered during compilation
+* @param includeMethods include methods in the component's members or not
+* @returns a compact format for component metadata, intended for runtime use
+*/
+const formatComponentRuntimeMeta = (compilerMeta, includeMethods) => {
+	let flags = 0;
+	if (compilerMeta.encapsulation === "shadow") {
+		flags |= CMP_FLAGS.shadowDomEncapsulation;
+		if (compilerMeta.shadowDelegatesFocus) flags |= CMP_FLAGS.shadowDelegatesFocus;
+		if (compilerMeta.slotAssignment === "manual") flags |= CMP_FLAGS.shadowSlotAssignmentManual;
+	} else if (compilerMeta.encapsulation === "scoped") flags |= CMP_FLAGS.scopedCssEncapsulation;
+	if (compilerMeta.formAssociated) flags |= CMP_FLAGS.formAssociated;
+	if (compilerMeta.encapsulation !== "shadow" && compilerMeta.htmlTagNames.includes("slot")) flags |= CMP_FLAGS.hasSlotRelocation;
+	if (compilerMeta.hasSlot) flags |= CMP_FLAGS.hasSlot;
+	if (compilerMeta.hasMode) flags |= CMP_FLAGS.hasMode;
+	if (compilerMeta.hasModernPropertyDecls) flags |= CMP_FLAGS.hasModernPropertyDecls;
+	const members = formatComponentRuntimeMembers(compilerMeta, includeMethods);
+	const hostListeners = formatHostListeners(compilerMeta);
+	const watchers = formatComponentRuntimeReactiveHandlers(compilerMeta, "watchers");
+	const serializers = formatComponentRuntimeReactiveHandlers(compilerMeta, "serializers");
+	const deserializers = formatComponentRuntimeReactiveHandlers(compilerMeta, "deserializers");
+	return trimFalsy([
+		flags,
+		compilerMeta.tagName,
+		Object.keys(members).length > 0 ? members : void 0,
+		hostListeners.length > 0 ? hostListeners : void 0,
+		Object.keys(watchers).length > 0 ? watchers : void 0,
+		Object.keys(serializers).length > 0 ? serializers : void 0,
+		Object.keys(deserializers).length > 0 ? deserializers : void 0
+	]);
+};
+const stringifyRuntimeData = (data) => {
+	const json = JSON.stringify(data);
+	if (json.length > 1e4) return `JSON.parse(${JSON.stringify(json)})`;
+	return json;
+};
+/**
+* Transforms Stencil compiler metadata into a {@link d.ComponentCompilerMeta} object.
+* This handles processing any compiler metadata transformed from components' uses of `@Watch()`, `@PropSerialize()`, and `@AttrDeserialize()`.
+* The map of watched properties to their callback(s) will be immediately available
+* to the runtime at bootstrap.
+*
+* @param compilerMeta Component metadata gathered during compilation
+* @param decorator The decorator type to be processed: 'watchers', 'serializers', or 'deserializers'
+* @returns An object mapping watched properties to their respective callback(s)
+*/
+const formatComponentRuntimeReactiveHandlers = (compilerMeta, decorator) => {
+	const handlers = {};
+	compilerMeta[decorator]?.forEach(({ propName, methodName, handlerOptions }) => {
+		let watcherFlags = 0;
+		if (handlerOptions?.immediate) watcherFlags |= WATCH_FLAGS.Immediate;
+		handlers[propName] = [...handlers[propName] ?? [], { [methodName]: watcherFlags }];
+	});
+	return handlers;
+};
+const formatComponentRuntimeMembers = (compilerMeta, includeMethods = true) => {
+	return {
+		...formatPropertiesRuntimeMember(compilerMeta.properties),
+		...formatStatesRuntimeMember(compilerMeta.states),
+		...includeMethods ? formatMethodsRuntimeMember(compilerMeta.methods) : {}
+	};
+};
+const formatPropertiesRuntimeMember = (properties) => {
+	const runtimeMembers = {};
+	properties.forEach((member) => {
+		runtimeMembers[member.name] = trimFalsy([formatFlags(member), formatAttrName(member)]);
+	});
+	return runtimeMembers;
+};
+const formatFlags = (compilerProperty) => {
+	let type = formatPropType(compilerProperty.type);
+	if (compilerProperty.mutable) type |= MEMBER_FLAGS.Mutable;
+	if (compilerProperty.reflect) type |= MEMBER_FLAGS.ReflectAttr;
+	if (compilerProperty.getter) type |= MEMBER_FLAGS.Getter;
+	if (compilerProperty.setter) type |= MEMBER_FLAGS.Setter;
+	return type;
+};
+/**
+* We mainly add the alternative kebab-case attribute name because it might
+* be used in an HTML environment (non JSX). Since we support hydration of
+* complex types we provide a kebab-case attribute name for properties with
+* these types.
+*/
+const kebabCaseSupportForTypes = ["string", "unknown"];
+const formatAttrName = (compilerProperty) => {
+	if (kebabCaseSupportForTypes.includes(typeof compilerProperty.attribute)) {
+		if (compilerProperty.name === compilerProperty.attribute) return;
+		return compilerProperty.attribute;
+	}
+};
+const formatPropType = (type) => {
+	if (type === "string") return MEMBER_FLAGS.String;
+	if (type === "number") return MEMBER_FLAGS.Number;
+	if (type === "boolean") return MEMBER_FLAGS.Boolean;
+	if (type === "any") return MEMBER_FLAGS.Any;
+	return MEMBER_FLAGS.Unknown;
+};
+const formatStatesRuntimeMember = (states) => {
+	const runtimeMembers = {};
+	states.forEach((member) => {
+		runtimeMembers[member.name] = [MEMBER_FLAGS.State];
+	});
+	return runtimeMembers;
+};
+const formatMethodsRuntimeMember = (methods) => {
+	const runtimeMembers = {};
+	methods.forEach((member) => {
+		runtimeMembers[member.name] = [MEMBER_FLAGS.Method];
+	});
+	return runtimeMembers;
+};
+const formatHostListeners = (compilerMeta) => {
+	return compilerMeta.listeners.map((compilerListener) => {
+		return [
+			computeListenerFlags(compilerListener),
+			compilerListener.name,
+			compilerListener.method
+		];
+	});
+};
+const computeListenerFlags = (listener) => {
+	let flags = 0;
+	if (listener.capture) flags |= LISTENER_FLAGS.Capture;
+	if (listener.passive) flags |= LISTENER_FLAGS.Passive;
+	switch (listener.target) {
+		case "document":
+			flags |= LISTENER_FLAGS.TargetDocument;
+			break;
+		case "window":
+			flags |= LISTENER_FLAGS.TargetWindow;
+			break;
+		case "body":
+			flags |= LISTENER_FLAGS.TargetBody;
+			break;
+		case "parent":
+			flags |= LISTENER_FLAGS.TargetParent;
+			break;
+	}
+	return flags;
+};
+const trimFalsy = (data) => {
+	const arr = data;
+	for (let i = arr.length - 1; i >= 0; i--) {
+		if (arr[i]) break;
+		arr.pop();
+	}
+	return arr;
+};
+//#endregion
+//#region src/utils/is-glob.ts
+/**
+* Check if a string is a glob pattern (e.g. 'src/*.js' or something like that)
+*
+* @param str a string to check
+* @returns whether the string is a glob pattern or not
+*/
+const isGlob = (str) => {
+	const chars = {
+		"{": "}",
+		"(": ")",
+		"[": "]"
+	};
+	const regex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
+	if (str === "") return false;
+	let match;
+	while (match = regex.exec(str)) {
+		if (match[2]) return true;
+		let idx = match.index + match[0].length;
+		const open = match[1];
+		const close = open ? chars[open] : null;
+		if (open && close) {
+			const n = str.indexOf(close, idx);
+			if (n !== -1) idx = n + 1;
+		}
+		str = str.slice(idx);
+	}
+	return false;
+};
+//#endregion
+//#region src/utils/is-root-path.ts
+/**
+* Checks if the path is the Operating System (OS) root path, such as "/" or "C:\". This function does not take the OS
+* the code is running on into account when performing this evaluation.
+* @param p the path to check
+* @returns `true` if the path is an OS root path, `false` otherwise
+*/
+const isRootPath = (p) => p === "/" || windowsPathRegex.test(p);
+const windowsPathRegex = /^(?:[a-zA-Z]:|[\\/]{2}[^\\/]+[\\/]+[^\\/]+)?[\\/]$/;
+//#endregion
+//#region src/utils/message-utils.ts
+/**
+* Builds a template `Diagnostic` entity for a build error. The created `Diagnostic` is returned, and have little
+* detail attached to it regarding the specifics of the error - it is the responsibility of the caller of this method
+* to attach the specifics of the error message.
+*
+* The created `Diagnostic` is pushed to the `diagnostics` argument as a side effect of calling this method.
+*
+* @param diagnostics the existing diagnostics that the created template `Diagnostic` should be added to
+* @returns the created `Diagnostic`
+*/
+const buildError = (diagnostics) => {
+	const diagnostic = {
+		level: "error",
+		type: "build",
+		header: "Build Error",
+		messageText: "build error",
+		relFilePath: void 0,
+		absFilePath: void 0,
+		lines: []
+	};
+	if (diagnostics) diagnostics.push(diagnostic);
+	return diagnostic;
+};
+/**
+* Builds a template `Diagnostic` entity for a build warning. The created `Diagnostic` is returned, and have little
+* detail attached to it regarding the specifics of the warning - it is the responsibility of the caller of this method
+* to attach the specifics of the warning message.
+*
+* The created `Diagnostic` is pushed to the `diagnostics` argument as a side effect of calling this method.
+*
+* @param diagnostics the existing diagnostics that the created template `Diagnostic` should be added to
+* @returns the created `Diagnostic`
+*/
+const buildWarn = (diagnostics) => {
+	const diagnostic = {
+		level: "warn",
+		type: "build",
+		header: "Build Warn",
+		messageText: "build warn",
+		lines: []
+	};
+	diagnostics.push(diagnostic);
+	return diagnostic;
+};
+/**
+* Create a diagnostic message suited for representing an error in a JSON
+* file. This includes information about the exact lines in the JSON file which
+* caused the error and the path to the file.
+*
+* @param compilerCtx the current compiler context
+* @param diagnostics a list of diagnostics used as a return param
+* @param jsonFilePath the path to the JSON file where the error occurred
+* @param msg the error message
+* @param jsonField the key for the field which caused the error, used for finding
+* the error line in the original JSON file
+* @returns a reference to the newly-created diagnostic
+*/
+const buildJsonFileError = (compilerCtx, diagnostics, jsonFilePath, msg, jsonField) => {
+	const err = buildError(diagnostics);
+	err.messageText = msg;
+	err.absFilePath = jsonFilePath;
+	if (typeof jsonField === "string") try {
+		const lines = compilerCtx.fs.readFileSync(jsonFilePath).replace(/\r/g, "\n").split("\n");
+		for (let i = 0; i < lines.length; i++) {
+			const txtLine = lines[i];
+			const txtIndex = txtLine.indexOf(jsonField);
+			if (txtIndex > -1) {
+				const warnLine = {
+					lineIndex: i,
+					lineNumber: i + 1,
+					text: txtLine,
+					errorCharStart: txtIndex,
+					errorLength: jsonField.length
+				};
+				err.lineNumber = warnLine.lineNumber;
+				err.columnNumber = txtIndex + 1;
+				err.lines.push(warnLine);
+				if (i >= 0) {
+					const beforeWarnLine = {
+						lineIndex: warnLine.lineIndex - 1,
+						lineNumber: warnLine.lineNumber - 1,
+						text: lines[i - 1],
+						errorCharStart: -1,
+						errorLength: -1
+					};
+					err.lines.unshift(beforeWarnLine);
+				}
+				if (i < lines.length) {
+					const afterWarnLine = {
+						lineIndex: warnLine.lineIndex + 1,
+						lineNumber: warnLine.lineNumber + 1,
+						text: lines[i + 1],
+						errorCharStart: -1,
+						errorLength: -1
+					};
+					err.lines.push(afterWarnLine);
+				}
+				break;
+			}
+		}
+	} catch {}
+	return err;
+};
+/**
+* Builds a diagnostic from an `Error`, appends it to the `diagnostics` parameter, and returns the created diagnostic
+* @param diagnostics the series of diagnostics the newly created diagnostics should be added to
+* @param err the error to derive information from in generating the diagnostic
+* @param msg an optional message to use in place of `err` to generate the diagnostic
+* @returns the generated diagnostic
+*/
+const catchError = (diagnostics, err, msg) => {
+	const diagnostic = {
+		level: "error",
+		type: "build",
+		header: "Build Error",
+		messageText: "build error",
+		lines: []
+	};
+	if (isString(msg)) diagnostic.messageText = msg.length ? msg : "UNKNOWN ERROR";
+	else if (err != null) if (err.stack != null) diagnostic.messageText = err.stack.toString();
+	else if (err.message != null) diagnostic.messageText = err.message.length ? err.message : "UNKNOWN ERROR";
+	else diagnostic.messageText = err.toString();
+	if (diagnostics != null && !shouldIgnoreError(diagnostic.messageText)) diagnostics.push(diagnostic);
+	return diagnostic;
+};
+/**
+* Determine if the provided diagnostics have any build errors
+* @param diagnostics the diagnostics to inspect
+* @returns true if any of the diagnostics in the list provided are errors that did not occur at runtime. false
+* otherwise.
+*/
+const hasError = (diagnostics) => {
+	if (diagnostics == null || diagnostics.length === 0) return false;
+	return diagnostics.some((d) => d.level === "error" && d.type !== "runtime");
+};
+/**
+* Determine if the provided diagnostics have any warnings
+* @param diagnostics the diagnostics to inspect
+* @returns true if any of the diagnostics in the list provided are warnings. false otherwise.
+*/
+const hasWarning = (diagnostics) => {
+	if (diagnostics == null || diagnostics.length === 0) return false;
+	return diagnostics.some((d) => d.level === "warn");
+};
+const shouldIgnoreError = (msg) => {
+	return msg === TASK_CANCELED_MSG;
+};
+const TASK_CANCELED_MSG = `task canceled`;
+//#endregion
+//#region src/utils/logger/logger-utils.ts
+/**
+* Iterate through a series of diagnostics to provide minor fix-ups for various edge cases, deduplicate messages, etc.
+* @param compilerCtx the current compiler context
+* @param diagnostics the diagnostics to normalize
+* @returns the normalize documents
+*/
+const normalizeDiagnostics = (compilerCtx, diagnostics) => {
+	const maxErrorsToNormalize = 25;
+	const normalizedErrors = [];
+	const normalizedOthers = [];
+	const dups = /* @__PURE__ */ new Set();
+	for (let i = 0; i < diagnostics.length; i++) {
+		const diagnostic = normalizeDiagnostic(compilerCtx, diagnostics[i]);
+		const key = (diagnostic.absFilePath ?? "") + (diagnostic.code ?? "") + diagnostic.messageText + diagnostic.type;
+		if (dups.has(key)) continue;
+		dups.add(key);
+		const total = normalizedErrors.length + normalizedOthers.length;
+		if (diagnostic.level === "error") normalizedErrors.push(diagnostic);
+		else if (total < maxErrorsToNormalize) normalizedOthers.push(diagnostic);
+	}
+	return [...normalizedErrors, ...normalizedOthers];
+};
+/**
+* Perform post-processing on a `Diagnostic` to handle a few message edge cases, massaging error message text and
+* updating build failure contexts
+* @param compilerCtx the current compiler
+* @param diagnostic the diagnostic to normalize
+* @returns the altered diagnostic
+*/
+const normalizeDiagnostic = (compilerCtx, diagnostic) => {
+	if (diagnostic.messageText) {
+		if (typeof diagnostic.messageText.message === "string") diagnostic.messageText = diagnostic.messageText.message;
+		else if (typeof diagnostic.messageText === "string" && diagnostic.messageText.indexOf("Error: ") === 0) diagnostic.messageText = diagnostic.messageText.slice(7);
+	}
+	if (diagnostic.messageText) {
+		if (diagnostic.messageText.includes(`Cannot find name 'h'`)) {
+			diagnostic.header = `Missing "h" import for JSX types`;
+			diagnostic.messageText = `In order to load accurate JSX types for components, the "h" function must be imported from "@stencil/core" by each component using JSX. For example: import { Component, h } from '@stencil/core';`;
+			if (diagnostic.absFilePath) try {
+				const srcLines = splitLineBreaks(compilerCtx.fs.readFileSync(diagnostic.absFilePath));
+				for (let i = 0; i < srcLines.length; i++) {
+					const srcLine = srcLines[i];
+					if (srcLine.includes("@stencil/core")) {
+						const msgLines = [];
+						const beforeLineIndex = i - 1;
+						if (beforeLineIndex > -1) {
+							const beforeLine = {
+								lineIndex: beforeLineIndex,
+								lineNumber: beforeLineIndex + 1,
+								text: srcLines[beforeLineIndex],
+								errorCharStart: -1,
+								errorLength: -1
+							};
+							msgLines.push(beforeLine);
+						}
+						const errorLine = {
+							lineIndex: i,
+							lineNumber: i + 1,
+							text: srcLine,
+							errorCharStart: 0,
+							errorLength: -1
+						};
+						msgLines.push(errorLine);
+						diagnostic.lineNumber = errorLine.lineNumber;
+						diagnostic.columnNumber = srcLine.indexOf("}");
+						const afterLineIndex = i + 1;
+						if (afterLineIndex < srcLines.length) {
+							const afterLine = {
+								lineIndex: afterLineIndex,
+								lineNumber: afterLineIndex + 1,
+								text: srcLines[afterLineIndex],
+								errorCharStart: -1,
+								errorLength: -1
+							};
+							msgLines.push(afterLine);
+						}
+						diagnostic.lines = msgLines;
+						break;
+					}
+				}
+			} catch {}
+		}
+	}
+	return diagnostic;
+};
+/**
+* Split a corpus by newlines. Carriage returns are treated a newlines.
+* @param sourceText the corpus to split
+* @returns the split text
+*/
+const splitLineBreaks = (sourceText) => {
+	if (typeof sourceText !== "string") return [];
+	sourceText = sourceText.replace(/\\r/g, "\n");
+	return sourceText.split("\n");
+};
+const escapeHtml = (unsafe) => {
+	if (unsafe === void 0) return "undefined";
+	if (unsafe === null) return "null";
+	if (typeof unsafe !== "string") unsafe = unsafe.toString();
+	return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+};
+//#endregion
+//#region src/utils/logger/logger-rollup.ts
+const loadRollupDiagnostics = (config, compilerCtx, buildCtx, rollupError) => {
+	const formattedCode = formatErrorCode(rollupError.code);
+	const diagnostic = {
+		level: "error",
+		type: "bundling",
+		language: "javascript",
+		code: rollupError.code,
+		header: `Rollup${formattedCode.length > 0 ? ": " + formattedCode : ""}`,
+		messageText: formattedCode,
+		relFilePath: void 0,
+		absFilePath: void 0,
+		lines: []
+	};
+	if (config.logLevel === "debug" && rollupError.stack) diagnostic.messageText = rollupError.stack;
+	else if (rollupError.message) diagnostic.messageText = rollupError.message;
+	if (rollupError.plugin) diagnostic.messageText += ` (plugin: ${rollupError.plugin}${rollupError.hook ? `, ${rollupError.hook}` : ""})`;
+	const loc = rollupError.loc;
+	if (loc != null) {
+		const srcFile = loc.file || rollupError.id;
+		if (isString(srcFile)) try {
+			const sourceText = compilerCtx.fs.readFileSync(srcFile);
+			if (sourceText) {
+				diagnostic.absFilePath = srcFile;
+				try {
+					const srcLines = splitLineBreaks(sourceText);
+					const errorLine = {
+						lineIndex: loc.line - 1,
+						lineNumber: loc.line,
+						text: srcLines[loc.line - 1],
+						errorCharStart: loc.column,
+						errorLength: 0
+					};
+					diagnostic.lineNumber = errorLine.lineNumber;
+					diagnostic.columnNumber = errorLine.errorCharStart;
+					const highlightLine = errorLine.text?.slice(loc.column) ?? "";
+					for (let i = 0; i < highlightLine.length; i++) {
+						if (charBreak.has(highlightLine.charAt(i))) break;
+						errorLine.errorLength++;
+					}
+					diagnostic.lines.push(errorLine);
+					if (errorLine.errorLength === 0 && errorLine.errorCharStart > 0) {
+						errorLine.errorLength = 1;
+						errorLine.errorCharStart--;
+					}
+					if (errorLine.lineIndex > 0) {
+						const previousLine = {
+							lineIndex: errorLine.lineIndex - 1,
+							lineNumber: errorLine.lineNumber - 1,
+							text: srcLines[errorLine.lineIndex - 1],
+							errorCharStart: -1,
+							errorLength: -1
+						};
+						diagnostic.lines.unshift(previousLine);
+					}
+					if (errorLine.lineIndex + 1 < srcLines.length) {
+						const nextLine = {
+							lineIndex: errorLine.lineIndex + 1,
+							lineNumber: errorLine.lineNumber + 1,
+							text: srcLines[errorLine.lineIndex + 1],
+							errorCharStart: -1,
+							errorLength: -1
+						};
+						diagnostic.lines.push(nextLine);
+					}
+				} catch {
+					diagnostic.messageText += `\nError parsing: ${diagnostic.absFilePath}, line: ${loc.line}, column: ${loc.column}`;
+					diagnostic.debugText = sourceText;
+				}
+			} else if (typeof rollupError.frame === "string") diagnostic.messageText += "\n" + rollupError.frame;
+		} catch {}
+	}
+	buildCtx.diagnostics.push(diagnostic);
+};
+const createOnWarnFn = (diagnostics, bundleModulesFiles) => {
+	const previousWarns = /* @__PURE__ */ new Set();
+	return function onWarningMessage(warning) {
+		if (warning == null || warning.code && ignoreWarnCodes.has(warning.code) || warning.message && previousWarns.has(warning.message)) return;
+		if (warning.message) previousWarns.add(warning.message);
+		let label = "";
+		if (bundleModulesFiles) {
+			label = bundleModulesFiles.reduce((cmps, m) => {
+				cmps.push(...m.cmps);
+				return cmps;
+			}, []).join(", ").trim();
+			if (label.length) label += ": ";
+		}
+		const diagnostic = buildWarn(diagnostics);
+		diagnostic.header = `Bundling Warning ${warning.code}`;
+		diagnostic.messageText = label + (warning.message || warning);
+	};
+};
+const ignoreWarnCodes = new Set([
+	"THIS_IS_UNDEFINED",
+	"NON_EXISTENT_EXPORT",
+	"CIRCULAR_DEPENDENCY",
+	"EMPTY_BUNDLE",
+	"UNUSED_EXTERNAL_IMPORT"
+]);
+const charBreak = new Set([
+	" ",
+	"=",
+	".",
+	",",
+	"?",
+	":",
+	";",
+	"(",
+	")",
+	"{",
+	"}",
+	"[",
+	"]",
+	"|",
+	`'`,
+	`"`,
+	"`"
+]);
+const formatErrorCode = (errorCode) => {
+	if (typeof errorCode === "string") return errorCode.split("_").map((c) => {
+		return toTitleCase(c.toLowerCase());
+	}).join(" ");
+	return (errorCode || "").trim();
+};
+//#endregion
+//#region src/utils/path.ts
+/**
+* Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
+* Forward-slash paths can be used in Windows as long as they're not
+* extended-length paths and don't contain any non-ascii characters.
+* This was created since the path methods in Node.js outputs \\ paths on Windows.
+* @param path the Windows-based path to convert
+* @param relativize whether or not a relative path should have `./` prepended
+* @returns the converted path
+*/
+const normalizePath = (path, relativize = true) => {
+	if (typeof path !== "string") throw new Error(`invalid path to normalize`);
+	path = normalizeSlashes(path.trim());
+	const reducedComponents = reducePathComponents(pathComponents(path, getRootLength(path)));
+	const rootPart = reducedComponents[0];
+	const secondPart = reducedComponents[1];
+	const normalized = rootPart + reducedComponents.slice(1).join("/");
+	if (normalized === "") return ".";
+	if (rootPart === "" && secondPart && path.includes("/") && !secondPart.startsWith(".") && !secondPart.startsWith("@") && relativize) return "./" + normalized;
+	return normalized;
+};
+const normalizeSlashes = (path) => path.replace(backslashRegExp, "/");
+const altDirectorySeparator = "\\";
+const urlSchemeSeparator = "://";
+const backslashRegExp = /\\/g;
+const reducePathComponents = (components) => {
+	if (!Array.isArray(components) || components.length === 0) return [];
+	const reduced = [components[0]];
+	for (let i = 1; i < components.length; i++) {
+		const component = components[i];
+		if (!component) continue;
+		if (component === ".") continue;
+		if (component === "..") {
+			if (reduced.length > 1) {
+				if (reduced[reduced.length - 1] !== "..") {
+					reduced.pop();
+					continue;
+				}
+			} else if (reduced[0]) continue;
+		}
+		reduced.push(component);
+	}
+	return reduced;
+};
+const getRootLength = (path) => {
+	const rootLength = getEncodedRootLength(path);
+	return rootLength < 0 ? ~rootLength : rootLength;
+};
+const getEncodedRootLength = (path) => {
+	if (!path) return 0;
+	const ch0 = path.charCodeAt(0);
+	if (ch0 === CharacterCodes.slash || ch0 === CharacterCodes.backslash) {
+		if (path.charCodeAt(1) !== ch0) return 1;
+		const p1 = path.indexOf(ch0 === CharacterCodes.slash ? "/" : altDirectorySeparator, 2);
+		if (p1 < 0) return path.length;
+		return p1 + 1;
+	}
+	if (isVolumeCharacter(ch0) && path.charCodeAt(1) === CharacterCodes.colon) {
+		const ch2 = path.charCodeAt(2);
+		if (ch2 === CharacterCodes.slash || ch2 === CharacterCodes.backslash) return 3;
+		if (path.length === 2) return 2;
+	}
+	const schemeEnd = path.indexOf(urlSchemeSeparator);
+	if (schemeEnd !== -1) {
+		const authorityStart = schemeEnd + 3;
+		const authorityEnd = path.indexOf("/", authorityStart);
+		if (authorityEnd !== -1) {
+			const scheme = path.slice(0, schemeEnd);
+			const authority = path.slice(authorityStart, authorityEnd);
+			if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
+				const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
+				if (volumeSeparatorEnd !== -1) {
+					if (path.charCodeAt(volumeSeparatorEnd) === CharacterCodes.slash) return ~(volumeSeparatorEnd + 1);
+					if (volumeSeparatorEnd === path.length) return ~volumeSeparatorEnd;
+				}
+			}
+			return ~(authorityEnd + 1);
+		}
+		return ~path.length;
+	}
+	return 0;
+};
+const isVolumeCharacter = (charCode) => charCode >= CharacterCodes.a && charCode <= CharacterCodes.z || charCode >= CharacterCodes.A && charCode <= CharacterCodes.Z;
+const getFileUrlVolumeSeparatorEnd = (url, start) => {
+	const ch0 = url.charCodeAt(start);
+	if (ch0 === CharacterCodes.colon) return start + 1;
+	if (ch0 === CharacterCodes.percent && url.charCodeAt(start + 1) === CharacterCodes._3) {
+		const ch2 = url.charCodeAt(start + 2);
+		if (ch2 === CharacterCodes.a || ch2 === CharacterCodes.A) return start + 3;
+	}
+	return -1;
+};
+const pathComponents = (path, rootLength) => {
+	const root = path.substring(0, rootLength);
+	const rest = path.substring(rootLength).split("/");
+	const restLen = rest.length;
+	if (restLen > 0 && !rest[restLen - 1]) rest.pop();
+	return [root, ...rest];
+};
+/**
+* Same as normalizePath(), expect it'll also strip any query strings
+* from the path name. So /dir/file.css?tag=cmp-a becomes /dir/file.css
+* @param p the path to normalize
+* @returns the normalized path, sans any query strings
+*/
+const normalizeFsPath = (p) => normalizePath(p.split("?")[0].replace(/\0/g, ""));
+const normalizeFsPathQuery = (importPath) => {
+	const pathParts = importPath.split("?");
+	const filePath = normalizePath(pathParts[0]);
+	const filePathParts = filePath.split(".");
+	const ext = filePathParts.length > 1 ? filePathParts.pop().toLowerCase() : null;
+	const params = pathParts.length > 1 ? new URLSearchParams(pathParts[1]) : null;
+	return {
+		filePath,
+		ext,
+		format: params ? params.get("format") : null
+	};
+};
+var CharacterCodes = /* @__PURE__ */ function(CharacterCodes) {
+	CharacterCodes[CharacterCodes["a"] = 97] = "a";
+	CharacterCodes[CharacterCodes["A"] = 65] = "A";
+	CharacterCodes[CharacterCodes["z"] = 122] = "z";
+	CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+	CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+	CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+	CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+	CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+	CharacterCodes[CharacterCodes["percent"] = 37] = "percent";
+	CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+	return CharacterCodes;
+}(CharacterCodes || {});
+/**
+* A wrapped version of node.js' {@link path.relative} which adds our custom
+* normalization logic. This solves the relative path between `from` and `to`!
+*
+* The calculation of the returned path follows that of Node's logic, with one exception - if the calculated path
+* results in an empty string, a string of length one with a period (`'.'`) is returned.
+*
+* @throws the underlying node.js function can throw if either path is not a
+* string
+* @param from the path where relative resolution starts
+* @param to the destination path
+* @returns the resolved relative path
+*/
+function relative$1(from, to) {
+	/**
+	* When normalizing, we should _not_ attempt to relativize the path returned by the native Node `relative` method.
+	* When finding the relative path between `from` and `to`, Node does not prepend './' to a non-zero length calculated
+	* path. However, our algorithm does differ from that of Node's, as described in this function's JSDoc when a zero
+	* length string is encountered.
+	*/
+	return normalizePath(path.relative(from, to), false);
+}
+/**
+* A wrapped version of node.js' {@link path.join} which adds our custom
+* normalization logic. This joins all the arguments (path fragments) into a
+* single path.
+*
+* The calculation of the returned path follows that of Node's logic, with one exception - any trailing slashes will
+* be removed from the calculated path.
+*
+* @throws the underlying node function will throw if any argument is not a
+* string
+* @param paths the paths to join together
+* @returns a joined path!
+*/
+function join$1(...paths) {
+	/**
+	* When normalizing, we should _not_ attempt to relativize the path returned by the native Node `join` method. When
+	* calculating the path from each of the string-based parts, Node does not prepend './' to any calculated path.
+	*
+	* Note that our algorithm does differ from Node's, as described in this function's JSDoc regarding trailing
+	* slashes.
+	*/
+	return normalizePath(path.join(...paths), false);
+}
+/**
+* A wrapped version of node.js' {@link path.resolve} which adds our custom
+* normalization logic. This resolves a path to a given (relative or absolute)
+* path.
+*
+* @throws the underlying node function will throw if any argument is not a
+* string
+* @param paths a path or path fragments to resolve
+* @returns a resolved path!
+*/
+function resolve(...paths) {
+	/**
+	* When normalizing, we should _not_ attempt to relativize the path returned by the native Node `resolve` method. When
+	* calculating the path from each of the string-based parts, Node does not prepend './' to the calculated path.
+	*/
+	return normalizePath(path.resolve(...paths), false);
+}
+/**
+* A wrapped version of node.js' {@link path.normalize} which adds our custom
+* normalization logic. This normalizes a path, de-duping repeated segment
+* separators and resolving `'..'` segments.
+*
+* @throws the underlying node function will throw if the argument is not a
+* string
+* @param toNormalize a path to normalize
+* @returns a normalized path!
+*/
+function normalize(toNormalize) {
+	/**
+	* When normalizing, we should _not_ attempt to relativize the path returned by the native Node `normalize` method.
+	* When calculating the path from each of the string-based parts, Node does not prepend './' to the calculated path.
+	*/
+	return normalizePath(path.normalize(toNormalize), false);
+}
+//#endregion
+//#region src/utils/logger/logger-typescript.ts
+/**
+* Augment a `Diagnostic` with information from a `Node` in the AST to provide richer error information
+* @param d the diagnostic to augment
+* @param node the node to augment with additional information
+* @returns the augmented diagnostic
+*/
+const augmentDiagnosticWithNode = (d, node) => {
+	if (!node) return d;
+	const sourceFile = node.getSourceFile();
+	if (!sourceFile) return d;
+	d.absFilePath = normalizePath(sourceFile.fileName);
+	const sourceText = sourceFile.text;
+	const srcLines = splitLineBreaks(sourceText);
+	const start = node.getStart();
+	const end = node.getEnd();
+	const posStart = sourceFile.getLineAndCharacterOfPosition(start);
+	const errorLine = {
+		lineIndex: posStart.line,
+		lineNumber: posStart.line + 1,
+		text: srcLines[posStart.line],
+		errorCharStart: posStart.character,
+		errorLength: Math.max(end - start, 1)
+	};
+	d.lineNumber = errorLine.lineNumber;
+	d.columnNumber = errorLine.errorCharStart + 1;
+	d.lines.push(errorLine);
+	if (errorLine.errorLength === 0 && errorLine.errorCharStart > 0) {
+		errorLine.errorLength = 1;
+		errorLine.errorCharStart--;
+	}
+	if (errorLine.lineIndex > 0) {
+		const previousLine = {
+			lineIndex: errorLine.lineIndex - 1,
+			lineNumber: errorLine.lineNumber - 1,
+			text: srcLines[errorLine.lineIndex - 1],
+			errorCharStart: -1,
+			errorLength: -1
+		};
+		d.lines.unshift(previousLine);
+	}
+	if (errorLine.lineIndex + 1 < srcLines.length) {
+		const nextLine = {
+			lineIndex: errorLine.lineIndex + 1,
+			lineNumber: errorLine.lineNumber + 1,
+			text: srcLines[errorLine.lineIndex + 1],
+			errorCharStart: -1,
+			errorLength: -1
+		};
+		d.lines.push(nextLine);
+	}
+	return d;
+};
+/**
+* Ok, so formatting overkill, we know. But whatever, it makes for great
+* error reporting within a terminal. So, yeah, let's code it up, shall we?
+*/
+/**
+* Convert an array of TypeScript diagnostics to Stencil diagnostic format.
+*
+* @param tsDiagnostics - array of TypeScript diagnostic objects
+* @returns array of Stencil diagnostic objects
+*/
+const loadTypeScriptDiagnostics = (tsDiagnostics) => {
+	const diagnostics = [];
+	const maxErrors = Math.min(tsDiagnostics.length, 50);
+	for (let i = 0; i < maxErrors; i++) diagnostics.push(loadTypeScriptDiagnostic(tsDiagnostics[i]));
+	return diagnostics;
+};
+/**
+* Convert a TypeScript diagnostic object into our internal, Stencil-specific
+* diagnostic format
+*
+* @param tsDiagnostic a TypeScript diagnostic message record
+* @returns a Stencil diagnostic, suitable for showing an error to the user
+*/
+const loadTypeScriptDiagnostic = (tsDiagnostic) => {
+	const d = {
+		absFilePath: void 0,
+		code: tsDiagnostic.code.toString(),
+		columnNumber: void 0,
+		header: "TypeScript",
+		language: "typescript",
+		level: "warn",
+		lineNumber: void 0,
+		lines: [],
+		messageText: flattenDiagnosticMessageText(tsDiagnostic, tsDiagnostic.messageText),
+		relFilePath: void 0,
+		type: "typescript"
+	};
+	if (tsDiagnostic.category === 1) d.level = "error";
+	if (tsDiagnostic.file && typeof tsDiagnostic.start === "number") {
+		d.absFilePath = tsDiagnostic.file.fileName;
+		const sourceText = tsDiagnostic.file.text;
+		const srcLines = splitLineBreaks(sourceText);
+		const posData = tsDiagnostic.file.getLineAndCharacterOfPosition(tsDiagnostic.start);
+		const errorLine = {
+			lineIndex: posData.line,
+			lineNumber: posData.line + 1,
+			text: srcLines[posData.line],
+			errorCharStart: posData.character,
+			errorLength: Math.max(tsDiagnostic.length ?? 0, 1)
+		};
+		d.lineNumber = errorLine.lineNumber;
+		d.columnNumber = errorLine.errorCharStart + 1;
+		d.lines.push(errorLine);
+		if (errorLine.errorLength === 0 && errorLine.errorCharStart > 0) {
+			errorLine.errorLength = 1;
+			errorLine.errorCharStart--;
+		}
+		if (errorLine.lineIndex > 0) {
+			const previousLine = {
+				lineIndex: errorLine.lineIndex - 1,
+				lineNumber: errorLine.lineNumber - 1,
+				text: srcLines[errorLine.lineIndex - 1],
+				errorCharStart: -1,
+				errorLength: -1
+			};
+			d.lines.unshift(previousLine);
+		}
+		if (errorLine.lineIndex + 1 < srcLines.length) {
+			const nextLine = {
+				lineIndex: errorLine.lineIndex + 1,
+				lineNumber: errorLine.lineNumber + 1,
+				text: srcLines[errorLine.lineIndex + 1],
+				errorCharStart: -1,
+				errorLength: -1
+			};
+			d.lines.push(nextLine);
+		}
+	}
+	return d;
+};
+/**
+* Flatten a TypeScript diagnostic object into a string which can be easily
+* included in a Stencil diagnostic record.
+*
+* @param tsDiagnostic a TypeScript diagnostic record
+* @param diag a {@link DiagnosticMessageChain} or a string with further info
+* @returns a string with the relevant error message
+*/
+const flattenDiagnosticMessageText = (tsDiagnostic, diag) => {
+	if (typeof diag === "string") return diag;
+	else if (diag === void 0) return "";
+	const ignoreCodes = [];
+	const isStencilConfig = (tsDiagnostic.file?.fileName ?? "").includes("stencil.config");
+	if (isStencilConfig) ignoreCodes.push(2322);
+	let result = "";
+	if (!ignoreCodes.includes(diag.code)) {
+		result = diag.messageText;
+		if (isIterable(diag.next)) for (const kid of diag.next) result += flattenDiagnosticMessageText(tsDiagnostic, kid);
+	}
+	if (isStencilConfig) {
+		result = result.replace(`type 'StencilConfig'`, `Stencil Config`);
+		result = result.replace(`Object literal may only specify known properties, but `, ``);
+		result = result.replace(`Object literal may only specify known properties, and `, ``);
+	}
+	return result.trim();
+};
+//#endregion
+//#region src/utils/output-target.ts
+/**
+* Checks if a component tag name matches any of the exclude patterns.
+* Supports glob patterns using minimatch.
+*
+* @param tagName The component's tag name to check
+* @param excludePatterns Array of patterns to match against (supports globs)
+* @returns true if the component should be excluded, false otherwise
+*/
+const shouldExcludeComponent = (tagName, excludePatterns) => {
+	if (!excludePatterns || excludePatterns.length === 0) return false;
+	return excludePatterns.some((pattern) => {
+		if (isGlob(pattern)) return minimatch(tagName, pattern);
+		return pattern === tagName;
+	});
+};
+/**
+* Filters out components that match the excludeComponents patterns from the config.
+* Only applies filtering to production builds (when devMode is false) - dev builds include all components.
+*
+* @param components Array of component metadata
+* @param config The validated Stencil configuration
+* @returns Object containing filtered components and excluded components
+*/
+const filterExcludedComponents = (components, config) => {
+	if (config.devMode) return {
+		components,
+		excludedComponents: []
+	};
+	const excludePatterns = config.excludeComponents;
+	if (!excludePatterns || excludePatterns.length === 0) return {
+		components,
+		excludedComponents: []
+	};
+	const excludedComponents = [];
+	const excludedTags = [];
+	const filtered = components.filter((cmp) => {
+		const shouldExclude = shouldExcludeComponent(cmp.tagName, excludePatterns);
+		if (shouldExclude) {
+			excludedComponents.push(cmp);
+			excludedTags.push(cmp.tagName);
+			config.logger.debug(`Excluding component from build: ${cmp.tagName}`);
+		}
+		return !shouldExclude;
+	});
+	if (excludedTags.length > 0) {
+		const tagList = excludedTags.join(", ");
+		config.logger.info(`Excluding ${excludedTags.length} component${excludedTags.length === 1 ? "" : "s"} from production build: ${tagList}`);
+	}
+	return {
+		components: filtered,
+		excludedComponents
+	};
+};
+const relativeImport = (pathFrom, pathTo, ext, addPrefix = true) => {
+	let relativePath = relative(dirname(pathFrom), dirname(pathTo));
+	if (addPrefix) {
+		if (relativePath === "") relativePath = ".";
+		else if (relativePath[0] !== ".") relativePath = "./" + relativePath;
+	}
+	return normalizePath(`${relativePath}/${basename(pathTo, ext)}`);
+};
+const getComponentsDtsSrcFilePath = (config) => join$1(config.srcDir, GENERATED_DTS);
+/**
+* Helper to get an appropriate file path for `components.d.ts` for a `"dist"`
+* or `"dist-types"` output target.
+*
+* @param outputTarget the output target of interest
+* @returns a properly-formatted path
+*/
+const getComponentsDtsTypesFilePath = (outputTarget) => join$1(outputTarget.typesDir, GENERATED_DTS);
+const isOutputTargetDist = (o) => o.type === DIST;
+const isOutputTargetDistCollection = (o) => o.type === DIST_COLLECTION;
+const isOutputTargetDistCustomElements = (o) => o.type === DIST_CUSTOM_ELEMENTS;
+const isOutputTargetCopy = (o) => o.type === COPY;
+const isOutputTargetDistLazy = (o) => o.type === DIST_LAZY;
+const isOutputTargetDistLazyLoader = (o) => o.type === DIST_LAZY_LOADER;
+const isOutputTargetDistGlobalStyles = (o) => o.type === DIST_GLOBAL_STYLES;
+const isOutputTargetHydrate = (o) => o.type === DIST_HYDRATE_SCRIPT;
+const isOutputTargetCustom = (o) => o.type === CUSTOM;
+const isOutputTargetDocs = (o) => o.type === "docs-readme" || o.type === "docs-json" || o.type === "docs-custom" || o.type === "docs-vscode" || o.type === "docs-custom-elements-manifest";
+const isOutputTargetDocsReadme = (o) => o.type === DOCS_README;
+const isOutputTargetDocsJson = (o) => o.type === DOCS_JSON;
+const isOutputTargetDocsCustom = (o) => o.type === DOCS_CUSTOM;
+const isOutputTargetDocsVscode = (o) => o.type === DOCS_VSCODE;
+const isOutputTargetDocsCustomElementsManifest = (o) => o.type === DOCS_CUSTOM_ELEMENTS_MANIFEST;
+const isOutputTargetWww = (o) => o.type === "www";
+const isOutputTargetStats = (o) => o.type === STATS;
+const isOutputTargetDistTypes = (o) => o.type === DIST_TYPES;
+/**
+* Checks whether or not the supplied output target's type matches one of the eligible primary
+* package output target types (i.e. it can have `isPrimaryPackageOutputTarget: true` in its config).
+*
+* @param o The output target to check.
+* @returns Whether the output target type is one of the "primary" output targets.
+*/
+const isEligiblePrimaryPackageOutputTarget = (o) => isOutputTargetDist(o) || isOutputTargetDistCollection(o) || isOutputTargetDistCustomElements(o) || isOutputTargetDistTypes(o);
+/**
+* Retrieve the Stencil component compiler metadata from a collection of Stencil {@link d.Module}s
+* @param moduleFiles the collection of `Module`s to retrieve the metadata from
+* @returns the metadata, lexicographically sorted by the tag names of the components
+*/
+const getComponentsFromModules = (moduleFiles) => sortBy(flatOne(moduleFiles.map((m) => m.cmps)), (c) => c.tagName);
+/**
+* Check whether a given output target is a valid one to be set in a Stencil config
+*
+* @param targetType the type which we want to check
+* @returns whether or not the targetType is a valid, configurable output target.
+*/
+function isValidConfigOutputTarget(targetType) {
+	return VALID_CONFIG_OUTPUT_TARGETS.includes(targetType);
+}
+//#endregion
+//#region src/utils/result.ts
+var result_exports = /* @__PURE__ */ __exportAll({
+	err: () => err,
+	map: () => map,
+	ok: () => ok,
+	unwrap: () => unwrap,
+	unwrapErr: () => unwrapErr
+});
+/**
+* Create an `Ok` given a value. This doesn't do any checking that the value is
+* 'ok-ish' since doing so would make an undue assumption about what is 'ok'.
+* Instead, this trusts the user to determine, at the call site, whether
+* something is `ok()` or `err()`.
+*
+* @param value the value to wrap up in an `Ok`
+* @returns an Ok wrapping the value
+*/
+const ok = (value) => ({
+	isOk: true,
+	isErr: false,
+	value
+});
+/**
+* Create an `Err` given a value.
+*
+* @param value the value to wrap up in an `Err`
+* @returns an Ok wrapping the value
+*/
+const err = (value) => ({
+	isOk: false,
+	isErr: true,
+	value
+});
+function map(result, fn) {
+	if (result.isOk) {
+		const val = fn(result.value);
+		if (val instanceof Promise) return val.then((newVal) => ok(newVal));
+		else return ok(val);
+	}
+	if (result.isErr) {
+		const value = result.value;
+		return err(value);
+	}
+	throw "should never get here";
+}
+/**
+* Unwrap a {@link Result}, return the value inside if it is an `Ok` and
+* throw with the wrapped value if it is an `Err`.
+*
+* @throws with the wrapped value if it is an `Err`.
+* @param result a result to peer inside of
+* @returns the wrapped value, if `Ok`
+*/
+const unwrap = (result) => {
+	if (result.isOk) return result.value;
+	else throw result.value;
+};
+/**
+* Unwrap a {@link Result}, return the value inside if it is an `Err` and
+* throw with the wrapped value if it is an `Ok`.
+*
+* @throws with the wrapped value if it is an `Ok`.
+* @param result a result to peer inside of
+* @returns the wrapped value, if `Err`
+*/
+const unwrapErr = (result) => {
+	if (result.isErr) return result.value;
+	else throw result.value;
+};
+//#endregion
+//#region src/utils/sourcemaps.ts
+function rollupToStencilSourceMap(rollupSourceMap) {
+	if (!rollupSourceMap || !rollupSourceMap.file) return null;
+	return {
+		file: rollupSourceMap.file,
+		mappings: rollupSourceMap.mappings,
+		names: rollupSourceMap.names,
+		sources: rollupSourceMap.sources,
+		sourcesContent: rollupSourceMap.sourcesContent,
+		version: rollupSourceMap.version
+	};
+}
+/**
+* A JavaScript formatted string used to link generated code back to the original. This string follows the guidelines
+* found in the [Linking generated code to source maps](https://sourcemaps.info/spec.html#h.lmz475t4mvbx) section of
+* the Sourcemaps V3 specification proposal.
+*/
+const JS_SOURCE_MAPPING_URL_LINKER = "//# sourceMappingURL=";
+/**
+* Generates an RFC-3986 compliant string for the given input.
+* More information about RFC-3986 can be found [here](https://datatracker.ietf.org/doc/html/rfc3986)
+* This function's original source is derived from
+* [MDN's encodeURIComponent documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent#description)
+* @param filename the filename to encode
+* @returns the encoded URI
+*/
+const encodeToRfc3986 = (filename) => {
+	return encodeURIComponent(filename).replace(/[!'()*]/g, (matchedCharacter) => {
+		return "%" + matchedCharacter.charCodeAt(0).toString(16);
+	});
+};
+/**
+* Generates a string used to link generated code with the original source, to be placed at the end of the generated
+* code.
+* @param url the url of the source map
+* @returns a linker string, of the format {@link JS_SOURCE_MAPPING_URL_LINKER}=<url>
+*/
+const getSourceMappingUrlLinker = (url) => {
+	return `${JS_SOURCE_MAPPING_URL_LINKER}${encodeToRfc3986(url)}`;
+};
+/**
+* Generates a string used to link generated code with the original source, to be placed at the end of the generated
+* code as an inline source map.
+* @param sourceMapContents the sourceMapContents of the source map
+* @returns a linker string, of the format {@link JS_SOURCE_MAPPING_URL_LINKER}<dataUriPrefixAndMime><sourceMapContents>
+*/
+const getInlineSourceMappingUrlLinker = (sourceMapContents) => {
+	return `${JS_SOURCE_MAPPING_URL_LINKER}data:application/json;charset=utf-8;base64,${Buffer.from(sourceMapContents, "utf8").toString("base64")}`;
+};
+/**
+* Generates a string used to link generated code with the original source, to be placed at the end of the generated
+* code. This function prepends a newline to the string.
+* @param url the url of the source map
+* @returns a linker string, of the format {@link JS_SOURCE_MAPPING_URL_LINKER}=<url>.map, prepended with a newline
+*/
+const getSourceMappingUrlForEndOfFile = (url) => {
+	return `\n${getSourceMappingUrlLinker(url)}.map`;
+};
+//#endregion
+//#region src/utils/url-paths.ts
+/**
+* Determines whether a string should be considered a remote url or not.
+*
+* This helper only checks the provided string to evaluate is one of a few pre-defined schemes, and should not be
+* considered all-encompassing
+*
+* @param p the string to evaluate
+* @returns `true` if the provided string is a remote url, `false` otherwise
+*/
+const isRemoteUrl = (p) => {
+	if (isString(p)) {
+		p = p.toLowerCase();
+		return p.startsWith("https://") || p.startsWith("http://");
+	}
+	return false;
+};
+//#endregion
+//#region src/utils/util.ts
+/**
+* A set of JSDoc tags which should be excluded from JSDoc comments
+* included in output typedefs.
+*/
+const SUPPRESSED_JSDOC_TAGS = [
+	"virtualProp",
+	"slot",
+	"part",
+	"internal"
+];
+const LINE_BREAK_REGEX = /\r?\n|\r/g;
+/**
+* Create a stylistically-appropriate JS variable name from a filename
+*
+* If the filename has any of the special characters "?", "#", "&" and "=" it
+* will take the string before the left-most instance of one of those
+* characters.
+*
+* @param fileName the filename which serves as starting material
+* @returns a JS variable name based on the filename
+*/
+const createJsVarName = (fileName) => {
+	if (isString(fileName)) {
+		fileName = fileName.split("?")[0];
+		fileName = fileName.split("#")[0];
+		fileName = fileName.split("&")[0];
+		fileName = fileName.split("=")[0];
+		fileName = toDashCase(fileName);
+		fileName = fileName.replace(/[|;$%@"<>()+,.{}_!/\\]/g, "-");
+		fileName = dashToPascalCase(fileName);
+		if (fileName.length > 1) fileName = fileName[0].toLowerCase() + fileName.slice(1);
+		else fileName = fileName.toLowerCase();
+		if (fileName.length > 0 && !isNaN(fileName[0])) fileName = "_" + fileName;
+	}
+	return fileName;
+};
+/**
+* Create a function that lowercases the first string parameter before passing it to the provided function
+* @param fn the function to pass the lowercased path to
+* @returns the result of the provided function
+*/
+const lowerPathParam = (fn) => (p) => fn(p.toLowerCase());
+/**
+* Determine if a stringified file path is a TypeScript declaration file based on the extension at the end of the path.
+* @param p the path to evaluate
+* @returns `true` if the path ends in `.d.ts` (case-sensitive), `false` otherwise.
+*/
+const isDtsFile = lowerPathParam((p) => p.endsWith(".d.ts") || p.endsWith(".d.mts") || p.endsWith(".d.cts"));
+/**
+* Determine if a stringified file path is a TypeScript file based on the extension at the end of the path. This
+* function does _not_ consider type declaration files (`.d.ts` files) to be TypeScript files.
+* @param p the path to evaluate
+* @returns `true` if the path ends in `.ts` (case-sensitive) but does _not_ end in `.d.ts`, `false` otherwise.
+*/
+const isTsFile = lowerPathParam((p) => !isDtsFile(p) && (p.endsWith(".ts") || p.endsWith(".mts") || p.endsWith(".cts")));
+/**
+* Determine if a stringified file path is a TSX file based on the extension at the end of the path
+* @param p the path to evaluate
+* @returns `true` if the path ends in `.tsx` (case-sensitive), `false` otherwise.
+*/
+const isTsxFile = lowerPathParam((p) => p.endsWith(".tsx") || p.endsWith(".mtsx") || p.endsWith(".ctsx"));
+/**
+* Determine if a stringified file path is a JSX file based on the extension at the end of the path
+* @param p the path to evaluate
+* @returns `true` if the path ends in `.jsx` (case-sensitive), `false` otherwise.
+*/
+const isJsxFile = lowerPathParam((p) => p.endsWith(".jsx") || p.endsWith(".mjsx") || p.endsWith(".cjsx"));
+/**
+* Determine if a stringified file path is a JavaScript file based on the extension at the end of the path
+* @param p the path to evaluate
+* @returns `true` if the path ends in `.js` (case-sensitive), `false` otherwise.
+*/
+const isJsFile = lowerPathParam((p) => p.endsWith(".js") || p.endsWith(".mjs") || p.endsWith(".cjs"));
+/**
+* Generate the preamble to be placed atop the main file of the build
+* @param config the Stencil configuration file
+* @returns the generated preamble
+*/
+const generatePreamble = (config) => {
+	const { preamble } = config;
+	if (!preamble) return "";
+	const preambleComment = preamble.split("\n").map((l) => ` * ${l}`);
+	preambleComment.unshift(`/*!`);
+	preambleComment.push(` */`);
+	return preambleComment.join("\n");
+};
+function getTextDocs(docs) {
+	if (docs == null) return "";
+	return [escapeWithPattern(docs.text.replace(LINE_BREAK_REGEX, " "), /\*\//, "*\\/", true), ...docs.tags.filter((tag) => tag.name !== "internal").map((tag) => {
+		const tagText = escapeWithPattern((tag.text || "").replace(LINE_BREAK_REGEX, " "), /\*\//, "*\\/", true);
+		return `@${tag.name} ${tagText}`;
+	})].join("\n").trim();
+}
+/**
+* Adds a doc block to a string
+* @param str the string to add a doc block to
+* @param docs the compiled JS docs
+* @param indentation number of spaces to indent the block with
+* @returns the doc block
+*/
+function addDocBlock(str, docs, indentation = 0) {
+	if (!docs) return str;
+	return [formatDocBlock(docs, indentation), str].filter(Boolean).join(`\n`);
+}
+/**
+* Formats the given compiled docs to a JavaScript doc block
+* @param docs the compiled JS docs
+* @param indentation number of spaces to indent the block with
+* @returns the formatted doc block
+*/
+function formatDocBlock(docs, indentation = 0) {
+	const textDocs = getDocBlockLines(docs);
+	if (!textDocs.filter(Boolean).length) return "";
+	const spaces = new Array(indentation + 1).join(" ");
+	return [
+		spaces + "/**",
+		...textDocs.map((line) => spaces + ` * ${line}`),
+		spaces + " */"
+	].join(`\n`);
+}
+/**
+* Get all lines which are part of the doc block
+*
+* @param docs the compiled JS docs
+* @returns list of lines part of the doc block
+*/
+function getDocBlockLines(docs) {
+	return [...docs.text.split(LINE_BREAK_REGEX), ...docs.tags.filter((tag) => !SUPPRESSED_JSDOC_TAGS.includes(tag.name)).map((tag) => `@${tag.name} ${tag.text || ""}`.split(LINE_BREAK_REGEX))].flat().filter(Boolean);
+}
+/**
+* Retrieve a project's dependencies from the current build context
+* @param buildCtx the current build context to query for a specific package
+* @returns a list of package names the project is dependent on
+*/
+const getDependencies = (buildCtx) => Object.keys(buildCtx?.packageJson?.dependencies ?? {}).filter((pkgName) => !SKIP_DEPS.includes(pkgName));
+/**
+* Utility to determine whether a project has a dependency on a package
+* @param buildCtx the current build context to query for a specific package
+* @param depName the name of the dependency/package
+* @returns `true` if the project has a dependency a packaged with the provided name, `false` otherwise
+*/
+const hasDependency = (buildCtx, depName) => {
+	return getDependencies(buildCtx).includes(depName);
+};
+const readPackageJson = async (config, compilerCtx, buildCtx) => {
+	try {
+		const pkgJson = await compilerCtx.fs.readFile(config.packageJsonFilePath);
+		if (pkgJson) {
+			const parseResults = parsePackageJson(pkgJson, config.packageJsonFilePath);
+			if (parseResults.diagnostic) buildCtx.diagnostics.push(parseResults.diagnostic);
+			else buildCtx.packageJson = parseResults.data;
+		}
+	} catch {
+		if (!config.outputTargets.some((o) => o.type.includes("dist"))) {
+			const diagnostic = buildError(buildCtx.diagnostics);
+			diagnostic.header = `Missing "package.json"`;
+			diagnostic.messageText = `Valid "package.json" file is required for distribution: ${config.packageJsonFilePath}`;
+		}
+	}
+};
+/**
+* Parse a string read from a `package.json` file
+* @param pkgJsonStr the string read from a `package.json` file
+* @param pkgJsonFilePath the path to the already read `package.json` file
+* @returns the results of parsing the provided contents of the `package.json` file
+*/
+const parsePackageJson = (pkgJsonStr, pkgJsonFilePath) => {
+	const parseResult = {
+		diagnostic: null,
+		data: null,
+		filePath: pkgJsonFilePath
+	};
+	try {
+		parseResult.data = JSON.parse(pkgJsonStr);
+	} catch (e) {
+		parseResult.diagnostic = buildError();
+		parseResult.diagnostic.absFilePath = isString(pkgJsonFilePath) ? pkgJsonFilePath : void 0;
+		parseResult.diagnostic.header = `Error Parsing JSON`;
+		if (e instanceof Error) parseResult.diagnostic.messageText = e.message;
+	}
+	return parseResult;
+};
+const SKIP_DEPS = ["@stencil/core"];
+/**
+* Check whether a string is a member of a ReadonlyArray<string>
+*
+* We need a little helper for this because unfortunately `includes` is typed
+* on `ReadonlyArray<T>` as `(el: T): boolean` so a `string` cannot be passed
+* to `includes` on a `ReadonlyArray` 😢 thus we have a little helper function
+* where we do the type coercion just once.
+*
+* see microsoft/TypeScript#31018 for some discussion of this
+*
+* @param readOnlyArray the array we're checking
+* @param maybeMember a value which is possibly a member of the array
+* @returns whether the array contains the member or not
+*/
+const readOnlyArrayHasStringMember = (readOnlyArray, maybeMember) => readOnlyArray.includes(maybeMember);
+//#endregion
+//#region src/utils/validation.ts
+/**
+* Validates that a component tag meets required naming conventions to be used for a web component
+* @param tag the tag to validate
+* @returns an error message if the tag has an invalid name, undefined if the tag name passes all checks
+*/
+const validateComponentTag = (tag) => {
+	if (typeof tag !== "string") return `Tag "${tag}" must be a string type`;
+	if (tag !== tag.trim()) return `Tag can not contain white spaces`;
+	if (tag !== tag.toLowerCase()) return `Tag can not contain upper case characters`;
+	if (tag.length === 0) return `Received empty tag value`;
+	if (tag.indexOf(" ") > -1) return `"${tag}" tag cannot contain a space`;
+	if (tag.indexOf(",") > -1) return `"${tag}" tag cannot be used for multiple tags`;
+	const invalidChars = tag.replace(/\w|-/g, "");
+	if (invalidChars !== "") return `"${tag}" tag contains invalid characters: ${invalidChars}`;
+	if (tag.indexOf("-") === -1) return `"${tag}" tag must contain a dash (-) to work as a valid web component`;
+	if (tag.indexOf("--") > -1) return `"${tag}" tag cannot contain multiple dashes (--) next to each other`;
+	if (tag.indexOf("-") === 0) return `"${tag}" tag cannot start with a dash (-)`;
+	if (tag.lastIndexOf("-") === tag.length - 1) return `"${tag}" tag cannot end with a dash (-)`;
+};
+//#endregion
+export { join$1 as $, isOutputTargetCustom as A, isOutputTargetDocsCustomElementsManifest as B, result_exports as C, stringifyRuntimeData as Ct, getComponentsFromModules as D, getComponentsDtsTypesFilePath as E, isOutputTargetDistLazy as F, isOutputTargetStats as G, isOutputTargetDocsReadme as H, isOutputTargetDistLazyLoader as I, relativeImport as J, isOutputTargetWww as K, isOutputTargetDistTypes as L, isOutputTargetDistCollection as M, isOutputTargetDistCustomElements as N, isEligiblePrimaryPackageOutputTarget as O, isOutputTargetDistGlobalStyles as P, loadTypeScriptDiagnostics as Q, isOutputTargetDocs as R, ok as S, formatLazyBundleRuntimeMeta as St, getComponentsDtsSrcFilePath as T, isOutputTargetDocsVscode as U, isOutputTargetDocsJson as V, isOutputTargetHydrate as W, augmentDiagnosticWithNode as X, shouldExcludeComponent as Y, loadTypeScriptDiagnostic as Z, getSourceMappingUrlForEndOfFile as _, hasWarning as _t, getTextDocs as a, resolve as at, err as b, isGlob as bt, isJsFile as c, escapeHtml as ct, isTsxFile as d, TASK_CANCELED_MSG as dt, normalize as et, parsePackageJson as f, buildError as ft, getInlineSourceMappingUrlLinker as g, hasError as gt, isRemoteUrl as h, catchError as ht, generatePreamble as i, relative$1 as it, isOutputTargetDist as j, isOutputTargetCopy as k, isJsxFile as l, normalizeDiagnostics as lt, readPackageJson as m, buildWarn as mt, addDocBlock as n, normalizeFsPathQuery as nt, hasDependency as o, createOnWarnFn as ot, readOnlyArrayHasStringMember as p, buildJsonFileError as pt, isValidConfigOutputTarget as q, createJsVarName as r, normalizePath as rt, isDtsFile as s, loadRollupDiagnostics as st, validateComponentTag as t, normalizeFsPath as tt, isTsFile as u, splitLineBreaks as ut, getSourceMappingUrlLinker as v, shouldIgnoreError as vt, filterExcludedComponents as w, byteSize as wt, map as x, formatComponentRuntimeMeta as xt, rollupToStencilSourceMap as y, isRootPath as yt, isOutputTargetDocsCustom as z };