@stencil/core 5.0.0-alpha.9 → 5.0.0-beta.0

package/dist/validation-DAdGTrys.mjs

@@ -0,0 +1,791 @@
+import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
+import { C as CMP_FLAGS, H as LISTENER_FLAGS, W as MEMBER_FLAGS, et as WATCH_FLAGS, f as isString, l as isIterable, y as toTitleCase } from "./helpers-Cpp3qc3u.mjs";
+import { K as normalizePath, Q as buildWarn } from "./util-IKfWWLJo.mjs";
+//#region src/utils/regular-expression.ts
+/**
+* Utility function that will escape all regular expression special characters in a string.
+*
+* @param text The string potentially containing special characters.
+* @returns The string with all special characters escaped.
+*/
+const escapeRegExpSpecialCharacters = (text) => {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+//#endregion
+//#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;
+		if (compilerMeta.shadowMode === "closed") flags |= CMP_FLAGS.shadowModeClosed;
+		if (compilerMeta.shadowClonable) flags |= CMP_FLAGS.shadowClonable;
+		if (compilerMeta.shadowSerializable) flags |= CMP_FLAGS.shadowSerializable;
+	} 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;
+	if (compilerMeta.patches) {
+		if (compilerMeta.patches.all) flags |= CMP_FLAGS.patchAll;
+		if (compilerMeta.patches.children) flags |= CMP_FLAGS.patchChildren;
+		if (compilerMeta.patches.clone) flags |= CMP_FLAGS.patchClone;
+		if (compilerMeta.patches.insert) flags |= CMP_FLAGS.patchInsert;
+	}
+	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;
+	}
+	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-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/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 sourceText = compilerCtx.fs.readFileSync(diagnostic.absFilePath);
+				const srcLines = splitLineBreaks(sourceText);
+				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-rolldown.ts
+const isRolldownError = (e) => typeof e === "object" && e !== null && "message" in e;
+const loadRolldownDiagnostics = (config, compilerCtx, buildCtx, rolldownError) => {
+	const formattedCode = formatErrorCode(rolldownError.code);
+	const diagnostic = {
+		level: "error",
+		type: "bundling",
+		language: "javascript",
+		code: rolldownError.code,
+		header: `Rolldown${formattedCode.length > 0 ? ": " + formattedCode : ""}`,
+		messageText: formattedCode,
+		relFilePath: void 0,
+		absFilePath: void 0,
+		lines: []
+	};
+	if (config.logLevel === "debug" && rolldownError.stack) diagnostic.messageText = rolldownError.stack;
+	else if (rolldownError.message) diagnostic.messageText = rolldownError.message;
+	if (rolldownError.plugin) diagnostic.messageText += ` (plugin: ${rolldownError.plugin}${rolldownError.hook ? `, ${rolldownError.hook}` : ""})`;
+	const loc = rolldownError.loc;
+	if (loc != null) {
+		const srcFile = loc.file || rolldownError.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 rolldownError.frame === "string") diagnostic.messageText += "\n" + rolldownError.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 = /* @__PURE__ */ new Set([
+	"THIS_IS_UNDEFINED",
+	"NON_EXISTENT_EXPORT",
+	"CIRCULAR_DEPENDENCY",
+	"EMPTY_BUNDLE",
+	"UNUSED_EXTERNAL_IMPORT",
+	"EMPTY_IMPORT_META"
+]);
+const charBreak = /* @__PURE__ */ 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/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/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 rolldownToStencilSourceMap(rolldownSourceMap) {
+	if (!rolldownSourceMap || !rolldownSourceMap.file) return null;
+	return {
+		file: rolldownSourceMap.file,
+		mappings: rolldownSourceMap.mappings,
+		names: rolldownSourceMap.names,
+		sources: rolldownSourceMap.sources,
+		sourcesContent: rolldownSourceMap.sourcesContent,
+		version: rolldownSourceMap.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) => {
+	const mapBase64 = Buffer.from(sourceMapContents, "utf8").toString("base64");
+	return `${JS_SOURCE_MAPPING_URL_LINKER}data:application/json;charset=utf-8;base64,${mapBase64}`;
+};
+/**
+* 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/validation.ts
+const getModeKeys = (value) => {
+	if (value == null || typeof value !== "object" || Array.isArray(value) || value.__identifier) return [];
+	return Object.keys(value);
+};
+/**
+* Validates the mode keys used in a component's `styleUrls`/`styles` against a
+* `config.modes` allowlist, if one is declared.
+* @param configModes the `config.modes` allowlist (mixed string/{@link d.ModeConfig} entries)
+* @param componentOptions the `@Component()` decorator options for a single component
+* @returns a validation error if a used mode is unknown or a required mode is missing, undefined otherwise
+*/
+const validateComponentModes = (configModes, componentOptions) => {
+	if (!configModes || configModes.length === 0) return;
+	const allowedModes = /* @__PURE__ */ new Map();
+	for (const entry of configModes) if (typeof entry === "string") allowedModes.set(entry, false);
+	else allowedModes.set(entry.mode, !!entry.required);
+	const fields = [{
+		propName: "styleUrls",
+		keys: getModeKeys(componentOptions.styleUrls)
+	}, {
+		propName: "styles",
+		keys: getModeKeys(componentOptions.styles)
+	}];
+	for (const field of fields) for (const key of field.keys) if (!allowedModes.has(key)) return {
+		propName: field.propName,
+		message: `Invalid mode "${key}" in "${field.propName}". Valid modes are: ${[...allowedModes.keys()].join(", ")}.`
+	};
+	const usedModes = /* @__PURE__ */ new Set([...fields[0].keys, ...fields[1].keys]);
+	if (usedModes.size > 0) {
+		const missingRequired = [...allowedModes.entries()].filter(([mode, required]) => required && !usedModes.has(mode)).map(([mode]) => mode);
+		if (missingRequired.length > 0) return {
+			propName: fields[0].keys.length > 0 ? "styleUrls" : "styles",
+			message: `Missing required mode${missingRequired.length > 1 ? "s" : ""}: ${missingRequired.join(", ")}.`
+		};
+	}
+};
+/**
+* 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 { formatLazyBundleRuntimeMeta as C, escapeRegExpSpecialCharacters as E, formatComponentRuntimeMeta as S, byteSize as T, loadRolldownDiagnostics as _, getSourceMappingUrlForEndOfFile as a, splitLineBreaks as b, err as c, result_exports as d, augmentDiagnosticWithNode as f, isRolldownError as g, createOnWarnFn as h, getInlineSourceMappingUrlLinker as i, map as l, loadTypeScriptDiagnostics as m, validateComponentTag as n, getSourceMappingUrlLinker as o, loadTypeScriptDiagnostic as p, isRemoteUrl as r, rolldownToStencilSourceMap as s, validateComponentModes as t, ok as u, escapeHtml as v, stringifyRuntimeData as w, isRootPath as x, normalizeDiagnostics as y };