@stencil/core 4.43.2 → 5.0.0-next.0

package/dist/runtime/server/runner.mjs

@@ -0,0 +1,1976 @@
+import { MockWindow, cloneWindow, constrainTimeouts, patchWindow, serializeNodeToHtml } from "@stencil/mock-doc";
+import { Readable } from "node:stream";
+import "minimatch";
+
+//#region src/server/runner/create-window.ts
+const templateWindows = /* @__PURE__ */ new Map();
+function createWindowFromHtml(templateHtml, uniqueId) {
+	let templateWindow = templateWindows.get(uniqueId);
+	if (templateWindow == null) {
+		templateWindow = new MockWindow(templateHtml);
+		templateWindows.set(uniqueId, templateWindow);
+	}
+	return cloneWindow(templateWindow);
+}
+
+//#endregion
+//#region src/server/runner/hydrate-factory.ts
+function hydrateFactory(win, opts, results, afterHydrate, resolve) {}
+
+//#endregion
+//#region src/app-data/index.ts
+/**
+* A collection of default build flags for a Stencil project.
+*
+* This collection can be found throughout the Stencil codebase, often imported from the `virtual:app-data` module like so:
+* ```ts
+* import { BUILD } from 'virtual:app-data';
+* ```
+* and is used to determine if a portion of the output of a Stencil _project_'s compilation step can be eliminated.
+*
+* e.g. When `BUILD.allRenderFn` evaluates to `false`, the compiler will eliminate conditional statements like:
+* ```ts
+* if (BUILD.allRenderFn) {
+*   // some code that will be eliminated if BUILD.allRenderFn is false
+* }
+* ```
+*
+* `virtual:app-data`, the module that `BUILD` is imported from, is an alias for the `@stencil/core/runtime/app-data`, and is
+* partially referenced by {@link STENCIL_APP_DATA_ID}. The `src/compiler/bundle/app-data-plugin.ts` references
+* `STENCIL_APP_DATA_ID` uses it to replace these defaults with {@link BuildConditionals} that are derived from a
+* Stencil project's contents (i.e. metadata from the components). This replacement happens at a Stencil project's
+* compile time. Such code can be found at `src/compiler/app-core/app-data.ts`.
+*/
+const BUILD = {
+	allRenderFn: false,
+	element: true,
+	event: true,
+	hasRenderFn: true,
+	hostListener: true,
+	hostListenerTargetWindow: true,
+	hostListenerTargetDocument: true,
+	hostListenerTargetBody: true,
+	hostListenerTargetParent: false,
+	hostListenerTarget: true,
+	member: true,
+	method: true,
+	mode: true,
+	observeAttribute: true,
+	prop: true,
+	propMutable: true,
+	reflect: true,
+	scoped: true,
+	shadowDom: true,
+	slot: true,
+	cssAnnotations: true,
+	state: true,
+	style: true,
+	formAssociated: false,
+	svg: true,
+	updatable: true,
+	vdomAttribute: true,
+	vdomXlink: true,
+	vdomClass: true,
+	vdomFunctional: true,
+	vdomKey: true,
+	vdomListener: true,
+	vdomRef: true,
+	vdomPropOrAttr: true,
+	vdomRender: true,
+	vdomStyle: true,
+	vdomText: true,
+	propChangeCallback: true,
+	taskQueue: true,
+	hotModuleReplacement: false,
+	isDebug: false,
+	isDev: false,
+	isTesting: false,
+	hydrateServerSide: false,
+	hydrateClientSide: false,
+	lifecycleDOMEvents: false,
+	lazyLoad: false,
+	profile: false,
+	slotRelocation: true,
+	appendChildSlotFix: false,
+	cloneNodeFix: false,
+	hydratedAttribute: false,
+	hydratedClass: true,
+	scopedSlotTextContentFix: false,
+	shadowDomShim: false,
+	slotChildNodesFix: false,
+	invisiblePrehydration: true,
+	propBoolean: true,
+	propNumber: true,
+	propString: true,
+	constructableCSS: true,
+	devTools: false,
+	shadowDelegatesFocus: true,
+	shadowSlotAssignmentManual: false,
+	initializeNextTick: false,
+	asyncLoading: true,
+	asyncQueue: false,
+	transformTagName: false,
+	attachStyles: true,
+	experimentalSlotFixes: false
+};
+
+//#endregion
+//#region src/client/client-build.ts
+const Build = {
+	isDev: BUILD.isDev ? true : false,
+	isBrowser: true,
+	isServer: false,
+	isTesting: BUILD.isTesting ? true : false
+};
+
+//#endregion
+//#region src/utils/constants.ts
+const CF_scopedCssEncapsulation = 2;
+const CF_needsShadowDomShim = 8;
+/**
+* A set of flags used for bitwise calculations against {@link ComponentRuntimeMeta#$flags$}.
+*
+* These flags should only be used in conjunction with {@link ComponentRuntimeMeta#$flags$}.
+* They should _not_ be used for calculations against other fields/numbers
+*/
+const CMP_FLAGS = {
+	shadowDomEncapsulation: 1,
+	scopedCssEncapsulation: CF_scopedCssEncapsulation,
+	hasSlotRelocation: 4,
+	needsShadowDomShim: CF_needsShadowDomShim,
+	shadowDelegatesFocus: 16,
+	hasMode: 32,
+	needsScopedEncapsulation: CF_scopedCssEncapsulation | CF_needsShadowDomShim,
+	formAssociated: 64,
+	shadowNeedsScopedCss: 128,
+	hasSlot: 256,
+	hasModernPropertyDecls: 512,
+	shadowSlotAssignmentManual: 1024
+};
+/**
+* Represents a primitive type.
+* Described in https://w3c.github.io/webdriver-bidi/#type-script-PrimitiveProtocolValue.
+*/
+const PrimitiveType = {
+	Undefined: "undefined",
+	Null: "null",
+	String: "string",
+	Number: "number",
+	SpecialNumber: "number",
+	Boolean: "boolean",
+	BigInt: "bigint"
+};
+/**
+* Represents a non-primitive type.
+* Described in https://w3c.github.io/webdriver-bidi/#type-script-RemoteValue.
+* @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead.
+*/
+const NonPrimitiveType = {
+	Array: "array",
+	Date: "date",
+	Map: "map",
+	Object: "object",
+	RegularExpression: "regexp",
+	Set: "set",
+	Channel: "channel",
+	Symbol: "symbol"
+};
+/**  @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead. */
+const TYPE_CONSTANT = "type";
+/**  @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead. */
+const VALUE_CONSTANT = "value";
+/**  @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead. */
+const SERIALIZED_PREFIX = "serialized:";
+
+//#endregion
+//#region src/client/client-log.ts
+const STENCIL_DEV_MODE = BUILD.isTesting ? ["STENCIL:"] : ["%cstencil", "color: white;background:#4c47ff;font-weight: bold; font-size:10px; padding:2px 6px; border-radius: 5px"];
+
+//#endregion
+//#region src/client/client-style.ts
+const modeResolutionChain = [];
+
+//#endregion
+//#region src/runtime/runtime-constants.ts
+const PF_appLoaded = 2;
+const PF_queueSync = 4;
+const PLATFORM_FLAGS = {
+	isTmpDisconnected: 1,
+	appLoaded: PF_appLoaded,
+	queueSync: PF_queueSync,
+	queueMask: PF_appLoaded | PF_queueSync
+};
+const HYDRATED_STYLE_ID = "sty-id";
+const STENCIL_DOC_DATA = "_stencilDocData";
+
+//#endregion
+//#region src/client/client-window.ts
+const win = typeof window !== "undefined" ? window : {};
+const H = win.HTMLElement || class {};
+const supportsShadow = BUILD.shadowDom;
+const supportsConstructableStylesheets = BUILD.constructableCSS ? /* @__PURE__ */ (() => {
+	try {
+		if (!win.document.adoptedStyleSheets) return false;
+		new CSSStyleSheet();
+		return typeof new CSSStyleSheet().replaceSync === "function";
+	} catch (e) {}
+	return false;
+})() : false;
+const supportsMutableAdoptedStyleSheets = supportsConstructableStylesheets ? !!win.document && Object.getOwnPropertyDescriptor(win.document.adoptedStyleSheets, "length").writable : false;
+
+//#endregion
+//#region src/utils/helpers.ts
+const isString = (v) => typeof v === "string";
+
+//#endregion
+//#region src/utils/shadow-css.ts
+const _polyfillHost = "-shadowcsshost";
+const _polyfillSlotted = "-shadowcssslotted";
+const _polyfillHostContext = "-shadowcsscontext";
+const _parenSuffix = ")(?:\\(((?:\\([^)(]*\\)|[^)(]*)+?)\\))?([^,{]*)";
+const _cssColonHostRe = new RegExp("(" + _polyfillHost + _parenSuffix, "gim");
+const _cssColonHostContextRe = new RegExp("(" + _polyfillHostContext + _parenSuffix, "gim");
+const _cssColonSlottedRe = new RegExp("(" + _polyfillSlotted + _parenSuffix, "gim");
+const _polyfillHostNoCombinator = _polyfillHost + "-no-combinator";
+
+//#endregion
+//#region src/runtime/mode.ts
+const setMode = (handler) => modeResolutionChain.push(handler);
+
+//#endregion
+//#region src/utils/local-value.ts
+/**
+* Represents a local value with a specified type and optional value.
+* Described in https://w3c.github.io/webdriver-bidi/#type-script-LocalValue
+* @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead.
+*/
+var LocalValue = class LocalValue {
+	type;
+	value;
+	constructor(type, value) {
+		if (type === PrimitiveType.Undefined || type === PrimitiveType.Null) this.type = type;
+		else {
+			this.type = type;
+			this.value = value;
+		}
+	}
+	/**
+	* Creates a new LocalValue object with a string value.
+	*
+	* @param {string} value - The string value to be stored in the LocalValue object.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createStringValue(value) {
+		return new LocalValue(PrimitiveType.String, value);
+	}
+	/**
+	* Creates a new LocalValue object with a number value.
+	*
+	* @param {number} value - The number value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createNumberValue(value) {
+		return new LocalValue(PrimitiveType.Number, value);
+	}
+	/**
+	* Creates a new LocalValue object with a special number value.
+	*
+	* @param {number} value - The value of the special number.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createSpecialNumberValue(value) {
+		if (Number.isNaN(value)) return new LocalValue(PrimitiveType.SpecialNumber, "NaN");
+		if (Object.is(value, -0)) return new LocalValue(PrimitiveType.SpecialNumber, "-0");
+		if (value === Infinity) return new LocalValue(PrimitiveType.SpecialNumber, "Infinity");
+		if (value === -Infinity) return new LocalValue(PrimitiveType.SpecialNumber, "-Infinity");
+		return new LocalValue(PrimitiveType.SpecialNumber, value);
+	}
+	/**
+	* Creates a new LocalValue object with an undefined value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createUndefinedValue() {
+		return new LocalValue(PrimitiveType.Undefined);
+	}
+	/**
+	* Creates a new LocalValue object with a null value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createNullValue() {
+		return new LocalValue(PrimitiveType.Null);
+	}
+	/**
+	* Creates a new LocalValue object with a boolean value.
+	*
+	* @param {boolean} value - The boolean value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createBooleanValue(value) {
+		return new LocalValue(PrimitiveType.Boolean, value);
+	}
+	/**
+	* Creates a new LocalValue object with a BigInt value.
+	*
+	* @param {BigInt} value - The BigInt value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createBigIntValue(value) {
+		return new LocalValue(PrimitiveType.BigInt, value.toString());
+	}
+	/**
+	* Creates a new LocalValue object with an array.
+	*
+	* @param {Array} value - The array.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createArrayValue(value) {
+		return new LocalValue(NonPrimitiveType.Array, value);
+	}
+	/**
+	* Creates a new LocalValue object with date value.
+	*
+	* @param {string} value - The date.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createDateValue(value) {
+		return new LocalValue(NonPrimitiveType.Date, value);
+	}
+	/**
+	* Creates a new LocalValue object of map value.
+	* @param {Map} map - The map.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createMapValue(map) {
+		const value = [];
+		Array.from(map.entries()).forEach(([key, val]) => {
+			value.push([LocalValue.getArgument(key), LocalValue.getArgument(val)]);
+		});
+		return new LocalValue(NonPrimitiveType.Map, value);
+	}
+	/**
+	* Creates a new LocalValue object from the passed object.
+	*
+	* @param object the object to create a LocalValue from
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createObjectValue(object) {
+		const value = [];
+		Object.entries(object).forEach(([key, val]) => {
+			value.push([key, LocalValue.getArgument(val)]);
+		});
+		return new LocalValue(NonPrimitiveType.Object, value);
+	}
+	/**
+	* Creates a new LocalValue object of regular expression value.
+	*
+	* @param {string} value - The value of the regular expression.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createRegularExpressionValue(value) {
+		return new LocalValue(NonPrimitiveType.RegularExpression, value);
+	}
+	/**
+	* Creates a new LocalValue object with the specified value.
+	* @param {Set} value - The value to be set.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createSetValue(value) {
+		return new LocalValue(NonPrimitiveType.Set, value);
+	}
+	/**
+	* Creates a new LocalValue object with the given channel value
+	*
+	* @param {ChannelValue} value - The channel value.
+	* @returns {LocalValue} - The created LocalValue object.
+	*/
+	static createChannelValue(value) {
+		return new LocalValue(NonPrimitiveType.Channel, value);
+	}
+	/**
+	* Creates a new LocalValue object with a Symbol value.
+	*
+	* @param {Symbol} symbol - The Symbol value
+	* @returns {LocalValue} - The created LocalValue object
+	*/
+	static createSymbolValue(symbol) {
+		const description = symbol.description || "Symbol()";
+		return new LocalValue(NonPrimitiveType.Symbol, description);
+	}
+	static getArgument(argument) {
+		const type = typeof argument;
+		switch (type) {
+			case PrimitiveType.String: return LocalValue.createStringValue(argument);
+			case PrimitiveType.Number:
+				if (Number.isNaN(argument) || Object.is(argument, -0) || !Number.isFinite(argument)) return LocalValue.createSpecialNumberValue(argument);
+				return LocalValue.createNumberValue(argument);
+			case PrimitiveType.Boolean: return LocalValue.createBooleanValue(argument);
+			case PrimitiveType.BigInt: return LocalValue.createBigIntValue(argument);
+			case PrimitiveType.Undefined: return LocalValue.createUndefinedValue();
+			case NonPrimitiveType.Symbol: return LocalValue.createSymbolValue(argument);
+			case NonPrimitiveType.Object:
+				if (argument === null) return LocalValue.createNullValue();
+				if (argument instanceof Date) return LocalValue.createDateValue(argument);
+				if (argument instanceof Map) {
+					const map = [];
+					argument.forEach((value, key) => {
+						const objectKey = typeof key === "string" ? key : LocalValue.getArgument(key);
+						const objectValue = LocalValue.getArgument(value);
+						map.push([objectKey, objectValue]);
+					});
+					return LocalValue.createMapValue(argument);
+				}
+				if (argument instanceof Set) {
+					const set = [];
+					argument.forEach((value) => {
+						set.push(LocalValue.getArgument(value));
+					});
+					return LocalValue.createSetValue(set);
+				}
+				if (argument instanceof Array) {
+					const arr = [];
+					argument.forEach((value) => {
+						arr.push(LocalValue.getArgument(value));
+					});
+					return LocalValue.createArrayValue(arr);
+				}
+				if (argument instanceof RegExp) return LocalValue.createRegularExpressionValue({
+					pattern: argument.source,
+					flags: argument.flags
+				});
+				return LocalValue.createObjectValue(argument);
+		}
+		throw new Error(`Unsupported type: ${type}`);
+	}
+	asMap() {
+		return {
+			[TYPE_CONSTANT]: this.type,
+			...!(this.type === PrimitiveType.Null || this.type === PrimitiveType.Undefined) ? { [VALUE_CONSTANT]: this.value } : {}
+		};
+	}
+};
+
+//#endregion
+//#region src/utils/remote-value.ts
+/**
+* RemoteValue class for deserializing LocalValue serialized objects back into their original form
+* @deprecated will be removed in v5. Use `@AttrDeserialize()` / `@PropDeserialize()` decorators instead.
+*/
+var RemoteValue = class RemoteValue {
+	/**
+	* Deserializes a LocalValue serialized object back to its original JavaScript representation
+	*
+	* @param serialized The serialized LocalValue object
+	* @returns The original JavaScript value/object
+	*/
+	static fromLocalValue(serialized) {
+		const type = serialized[TYPE_CONSTANT];
+		const value = VALUE_CONSTANT in serialized ? serialized[VALUE_CONSTANT] : void 0;
+		switch (type) {
+			case PrimitiveType.String: return value;
+			case PrimitiveType.Boolean: return value;
+			case PrimitiveType.BigInt: return BigInt(value);
+			case PrimitiveType.Undefined: return;
+			case PrimitiveType.Null: return null;
+			case PrimitiveType.Number:
+				if (value === "NaN") return NaN;
+				if (value === "-0") return -0;
+				if (value === "Infinity") return Infinity;
+				if (value === "-Infinity") return -Infinity;
+				return value;
+			case NonPrimitiveType.Array: return value.map((item) => RemoteValue.fromLocalValue(item));
+			case NonPrimitiveType.Date: return new Date(value);
+			case NonPrimitiveType.Map:
+				const map = /* @__PURE__ */ new Map();
+				for (const [key, val] of value) {
+					const deserializedKey = typeof key === "object" && key !== null ? RemoteValue.fromLocalValue(key) : key;
+					const deserializedValue = RemoteValue.fromLocalValue(val);
+					map.set(deserializedKey, deserializedValue);
+				}
+				return map;
+			case NonPrimitiveType.Object:
+				const obj = {};
+				for (const [key, val] of value) obj[key] = RemoteValue.fromLocalValue(val);
+				return obj;
+			case NonPrimitiveType.RegularExpression:
+				const { pattern, flags } = value;
+				return new RegExp(pattern, flags);
+			case NonPrimitiveType.Set:
+				const set = /* @__PURE__ */ new Set();
+				for (const item of value) set.add(RemoteValue.fromLocalValue(item));
+				return set;
+			case NonPrimitiveType.Symbol: return Symbol(value);
+			default: throw new Error(`Unsupported type: ${type}`);
+		}
+	}
+	/**
+	* Utility method to deserialize multiple LocalValues at once
+	*
+	* @param serializedValues Array of serialized LocalValue objects
+	* @returns Array of deserialized JavaScript values
+	*/
+	static fromLocalValueArray(serializedValues) {
+		return serializedValues.map((value) => RemoteValue.fromLocalValue(value));
+	}
+	/**
+	* Verifies if the given object matches the structure of a serialized LocalValue
+	*
+	* @param obj Object to verify
+	* @returns boolean indicating if the object has LocalValue structure
+	*/
+	static isLocalValueObject(obj) {
+		if (typeof obj !== "object" || obj === null) return false;
+		if (!obj.hasOwnProperty(TYPE_CONSTANT)) return false;
+		const type = obj[TYPE_CONSTANT];
+		if (!Object.values({
+			...PrimitiveType,
+			...NonPrimitiveType
+		}).includes(type)) return false;
+		if (type !== PrimitiveType.Null && type !== PrimitiveType.Undefined) return obj.hasOwnProperty(VALUE_CONSTANT);
+		return true;
+	}
+};
+
+//#endregion
+//#region src/utils/serialize.ts
+/**
+* Serialize a value to a string that can be deserialized later.
+* @param {unknown} value - The value to serialize.
+* @returns {string} A string that can be deserialized later.
+* @deprecated will be removed in v5. Use `@PropSerialize()` decorator instead.
+*/
+function serializeProperty(value) {
+	/**
+	* If the value is a primitive type, return it as is.
+	*/
+	if ([
+		"string",
+		"boolean",
+		"undefined"
+	].includes(typeof value) || typeof value === "number" && value !== Infinity && value !== -Infinity && !isNaN(value)) return value;
+	const arg = LocalValue.getArgument(value);
+	return SERIALIZED_PREFIX + btoa(JSON.stringify(arg));
+}
+/**
+* Deserialize a value from a string that was serialized earlier.
+* @param {string} value - The string to deserialize.
+* @returns {unknown} The deserialized value.
+* @deprecated will be removed in v5. Use `@AttrDeserialize()` decorator instead.
+*/
+function deserializeProperty(value) {
+	if (typeof value !== "string" || !value.startsWith(SERIALIZED_PREFIX)) return value;
+	return RemoteValue.fromLocalValue(JSON.parse(atob(value.slice(SERIALIZED_PREFIX.length))));
+}
+
+//#endregion
+//#region src/runtime/vdom/set-accessor.ts
+const CAPTURE_EVENT_SUFFIX = "Capture";
+const CAPTURE_EVENT_REGEX = new RegExp(CAPTURE_EVENT_SUFFIX + "$");
+
+//#endregion
+//#region src/runtime/mixin.ts
+const baseClass = BUILD.lazyLoad ? class {} : globalThis.HTMLElement || class {};
+
+//#endregion
+//#region src/runtime/tag-transform.ts
+let tagTransformer = void 0;
+/**
+* Transforms a tag name using the current tag transformer
+* @param tag - the tag to transform e.g. `my-tag`
+* @returns the transformed tag e.g. `new-my-tag`
+*/
+function transformTag(tag) {
+	if (!tagTransformer) return tag;
+	return tagTransformer(tag);
+}
+/**
+* Sets the tag transformer to be used when rendering custom elements
+* @param transformer the transformer function to use. Must return a string
+*/
+function setTagTransformer(transformer) {
+	if (tagTransformer) console.warn(`
+      A tagTransformer has already been set. 
+      Overwriting it may lead to error and unexpected results if your components have already been defined.
+    `);
+	tagTransformer = transformer;
+}
+
+//#endregion
+//#region src/utils/message-utils.ts
+/**
+* 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");
+};
+const shouldIgnoreError = (msg) => {
+	return msg === TASK_CANCELED_MSG;
+};
+const TASK_CANCELED_MSG = `task canceled`;
+
+//#endregion
+//#region src/utils/util.ts
+/**
+* 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"));
+
+//#endregion
+//#region src/compiler/html/canonical-link.ts
+const updateCanonicalLink = (doc, href) => {
+	let canonicalLinkElm = doc.head.querySelector("link[rel=\"canonical\"]");
+	if (typeof href === "string") {
+		if (canonicalLinkElm == null) {
+			canonicalLinkElm = doc.createElement("link");
+			canonicalLinkElm.setAttribute("rel", "canonical");
+			doc.head.appendChild(canonicalLinkElm);
+		}
+		canonicalLinkElm.setAttribute("href", href);
+	} else if (canonicalLinkElm != null) {
+		if (!canonicalLinkElm.getAttribute("href")) canonicalLinkElm.parentNode?.removeChild(canonicalLinkElm);
+	}
+};
+
+//#endregion
+//#region src/compiler/html/relocate-meta-charset.ts
+const relocateMetaCharset = (doc) => {
+	const head = doc.head;
+	let charsetElm = head.querySelector("meta[charset]");
+	if (charsetElm == null) {
+		charsetElm = doc.createElement("meta");
+		charsetElm.setAttribute("charset", "utf-8");
+	} else charsetElm.remove();
+	head.insertBefore(charsetElm, head.firstChild);
+};
+
+//#endregion
+//#region src/compiler/style/css-parser/css-parse-declarations.ts
+let CssNodeType = /* @__PURE__ */ function(CssNodeType) {
+	CssNodeType[CssNodeType["Charset"] = 0] = "Charset";
+	CssNodeType[CssNodeType["Comment"] = 1] = "Comment";
+	CssNodeType[CssNodeType["CustomMedia"] = 2] = "CustomMedia";
+	CssNodeType[CssNodeType["Document"] = 3] = "Document";
+	CssNodeType[CssNodeType["Declaration"] = 4] = "Declaration";
+	CssNodeType[CssNodeType["FontFace"] = 5] = "FontFace";
+	CssNodeType[CssNodeType["Host"] = 6] = "Host";
+	CssNodeType[CssNodeType["Import"] = 7] = "Import";
+	CssNodeType[CssNodeType["KeyFrames"] = 8] = "KeyFrames";
+	CssNodeType[CssNodeType["KeyFrame"] = 9] = "KeyFrame";
+	CssNodeType[CssNodeType["Media"] = 10] = "Media";
+	CssNodeType[CssNodeType["Container"] = 11] = "Container";
+	CssNodeType[CssNodeType["Namespace"] = 12] = "Namespace";
+	CssNodeType[CssNodeType["Page"] = 13] = "Page";
+	CssNodeType[CssNodeType["Rule"] = 14] = "Rule";
+	CssNodeType[CssNodeType["StyleSheet"] = 15] = "StyleSheet";
+	CssNodeType[CssNodeType["Supports"] = 16] = "Supports";
+	return CssNodeType;
+}({});
+
+//#endregion
+//#region src/compiler/style/css-parser/parse-css.ts
+/**
+* Parses CSS string input into an AST representation.
+* Used for minification, finding & resolving URLs and during SSR / prerendering, removing unused selectors.
+*
+* @param css The CSS string to parse
+* @param filePath Optional file path for diagnostic reporting
+* @returns The results of the CSS parsing, including the AST and any diagnostics
+*/
+const parseCss = (css, filePath) => {
+	let lineno = 1;
+	let column = 1;
+	const diagnostics = [];
+	const updatePosition = (str) => {
+		const lines = str.match(/\n/g);
+		if (lines) lineno += lines.length;
+		const i = str.lastIndexOf("\n");
+		column = ~i ? str.length - i : column + str.length;
+	};
+	const position = () => {
+		const start = {
+			line: lineno,
+			column
+		};
+		return (node) => {
+			node.position = new ParsePosition(start);
+			whitespace();
+			return node;
+		};
+	};
+	const error = (msg) => {
+		const srcLines = css.split("\n");
+		const d = {
+			level: "error",
+			type: "css",
+			language: "css",
+			header: "CSS Parse",
+			messageText: msg,
+			absFilePath: filePath,
+			lines: [{
+				lineIndex: lineno - 1,
+				lineNumber: lineno,
+				errorCharStart: column,
+				text: css[lineno - 1]
+			}]
+		};
+		if (lineno > 1) {
+			const previousLine = {
+				lineIndex: lineno - 1,
+				lineNumber: lineno - 1,
+				text: css[lineno - 2],
+				errorCharStart: -1,
+				errorLength: -1
+			};
+			d.lines.unshift(previousLine);
+		}
+		if (lineno + 2 < srcLines.length) {
+			const nextLine = {
+				lineIndex: lineno,
+				lineNumber: lineno + 1,
+				text: srcLines[lineno],
+				errorCharStart: -1,
+				errorLength: -1
+			};
+			d.lines.push(nextLine);
+		}
+		diagnostics.push(d);
+		return null;
+	};
+	const stylesheet = () => {
+		const rulesList = rules();
+		return {
+			type: CssNodeType.StyleSheet,
+			stylesheet: {
+				source: filePath,
+				rules: rulesList
+			}
+		};
+	};
+	const open = () => match(/^{\s*/);
+	const close = () => match(/^}/);
+	const match = (re) => {
+		const m = re.exec(css);
+		if (!m) return;
+		const str = m[0];
+		updatePosition(str);
+		css = css.slice(str.length);
+		return m;
+	};
+	const rules = () => {
+		let node;
+		const rules = [];
+		whitespace();
+		comments(rules);
+		while (css.length && css.charAt(0) !== "}" && (node = atrule() || rule())) {
+			rules.push(node);
+			comments(rules);
+		}
+		return rules;
+	};
+	/**
+	* Parse whitespace.
+	*/
+	const whitespace = () => match(/^\s*/);
+	const comments = (rules) => {
+		let c;
+		rules = rules || [];
+		while (c = comment()) rules.push(c);
+		return rules;
+	};
+	const comment = () => {
+		const pos = position();
+		if ("/" !== css.charAt(0) || "*" !== css.charAt(1)) return null;
+		let i = 2;
+		while ("" !== css.charAt(i) && ("*" !== css.charAt(i) || "/" !== css.charAt(i + 1))) ++i;
+		i += 2;
+		if ("" === css.charAt(i - 1)) return error("End of comment missing");
+		const comment = css.slice(2, i - 2);
+		column += 2;
+		updatePosition(comment);
+		css = css.slice(i);
+		column += 2;
+		return pos({
+			type: CssNodeType.Comment,
+			comment
+		});
+	};
+	const selector = () => {
+		const m = match(/^([^{]+)/);
+		if (!m) return null;
+		return trim(m[0]).replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/g, "").replace(/"(?:\\"|[^"])*"|'(?:\\'|[^'])*'/g, function(m) {
+			return m.replace(/,/g, "‌");
+		}).split(/\s*(?![^(]*\)),\s*/).map(function(s) {
+			return s.replace(/\u200C/g, ",");
+		});
+	};
+	const declaration = () => {
+		const pos = position();
+		let prop = match(/^(\*?[-#\/\*\\\w]+(\[[0-9a-z_-]+\])?)\s*/);
+		if (!prop) return null;
+		prop = trim(prop[0]);
+		if (!match(/^:\s*/)) return error(`property missing ':'`);
+		const val = match(/^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^\)]*?\)|[^};])+)/);
+		const ret = pos({
+			type: CssNodeType.Declaration,
+			property: prop.replace(commentre, ""),
+			value: val ? trim(val[0]).replace(commentre, "") : ""
+		});
+		match(/^[;\s]*/);
+		return ret;
+	};
+	const declarations = () => {
+		const decls = [];
+		if (!open()) return error(`missing '{'`);
+		comments(decls);
+		let decl;
+		while (decl = declaration()) {
+			decls.push(decl);
+			comments(decls);
+		}
+		if (!close()) return error(`missing '}'`);
+		return decls;
+	};
+	const keyframe = () => {
+		let m;
+		const values = [];
+		const pos = position();
+		while (m = match(/^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/)) {
+			values.push(m[1]);
+			match(/^,\s*/);
+		}
+		if (!values.length) return null;
+		return pos({
+			type: CssNodeType.KeyFrame,
+			values,
+			declarations: declarations()
+		});
+	};
+	const atkeyframes = () => {
+		const pos = position();
+		let m = match(/^@([-\w]+)?keyframes\s*/);
+		if (!m) return null;
+		const vendor = m[1];
+		m = match(/^([-\w]+)\s*/);
+		if (!m) return error(`@keyframes missing name`);
+		const name = m[1];
+		if (!open()) return error(`@keyframes missing '{'`);
+		let frame;
+		let frames = comments();
+		while (frame = keyframe()) {
+			frames.push(frame);
+			frames = frames.concat(comments());
+		}
+		if (!close()) return error(`@keyframes missing '}'`);
+		return pos({
+			type: CssNodeType.KeyFrames,
+			name,
+			vendor,
+			keyframes: frames
+		});
+	};
+	const atsupports = () => {
+		const pos = position();
+		const m = match(/^@supports *([^{]+)/);
+		if (!m) return null;
+		const supports = trim(m[1]);
+		if (!open()) return error(`@supports missing '{'`);
+		const style = comments().concat(rules());
+		if (!close()) return error(`@supports missing '}'`);
+		return pos({
+			type: CssNodeType.Supports,
+			supports,
+			rules: style
+		});
+	};
+	const athost = () => {
+		const pos = position();
+		if (!match(/^@host\s*/)) return null;
+		if (!open()) return error(`@host missing '{'`);
+		const style = comments().concat(rules());
+		if (!close()) return error(`@host missing '}'`);
+		return pos({
+			type: CssNodeType.Host,
+			rules: style
+		});
+	};
+	const atquery = (name) => {
+		const pos = position();
+		const m = match(new RegExp("^@" + name + " *([^{]+)"));
+		if (!m) return null;
+		const media = trim(m[1]);
+		if (!open()) return error(`@${name} missing '{'`);
+		const style = comments().concat(rules());
+		if (!close()) return error(`@${name} missing '}'`);
+		return pos({
+			type: name === "media" ? CssNodeType.Media : CssNodeType.Container,
+			media,
+			rules: style
+		});
+	};
+	/**
+	* Parse nested @ rule that contains declarations instead of rules
+	*/
+	const nestedAtQuery = (name) => {
+		const pos = position();
+		const m = match(new RegExp("^@" + name + " *([^{]+)"));
+		if (!m) return null;
+		const media = trim(m[1]);
+		const decls = declarations();
+		if (!decls) return null;
+		return pos({
+			type: name === "media" ? CssNodeType.Media : name === "container" ? CssNodeType.Container : CssNodeType.Supports,
+			media,
+			declarations: decls
+		});
+	};
+	/**
+	* Try to parse a nested at-rule (one that contains declarations, not rules)
+	*/
+	const nestedAtrule = () => {
+		if (css[0] !== "@") return null;
+		return nestedAtQuery("media") || nestedAtQuery("supports") || nestedAtQuery("container");
+	};
+	const atcustommedia = () => {
+		const pos = position();
+		const m = match(/^@custom-media\s+(--[^\s]+)\s*([^{;]+);/);
+		if (!m) return null;
+		return pos({
+			type: CssNodeType.CustomMedia,
+			name: trim(m[1]),
+			media: trim(m[2])
+		});
+	};
+	const atpage = () => {
+		const pos = position();
+		if (!match(/^@page */)) return null;
+		const sel = selector() || [];
+		if (!open()) return error(`@page missing '{'`);
+		let decls = comments();
+		let decl;
+		while (decl = declaration()) {
+			decls.push(decl);
+			decls = decls.concat(comments());
+		}
+		if (!close()) return error(`@page missing '}'`);
+		return pos({
+			type: CssNodeType.Page,
+			selectors: sel,
+			declarations: decls
+		});
+	};
+	const atdocument = () => {
+		const pos = position();
+		const m = match(/^@([-\w]+)?document *([^{]+)/);
+		if (!m) return null;
+		const vendor = trim(m[1]);
+		const doc = trim(m[2]);
+		if (!open()) return error(`@document missing '{'`);
+		const style = comments().concat(rules());
+		if (!close()) return error(`@document missing '}'`);
+		return pos({
+			type: CssNodeType.Document,
+			document: doc,
+			vendor,
+			rules: style
+		});
+	};
+	const atfontface = () => {
+		const pos = position();
+		if (!match(/^@font-face\s*/)) return null;
+		if (!open()) return error(`@font-face missing '{'`);
+		let decls = comments();
+		let decl;
+		while (decl = declaration()) {
+			decls.push(decl);
+			decls = decls.concat(comments());
+		}
+		if (!close()) return error(`@font-face missing '}'`);
+		return pos({
+			type: CssNodeType.FontFace,
+			declarations: decls
+		});
+	};
+	const compileAtrule = (nodeName, nodeType) => {
+		const re = new RegExp("^@" + nodeName + "\\s*([^;]+);");
+		return () => {
+			const pos = position();
+			const m = match(re);
+			if (!m) return null;
+			const node = { type: nodeType };
+			node[nodeName] = m[1].trim();
+			return pos(node);
+		};
+	};
+	const atimport = compileAtrule("import", CssNodeType.Import);
+	const atcharset = compileAtrule("charset", CssNodeType.Charset);
+	const atnamespace = compileAtrule("namespace", CssNodeType.Namespace);
+	const atrule = () => {
+		if (css[0] !== "@") return null;
+		return atkeyframes() || atquery("media") || atquery("container") || atcustommedia() || atsupports() || atimport() || atcharset() || atnamespace() || atdocument() || atpage() || athost() || atfontface();
+	};
+	const rule = () => {
+		const pos = position();
+		const sel = selector();
+		if (!sel) return error("selector missing");
+		comments();
+		if (!open()) return error(`missing '{'`);
+		const decls = [];
+		const nestedRules = [];
+		comments(decls);
+		while (css.length && css.charAt(0) !== "}") {
+			whitespace();
+			if (!css.length || css.charAt(0) === "}") break;
+			const nextChar = css.charAt(0);
+			if (nextChar === "@") {
+				const nestedAt = nestedAtrule();
+				if (nestedAt) {
+					nestedRules.push(nestedAt);
+					comments(nestedRules);
+					continue;
+				}
+			}
+			if (nextChar === "&" || nextChar === ":" || /[a-zA-Z\.\#\[]/.test(nextChar)) {
+				let hasOpenBrace = false;
+				if (nextChar === "&" || nextChar === ":") {
+					const lookAhead = css.match(/^[^{}]+/);
+					hasOpenBrace = lookAhead && css[lookAhead[0].length] === "{";
+				} else {
+					const lookAhead = css.match(/^[^{};]+/);
+					if (lookAhead) hasOpenBrace = css[lookAhead[0].length] === "{";
+				}
+				if (hasOpenBrace) {
+					const nestedRule = rule();
+					if (nestedRule) {
+						nestedRules.push(nestedRule);
+						comments(nestedRules);
+						continue;
+					}
+				}
+			}
+			const decl = declaration();
+			if (decl) {
+				decls.push(decl);
+				comments(decls);
+				continue;
+			}
+			break;
+		}
+		if (!close()) return error(`missing '}'`);
+		return pos({
+			type: CssNodeType.Rule,
+			selectors: sel,
+			declarations: decls,
+			rules: nestedRules.length > 0 ? nestedRules : null
+		});
+	};
+	class ParsePosition {
+		start;
+		end;
+		source;
+		content;
+		constructor(start) {
+			this.start = start;
+			this.end = {
+				line: lineno,
+				column
+			};
+			this.source = filePath;
+		}
+	}
+	ParsePosition.prototype.content = css;
+	return {
+		diagnostics,
+		...addParent(stylesheet())
+	};
+};
+const trim = (str) => str ? str.trim() : "";
+/**
+* Adds non-enumerable parent node reference to each node.
+*/
+const addParent = (obj, parent) => {
+	const isNode = obj && typeof obj.type === "string";
+	const childParent = isNode ? obj : parent;
+	for (const k in obj) {
+		const value = obj[k];
+		if (Array.isArray(value)) value.forEach(function(v) {
+			addParent(v, childParent);
+		});
+		else if (value && typeof value === "object") addParent(value, childParent);
+	}
+	if (isNode) Object.defineProperty(obj, "parent", {
+		configurable: true,
+		writable: true,
+		enumerable: false,
+		value: parent || null
+	});
+	return obj;
+};
+const commentre = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
+
+//#endregion
+//#region src/compiler/style/css-parser/get-css-selectors.ts
+const getCssSelectors = (sel) => {
+	SELECTORS.all.length = SELECTORS.tags.length = SELECTORS.classNames.length = SELECTORS.ids.length = SELECTORS.attrs.length = 0;
+	sel = sel.replace(/\./g, " .").replace(/\#/g, " #").replace(/\[/g, " [").replace(/\>/g, " > ").replace(/\+/g, " + ").replace(/\~/g, " ~ ").replace(/\*/g, " * ").replace(/\:not\((.*?)\)/g, " ");
+	const items = sel.split(" ");
+	for (let i = 0, l = items.length; i < l; i++) {
+		items[i] = items[i].split(":")[0];
+		if (items[i].length === 0) continue;
+		if (items[i].charAt(0) === ".") SELECTORS.classNames.push(items[i].slice(1));
+		else if (items[i].charAt(0) === "#") SELECTORS.ids.push(items[i].slice(1));
+		else if (items[i].charAt(0) === "[") {
+			items[i] = items[i].slice(1).split("=")[0].split("]")[0].trim();
+			SELECTORS.attrs.push(items[i].toLowerCase());
+		} else if (/[a-z]/g.test(items[i].charAt(0))) SELECTORS.tags.push(items[i].toLowerCase());
+	}
+	SELECTORS.classNames = SELECTORS.classNames.sort((a, b) => {
+		if (a.length < b.length) return -1;
+		if (a.length > b.length) return 1;
+		return 0;
+	});
+	return SELECTORS;
+};
+const SELECTORS = {
+	all: [],
+	tags: [],
+	classNames: [],
+	ids: [],
+	attrs: []
+};
+
+//#endregion
+//#region src/compiler/style/css-parser/serialize-css.ts
+/**
+* Serializes CSS AST back into a minified CSS string,
+* possibly filtering by used selectors (used during SSR / prerendering)
+*
+* @param stylesheet The CSS AST to serialize.
+* @param serializeOpts Options for serialization, including used selectors for filtering.
+* @returns The serialized CSS string.
+*/
+const serializeCss = (stylesheet, serializeOpts) => {
+	const usedSelectors = serializeOpts.usedSelectors || null;
+	const opts = {
+		usedSelectors: usedSelectors || null,
+		hasUsedAttrs: !!usedSelectors && usedSelectors.attrs.size > 0,
+		hasUsedClassNames: !!usedSelectors && usedSelectors.classNames.size > 0,
+		hasUsedIds: !!usedSelectors && usedSelectors.ids.size > 0,
+		hasUsedTags: !!usedSelectors && usedSelectors.tags.size > 0
+	};
+	const rules = stylesheet.rules;
+	if (!rules) return "";
+	const rulesLen = rules.length;
+	const out = [];
+	for (let i = 0; i < rulesLen; i++) out.push(serializeCssVisitNode(opts, rules[i], i, rulesLen));
+	return out.join("");
+};
+const serializeCssVisitNode = (opts, node, index, len) => {
+	const nodeType = node.type;
+	if (nodeType === CssNodeType.Declaration) return serializeCssDeclaration(node, index, len);
+	if (nodeType === CssNodeType.Rule) return serializeCssRule(opts, node);
+	if (nodeType === CssNodeType.Comment) if (node.comment?.[0] === "!") return `/*${node.comment}*/`;
+	else return "";
+	if (nodeType === CssNodeType.Media) return serializeCssMedia(opts, node);
+	if (nodeType === CssNodeType.Container) return serializeCssContainer(opts, node);
+	if (nodeType === CssNodeType.KeyFrames) return serializeCssKeyframes(opts, node);
+	if (nodeType === CssNodeType.KeyFrame) return serializeCssKeyframe(opts, node);
+	if (nodeType === CssNodeType.FontFace) return serializeCssFontFace(opts, node);
+	if (nodeType === CssNodeType.Supports) return serializeCssSupports(opts, node);
+	if (nodeType === CssNodeType.Import) return "@import " + node.import + ";";
+	if (nodeType === CssNodeType.Charset) return "@charset " + node.charset + ";";
+	if (nodeType === CssNodeType.Page) return serializeCssPage(opts, node);
+	if (nodeType === CssNodeType.Host) return "@host{" + serializeCssMapVisit(opts, node.rules) + "}";
+	if (nodeType === CssNodeType.CustomMedia) return "@custom-media " + node.name + " " + node.media + ";";
+	if (nodeType === CssNodeType.Document) return serializeCssDocument(opts, node);
+	if (nodeType === CssNodeType.Namespace) return "@namespace " + node.namespace + ";";
+	return "";
+};
+const serializeCssRule = (opts, node) => {
+	const decls = node.declarations;
+	const usedSelectors = opts.usedSelectors;
+	const selectors = node.selectors?.slice() ?? [];
+	const hasDecls = decls != null && decls.length > 0;
+	const hasNestedRules = node.rules != null && node.rules.length > 0;
+	if (!hasDecls && !hasNestedRules) return "";
+	if (usedSelectors) {
+		let i;
+		let j;
+		let include = true;
+		for (i = selectors.length - 1; i >= 0; i--) {
+			const sel = getCssSelectors(selectors[i]);
+			include = true;
+			let jlen = sel.classNames.length;
+			if (jlen > 0 && opts.hasUsedClassNames) {
+				for (j = 0; j < jlen; j++) if (!usedSelectors.classNames.has(sel.classNames[j])) {
+					include = false;
+					break;
+				}
+			}
+			if (include && opts.hasUsedTags) {
+				jlen = sel.tags.length;
+				if (jlen > 0) {
+					for (j = 0; j < jlen; j++) if (!usedSelectors.tags.has(sel.tags[j])) {
+						include = false;
+						break;
+					}
+				}
+			}
+			if (include && opts.hasUsedAttrs) {
+				jlen = sel.attrs.length;
+				if (jlen > 0) {
+					for (j = 0; j < jlen; j++) if (!usedSelectors.attrs.has(sel.attrs[j])) {
+						include = false;
+						break;
+					}
+				}
+			}
+			if (include && opts.hasUsedIds) {
+				jlen = sel.ids.length;
+				if (jlen > 0) {
+					for (j = 0; j < jlen; j++) if (!usedSelectors.ids.has(sel.ids[j])) {
+						include = false;
+						break;
+					}
+				}
+			}
+			if (!include) selectors.splice(i, 1);
+		}
+	}
+	if (selectors.length === 0) return "";
+	const cleanedSelectors = [];
+	let cleanedSelector = "";
+	if (node.selectors) for (const selector of node.selectors) {
+		cleanedSelector = removeSelectorWhitespace(selector);
+		if (!cleanedSelectors.includes(cleanedSelector)) cleanedSelectors.push(cleanedSelector);
+	}
+	let declsCss = decls && decls.length > 0 ? serializeCssMapVisit(opts, decls) : "";
+	const nestedRulesCss = node.rules ? serializeCssMapVisit(opts, node.rules) : "";
+	if (declsCss && nestedRulesCss && declsCss.length > 0) declsCss += ";";
+	return `${cleanedSelectors}{${declsCss}${nestedRulesCss}}`;
+};
+const serializeCssDeclaration = (node, index, len) => {
+	if (node.value === "") return "";
+	if (len - 1 === index) return node.property + ":" + node.value;
+	return node.property + ":" + node.value + ";";
+};
+const serializeCssMedia = (opts, node) => {
+	const mediaCss = node.declarations ? serializeCssMapVisit(opts, node.declarations) : serializeCssMapVisit(opts, node.rules);
+	if (mediaCss === "") return "";
+	return "@media " + removeMediaWhitespace(node.media) + "{" + mediaCss + "}";
+};
+const serializeCssKeyframes = (opts, node) => {
+	const keyframesCss = serializeCssMapVisit(opts, node.keyframes);
+	if (keyframesCss === "") return "";
+	return "@" + (node.vendor || "") + "keyframes " + node.name + "{" + keyframesCss + "}";
+};
+const serializeCssKeyframe = (opts, node) => {
+	return (node.values?.join(",") ?? "") + "{" + serializeCssMapVisit(opts, node.declarations) + "}";
+};
+const serializeCssFontFace = (opts, node) => {
+	const fontCss = serializeCssMapVisit(opts, node.declarations);
+	if (fontCss === "") return "";
+	return "@font-face{" + fontCss + "}";
+};
+const serializeCssSupports = (opts, node) => {
+	const supportsCss = node.declarations ? serializeCssMapVisit(opts, node.declarations) : serializeCssMapVisit(opts, node.rules);
+	if (supportsCss === "") return "";
+	return "@supports " + node.supports + "{" + supportsCss + "}";
+};
+const serializeCssContainer = (opts, node) => {
+	const containerCss = node.declarations ? serializeCssMapVisit(opts, node.declarations) : serializeCssMapVisit(opts, node.rules);
+	if (containerCss === "") return "";
+	return "@container " + removeMediaWhitespace(node.media) + "{" + containerCss + "}";
+};
+const serializeCssPage = (opts, node) => {
+	return "@page " + (node.selectors?.join(", ") ?? "") + "{" + serializeCssMapVisit(opts, node.declarations) + "}";
+};
+const serializeCssDocument = (opts, node) => {
+	const documentCss = serializeCssMapVisit(opts, node.rules);
+	const doc = "@" + (node.vendor || "") + "document " + node.document;
+	if (documentCss === "") return "";
+	return doc + "{" + documentCss + "}";
+};
+const serializeCssMapVisit = (opts, nodes) => {
+	let rtn = "";
+	if (nodes) for (let i = 0, len = nodes.length; i < len; i++) rtn += serializeCssVisitNode(opts, nodes[i], i, len);
+	return rtn;
+};
+const removeSelectorWhitespace = (selector) => {
+	let rtn = "";
+	let char = "";
+	let inAttr = false;
+	selector = selector.trim();
+	for (let i = 0, l = selector.length; i < l; i++) {
+		char = selector[i];
+		if (char === "[" && rtn[rtn.length - 1] !== "\\") inAttr = true;
+		else if (char === "]" && rtn[rtn.length - 1] !== "\\") inAttr = false;
+		if (!inAttr && CSS_WS_REG.test(char)) {
+			if (CSS_NEXT_CHAR_REG.test(selector[i + 1])) continue;
+			if (CSS_PREV_CHAR_REG.test(rtn[rtn.length - 1])) continue;
+			rtn += " ";
+		} else rtn += char;
+	}
+	return rtn;
+};
+const removeMediaWhitespace = (media) => {
+	let rtn = "";
+	let char = "";
+	media = media?.trim() ?? "";
+	for (let i = 0, l = media.length; i < l; i++) {
+		char = media[i];
+		if (CSS_WS_REG.test(char)) {
+			if (CSS_WS_REG.test(rtn[rtn.length - 1])) continue;
+			rtn += " ";
+		} else rtn += char;
+	}
+	return rtn;
+};
+const CSS_WS_REG = /\s/;
+const CSS_NEXT_CHAR_REG = /[>\(\)\~\,\+\s]/;
+const CSS_PREV_CHAR_REG = /[>\(\~\,\+]/;
+
+//#endregion
+//#region src/compiler/style/css-parser/used-selectors.ts
+/**
+* Collects all used selectors (tags, class names, ids, attributes) from a given DOM element and its children.
+* Mainly used during SSR / prerendering to determine which CSS rules are necessary.
+*
+* @param elm The root element from which to start collecting used selectors.
+* @returns The set of used selectors found within the element and its descendants.
+*/
+const getUsedSelectors = (elm) => {
+	const usedSelectors = {
+		attrs: /* @__PURE__ */ new Set(),
+		classNames: /* @__PURE__ */ new Set(),
+		ids: /* @__PURE__ */ new Set(),
+		tags: /* @__PURE__ */ new Set()
+	};
+	collectUsedSelectors(usedSelectors, elm);
+	return usedSelectors;
+};
+const collectUsedSelectors = (usedSelectors, elm) => {
+	if (elm != null && elm.nodeType === 1) {
+		const children = elm.children;
+		const tagName = elm.nodeName.toLowerCase();
+		usedSelectors.tags.add(tagName);
+		const attributes = elm.attributes;
+		for (let i = 0, l = attributes.length; i < l; i++) {
+			const attr = attributes.item(i);
+			const attrName = attr.name.toLowerCase();
+			usedSelectors.attrs.add(attrName);
+			if (attrName === "class") {
+				const classList = elm.classList;
+				for (let i = 0, l = classList.length; i < l; i++) usedSelectors.classNames.add(classList.item(i));
+			} else if (attrName === "id") usedSelectors.ids.add(attr.value);
+		}
+		if (children) for (let i = 0, l = children.length; i < l; i++) collectUsedSelectors(usedSelectors, children[i]);
+	}
+};
+
+//#endregion
+//#region src/compiler/html/remove-unused-styles.ts
+/**
+* Removes unused CSS styles from the document's style elements based on the selectors used in the document.
+* Primarily used during SSR / prerendering to optimize CSS delivery.
+*
+* @param doc The HTML document to process.
+* @param diagnostics An array to collect diagnostic messages.
+*/
+const removeUnusedStyles = (doc, diagnostics) => {
+	try {
+		const styleElms = doc.head.querySelectorAll(`style[data-styles]`);
+		const styleLen = styleElms.length;
+		if (styleLen > 0) {
+			const usedSelectors = getUsedSelectors(doc.documentElement);
+			for (let i = 0; i < styleLen; i++) removeUnusedStyleText(usedSelectors, diagnostics, styleElms[i]);
+		}
+	} catch (e) {
+		catchError(diagnostics, e);
+	}
+};
+const removeUnusedStyleText = (usedSelectors, diagnostics, styleElm) => {
+	try {
+		const parseResults = parseCss(styleElm.innerHTML);
+		diagnostics.push(...parseResults.diagnostics);
+		if (hasError(diagnostics)) return;
+		try {
+			styleElm.innerHTML = serializeCss(parseResults.stylesheet, { usedSelectors });
+		} catch (e) {
+			diagnostics.push({
+				level: "warn",
+				type: "css",
+				header: "CSS Stringify",
+				messageText: e,
+				lines: []
+			});
+		}
+	} catch (e) {
+		diagnostics.push({
+			level: "warn",
+			type: "css",
+			header: "CSS Parse",
+			messageText: e,
+			lines: []
+		});
+	}
+};
+
+//#endregion
+//#region src/server/runner/inspect-element.ts
+function inspectElement(results, elm, depth) {
+	const children = [...Array.from(elm.children), ...Array.from(elm.shadowRoot ? elm.shadowRoot.children : [])];
+	for (let i = 0, ii = children.length; i < ii; i++) {
+		const childElm = children[i];
+		const tagName = childElm.nodeName.toLowerCase();
+		if (tagName.includes("-")) {
+			const cmp = results.components.find((c) => c.tag === tagName);
+			if (cmp != null) {
+				cmp.count++;
+				if (depth > cmp.depth) cmp.depth = depth;
+			}
+		} else switch (tagName) {
+			case "a":
+				const anchor = collectAttributes(childElm);
+				anchor.href = childElm.href;
+				if (typeof anchor.href === "string") {
+					if (!results.anchors.some((a) => a.href === anchor.href)) results.anchors.push(anchor);
+				}
+				break;
+			case "img":
+				const img = collectAttributes(childElm);
+				img.src = childElm.src;
+				if (typeof img.src === "string") {
+					if (!results.imgs.some((a) => a.src === img.src)) results.imgs.push(img);
+				}
+				break;
+			case "link":
+				const link = collectAttributes(childElm);
+				link.href = childElm.href;
+				if (typeof link.rel === "string" && link.rel.toLowerCase() === "stylesheet") {
+					if (typeof link.href === "string") {
+						if (!results.styles.some((s) => s.link === link.href)) {
+							delete link.rel;
+							delete link.type;
+							results.styles.push(link);
+						}
+					}
+				}
+				break;
+			case "script":
+				const script = collectAttributes(childElm);
+				if (childElm.hasAttribute("src")) {
+					script.src = childElm.src;
+					if (typeof script.src === "string") {
+						if (!results.scripts.some((s) => s.src === script.src)) results.scripts.push(script);
+					}
+				} else {
+					const staticDataKey = childElm.getAttribute("data-stencil-static");
+					if (staticDataKey) results.staticData.push({
+						id: staticDataKey,
+						type: childElm.getAttribute("type"),
+						content: childElm.textContent
+					});
+				}
+				break;
+		}
+		depth++;
+		inspectElement(results, childElm, depth);
+	}
+}
+function collectAttributes(node) {
+	const parsedElm = {};
+	const attrs = node.attributes;
+	for (let i = 0, ii = attrs.length; i < ii; i++) {
+		const attr = attrs.item(i);
+		const attrName = attr.nodeName.toLowerCase();
+		if (SKIP_ATTRS.has(attrName)) continue;
+		const attrValue = attr.nodeValue;
+		if (attrName === "class" && attrValue === "") continue;
+		parsedElm[attrName] = attrValue;
+	}
+	return parsedElm;
+}
+const SKIP_ATTRS = new Set(["s-id", "c-id"]);
+
+//#endregion
+//#region src/server/runner/patch-dom-implementation.ts
+function patchDomImplementation(doc, opts) {
+	let win;
+	if (doc.defaultView != null) {
+		opts.destroyWindow = true;
+		patchWindow(doc.defaultView);
+		win = doc.defaultView;
+	} else {
+		opts.destroyWindow = true;
+		opts.destroyDocument = false;
+		win = new MockWindow(false);
+	}
+	if (win.document !== doc) win.document = doc;
+	if (doc.defaultView !== win) doc.defaultView = win;
+	if (typeof doc.documentElement.constructor.prototype.getRootNode !== "function") {
+		const HTMLUnknownElement = doc.createElement("unknown-element").constructor.prototype;
+		HTMLUnknownElement.getRootNode = getRootNode;
+	}
+	if (typeof doc.createEvent === "function") {
+		const CustomEvent = doc.createEvent("CustomEvent").constructor;
+		if (win.CustomEvent !== CustomEvent) win.CustomEvent = CustomEvent;
+	}
+	try {
+		win.__stencil_baseURI = doc.baseURI;
+	} catch (e) {
+		Object.defineProperty(doc, "baseURI", { get() {
+			const baseElm = doc.querySelector("base[href]");
+			if (baseElm) return new URL(baseElm.getAttribute("href"), win.location.href).href;
+			return win.location.href;
+		} });
+	}
+	return win;
+}
+function getRootNode(opts) {
+	const isComposed = opts != null && opts.composed === true;
+	let node = this;
+	while (node.parentNode != null) {
+		node = node.parentNode;
+		if (isComposed === true && node.parentNode == null && node.host != null) node = node.host;
+	}
+	return node;
+}
+
+//#endregion
+//#region src/server/runner/render-utils.ts
+function normalizeHydrateOptions(inputOpts) {
+	const outputOpts = Object.assign({
+		serializeToHtml: false,
+		destroyWindow: false,
+		destroyDocument: false
+	}, inputOpts || {});
+	if (typeof outputOpts.clientHydrateAnnotations !== "boolean") outputOpts.clientHydrateAnnotations = true;
+	if (typeof outputOpts.constrainTimeouts !== "boolean") outputOpts.constrainTimeouts = true;
+	if (typeof outputOpts.maxHydrateCount !== "number") outputOpts.maxHydrateCount = 300;
+	if (typeof outputOpts.runtimeLogging !== "boolean") outputOpts.runtimeLogging = false;
+	if (typeof outputOpts.timeout !== "number") outputOpts.timeout = 15e3;
+	if (Array.isArray(outputOpts.excludeComponents)) outputOpts.excludeComponents = outputOpts.excludeComponents.filter(filterValidTags).map(mapValidTags);
+	else outputOpts.excludeComponents = [];
+	if (Array.isArray(outputOpts.staticComponents)) outputOpts.staticComponents = outputOpts.staticComponents.filter(filterValidTags).map(mapValidTags);
+	else outputOpts.staticComponents = [];
+	return outputOpts;
+}
+function filterValidTags(tag) {
+	return typeof tag === "string" && tag.includes("-");
+}
+function mapValidTags(tag) {
+	return tag.trim().toLowerCase();
+}
+function generateHydrateResults(opts) {
+	if (typeof opts.url !== "string") opts.url = `https://hydrate.stenciljs.com/`;
+	if (typeof opts.buildId !== "string") opts.buildId = createHydrateBuildId();
+	const results = {
+		buildId: opts.buildId,
+		diagnostics: [],
+		url: opts.url,
+		host: null,
+		hostname: null,
+		href: null,
+		pathname: null,
+		port: null,
+		search: null,
+		hash: null,
+		html: null,
+		httpStatus: null,
+		hydratedCount: 0,
+		anchors: [],
+		components: [],
+		imgs: [],
+		scripts: [],
+		staticData: [],
+		styles: [],
+		title: null
+	};
+	try {
+		const url = new URL(opts.url, `https://hydrate.stenciljs.com/`);
+		results.url = url.href;
+		results.host = url.host;
+		results.hostname = url.hostname;
+		results.href = url.href;
+		results.port = url.port;
+		results.pathname = url.pathname;
+		results.search = url.search;
+		results.hash = url.hash;
+	} catch (e) {
+		renderCatchError(results, e);
+	}
+	return results;
+}
+const createHydrateBuildId = () => {
+	let chars = "abcdefghijklmnopqrstuvwxyz";
+	let buildId = "";
+	while (buildId.length < 8) {
+		const char = chars[Math.floor(Math.random() * chars.length)];
+		buildId += char;
+		if (buildId.length === 1) chars += "0123456789";
+	}
+	return buildId;
+};
+function renderBuildDiagnostic(results, level, header, msg) {
+	const diagnostic = {
+		level,
+		type: "build",
+		header,
+		messageText: msg,
+		relFilePath: void 0,
+		absFilePath: void 0,
+		lines: []
+	};
+	if (results.pathname) {
+		if (results.pathname !== "/") diagnostic.header += ": " + results.pathname;
+	} else if (results.url) diagnostic.header += ": " + results.url;
+	results.diagnostics.push(diagnostic);
+	return diagnostic;
+}
+function renderBuildError(results, msg) {
+	return renderBuildDiagnostic(results, "error", "Hydrate Error", msg || "");
+}
+function renderCatchError(results, err) {
+	const diagnostic = renderBuildError(results);
+	if (err != null) if (err.stack != null) diagnostic.messageText = err.stack.toString();
+	else if (err.message != null) diagnostic.messageText = err.message.toString();
+	else diagnostic.messageText = err.toString();
+	return diagnostic;
+}
+
+//#endregion
+//#region src/server/runner/runtime-log.ts
+function runtimeLogging(win, opts, results) {
+	try {
+		const pathname = win.location.pathname;
+		win.console.error = (...msgs) => {
+			const errMsg = msgs.reduce((errMsg, m) => {
+				if (m) {
+					if (m.stack != null) return errMsg + " " + String(m.stack);
+					else if (m.message != null) return errMsg + " " + String(m.message);
+				}
+				return String(m);
+			}, "").trim();
+			if (errMsg !== "") {
+				renderCatchError(results, errMsg);
+				if (opts.runtimeLogging) runtimeLog(pathname, "error", [errMsg]);
+			}
+		};
+		win.console.debug = (...msgs) => {
+			renderBuildDiagnostic(results, "debug", "Hydrate Debug", [...msgs].join(", "));
+			if (opts.runtimeLogging) runtimeLog(pathname, "debug", msgs);
+		};
+		if (opts.runtimeLogging) [
+			"log",
+			"warn",
+			"assert",
+			"info",
+			"trace"
+		].forEach((type) => {
+			win.console[type] = (...msgs) => {
+				runtimeLog(pathname, type, msgs);
+			};
+		});
+	} catch (e) {
+		renderCatchError(results, e);
+	}
+}
+function runtimeLog(pathname, type, msgs) {
+	global.console[type].apply(global.console, [`[ ${pathname}  ${type} ] `, ...msgs]);
+}
+
+//#endregion
+//#region src/server/runner/window-initialize.ts
+/**
+* Maintain a unique `docData` object across multiple hydration runs
+* to ensure that host ids remain unique.
+*/
+const docData = {
+	hostIds: 0,
+	rootLevelIds: 0,
+	staticComponents: /* @__PURE__ */ new Set()
+};
+function initializeWindow(win, doc, opts, results) {
+	if (typeof opts.url === "string") try {
+		win.location.href = opts.url;
+	} catch (e) {}
+	if (typeof opts.userAgent === "string") try {
+		win.navigator.userAgent = opts.userAgent;
+	} catch (e) {}
+	if (typeof opts.cookie === "string") try {
+		doc.cookie = opts.cookie;
+	} catch (e) {}
+	if (typeof opts.referrer === "string") try {
+		doc.referrer = opts.referrer;
+	} catch (e) {}
+	if (typeof opts.direction === "string") try {
+		doc.documentElement.setAttribute("dir", opts.direction);
+	} catch (e) {}
+	if (typeof opts.language === "string") try {
+		doc.documentElement.setAttribute("lang", opts.language);
+	} catch (e) {}
+	if (typeof opts.buildId === "string") try {
+		doc.documentElement.setAttribute("data-stencil-build", opts.buildId);
+	} catch (e) {}
+	try {
+		win.customElements = null;
+	} catch (e) {}
+	if (opts.constrainTimeouts) constrainTimeouts(win);
+	runtimeLogging(win, opts, results);
+	doc[STENCIL_DOC_DATA] = docData;
+	return win;
+}
+
+//#endregion
+//#region src/server/runner/render.ts
+const NOOP = () => {};
+function streamToString(html, option) {
+	return renderToString(html, option, true);
+}
+function renderToString(html, options, asStream) {
+	const opts = normalizeHydrateOptions(options);
+	/**
+	* Makes the rendered DOM not being rendered to a string.
+	*/
+	opts.serializeToHtml = true;
+	/**
+	* Set the flag whether or not we like to render into a declarative shadow root.
+	*/
+	opts.fullDocument = typeof opts.fullDocument === "boolean" ? opts.fullDocument : true;
+	/**
+	* Defines whether we render the shadow root as a declarative shadow root or as scoped shadow root.
+	*/
+	opts.serializeShadowRoot = typeof opts.serializeShadowRoot === "undefined" ? "declarative-shadow-dom" : opts.serializeShadowRoot;
+	/**
+	* Make sure we wait for components to be hydrated.
+	*/
+	opts.constrainTimeouts = false;
+	return hydrateDocument(html, opts, asStream);
+}
+function hydrateDocument(doc, options, asStream) {
+	const opts = normalizeHydrateOptions(options);
+	/**
+	* Defines whether we render the shadow root as a declarative shadow root or as scoped shadow root.
+	*/
+	opts.serializeShadowRoot = typeof opts.serializeShadowRoot === "undefined" ? "declarative-shadow-dom" : opts.serializeShadowRoot;
+	let win = null;
+	const results = generateHydrateResults(opts);
+	if (hasError(results.diagnostics)) return Promise.resolve(results);
+	if (typeof doc === "string") try {
+		opts.destroyWindow = true;
+		opts.destroyDocument = true;
+		win = new MockWindow(doc);
+		if (!asStream) return render(win, opts, results).then(() => results);
+		return renderStream(win, opts, results);
+	} catch (e) {
+		if (win && win.close) win.close();
+		win = null;
+		renderCatchError(results, e);
+		return Promise.resolve(results);
+	}
+	if (isValidDocument(doc)) try {
+		opts.destroyDocument = false;
+		win = patchDomImplementation(doc, opts);
+		if (!asStream) return render(win, opts, results).then(() => results);
+		return renderStream(win, opts, results);
+	} catch (e) {
+		if (win && win.close) win.close();
+		win = null;
+		renderCatchError(results, e);
+		return Promise.resolve(results);
+	}
+	renderBuildError(results, `Invalid html or document. Must be either a valid "html" string, or DOM "document".`);
+	return Promise.resolve(results);
+}
+async function render(win, opts, results) {
+	if ("process" in globalThis && typeof process.on === "function" && !process.__stencilErrors) {
+		process.__stencilErrors = true;
+		process.on("unhandledRejection", (e) => {
+			console.log("unhandledRejection", e);
+		});
+	}
+	initializeWindow(win, win.document, opts, results);
+	const beforeHydrateFn = typeof opts.beforeHydrate === "function" ? opts.beforeHydrate : NOOP;
+	try {
+		await Promise.resolve(beforeHydrateFn(win.document));
+		return new Promise((resolve) => {
+			if (Array.isArray(opts.modes)) {
+				/**
+				* Reset the mode resolution chain as we expect every `renderToString` call to render
+				* the components in new environment/document.
+				*/
+				modeResolutionChain.length = 0;
+				opts.modes.forEach((mode) => setMode(mode));
+			}
+			return /* @__PURE__ */ hydrateFactory(win, opts, results, afterHydrate, resolve);
+		});
+	} catch (e) {
+		renderCatchError(results, e);
+		return finalizeHydrate(win, win.document, opts, results);
+	}
+}
+/**
+* Wrapper around `render` method to enable streaming by returning a Readable instead of a promise.
+* @param win MockDoc window object
+* @param opts serialization options
+* @param results render result object
+* @returns a Readable that can be passed into a response
+*/
+function renderStream(win, opts, results) {
+	async function* processRender() {
+		yield (await render(win, opts, results)).html;
+	}
+	return Readable.from(processRender());
+}
+async function afterHydrate(win, opts, results, resolve) {
+	const afterHydrateFn = typeof opts.afterHydrate === "function" ? opts.afterHydrate : NOOP;
+	try {
+		await Promise.resolve(afterHydrateFn(win.document));
+		return resolve(finalizeHydrate(win, win.document, opts, results));
+	} catch (e) {
+		renderCatchError(results, e);
+		return resolve(finalizeHydrate(win, win.document, opts, results));
+	}
+}
+function finalizeHydrate(win, doc, opts, results) {
+	try {
+		inspectElement(results, doc.documentElement, 0);
+		if (opts.removeUnusedStyles !== false) try {
+			removeUnusedStyles(doc, results.diagnostics);
+		} catch (e) {
+			renderCatchError(results, e);
+		}
+		if (typeof opts.title === "string") try {
+			doc.title = opts.title;
+		} catch (e) {
+			renderCatchError(results, e);
+		}
+		results.title = doc.title;
+		if (opts.removeScripts) removeScripts(doc.documentElement);
+		const styles = doc.querySelectorAll("head style");
+		if (styles.length > 0) results.styles.push(...Array.from(styles).map((style) => ({
+			href: style.getAttribute("href"),
+			id: style.getAttribute(HYDRATED_STYLE_ID),
+			content: style.textContent
+		})));
+		try {
+			updateCanonicalLink(doc, opts.canonicalUrl);
+		} catch (e) {
+			renderCatchError(results, e);
+		}
+		try {
+			relocateMetaCharset(doc);
+		} catch (e) {}
+		if (!hasError(results.diagnostics)) results.httpStatus = 200;
+		try {
+			const metaStatus = doc.head.querySelector("meta[http-equiv=\"status\"]");
+			if (metaStatus != null) {
+				const metaStatusContent = metaStatus.getAttribute("content");
+				if (metaStatusContent && metaStatusContent.length > 0) results.httpStatus = parseInt(metaStatusContent, 10);
+			}
+		} catch (e) {}
+		if (opts.clientHydrateAnnotations) doc.documentElement.classList.add("hydrated");
+		if (opts.serializeToHtml) results.html = serializeDocumentToString(doc, opts);
+	} catch (e) {
+		renderCatchError(results, e);
+	}
+	destroyWindow(win, doc, opts, results);
+	return results;
+}
+function destroyWindow(win, doc, opts, results) {
+	if (!opts.destroyWindow) return;
+	try {
+		if (!opts.destroyDocument) {
+			win.document = null;
+			doc.defaultView = null;
+		}
+		if (win.close) win.close();
+	} catch (e) {
+		renderCatchError(results, e);
+	}
+}
+function serializeDocumentToString(doc, opts) {
+	return serializeNodeToHtml(doc, {
+		approximateLineWidth: opts.approximateLineWidth,
+		outerHtml: false,
+		prettyHtml: opts.prettyHtml,
+		removeAttributeQuotes: opts.removeAttributeQuotes,
+		removeBooleanAttributeQuotes: opts.removeBooleanAttributeQuotes,
+		removeEmptyAttributes: opts.removeEmptyAttributes,
+		removeHtmlComments: opts.removeHtmlComments,
+		serializeShadowRoot: opts.serializeShadowRoot,
+		fullDocument: opts.fullDocument
+	});
+}
+function isValidDocument(doc) {
+	return doc != null && doc.nodeType === 9 && doc.documentElement != null && doc.documentElement.nodeType === 1 && doc.body != null && doc.body.nodeType === 1;
+}
+function removeScripts(elm) {
+	const children = elm.children;
+	for (let i = children.length - 1; i >= 0; i--) {
+		const child = children[i];
+		removeScripts(child);
+		if (child.nodeName === "SCRIPT" || child.nodeName === "LINK" && child.getAttribute("rel") === "modulepreload") child.remove();
+	}
+}
+
+//#endregion
+export { createWindowFromHtml, deserializeProperty, hydrateDocument, renderToString, serializeDocumentToString, serializeProperty, setTagTransformer, streamToString, transformTag };