@stencil/core 4.43.2 → 5.0.0-next.0

package/dist/testing/index.mjs

@@ -0,0 +1,1188 @@
+import "../chunk-ClPoSABd.mjs";
+import { C as reWireGetterSetter, E as Env, T as BUILD, _ as setAssetPath, a as bootstrapLazy, c as renderVdom, d as getMode, g as getAssetPath, h, i as Fragment, l as createEvent, m as Host, o as forceUpdate, r as Mixin, s as getRenderingRef, t as insertVdomAnnotations, u as getElement } from "../client-DR9zhmKG.mjs";
+import { D as CMP_FLAGS, G as EVENT_FLAGS, y as noop } from "../serialize-BJvhE9aQ.mjs";
+import { f as createInMemoryFs, g as getBuildFeatures, m as BuildContext, p as Cache, r as createSystem, s as createWorkerContext } from "../transpile-CJQcQEVa.mjs";
+import { St as formatLazyBundleRuntimeMeta } from "../validation-BdcPruW_.mjs";
+import { o as buildEvents } from "../node-sys-BGURUNOZ.mjs";
+import "../compiler/index.mjs";
+import path from "node:path";
+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,
+	hasListenerTargetParent: false,
+	hasListenerTargetWindow: false,
+	hasMember: false,
+	hasMethod: false,
+	hasMode: false,
+	hasModernPropertyDecls: 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,
+	hasWatchCallback: false,
+	htmlAttrNames: [],
+	htmlParts: [],
+	htmlTagNames: [],
+	internal: false,
+	isCollectionDependency: false,
+	isPlain: false,
+	isUpdateable: false,
+	jsFilePath: "/some/stubbed/path/my-component.js",
+	listeners: [],
+	methods: [],
+	potentialCmpRefs: [],
+	properties: [],
+	serializers: [],
+	shadowDelegatesFocus: false,
+	slotAssignment: null,
+	sourceFilePath: "/some/stubbed/path/my-component.tsx",
+	sourceMapPath: "/some/stubbed/path/my-component.js.map",
+	states: [],
+	styleDocs: [],
+	styles: [],
+	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,
+		buildEs5: false,
+		cacheDir: ".stencil",
+		devMode: true,
+		devServer: {},
+		extras: {},
+		fsNamespace: "testing",
+		hashFileNames: false,
+		hashedFileNameLength: 8,
+		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,
+		sys: createTestingSystem(),
+		testing: {},
+		transformAliasedImportPaths: true,
+		rollupConfig: {
+			inputOptions: {},
+			outputOptions: {}
+		},
+		validatePrimaryPackageOutputTarget: false,
+		...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,
+		buildDist: true,
+		buildEs5: false,
+		bundles: null,
+		devMode: true,
+		enableCache: false,
+		extras: {},
+		globalScript: null,
+		hashFileNames: false,
+		logger: new TestingLogger(),
+		maxConcurrentWorkers: 0,
+		minifyCss: false,
+		minifyJs: false,
+		namespace: "Testing",
+		nodeResolve: { customResolveOptions: {} },
+		outputTargets: null,
+		rollupPlugins: {
+			before: [],
+			after: []
+		},
+		rootDir,
+		sourceMap: true,
+		suppressReservedPublicNameWarnings: false,
+		sys,
+		testing: null,
+		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,
+		initTsConfig: true,
+		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,
+		cachedGlobalStyle: null,
+		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(),
+		rollupCache: /* @__PURE__ */ new Map(),
+		rollupCacheHydrate: null,
+		rollupCacheLazy: null,
+		rollupCacheNative: null,
+		styleModeNames: /* @__PURE__ */ new Set(),
+		worker: createWorkerContext(innerConfig.sys)
+	};
+	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,
+	...mod
+});
+
+//#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.__stencil__getHostRef) return elm.__stencil__getHostRef();
+};
+/**
+* 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.__stencil__getHostRef = () => 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.__stencil__getHostRef = () => hostRef;
+};
+
+//#endregion
+//#region src/testing/platform/testing-log.ts
+let customError;
+const setErrorHandler = (handler) => customError = 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
+let supportsShadow = true;
+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)
+};
+/**
+* Helper function to programmatically set shadow DOM support in testing scenarios.
+*
+* This function modifies the global {@link supportsShadow} variable.
+*
+* @param supports `true` if shadow DOM is supported, `false` otherwise
+*/
+const setSupportsShadowDom = (supports) => {
+	supportsShadow = supports;
+};
+/**
+* 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/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.appendChildSlotFix = false;
+	b.cloneNodeFix = false;
+	b.hotModuleReplacement = false;
+	b.scopedSlotTextContentFix = false;
+	b.slotChildNodesFix = false;
+	b.experimentalSlotFixes = false;
+	b.experimentalScopedSlotChanges = 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;
+		setSupportsShadowDom(false);
+	} else {
+		opts.includeAnnotations = !!opts.includeAnnotations;
+		if (opts.supportsShadowDom === false) setSupportsShadowDom(false);
+		else setSupportsShadowDom(true);
+	}
+	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 styles = {};
+				stylesMeta.forEach((style) => {
+					styles[style.modeName] = style.styleStr;
+				});
+				Cstr.style = styles;
+			} 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.cloneNodeFix = false;
+	BUILD.shadowDomShim = false;
+	BUILD.attachStyles = !!opts.attachStyles;
+	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 (e) {}
+	if (typeof opts.referrer === "string") try {
+		page.doc.referrer = opts.referrer;
+	} catch (e) {}
+	if (typeof opts.userAgent === "string") try {
+		page.win.navigator.userAgent = opts.userAgent;
+	} catch (e) {}
+	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;
+		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;
+		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;
+		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
+*/
+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, createTestingSystem, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRenderingRef, h, mockBuildCtx, mockCompilerCtx, mockCompilerSystem, mockComponentMeta, mockConfig, mockDocument, mockLoadConfigInit, mockLogger, mockModule, mockValidatedConfig, mockWindow, newSpecPage, readTask, registerHost, registerInstance, setAssetPath, setErrorHandler, setMode, setupConsoleMocker, shuffleArray, writeTask };