@stencil/core 4.43.5 → 5.0.0-alpha.10

package/dist/testing/index.mjs

@@ -0,0 +1,1477 @@
+import { A as HYDRATE_ID, C as setAssetPath, D as DEFAULT_DOC_DATA, F as reWireGetterSetter, M as STENCIL_DOC_DATA, P as getHostRef$1, S as getAssetPath, X as Env, Y as BUILD, _ as insertBefore, b as getElement, c as Fragment, g as getRenderingRef, h as forceUpdate, j as NODE_TYPE, k as HYDRATE_CHILD_ID, l as bootstrapLazy, m as h, p as Host, s as Mixin, u as getMode, v as renderVdom, y as createEvent } from "../client-aTQ7xHxx.mjs";
+import { L as EVENT_FLAGS, h as noop, w as CMP_FLAGS } from "../regular-expression-CFVJOTUh.mjs";
+import { _ as getBuildFeatures, c as createWorkerContext, g as BuildContext, h as Cache, i as createSystem, o as loadConfig, p as createInMemoryFs, s as createCompiler } from "../compiler-lTINDSgw.mjs";
+import { wt as formatLazyBundleRuntimeMeta } from "../validation-ByxKj8bC.mjs";
+import { o as buildEvents } from "../node--akYC-sG.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import path$1 from "path";
+import { MockWindow, setupGlobal } from "@stencil/mock-doc";
+import { createHash } from "crypto";
+import { afterAll, vi } from "vitest";
+//#region src/testing/testing-logger.ts
+var TestingLogger = class {
+	isEnabled = false;
+	enable() {
+		this.isEnabled = true;
+	}
+	setLevel(_level) {}
+	getLevel() {
+		return "info";
+	}
+	enableColors(_useColors) {}
+	emoji(_) {
+		return "";
+	}
+	info(...msg) {
+		if (this.isEnabled) console.log(...msg);
+	}
+	warn(...msg) {
+		if (this.isEnabled) console.warn(...msg);
+	}
+	error(...msg) {
+		if (this.isEnabled) console.error(...msg);
+	}
+	debug(...msg) {
+		if (this.isEnabled) console.log(...msg);
+	}
+	color(_msg, _color) {}
+	red(msg) {
+		return msg;
+	}
+	green(msg) {
+		return msg;
+	}
+	yellow(msg) {
+		return msg;
+	}
+	blue(msg) {
+		return msg;
+	}
+	magenta(msg) {
+		return msg;
+	}
+	cyan(msg) {
+		return msg;
+	}
+	gray(msg) {
+		return msg;
+	}
+	bold(msg) {
+		return msg;
+	}
+	dim(msg) {
+		return msg;
+	}
+	bgRed(msg) {
+		return msg;
+	}
+	createTimeSpan(_startMsg, _debug = false) {
+		return {
+			duration() {
+				return 0;
+			},
+			finish() {
+				return 0;
+			}
+		};
+	}
+	printDiagnostics(_diagnostics) {}
+};
+//#endregion
+//#region src/testing/testing-sys.ts
+function isTestingSystem(sys) {
+	return "diskReads" in sys && "diskWrites" in sys;
+}
+const createTestingSystem = () => {
+	let diskReads = 0;
+	let diskWrites = 0;
+	const sys = createSystem();
+	sys.platformPath = path$1;
+	sys.generateContentHash = (content, length) => {
+		let hash = createHash("sha1").update(content).digest("hex").toLowerCase();
+		if (typeof length === "number") hash = hash.slice(0, length);
+		return Promise.resolve(hash);
+	};
+	const wrapRead = (fn) => {
+		const orgFn = fn;
+		return (...args) => {
+			diskReads++;
+			return orgFn.apply(orgFn, args);
+		};
+	};
+	const wrapWrite = (fn) => {
+		const orgFn = fn;
+		return (...args) => {
+			diskWrites++;
+			return orgFn.apply(orgFn, args);
+		};
+	};
+	sys.access = wrapRead(sys.access);
+	sys.accessSync = wrapRead(sys.accessSync);
+	sys.homeDir = wrapRead(sys.homeDir);
+	sys.readFile = wrapRead(sys.readFile);
+	sys.readFileSync = wrapRead(sys.readFileSync);
+	sys.readDir = wrapRead(sys.readDir);
+	sys.readDirSync = wrapRead(sys.readDirSync);
+	sys.stat = wrapRead(sys.stat);
+	sys.statSync = wrapRead(sys.statSync);
+	sys.copyFile = wrapWrite(sys.copyFile);
+	sys.createDir = wrapWrite(sys.createDir);
+	sys.createDirSync = wrapWrite(sys.createDirSync);
+	sys.removeFile = wrapWrite(sys.removeFile);
+	sys.removeFileSync = wrapWrite(sys.removeFileSync);
+	sys.writeFile = wrapWrite(sys.writeFile);
+	sys.writeFileSync = wrapWrite(sys.writeFileSync);
+	sys.getCompilerExecutingPath = () => "bin/stencil.js";
+	Object.defineProperties(sys, {
+		diskReads: {
+			get() {
+				return diskReads;
+			},
+			set(val) {
+				diskReads = val;
+			}
+		},
+		diskWrites: {
+			get() {
+				return diskWrites;
+			},
+			set(val) {
+				diskWrites = val;
+			}
+		}
+	});
+	if (!isTestingSystem(sys)) throw new Error("could not generate TestingSystem");
+	return sys;
+};
+//#endregion
+//#region src/testing/mocks.ts
+/**
+* Generates a stub {@link d.ComponentCompilerMeta}. This function uses sensible defaults for the initial stub. However,
+* any field in the object may be overridden via the `overrides` argument.
+* @param overrides a partial implementation of `ComponentCompilerMeta`. Any provided fields will override the
+* defaults provided by this function.
+* @returns the stubbed `ComponentCompilerMeta`
+*/
+const mockComponentMeta = (overrides = {}) => ({
+	assetsDirs: [],
+	attachInternalsMemberName: null,
+	attachInternalsCustomStates: [],
+	componentClassName: "StubCmp",
+	dependencies: [],
+	dependents: [],
+	deserializers: [],
+	directDependencies: [],
+	directDependents: [],
+	docs: {
+		text: "docs",
+		tags: []
+	},
+	doesExtend: false,
+	elementRef: "",
+	encapsulation: "none",
+	events: [],
+	excludeFromCollection: false,
+	formAssociated: false,
+	hasAttribute: false,
+	hasAttributeChangedCallbackFn: false,
+	hasComponentDidLoadFn: false,
+	hasComponentDidRenderFn: false,
+	hasComponentDidUpdateFn: false,
+	hasComponentShouldUpdateFn: false,
+	hasComponentWillLoadFn: false,
+	hasComponentWillRenderFn: false,
+	hasComponentWillUpdateFn: false,
+	hasConnectedCallbackFn: false,
+	hasDeserializer: false,
+	hasDisconnectedCallbackFn: false,
+	hasElement: false,
+	hasEvent: false,
+	hasLifecycle: false,
+	hasListener: false,
+	hasListenerTarget: false,
+	hasListenerTargetBody: false,
+	hasListenerTargetDocument: false,
+	hasListenerTargetWindow: false,
+	hasMember: false,
+	hasMethod: false,
+	hasMode: false,
+	hasModernPropertyDecls: false,
+	hasPatchAll: false,
+	hasPatchChildren: false,
+	hasPatchClone: false,
+	hasPatchInsert: false,
+	hasProp: false,
+	hasPropBoolean: false,
+	hasPropMutable: false,
+	hasPropNumber: false,
+	hasPropString: false,
+	hasReflect: false,
+	hasRenderFn: false,
+	hasSerializer: false,
+	hasSlot: false,
+	hasState: false,
+	hasStyle: false,
+	hasVdomAttribute: false,
+	hasVdomClass: false,
+	hasVdomFunctional: false,
+	hasVdomKey: false,
+	hasVdomListener: false,
+	hasVdomPropOrAttr: false,
+	hasVdomRef: false,
+	hasVdomRender: false,
+	hasVdomStyle: false,
+	hasVdomText: false,
+	hasVdomXlink: false,
+	hasSignalsImport: false,
+	hasWatchCallback: false,
+	htmlAttrNames: [],
+	htmlParts: [],
+	htmlTagNames: [],
+	internal: false,
+	isCollectionDependency: false,
+	isPlain: false,
+	isUpdateable: false,
+	jsFilePath: "/some/stubbed/path/my-component.js",
+	listeners: [],
+	methods: [],
+	patches: null,
+	potentialCmpRefs: [],
+	properties: [],
+	serializers: [],
+	shadowDelegatesFocus: false,
+	shadowMode: null,
+	slotAssignment: null,
+	sourceFilePath: "/some/stubbed/path/my-component.tsx",
+	sourceMapPath: "/some/stubbed/path/my-component.js.map",
+	states: [],
+	styleDocs: [],
+	styles: [],
+	globalStyles: [],
+	tagName: "stub-cmp",
+	virtualProperties: [],
+	watchers: [],
+	...overrides
+});
+/**
+* Creates a mock instance of an internal, validated Stencil configuration object
+* the caller
+* @param overrides a partial implementation of `ValidatedConfig`. Any provided fields will override the defaults
+* provided by this function.
+* @returns the mock Stencil configuration
+*/
+function mockValidatedConfig(overrides = {}) {
+	const baseConfig = mockConfig(overrides);
+	const rootDir = path.resolve("/");
+	return {
+		...baseConfig,
+		cacheDir: ".stencil",
+		devMode: true,
+		devServer: {},
+		compat: {},
+		fsNamespace: "testing",
+		hydratedFlag: null,
+		logLevel: "info",
+		logger: mockLogger(),
+		minifyCss: false,
+		minifyJs: false,
+		namespace: "Testing",
+		outputTargets: baseConfig.outputTargets ?? [],
+		packageJsonFilePath: path.join(rootDir, "package.json"),
+		rootDir,
+		sourceMap: true,
+		srcDir: "/src",
+		srcIndexHtml: "src/index.html",
+		suppressReservedPublicNameWarnings: false,
+		suppressReservedEventNameWarnings: false,
+		sys: createTestingSystem(),
+		transformAliasedImportPaths: true,
+		rolldownConfig: {},
+		...overrides
+	};
+}
+/**
+* Creates a mock instance of a Stencil configuration entity. The mocked configuration has no guarantees around the
+* types/validity of its data.
+* @param overrides a partial implementation of `UnvalidatedConfig`. Any provided fields will override the defaults
+* provided by this function.
+* @returns the mock Stencil configuration
+*/
+function mockConfig(overrides = {}) {
+	const rootDir = path.resolve("/");
+	let { sys } = overrides;
+	if (!sys) sys = createTestingSystem();
+	sys.getCurrentDirectory = () => rootDir;
+	return {
+		_isTesting: true,
+		buildAppCore: false,
+		bundles: null,
+		devMode: true,
+		enableCache: false,
+		compat: {},
+		globalScript: null,
+		logger: new TestingLogger(),
+		maxConcurrentWorkers: 0,
+		minifyCss: false,
+		minifyJs: false,
+		namespace: "Testing",
+		nodeResolve: {},
+		outputTargets: null,
+		rolldownPlugins: {
+			before: [],
+			after: []
+		},
+		rootDir,
+		sourceMap: true,
+		suppressReservedPublicNameWarnings: false,
+		suppressReservedEventNameWarnings: false,
+		sys,
+		validateTypes: false,
+		...overrides
+	};
+}
+/**
+* Creates a configuration object used to bootstrap a Stencil task invocation
+*
+* Several fields are intentionally undefined for this entity. While it would be trivial to stub them out, this mock
+* generation function operates under the assumption that entities like loggers and compiler system abstractions will
+* be shared by multiple entities in a test suite, who should provide those entities to this function
+*
+* @param overrides the properties on the default entity to manually override
+* @returns the default configuration initialization object, with any overrides applied
+*/
+const mockLoadConfigInit = (overrides) => {
+	return {
+		config: {},
+		configPath: void 0,
+		logger: void 0,
+		sys: void 0,
+		...overrides
+	};
+};
+function mockCompilerCtx(config) {
+	const innerConfig = config || mockValidatedConfig();
+	const compilerCtx = {
+		version: 1,
+		activeBuildId: 0,
+		activeDirsAdded: [],
+		activeDirsDeleted: [],
+		activeFilesAdded: [],
+		activeFilesDeleted: [],
+		activeFilesUpdated: [],
+		addWatchDir: noop,
+		addWatchFile: noop,
+		globalStyleCache: /* @__PURE__ */ new Map(),
+		changedFiles: /* @__PURE__ */ new Set(),
+		changedModules: /* @__PURE__ */ new Set(),
+		collections: [],
+		compilerOptions: null,
+		cache: null,
+		cssModuleImports: /* @__PURE__ */ new Map(),
+		events: buildEvents(),
+		fs: null,
+		hasSuccessfulBuild: false,
+		isActivelyBuilding: false,
+		lastBuildResults: null,
+		moduleMap: /* @__PURE__ */ new Map(),
+		nodeMap: /* @__PURE__ */ new WeakMap(),
+		reset: noop,
+		resolvedCollections: /* @__PURE__ */ new Set(),
+		rolldownCache: /* @__PURE__ */ new Map(),
+		rolldownCacheSsr: null,
+		rolldownCacheLazy: null,
+		rolldownCacheNative: null,
+		transpileCache: /* @__PURE__ */ new Map(),
+		prevStylesMap: /* @__PURE__ */ new Map(),
+		styleModeNames: /* @__PURE__ */ new Set(),
+		worker: createWorkerContext(innerConfig.sys),
+		cssTransformCache: /* @__PURE__ */ new Map()
+	};
+	Object.defineProperty(compilerCtx, "fs", { get() {
+		if (this._fs == null) this._fs = createInMemoryFs(innerConfig.sys);
+		return this._fs;
+	} });
+	Object.defineProperty(compilerCtx, "cache", { get() {
+		if (this._cache == null) this._cache = mockCache(innerConfig, compilerCtx);
+		return this._cache;
+	} });
+	return compilerCtx;
+}
+function mockBuildCtx(config, compilerCtx) {
+	const validatedConfig = config || mockValidatedConfig();
+	return new BuildContext(validatedConfig, compilerCtx || mockCompilerCtx(validatedConfig));
+}
+function mockCache(config, compilerCtx) {
+	config.enableCache = true;
+	const cache = new Cache(config, compilerCtx.fs);
+	cache.initCacheDir();
+	return cache;
+}
+function mockLogger() {
+	return new TestingLogger();
+}
+/**
+* Create a {@link d.CompilerSystem} entity for testing the compiler.
+*
+* This function acts as a thin wrapper around a {@link TestingSystem} entity creation. It exists to provide a logical
+* place in the codebase where we might expect Stencil engineers to reach for when attempting to mock a
+* {@link d.CompilerSystem} base type. Should there prove to be usage of both this function and the one it wraps,
+* reconsider if this wrapper is necessary.
+*
+* @returns a System instance for testing purposes.
+*/
+function mockCompilerSystem() {
+	return createTestingSystem();
+}
+function mockDocument(html = null) {
+	return new MockWindow(html).document;
+}
+function mockWindow(html) {
+	return new MockWindow(html);
+}
+/**
+* This gives you a mock Module, an interface which is the internal compiler
+* representation of a module. It includes a bunch of information necessary for
+* compilation, this mock basically sets sane defaults for all those values.
+*
+* @param mod is an override module that you can supply to set particular values
+* @returns a module object ready to use in tests!
+*/
+const mockModule = (mod = {}) => ({
+	cmps: [],
+	isExtended: false,
+	isMixin: false,
+	hasExportableMixins: false,
+	coreRuntimeApis: [],
+	outputTargetCoreRuntimeApis: {},
+	collectionName: "",
+	dtsFilePath: "",
+	excludeFromCollection: false,
+	externalImports: [],
+	htmlAttrNames: [],
+	htmlTagNames: [],
+	htmlParts: [],
+	isCollectionDependency: false,
+	isLegacy: false,
+	jsFilePath: "",
+	localImports: [],
+	functionalComponentDeps: [],
+	originalImports: [],
+	originalCollectionComponentPath: "",
+	potentialCmpRefs: [],
+	sourceFilePath: "",
+	staticSourceFile: "",
+	staticSourceFileText: "",
+	sourceMapPath: "",
+	sourceMapFileText: "",
+	hasVdomAttribute: false,
+	hasVdomClass: false,
+	hasVdomFunctional: false,
+	hasVdomKey: false,
+	hasVdomListener: false,
+	hasVdomPropOrAttr: false,
+	hasVdomRef: false,
+	hasVdomRender: false,
+	hasVdomStyle: false,
+	hasVdomText: false,
+	hasVdomXlink: false,
+	hasSignalsImport: false,
+	...mod
+});
+//#endregion
+//#region src/testing/create-test-compiler.ts
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TESTING_TSCONFIG = path.resolve(__dirname, "fixtures/tsconfig.testing.json");
+/**
+* Builds a patched sys that falls through to real disk for TypeScript lib files.
+*
+* @returns A compiler system instance with patched readFileSync, readFile, accessSync, and statSync methods
+*/
+const createPatchedSys = () => {
+	const sys = mockCompilerSystem();
+	const originalReadFileSync = sys.readFileSync.bind(sys);
+	sys.readFileSync = (p) => {
+		const mem = originalReadFileSync(p);
+		if (mem !== void 0) return mem;
+		try {
+			return fs.readFileSync(p, "utf-8");
+		} catch {
+			return;
+		}
+	};
+	const originalReadFile = sys.readFile.bind(sys);
+	sys.readFile = async (p) => {
+		const mem = await originalReadFile(p);
+		if (mem !== void 0) return mem;
+		try {
+			return fs.readFileSync(p, "utf-8");
+		} catch {
+			return;
+		}
+	};
+	const originalAccessSync = sys.accessSync.bind(sys);
+	sys.accessSync = (p) => {
+		if (originalAccessSync(p)) return true;
+		try {
+			fs.accessSync(p);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	const originalStatSync = sys.statSync.bind(sys);
+	sys.statSync = (p) => {
+		const mem = originalStatSync(p);
+		if (!mem.error) return mem;
+		try {
+			const s = fs.statSync(p);
+			return {
+				isDirectory: s.isDirectory(),
+				isFile: s.isFile(),
+				isSymbolicLink: s.isSymbolicLink(),
+				size: s.size,
+				error: null
+			};
+		} catch {
+			return mem;
+		}
+	};
+	sys.getCompilerExecutingPath = () => path.resolve(__dirname, "../../dist/compiler/index.mjs");
+	return sys;
+};
+/**
+* Runs the expensive one-time setup for a test compiler suite: patching the
+* sys, reading and validating the tsconfig. Use this in a `beforeAll` block
+* when a describe block contains multiple tests that each need a fresh
+* compiler, to avoid repeating `loadConfig` on every test.
+*
+* @param options - Configuration options for preparing the test compiler
+* @returns A {@link PreparedTestCompiler} that can be passed to {@link createTestCompiler}
+*
+* @example
+* ```ts
+* let setup: PreparedTestCompiler;
+* beforeAll(async () => { setup = await prepareTestCompiler(); });
+* beforeEach(async () => {
+*   const { compiler } = await createTestCompiler({ setup });
+* });
+* ```
+*/
+const prepareTestCompiler = async (options = {}) => {
+	const sys = createPatchedSys();
+	const tsconfigPath = options.tsconfig ?? TESTING_TSCONFIG;
+	const { config: validatedConfig } = await loadConfig({
+		sys,
+		config: {
+			devMode: true,
+			sourceMap: false,
+			enableCache: false,
+			minifyJs: false,
+			minifyCss: false,
+			namespace: "Testing",
+			tsconfig: tsconfigPath,
+			...options.config
+		}
+	});
+	return {
+		_validatedConfig: validatedConfig,
+		_tsconfigPath: tsconfigPath
+	};
+};
+/**
+* Creates a test compiler instance with a hybrid filesystem (reads from disk, writes to memory).
+* This utility handles the common setup pattern for compiler tests.
+*
+* When multiple tests in the same suite need independent compiler instances,
+* pass a {@link PreparedTestCompiler} from {@link prepareTestCompiler} as
+* `options.setup` to skip the expensive `loadConfig` step on each test.
+*
+* @param options - Configuration options for the test compiler
+* @returns An object with the compiler, validated config, and system instance
+*
+* @example
+* ```ts
+* const { compiler, config } = await createTestCompiler({
+*   config: { minifyCss: true }
+* });
+* await compiler.fs.writeFile('/src/index.html', '<cmp-a></cmp-a>');
+* const result = await compiler.build();
+* ```
+*/
+const createTestCompiler = async (options = {}) => {
+	let validatedConfig;
+	let tsconfigPath;
+	if (options.setup) {
+		const freshSys = createPatchedSys();
+		validatedConfig = {
+			...options.setup._validatedConfig,
+			sys: freshSys
+		};
+		tsconfigPath = options.setup._tsconfigPath;
+	} else {
+		const sys = createPatchedSys();
+		tsconfigPath = options.tsconfig ?? TESTING_TSCONFIG;
+		const { config } = await loadConfig({
+			sys,
+			config: {
+				devMode: true,
+				sourceMap: false,
+				enableCache: false,
+				minifyJs: false,
+				minifyCss: false,
+				namespace: "Testing",
+				tsconfig: tsconfigPath,
+				...options.config
+			}
+		});
+		validatedConfig = config;
+	}
+	const compiler = await createCompiler(validatedConfig);
+	const tsconfigObj = JSON.parse(fs.readFileSync(tsconfigPath, "utf-8"));
+	await compiler.fs.writeFile(tsconfigPath, JSON.stringify({
+		...tsconfigObj,
+		include: [validatedConfig.srcDir]
+	}));
+	await compiler.fs.writeFile(path.join(validatedConfig.srcDir, "components.d.ts"), "");
+	return {
+		compiler,
+		config: validatedConfig,
+		sys: validatedConfig.sys
+	};
+};
+//#endregion
+//#region src/testing/platform/testing-constants.ts
+const styles = /* @__PURE__ */ new Map();
+const modeResolutionChain = [];
+/**
+* A mapping of custom element tags (e.g. `my-component`) to their constructor
+*/
+const cstrs = /* @__PURE__ */ new Map();
+/**
+* A collection of callbacks to run on a NodeJS process 'tick'
+*/
+const queuedTicks = [];
+const queuedWriteTasks = [];
+const queuedReadTasks = [];
+const moduleLoaded = /* @__PURE__ */ new Map();
+const queuedLoadModules = [];
+/**
+* A collection of errors that were detected to surface during the rendering process
+*/
+const caughtErrors = [];
+//#endregion
+//#region src/testing/platform/testing-build.ts
+const Build = {
+	isDev: true,
+	isBrowser: false,
+	isServer: true,
+	isTesting: true
+};
+//#endregion
+//#region src/testing/platform/testing-host-ref.ts
+/**
+* Retrieve the data structure tracking the component by its runtime reference
+* @param elm the reference to the element
+* @returns the corresponding Stencil reference data structure, or undefined if one cannot be found
+*/
+const getHostRef = (elm) => {
+	if (elm.__s_ghr) return elm.__s_ghr();
+};
+/**
+* Add the provided `hostRef` instance to the global {@link hostRefs} map, using the provided `lazyInstance` as a key.
+* @param lazyInstance a Stencil component instance
+* @param hostRef an optional reference to Stencil's tracking data for the component. If none is provided, one will be created.
+* @throws if the provided `lazyInstance` coerces to `null`, or if the `lazyInstance` does not have a `constructor`
+* property
+*/
+const registerInstance = (lazyInstance, hostRef) => {
+	if (lazyInstance == null || lazyInstance.constructor == null) throw new Error(`Invalid component constructor`);
+	if (hostRef == null) {
+		const Cstr = lazyInstance.constructor;
+		const tagName = Cstr.COMPILER_META && Cstr.COMPILER_META.tagName ? Cstr.COMPILER_META.tagName : "div";
+		const elm = document.createElement(tagName);
+		registerHost(elm, {
+			$flags$: 0,
+			$tagName$: tagName
+		});
+		hostRef = getHostRef(elm);
+	}
+	lazyInstance.__s_ghr = () => hostRef;
+	hostRef.$lazyInstance$ = lazyInstance;
+	if (hostRef.$cmpMeta$?.$flags$ & CMP_FLAGS.hasModernPropertyDecls && (BUILD.state || BUILD.prop)) reWireGetterSetter(lazyInstance, hostRef);
+	const Cstr = lazyInstance.constructor;
+	const allEvents = [];
+	const seenEventMethods = /* @__PURE__ */ new Set();
+	if (Cstr.COMPILER_META && Cstr.COMPILER_META.events) Cstr.COMPILER_META.events.forEach((event) => {
+		if (!seenEventMethods.has(event.method)) {
+			allEvents.push(event);
+			seenEventMethods.add(event.method);
+		}
+	});
+	let currentProto = Object.getPrototypeOf(Cstr);
+	while (currentProto && currentProto !== Function.prototype && currentProto.name) {
+		if (typeof currentProto.events === "object" && Array.isArray(currentProto.events)) currentProto.events.forEach((event) => {
+			if (!seenEventMethods.has(event.method)) {
+				allEvents.push(event);
+				seenEventMethods.add(event.method);
+			}
+		});
+		currentProto = Object.getPrototypeOf(currentProto);
+	}
+	allEvents.forEach((eventMeta) => {
+		if (!lazyInstance[eventMeta.method]) {
+			let flags = 0;
+			if (eventMeta.bubbles) flags |= EVENT_FLAGS.Bubbles;
+			if (eventMeta.composed) flags |= EVENT_FLAGS.Composed;
+			if (eventMeta.cancelable) flags |= EVENT_FLAGS.Cancellable;
+			lazyInstance[eventMeta.method] = createEvent(lazyInstance, eventMeta.name, flags);
+		}
+	});
+};
+/**
+* Create a new {@link d.HostRef} instance to the global {@link hostRefs} map, using the provided `elm` as a key.
+* @param elm an HTMLElement instance associated with the Stencil component
+* @param cmpMeta the component compiler metadata associated with the component
+*/
+const registerHost = (elm, cmpMeta) => {
+	const hostRef = {
+		$flags$: 0,
+		$hostElement$: elm,
+		$cmpMeta$: cmpMeta,
+		$instanceValues$: /* @__PURE__ */ new Map(),
+		$serializerValues$: /* @__PURE__ */ new Map(),
+		$renderCount$: 0
+	};
+	hostRef.$fetchedCbList$ = [];
+	hostRef.$onInstancePromise$ = new Promise((r) => hostRef.$onInstanceResolve$ = r);
+	hostRef.$onReadyPromise$ = new Promise((r) => hostRef.$onReadyResolve$ = r);
+	elm["s-p"] = [];
+	elm["s-rc"] = [];
+	elm.__s_ghr = () => hostRef;
+};
+const setErrorHandler = (handler) => handler;
+//#endregion
+//#region src/testing/platform/testing-task-queue.ts
+/**
+* Reset the various data structures related to the testing rendering pipeline
+*/
+function resetTaskQueue() {
+	queuedTicks.length = 0;
+	queuedWriteTasks.length = 0;
+	queuedReadTasks.length = 0;
+	moduleLoaded.clear();
+	queuedLoadModules.length = 0;
+	caughtErrors.length = 0;
+}
+/**
+* Execute the callbacks in {@link queuedTicks} on the next NodeJS tick.
+*
+* Callbacks are invoked in the order that they appear in `queuedTasks` at the time this function is invoked.
+* Async callbacks are not `await`ed.
+*
+* Any callbacks that are added to `queuedTasks` while this function is running are scheduled to be flushed on the
+* next tick.
+*/
+function flushTicks() {
+	return new Promise((resolve, reject) => {
+		function drain() {
+			try {
+				if (queuedTicks.length > 0) {
+					const writeTasks = queuedTicks.slice();
+					queuedTicks.length = 0;
+					let cb;
+					while (cb = writeTasks.shift()) cb(Date.now());
+				}
+				if (queuedTicks.length > 0) process.nextTick(drain);
+				else resolve();
+			} catch (e) {
+				reject(`flushTicks: ${e}`);
+			}
+		}
+		process.nextTick(drain);
+	});
+}
+/**
+* Push a RequestAnimationFrame callback onto the {@link queuedWriteTasks} data structure
+* @param cb the callback to push onto `queuedWriteTasks`
+*/
+function writeTask(cb) {
+	queuedWriteTasks.push(cb);
+}
+/**
+* Push a RequestAnimationFrame callback onto the {@link queuedReadTasks} data structure
+* @param cb the callback to push onto `queuedReadTasks`
+*/
+function readTask(cb) {
+	queuedReadTasks.push(cb);
+}
+/**
+* Flush the {@link queuedReadTasks} and {@link queuedWriteTasks} data structures on the next NodeJS process tick.
+*
+* The read task queue is drained first, followed by the write task queue.
+* For each queue:
+* - Each task is processed in the order it is found in its respective data structure at the time `queuedReadTasks` and
+* `queuedWriteTasks` are read (note: these queues are not read at the same time).
+* - When a task queue is processed, it is marked as empty before acting on the entries in the queue.
+* - Items added to either queue after it has been read for processing will be handled on the subsequent tick.
+* - Async items will be `await`ed
+*/
+function flushQueue() {
+	return new Promise((resolve, reject) => {
+		async function drain() {
+			try {
+				if (queuedReadTasks.length > 0) {
+					const readTasks = queuedReadTasks.slice();
+					queuedReadTasks.length = 0;
+					let cb;
+					while (cb = readTasks.shift()) {
+						const result = cb(Date.now());
+						if (result != null && typeof result.then === "function") await result;
+					}
+				}
+				if (queuedWriteTasks.length > 0) {
+					const writeTasks = queuedWriteTasks.slice();
+					queuedWriteTasks.length = 0;
+					let cb;
+					while (cb = writeTasks.shift()) {
+						const result = cb(Date.now());
+						if (result != null && typeof result.then === "function") await result;
+					}
+				}
+				if (queuedReadTasks.length + queuedWriteTasks.length > 0) process.nextTick(drain);
+				else resolve();
+			} catch (e) {
+				reject(`flushQueue: ${e}`);
+			}
+		}
+		process.nextTick(drain);
+	});
+}
+async function flushAll() {
+	while (queuedTicks.length + queuedLoadModules.length + queuedWriteTasks.length + queuedReadTasks.length > 0) {
+		await flushTicks();
+		await flushLoadModule();
+		await flushQueue();
+	}
+	if (caughtErrors.length > 0) {
+		const err = caughtErrors[0];
+		if (err == null) throw new Error("Error!");
+		if (typeof err === "string") throw new Error(err);
+		throw err;
+	}
+	return new Promise((resolve) => process.nextTick(resolve));
+}
+function flushLoadModule(bundleId) {
+	return new Promise((resolve, reject) => {
+		try {
+			process.nextTick(() => {
+				if (bundleId != null) {
+					for (let i = 0; i < queuedLoadModules.length; i++) if (queuedLoadModules[i].bundleId === bundleId) {
+						queuedLoadModules[i].resolve();
+						queuedLoadModules.splice(i, 1);
+						i--;
+					}
+				} else {
+					let queuedLoadModule;
+					while (queuedLoadModule = queuedLoadModules.shift()) queuedLoadModule.resolve();
+				}
+				resolve();
+			});
+		} catch (e) {
+			reject(`flushLoadModule: ${e}`);
+		}
+	});
+}
+//#endregion
+//#region src/testing/platform/testing-window.ts
+const isVitestEnvironment = typeof process !== "undefined" && process.env?.VITEST;
+const existingWindow = typeof globalThis !== "undefined" && globalThis.window;
+const win = isVitestEnvironment && existingWindow ? existingWindow : setupGlobal(global);
+//#endregion
+//#region src/testing/platform/testing-platform.ts
+const plt = {
+	$flags$: 0,
+	$resourcesUrl$: "",
+	jmp: (h) => h(),
+	raf: (h) => requestAnimationFrame(h),
+	ael: (el, eventName, listener, opts) => el.addEventListener(eventName, listener, opts),
+	rel: (el, eventName, listener, opts) => el.removeEventListener(eventName, listener, opts),
+	ce: (eventName, opts) => new win.CustomEvent(eventName, opts)
+};
+/**
+* Resets global testing variables and collections, so that a new set of tests can be started with a "clean slate".
+*
+* It is expected that this function be called between spec tests, and should be automatically configured by Stencil to
+* do so.
+*
+* @param defaults default options for the {@link d.PlatformRuntime} used during testing. The values in this object
+* with be assigned to the global {@link plt} object used during testing.
+*/
+function resetPlatform(defaults = {}) {
+	if (win && typeof win.close === "function") win.close();
+	styles.clear();
+	plt.$flags$ = 0;
+	Object.assign(plt, defaults);
+	if (plt.$orgLocNodes$ != null) {
+		plt.$orgLocNodes$.clear();
+		plt.$orgLocNodes$ = void 0;
+	}
+	resetTaskQueue();
+	stopAutoApplyChanges();
+	cstrs.clear();
+}
+let isAutoApplyingChanges = false;
+let autoApplyTimer = void 0;
+/**
+* Cancels the JavaScript task of automatically flushing the render queue & applying DOM changes in tests
+*/
+function stopAutoApplyChanges() {
+	isAutoApplyingChanges = false;
+	if (autoApplyTimer) {
+		clearTimeout(autoApplyTimer);
+		autoApplyTimer = void 0;
+	}
+}
+/**
+* Creates a JavaScript task to flush the render pipeline without the user having to do so manually in their tests.
+*/
+async function startAutoApplyChanges() {
+	isAutoApplyingChanges = true;
+	flushAll().then(() => {
+		if (isAutoApplyingChanges) autoApplyTimer = setTimeout(() => {
+			startAutoApplyChanges();
+		}, 100);
+	});
+}
+/**
+* Registers a collection of component constructors with the global {@link cstrs} data structure
+* @param Cstrs the component constructors to register
+*/
+const registerComponents = (Cstrs) => {
+	Cstrs.filter((Cstr) => Cstr.COMPILER_META).forEach((Cstr) => {
+		cstrs.set(Cstr.COMPILER_META.tagName, Cstr);
+	});
+};
+/**
+* Add the provided component constructor, `Cstr`, to the {@link moduleLoaded} mapping, using the provided `bundleId`
+* as the key
+* @param bundleId the bundle identifier to use to store/retrieve the component constructor
+* @param Cstr the component constructor to store
+*/
+function registerModule(bundleId, Cstr) {
+	moduleLoaded.set(bundleId, Cstr);
+}
+//#endregion
+//#region src/runtime/vdom/vdom-annotations.ts
+/**
+* Updates the DOM generated on the server with annotations such as node attributes and
+* comment nodes to facilitate future client-side hydration. These annotations are used for things
+* like moving elements back to their original hosts if using Shadow DOM on the client, and for quickly
+* reconstructing the vNode representations of the DOM.
+*
+* @param doc The DOM generated by the server.
+* @param staticComponents Any components that should be considered static and do not need client-side hydration.
+*/
+const insertVdomAnnotations = (doc, staticComponents) => {
+	if (doc != null) {
+		/**
+		* Initiated `docData` object from the document if it exists to ensure we
+		* maintain the same `docData` object across multiple hydration hydration runs.
+		*/
+		const docData = "_stencilDocData" in doc ? doc[STENCIL_DOC_DATA] : { ...DEFAULT_DOC_DATA };
+		docData.staticComponents = new Set(staticComponents);
+		const orgLocationNodes = [];
+		parseVNodeAnnotations(doc, doc.body, docData, orgLocationNodes);
+		orgLocationNodes.forEach((orgLocationNode) => {
+			if (orgLocationNode != null && orgLocationNode["s-nr"]) {
+				const nodeRef = orgLocationNode["s-nr"];
+				let hostId = nodeRef["s-host-id"];
+				let nodeId = nodeRef["s-node-id"];
+				let childId = `${hostId}.${nodeId}`;
+				if (hostId == null) {
+					hostId = 0;
+					docData.rootLevelIds++;
+					nodeId = docData.rootLevelIds;
+					childId = `${hostId}.${nodeId}`;
+					if (nodeRef.nodeType === NODE_TYPE.ElementNode) {
+						nodeRef.setAttribute(HYDRATE_CHILD_ID, childId);
+						if (typeof nodeRef["s-sn"] === "string" && !nodeRef.getAttribute("slot")) nodeRef.setAttribute("s-sn", nodeRef["s-sn"]);
+					} else if (nodeRef.nodeType === NODE_TYPE.TextNode) {
+						if (hostId === 0) {
+							if (nodeRef.nodeValue?.trim() === "") {
+								orgLocationNode.remove();
+								return;
+							}
+						}
+						const commentBeforeTextNode = doc.createComment(childId);
+						commentBeforeTextNode.nodeValue = `t.${childId}`;
+						insertBefore(nodeRef.parentNode, commentBeforeTextNode, nodeRef);
+					} else if (nodeRef.nodeType === NODE_TYPE.CommentNode) {
+						const commentBeforeTextNode = doc.createComment(childId);
+						commentBeforeTextNode.nodeValue = `c.${childId}`;
+						nodeRef.parentNode.insertBefore(commentBeforeTextNode, nodeRef);
+					}
+				}
+				let orgLocationNodeId = `o.${childId}`;
+				const orgLocationParentNode = orgLocationNode.parentElement;
+				if (orgLocationParentNode) {
+					if (orgLocationParentNode["s-en"] === "") orgLocationNodeId += `.`;
+					else if (orgLocationParentNode["s-en"] === "c") orgLocationNodeId += `.c`;
+				}
+				orgLocationNode.nodeValue = orgLocationNodeId;
+			}
+		});
+	}
+};
+/**
+* Recursively parses a node generated by the server and its children to set host and child id
+* attributes read during client-side hydration. This function also tracks whether each node is
+* an original location reference node meaning that a node has been moved via slot relocation.
+*
+* @param doc The DOM generated by the server.
+* @param node The node to parse.
+* @param docData An object containing metadata about the document.
+* @param orgLocationNodes An array of nodes that have been moved via slot relocation.
+*/
+const parseVNodeAnnotations = (doc, node, docData, orgLocationNodes) => {
+	if (node == null) return;
+	if (node["s-nr"] != null) orgLocationNodes.push(node);
+	if (node.nodeType === NODE_TYPE.ElementNode) [...Array.from(node.childNodes), ...Array.from(node.shadowRoot?.childNodes || [])].forEach((childNode) => {
+		const hostRef = getHostRef$1(childNode);
+		if (hostRef != null && !docData.staticComponents.has(childNode.nodeName.toLowerCase())) insertVNodeAnnotations(doc, childNode, hostRef.$vnode$, docData, { nodeIds: 0 });
+		parseVNodeAnnotations(doc, childNode, docData, orgLocationNodes);
+	});
+};
+/**
+* Insert attribute annotations on an element for its host ID and, potentially, its child ID.
+* Also makes calls to insert annotations on the element's children, keeping track of the depth of
+* the component tree.
+*
+* @param doc The DOM generated by the server.
+* @param hostElm The element to insert annotations for.
+* @param vnode The vNode representation of the element.
+* @param docData An object containing metadata about the document.
+* @param cmpData An object containing metadata about the component.
+*/
+const insertVNodeAnnotations = (doc, hostElm, vnode, docData, cmpData) => {
+	if (vnode != null) {
+		const hostId = ++docData.hostIds;
+		hostElm.setAttribute(HYDRATE_ID, hostId);
+		if (hostElm["s-cr"] != null) hostElm["s-cr"].nodeValue = `r.${hostId}`;
+		if (vnode.$children$ != null) {
+			const depth = 0;
+			vnode.$children$.forEach((vnodeChild, index) => {
+				insertChildVNodeAnnotations(doc, vnodeChild, cmpData, hostId, depth, index);
+			});
+		}
+		if (hostElm && vnode && vnode.$elm$ && !hostElm.hasAttribute("c-id")) {
+			const parent = hostElm.parentElement;
+			if (parent && parent.childNodes) {
+				const parentChildNodes = Array.from(parent.childNodes);
+				const comment = parentChildNodes.find((node) => node.nodeType === NODE_TYPE.CommentNode && node["s-sr"]);
+				if (comment) {
+					const index = parentChildNodes.indexOf(hostElm) - 1;
+					vnode.$elm$.setAttribute(HYDRATE_CHILD_ID, `${comment["s-host-id"]}.${comment["s-node-id"]}.0.${index}`);
+				}
+			}
+		}
+	}
+};
+/**
+* Recursively analyzes the type of a child vNode and inserts annotations on the vNodes's element based on its type.
+* Element nodes receive a child ID attribute, text nodes have a comment with the child ID inserted before them,
+* and comment nodes representing a slot have their node value set to a slot node ID containing the child ID.
+*
+* @param doc The DOM generated by the server.
+* @param vnodeChild The vNode to insert annotations for.
+* @param cmpData An object containing metadata about the component.
+* @param hostId The host ID of this element's parent.
+* @param depth How deep this element sits in the component tree relative to its parent.
+* @param index The index of this element in its parent's children array.
+*/
+const insertChildVNodeAnnotations = (doc, vnodeChild, cmpData, hostId, depth, index) => {
+	const childElm = vnodeChild.$elm$;
+	if (childElm == null) return;
+	const nodeId = cmpData.nodeIds++;
+	const childId = `${hostId}.${nodeId}.${depth}.${index}`;
+	childElm["s-host-id"] = hostId;
+	childElm["s-node-id"] = nodeId;
+	if (childElm.nodeType === NODE_TYPE.ElementNode) {
+		childElm.setAttribute(HYDRATE_CHILD_ID, childId);
+		if (typeof childElm["s-sn"] === "string" && !childElm.getAttribute("slot")) childElm.setAttribute("s-sn", childElm["s-sn"]);
+	} else if (childElm.nodeType === NODE_TYPE.TextNode) {
+		const parentNode = childElm.parentNode;
+		const nodeName = parentNode?.nodeName;
+		if (nodeName !== "STYLE" && nodeName !== "SCRIPT") {
+			const textNodeId = `t.${childId}`;
+			insertBefore(parentNode, doc.createComment(textNodeId), childElm);
+		}
+	} else if (childElm.nodeType === NODE_TYPE.CommentNode) {
+		if (childElm["s-sr"]) childElm.nodeValue = `s.${childId}.${childElm["s-sn"] || ""}`;
+	}
+	if (vnodeChild.$children$ != null) {
+		const childDepth = depth + 1;
+		vnodeChild.$children$.forEach((vnode, childIndex) => {
+			insertChildVNodeAnnotations(doc, vnode, cmpData, hostId, childDepth, childIndex);
+		});
+	}
+};
+//#endregion
+//#region src/testing/platform/index.ts
+const setMode = (handler) => {
+	modeResolutionChain.length = 0;
+	modeResolutionChain.push(handler);
+};
+//#endregion
+//#region src/testing/reset-build-conditionals.ts
+/**
+* Reset build conditionals used for testing to a known "good state".
+*
+* This function does not return a value, but rather mutates its argument in place.
+* Certain values are set to `true` or `false` for testing purpose (see this function's implementation for the full
+* list). Build conditional options _not_ in that list that are set to `true` when this function is invoked will remain
+* set to `true`.
+*
+* @param b the build conditionals to reset.
+*/
+function resetBuildConditionals(b) {
+	Object.keys(b).forEach((key) => {
+		b[key] = true;
+	});
+	b.isDev = true;
+	b.isTesting = true;
+	b.isDebug = false;
+	b.lazyLoad = true;
+	b.member = true;
+	b.reflect = true;
+	b.scoped = true;
+	b.shadowDom = true;
+	b.slotRelocation = true;
+	b.asyncLoading = true;
+	b.svg = true;
+	b.updatable = true;
+	b.vdomAttribute = true;
+	b.vdomClass = true;
+	b.vdomFunctional = true;
+	b.vdomKey = true;
+	b.vdomPropOrAttr = true;
+	b.vdomRef = true;
+	b.vdomListener = true;
+	b.vdomStyle = true;
+	b.vdomText = true;
+	b.vdomXlink = true;
+	b.allRenderFn = false;
+	b.devTools = false;
+	b.hydrateClientSide = false;
+	b.hydrateServerSide = false;
+	b.cssAnnotations = false;
+	b.style = false;
+	b.hydratedAttribute = false;
+	b.hydratedClass = true;
+	b.invisiblePrehydration = true;
+	b.staticHydrationStyles = false;
+	b.lightDomPatches = false;
+	b.slotChildNodes = false;
+	b.slotCloneNode = false;
+	b.slotDomMutations = false;
+	b.slotTextContent = false;
+	b.hotModuleReplacement = false;
+}
+//#endregion
+//#region src/testing/spec-page.ts
+/**
+* Generates a random number for use in generating a bundle id
+* @returns a random number between 100000 and 999999
+*/
+const generateRandBundleId = () => Math.round(Math.random() * 899999) + 1e5;
+/**
+* Creates a new spec page for unit testing
+* @param opts the options to apply to the spec page that influence its configuration and operation
+* @returns the created spec page
+*/
+async function newSpecPage(opts) {
+	if (opts == null) throw new Error(`NewSpecPageOptions required`);
+	resetPlatform(opts.platform ?? {});
+	resetBuildConditionals(BUILD);
+	if (Array.isArray(opts.components)) registerComponents(opts.components);
+	if (opts.hydrateClientSide) opts.includeAnnotations = true;
+	if (opts.hydrateServerSide) opts.includeAnnotations = true;
+	else opts.includeAnnotations = !!opts.includeAnnotations;
+	BUILD.cssAnnotations = opts.includeAnnotations;
+	const cmpTags = /* @__PURE__ */ new Set();
+	win["__stencil_spec_options"] = opts;
+	const doc = win.document;
+	const page = {
+		win,
+		doc,
+		body: doc.body,
+		build: BUILD,
+		styles,
+		setContent: (html) => {
+			doc.body.innerHTML = html;
+			return flushAll();
+		},
+		waitForChanges: flushAll,
+		flushLoadModule,
+		flushQueue
+	};
+	const lazyBundles = opts.components.map((Cstr) => {
+		/**
+		* just pass through functional components that don't have styles nor any other metadata
+		*/
+		if (Cstr.COMPILER_META == null) return formatLazyBundleRuntimeMeta(`fc.${generateRandBundleId()}`, []);
+		cmpTags.add(Cstr.COMPILER_META.tagName);
+		Cstr.isProxied = false;
+		proxyComponentLifeCycles(Cstr);
+		const bundleId = `${Cstr.COMPILER_META.tagName}.${generateRandBundleId()}`;
+		const stylesMeta = Cstr.COMPILER_META.styles;
+		if (Array.isArray(stylesMeta)) {
+			if (stylesMeta.length > 1) {
+				const styleModes = {};
+				stylesMeta.forEach((style) => {
+					styleModes[style.modeName] = style.styleStr;
+				});
+				Cstr.style = styleModes;
+			} else if (stylesMeta.length === 1) Cstr.style = stylesMeta[0].styleStr;
+		}
+		registerModule(bundleId, Cstr);
+		return formatLazyBundleRuntimeMeta(bundleId, [Cstr.COMPILER_META]);
+	});
+	const cmpBuild = getBuildFeatures(opts.components.filter((Cstr) => Cstr.COMPILER_META != null).map((Cstr) => Cstr.COMPILER_META));
+	if (opts.strictBuild) Object.assign(BUILD, cmpBuild);
+	else Object.keys(cmpBuild).forEach((key) => {
+		if (cmpBuild[key] === true) BUILD[key] = true;
+	});
+	BUILD.asyncLoading = true;
+	if (opts.hydrateClientSide) {
+		BUILD.hydrateClientSide = true;
+		BUILD.hydrateServerSide = false;
+	} else if (opts.hydrateServerSide) {
+		BUILD.hydrateServerSide = true;
+		BUILD.hydrateClientSide = false;
+	}
+	BUILD.slotCloneNode = false;
+	if (opts.buildFlags) Object.assign(BUILD, opts.buildFlags);
+	if (typeof opts.url === "string") page.win.location.href = opts.url;
+	if (typeof opts.direction === "string") page.doc.documentElement.setAttribute("dir", opts.direction);
+	if (typeof opts.language === "string") page.doc.documentElement.setAttribute("lang", opts.language);
+	if (typeof opts.cookie === "string") try {
+		page.doc.cookie = opts.cookie;
+	} catch {}
+	if (typeof opts.referrer === "string") try {
+		page.doc.referrer = opts.referrer;
+	} catch {}
+	if (typeof opts.userAgent === "string") try {
+		page.win.navigator.userAgent = opts.userAgent;
+	} catch {}
+	if (opts.hydrateServerSide && opts.serializeShadowRoot === "scoped") {
+		for (const [, cmps] of lazyBundles) for (const cmp of cmps) if (cmp[0] & CMP_FLAGS.shadowDomEncapsulation) cmp[0] |= CMP_FLAGS.shadowNeedsScopedCss;
+	}
+	bootstrapLazy(lazyBundles);
+	if (typeof opts.template === "function") renderVdom({
+		$ancestorComponent$: void 0,
+		$flags$: 0,
+		$modeName$: void 0,
+		$cmpMeta$: {
+			$flags$: 0,
+			$tagName$: "body"
+		},
+		$hostElement$: page.body
+	}, opts.template());
+	else if (typeof opts.html === "string") page.body.innerHTML = opts.html;
+	if (opts.flushQueue !== false) await page.waitForChanges();
+	let rootComponent = null;
+	Object.defineProperty(page, "root", { get() {
+		if (rootComponent == null) rootComponent = findRootComponent(cmpTags, page.body);
+		if (rootComponent != null) return rootComponent;
+		const firstElementChild = page.body.firstElementChild;
+		if (firstElementChild != null) return firstElementChild;
+		return null;
+	} });
+	Object.defineProperty(page, "rootInstance", { get() {
+		const hostRef = getHostRef(page.root);
+		if (hostRef != null) return hostRef.$lazyInstance$;
+		return null;
+	} });
+	if (opts.hydrateServerSide) insertVdomAnnotations(doc, []);
+	if (opts.autoApplyChanges) {
+		startAutoApplyChanges();
+		page.waitForChanges = () => {
+			console.error("waitForChanges() cannot be used manually if the \"startAutoApplyChanges\" option is enabled");
+			return Promise.resolve();
+		};
+	}
+	return page;
+}
+/**
+* A helper method that proxies Stencil lifecycle methods by mutating the provided component class
+* @param Cstr the component class whose lifecycle methods will be proxied
+*/
+function proxyComponentLifeCycles(Cstr) {
+	if (typeof Cstr.prototype?.__componentWillLoad === "function") {
+		Cstr.prototype.componentWillLoad = Cstr.prototype.__componentWillLoad;
+		Cstr.prototype.__componentWillLoad = null;
+	}
+	if (typeof Cstr.prototype?.__componentWillUpdate === "function") {
+		Cstr.prototype.componentWillUpdate = Cstr.prototype.__componentWillUpdate;
+		Cstr.prototype.__componentWillUpdate = null;
+	}
+	if (typeof Cstr.prototype?.__componentWillRender === "function") {
+		Cstr.prototype.componentWillRender = Cstr.prototype.__componentWillRender;
+		Cstr.prototype.__componentWillRender = null;
+	}
+	if (typeof Cstr.prototype?.componentWillLoad === "function") {
+		Cstr.prototype.__componentWillLoad = Cstr.prototype.componentWillLoad;
+		/** @returns the result from the original componentWillLoad */
+		Cstr.prototype.componentWillLoad = function() {
+			const result = this.__componentWillLoad();
+			if (result != null && typeof result.then === "function") writeTask(() => result);
+			else writeTask(() => Promise.resolve());
+			return result;
+		};
+	}
+	if (typeof Cstr.prototype?.componentWillUpdate === "function") {
+		Cstr.prototype.__componentWillUpdate = Cstr.prototype.componentWillUpdate;
+		/** @returns the result from the original componentWillUpdate */
+		Cstr.prototype.componentWillUpdate = function() {
+			const result = this.__componentWillUpdate();
+			if (result != null && typeof result.then === "function") writeTask(() => result);
+			else writeTask(() => Promise.resolve());
+			return result;
+		};
+	}
+	if (typeof Cstr.prototype?.componentWillRender === "function") {
+		Cstr.prototype.__componentWillRender = Cstr.prototype.componentWillRender;
+		/** @returns the result from the original componentWillRender */
+		Cstr.prototype.componentWillRender = function() {
+			const result = this.__componentWillRender();
+			if (result != null && typeof result.then === "function") writeTask(() => result);
+			else writeTask(() => Promise.resolve());
+			return result;
+		};
+	}
+}
+/**
+* Return the first Element whose {@link Element#nodeName} property matches a tag found in the provided `cmpTags`
+* argument.
+*
+* If the `nodeName` property on the element matches any of the names found in the provided `cmpTags` argument, that
+* element is returned. If no match is found on the current element, the children will be inspected in a depth-first
+* search manner. This process continues until either:
+* - an element is found (and execution ends)
+* - no element is found after an exhaustive search
+*
+* @param cmpTags component tag names to use in the match criteria
+* @param node the node whose children are to be inspected
+* @returns An element whose name matches one of the strings in the provided `cmpTags`. If no match is found, `null` is
+* returned
+*/
+function findRootComponent(cmpTags, node) {
+	if (node != null) {
+		const children = node.children;
+		const childrenLength = children.length;
+		for (let i = 0; i < childrenLength; i++) {
+			const elm = children[i];
+			if (cmpTags.has(elm.nodeName.toLowerCase())) return elm;
+		}
+		for (let i = 0; i < childrenLength; i++) {
+			const r = findRootComponent(cmpTags, children[i]);
+			if (r != null) return r;
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/testing/testing-utils.ts
+/**
+* Shuffle an array using Fisher-Yates algorithm
+* http://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+*
+* @param array - the array to shuffle
+* @returns the shuffled array
+*/
+function shuffleArray(array) {
+	let currentIndex = array.length;
+	let temporaryValue;
+	let randomIndex;
+	while (0 !== currentIndex) {
+		randomIndex = Math.floor(Math.random() * currentIndex);
+		currentIndex -= 1;
+		temporaryValue = array[currentIndex];
+		array[currentIndex] = array[randomIndex];
+		array[randomIndex] = temporaryValue;
+	}
+	return array;
+}
+/**
+* Utility for silencing `console` functions in tests.
+*
+* When this function is first called it grabs a reference to the `log`,
+* `error`, and `warn` functions on `console` and then returns a per-test setup
+* function which sets up a fresh set of mocks (via `jest.fn()`) and then
+* assigns them to each of these functions. This setup function will return a
+* reference to each of the three mock functions so tests can make assertions
+* about their calls and so on.
+*
+* Because references to the original `.log`, `.error`, and `.warn` functions
+* exist in closure within the function, it can use an `afterAll` call to clean
+* up after itself and ensure that the original implementations are restored
+* after the test suite finishes.
+*
+* An example of using this to silence log statements in a single test could look
+* like this:
+*
+* ```ts
+* describe("my-test-suite", () => {
+*   const { setupConsoleMocks, teardownConsoleMocks } = setupConsoleMocker()
+*
+*   it("should log a message", () => {
+*     const { logMock } = setupConsoleMocks();
+*     myFunctionWhichLogs(foo, bar);
+*     expect(logMock).toBeCalledWith('my log message');
+*     teardownConsoleMocks();
+*   })
+* })
+* ```
+*
+* @returns a per-test mock setup function
+*/
+function setupConsoleMocker() {
+	const originalLog = console.log;
+	const originalWarn = console.warn;
+	const originalError = console.error;
+	/**
+	* Function to tear down console mocks where you're done with them! Ideally
+	* this would be called right after the assertion you're looking to make in
+	* your test.
+	*/
+	function teardownConsoleMocks() {
+		console.log = originalLog;
+		console.warn = originalWarn;
+		console.error = originalError;
+	}
+	afterAll(() => {
+		teardownConsoleMocks();
+	});
+	function setupConsoleMocks() {
+		const logMock = vi.fn();
+		const warnMock = vi.fn();
+		const errorMock = vi.fn();
+		console.log = logMock;
+		console.warn = warnMock;
+		console.error = errorMock;
+		return {
+			logMock,
+			warnMock,
+			errorMock
+		};
+	}
+	return {
+		setupConsoleMocks,
+		teardownConsoleMocks
+	};
+}
+//#endregion
+export { Build, Env, Fragment, Host, Mixin, createEvent, createTestCompiler, createTestingSystem, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRenderingRef, h, mockBuildCtx, mockCompilerCtx, mockCompilerSystem, mockComponentMeta, mockConfig, mockDocument, mockLoadConfigInit, mockLogger, mockModule, mockValidatedConfig, mockWindow, newSpecPage, prepareTestCompiler, readTask, registerHost, registerInstance, setAssetPath, setErrorHandler, setMode, setupConsoleMocker, shuffleArray, writeTask };