@stencil/core 5.0.0-alpha.27 → 5.0.0-alpha.29

package/dist/util-BIa-iHnt.mjs

@@ -0,0 +1,724 @@
+import { $ as TYPES, B as GLOBAL_STYLE, C as ASSETS, F as DOCS_JSON, I as DOCS_README, J as SSR_WASM, L as DOCS_VSCODE, M as DOCS_AGENT_SKILL, N as DOCS_CUSTOM, O as COPY, P as DOCS_CUSTOM_ELEMENTS_MANIFEST, T as COLLECTION, W as LOADER_BUNDLE, X as STATS, Y as STANDALONE, _ as sortBy, et as VALID_CONFIG_OUTPUT_TARGETS, i as flatOne, j as DIST_LAZY, k as CUSTOM, n as dashToPascalCase, p as isString, r as escapeWithPattern, y as toDashCase, z as GENERATED_DTS } from "./regular-expression-XqU5zmPp.mjs";
+import nodePath, { basename, dirname, relative } from "node:path";
+import picomatch from "picomatch";
+//#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/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. Only root-level keys (with minimal
+* indentation, typically 2 spaces) are highlighted to avoid matching nested keys.
+* @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");
+		let bestMatch = null;
+		const ROOT_LEVEL_INDENTATION = 2;
+		for (let i = 0; i < lines.length; i++) {
+			const txtLine = lines[i];
+			const txtIndex = txtLine.indexOf(jsonField);
+			if (txtIndex > -1) {
+				const indentation = txtLine.search(/\S/);
+				if (indentation === ROOT_LEVEL_INDENTATION) {
+					bestMatch = {
+						lineIndex: i,
+						charIndex: txtIndex,
+						indentation
+					};
+					break;
+				} else if (bestMatch === null || indentation < bestMatch.indentation) bestMatch = {
+					lineIndex: i,
+					charIndex: txtIndex,
+					indentation
+				};
+			}
+		}
+		if (bestMatch !== null && bestMatch.indentation === ROOT_LEVEL_INDENTATION) {
+			const i = bestMatch.lineIndex;
+			const txtIndex = bestMatch.charIndex;
+			const txtLine = lines[i];
+			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 - 1) {
+				const afterWarnLine = {
+					lineIndex: warnLine.lineIndex + 1,
+					lineNumber: warnLine.lineNumber + 1,
+					text: lines[i + 1],
+					errorCharStart: -1,
+					errorLength: -1
+				};
+				err.lines.push(afterWarnLine);
+			}
+		}
+	} 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/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 components = pathComponents(path, getRootLength(path));
+	const reducedComponents = reducePathComponents(components);
+	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 === 47 || ch0 === 92) {
+		if (path.charCodeAt(1) !== ch0) return 1;
+		const p1 = path.indexOf(ch0 === 47 ? "/" : altDirectorySeparator, 2);
+		if (p1 < 0) return path.length;
+		return p1 + 1;
+	}
+	if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58) {
+		const ch2 = path.charCodeAt(2);
+		if (ch2 === 47 || ch2 === 92) 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) === 47) return ~(volumeSeparatorEnd + 1);
+					if (volumeSeparatorEnd === path.length) return ~volumeSeparatorEnd;
+				}
+			}
+			return ~(authorityEnd + 1);
+		}
+		return ~path.length;
+	}
+	return 0;
+};
+const isVolumeCharacter = (charCode) => charCode >= 97 && charCode <= 122 || charCode >= 65 && charCode <= 90;
+const getFileUrlVolumeSeparatorEnd = (url, start) => {
+	const ch0 = url.charCodeAt(start);
+	if (ch0 === 58) return start + 1;
+	if (ch0 === 37 && url.charCodeAt(start + 1) === 51) {
+		const ch2 = url.charCodeAt(start + 2);
+		if (ch2 === 97 || ch2 === 65) 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
+	};
+};
+/**
+* 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(nodePath.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(nodePath.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$1(...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(nodePath.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(nodePath.normalize(toNormalize), false);
+}
+//#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 picomatch.isMatch(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 an output target.
+*
+* @param typesDir the directory where types are generated
+* @returns a properly-formatted path
+*/
+const getComponentsDtsTypesFilePath = (typesDir) => join$1(typesDir, GENERATED_DTS);
+const isOutputTargetLoaderBundle = (o) => o.type === LOADER_BUNDLE;
+const isOutputTargetStandalone = (o) => o.type === STANDALONE;
+const isOutputTargetSsr = (o) => o.type === "ssr";
+const isOutputTargetSsrWasm = (o) => o.type === SSR_WASM;
+const isOutputTargetCollection = (o) => o.type === COLLECTION;
+const isOutputTargetTypes = (o) => o.type === TYPES;
+const isOutputTargetGlobalStyle = (o) => o.type === GLOBAL_STYLE;
+const isOutputTargetAssets = (o) => o.type === ASSETS;
+const isOutputTargetCopy = (o) => o.type === COPY;
+const isOutputTargetDistLazy = (o) => o.type === DIST_LAZY;
+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" || o.type === "docs-agent-skill";
+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 isOutputTargetDocsAgentSkill = (o) => o.type === DOCS_AGENT_SKILL;
+const isOutputTargetWww = (o) => o.type === "www";
+const isOutputTargetStats = (o) => o.type === STATS;
+/**
+* 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);
+}
+/**
+* Filter output targets based on devMode and their skipInDev setting.
+* In dev mode, targets with `skipInDev: true` are filtered out.
+* In prod mode, all targets are included.
+*
+* @param targets Array of output targets to filter
+* @param devMode Whether we're in dev mode
+* @returns Filtered array of active targets
+*/
+const filterActiveTargets = (targets, devMode) => {
+	if (!devMode) return targets;
+	return targets.filter((t) => !t.skipInDev);
+};
+//#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
+export { catchError as $, isOutputTargetDocsVscode as A, relativeImport as B, isOutputTargetDistLazy as C, isOutputTargetDocsCustomElementsManifest as D, isOutputTargetDocsCustom as E, isOutputTargetStandalone as F, normalizeFsPathQuery as G, join$1 as H, isOutputTargetStats as I, resolve$1 as J, normalizePath as K, isOutputTargetTypes as L, isOutputTargetLoaderBundle as M, isOutputTargetSsr as N, isOutputTargetDocsJson as O, isOutputTargetSsrWasm as P, buildWarn as Q, isOutputTargetWww as R, isOutputTargetCustom as S, isOutputTargetDocsAgentSkill as T, normalize as U, shouldExcludeComponent as V, normalizeFsPath as W, buildError as X, TASK_CANCELED_MSG as Y, buildJsonFileError as Z, getComponentsDtsTypesFilePath as _, hasDependency as a, isOutputTargetCollection as b, isJsxFile as c, parsePackageJson as d, hasError as et, readOnlyArrayHasStringMember as f, getComponentsDtsSrcFilePath as g, filterExcludedComponents as h, getTextDocs as i, isOutputTargetGlobalStyle as j, isOutputTargetDocsReadme as k, isTsFile as l, filterActiveTargets as m, createJsVarName as n, shouldIgnoreError as nt, isDtsFile as o, readPackageJson as p, relative$1 as q, generatePreamble as r, isGlob as rt, isJsFile as s, addDocBlock as t, hasWarning as tt, isTsxFile as u, getComponentsFromModules as v, isOutputTargetDocs as w, isOutputTargetCopy as x, isOutputTargetAssets as y, isValidConfigOutputTarget as z };