@orkestrel/test 0.0.8 → 0.0.9

package/dist/src/browser/index.js

@@ -799,22 +799,119 @@ function waitForFrame() {
 	return new Promise((resolve) => requestAnimationFrame(() => resolve()));
 }
 /**
-* Renders trusted fixture markup into a container attached to the document.
+* Builds one unmounted element of a known tag, wearing the classes, text, and attributes asked for.
 *
-* @param markup - The fixture markup to render.
-* @returns The attached container.
+* @param tag - The HTML tag name, which fixes the returned element's exact type.
+* @param options - The class list, the text, and the attributes to apply.
+* @returns The built element, not yet in any document.
+*
+* @remarks
+* The element is unmounted on purpose, so a fixture is assembled before the page ever sees it and a
+* test decides where it goes. Nothing here resolves against the cascade: a built element computes no
+* style and lays out no box until {@link mount} puts it in the document.
+*
+* The text is set as text rather than parsed as markup, so a `<` in it stays a `<`. Use
+* {@link render} where the fixture is markup.
+*
+* @example
+* ```ts
+* const button = build('button', { classes: 'primary', text: 'Save', attributes: { type: 'button' } })
+* ```
+*/
+function build(tag, options) {
+	const element = document.createElement(tag);
+	if (options?.classes !== void 0) element.className = options.classes;
+	if (options?.text !== void 0) element.textContent = options.text;
+	for (const [name, value] of Object.entries(options?.attributes ?? {})) element.setAttribute(name, value);
+	return element;
+}
+/**
+* Puts one element into the document and hands it straight back.
+*
+* @param element - The element to attach.
+* @returns The same element, now appended to `document.body`.
+*
+* @remarks
+* What this buys is the composition, not the attachment: the `append` method returns `void`, and
+* this hands the element back, so it fits where an expression is expected. The {@link render} helper
+* returns its fixture through it, and the {@link rgba} helper probes through `mount(build('span'))`.
+* A bare `append` call breaks each of those call sites.
+*
+* Being connected is what the attachment then buys: `getComputedStyle` resolves against the shipped
+* cascade, custom properties inherit from `:root`, and the element lays out a real box. A detached
+* element answers each of those questions with the initial value instead, which reads as a styling
+* defect rather than as a detached node.
+*
+* Taking it back out belongs to the consumer's teardown, because this records nothing: a browser
+* test file shares one page, so a fixture left behind is the next test's resolver ambiguity. Build a
+* recorded container in a setup module and remove it from an `afterEach` hook.
+*
+* @example
+* ```ts
+* const panel = mount(build('div', { classes: 'surface' }))
+* panel.remove()
+* ```
+*/
+function mount(element) {
+	document.body.append(element);
+	return element;
+}
+function render(first, second) {
+	if (second === void 0) {
+		const container = build("div");
+		container.innerHTML = first;
+		return mount(container);
+	}
+	const element = document.createElement(first);
+	element.className = second;
+	return mount(element);
+}
+/**
+* Sets one field's value and announces it the way typing into the field does.
+*
+* @param element - The input or textarea to write into.
+* @param text - The value to set.
+*
+* @remarks
+* This is the synthetic pair of {@link typeAccessible}, for a component that listens for `input` and
+* a test that has the element already. It sets the value in one write and dispatches one bubbling
+* `input` event, so a delegated listener on an ancestor hears it. It sends no keystrokes, so a
+* component reading `key`, composition, or selection sees nothing. The dispatched event is a plain
+* `Event`, never an `InputEvent`, so a component reading `inputType` or testing
+* `instanceof InputEvent` sees neither. Drive a component that reads any of those through
+* `typeAccessible` instead.
+*
+* No `change` event follows. Use {@link commitInput} where the component waits for the field to be
+* committed.
+*
+* @example
+* ```ts
+* typeInput(requireValue(container.querySelector('input')), 'Ada')
+* ```
+*/
+function typeInput(element, text) {
+	element.value = text;
+	element.dispatchEvent(new Event("input", { bubbles: true }));
+}
+/**
+* Sets one field's value and commits it, the way typing and then leaving the field does.
+*
+* @param element - The input or textarea to write into.
+* @param text - The value to set.
+*
+* @remarks
+* The order is the browser's: {@link typeInput} first, so `input` is dispatched with the value
+* already set, and one bubbling `change` after it. A component that reads the value from either
+* event therefore reads `text` from both.
 *
 * @example
 * ```ts
-* const container = render('<button type="button">Save</button>')
-* container.remove()
+* commitInput(requireValue(container.querySelector('input')), 'Ada')
 * ```
 */
-function render(markup) {
-	const container = document.createElement("div");
-	container.innerHTML = markup;
-	document.body.append(container);
-	return container;
+function commitInput(element, text) {
+	typeInput(element, text);
+	element.dispatchEvent(new Event("change", { bubbles: true }));
 }
 /**
 * Clears both browser storage surfaces.
@@ -834,6 +931,35 @@ function clearStorage() {
 	sessionStorage.clear();
 }
 /**
+* Deletes one IndexedDB database and reports what the request actually did.
+*
+* @param name - The database name to delete.
+* @returns A promise resolving after the deletion completes.
+* @throws Thrown when the request errors, and when an open connection blocks it.
+*
+* @remarks
+* Deleting a database that was never created succeeds, so this is safe to call from a teardown hook
+* that runs whether or not the test reached the code that opens one.
+*
+* A block is a rejection rather than a wait. `blocked` fires when another connection is still open,
+* and a suite that swallowed it would leave the next test reading the previous test's records
+* through a database that reports itself deleted. The connection holding it open is the caller's to
+* close, so the block is handed back rather than absorbed.
+*
+* @example
+* ```ts
+* afterEach(() => removeDatabase('ledger'))
+* ```
+*/
+function removeDatabase(name) {
+	return new Promise((resolve, reject) => {
+		const request = globalThis.indexedDB.deleteDatabase(name);
+		request.addEventListener("success", () => resolve());
+		request.addEventListener("error", () => reject(/* @__PURE__ */ new Error(`IndexedDB database "${name}" could not be deleted`)));
+		request.addEventListener("blocked", () => reject(/* @__PURE__ */ new Error(`IndexedDB database "${name}" is blocked by an open connection`)));
+	});
+}
+/**
 * Parses one computed CSS color value into straight sRGB channels.
 *
 * @param value - A computed `rgb()`, `rgba()`, or `color(srgb …)` value.
@@ -877,6 +1003,80 @@ function parseColor(value) {
 	]);
 }
 /**
+* Resolves any CSS color expression to straight sRGB channels, by asking the browser.
+*
+* @param value - Any value the `color` property accepts: a keyword, a hex triple, a `var()`
+* reference, a `color-mix()`, or an already-computed `rgb()`.
+* @returns The resolved color's channels, or `undefined` when the CSSOM refuses the value or the
+* computed result names no color {@link parseColor} speaks.
+*
+* @remarks
+* This is the live half of the pair {@link parseColor} opens. `parseColor` reads text and speaks
+* only the computed syntaxes a cascade hands back; this stages a probe element, hands it to the real
+* cascade, and reads back what the engine computed — which is the only way a keyword, a hex triple,
+* or a `var()` reference becomes channels at all. The read itself goes through `parseColor`, so both
+* halves agree on what a computed value means.
+*
+* The probe is mounted, because an unmounted element inherits nothing and a `var()` reference to a
+* token declared on `:root` would resolve to the initial value instead. It is removed in a `finally`,
+* so a value that throws on the way through leaves no node behind.
+*
+* Refusal is the CSSOM's: an expression it will not parse leaves the probe's inline `color` empty
+* and this returns `undefined`. A `var()` naming an undeclared custom property is not refused,
+* because the cascade accepts it and computes the inherited color, so a test that means to catch a
+* missing token asserts on {@link token} rather than on this.
+*
+* @example
+* ```ts
+* rgba('rebeccapurple') // [102, 51, 153, 1]
+* rgba('not-a-color') // undefined
+* ```
+*/
+function rgba(value) {
+	const probe = mount(build("span"));
+	try {
+		probe.style.color = value;
+		if (probe.style.color === "") return void 0;
+		return parseColor(style(probe, "color"));
+	} finally {
+		probe.remove();
+	}
+}
+/**
+* Determines whether two colors render the same, within the rounding a browser does.
+*
+* @param first - A CSS color expression or an already-parsed color.
+* @param second - A CSS color expression or an already-parsed color.
+* @returns `true` when every channel and the alpha agree within the tolerance; `false` otherwise,
+* including when either side names no readable color.
+*
+* @remarks
+* Each string side is resolved through {@link rgba}, so a keyword, a token reference, and the
+* `rgb()` the engine computes for either of them compare equal without a test converting anything
+* first. A side that resolves to nothing makes the answer `false` rather than a throw, because this
+* is a predicate.
+*
+* The tolerance is half a channel step on the 0–255 scale, and the alpha is scaled onto that same
+* range before it is compared, so one number covers both. Half a step is what a composite of
+* translucent layers and a `color-mix()` round trip actually drift by; anything a reader could see
+* is further than that and reports unequal.
+*
+* @example
+* ```ts
+* colorEqual('rebeccapurple', 'rgb(102, 51, 153)') // true
+* colorEqual('red', [0, 0, 255, 1]) // false
+* ```
+*/
+function colorEqual(first, second) {
+	const left = typeof first === "string" ? rgba(first) : first;
+	const right = typeof second === "string" ? rgba(second) : second;
+	if (left === void 0 || right === void 0) return false;
+	const tolerance = .5;
+	const [leftRed, leftGreen, leftBlue, leftAlpha] = left;
+	const [rightRed, rightGreen, rightBlue, rightAlpha] = right;
+	return Math.abs(leftRed - rightRed) <= tolerance && Math.abs(leftGreen - rightGreen) <= tolerance && Math.abs(leftBlue - rightBlue) <= tolerance && Math.abs(leftAlpha - rightAlpha) * 255 <= tolerance;
+}
+/**
 * Composites one color over another.
 *
 * @param front - The color painted on top.
@@ -1102,12 +1302,24 @@ function readRing(control, worn) {
 /**
 * Collects every class token the stylesheets loaded into this document actually define.
 *
-* @returns The set of class names reachable in the shipped cascade.
+* @returns The set of class names reachable in the shipped cascade, in {@link readRules} order.
 *
 * @remarks
 * The set is what an authored-class conformance check measures against, so a class no loaded
 * stylesheet defines — an invented utility, a misspelled framework name — is absent from it.
 *
+* The tokens come from the {@link readRules} walk, which decides both the membership and the
+* insertion order this reader reports, and each answer is a deliberate difference from 0.0.8. A
+* class declared inside a grouping rule — a media query, a supports block, a layer, a nested style
+* rule — counts as defined, because a class the cascade defines under a condition is still one the
+* cascade defines; 0.0.8 read the top-level rules alone. Insertion order is breadth-first, so a
+* top-level class lands before a class declared inside an earlier grouping rule; 0.0.8 popped a
+* stack and inserted the deepest rule first. Iterate the set where the order is the subject, and
+* read `has` where membership is.
+*
+* `@keyframes` children are outside that walk, so an animation's own rules define no token here.
+* Reach the animation itself through {@link findKeyframes}.
+*
 * @example
 * ```ts
 * readCascade().has('card')
@@ -1115,17 +1327,98 @@ function readRing(control, worn) {
 */
 function readCascade() {
 	const known = /* @__PURE__ */ new Set();
-	const rules = [];
-	for (const sheet of document.styleSheets) rules.push(...sheet.cssRules);
-	while (rules.length > 0) {
-		const rule = rules.pop();
-		if (rule instanceof CSSGroupingRule) rules.push(...rule.cssRules);
+	for (const rule of readRules()) {
 		if (!(rule instanceof CSSStyleRule)) continue;
 		for (const match of rule.selectorText.matchAll(/\.([a-zA-Z][\w-]*)/g)) known.add(String(match[1]));
 	}
 	return known;
 }
 /**
+* Collects every rule the stylesheets loaded into this document hold, nested grouping rules
+* included.
+*
+* @returns Every rule reachable in the shipped cascade: each sheet's own rules in sheet order, then
+* the rules nested inside them, level by level.
+*
+* @remarks
+* The walk is iterative and reads the list it is still appending to, which is what expands a media
+* query, a supports block, a layer, and a nested style rule without recursion. Expanding by level
+* rather than by depth is why a top-level rule is always met before a rule nested inside an earlier
+* one; {@link findRule} returns the first match in exactly this order.
+*
+* The descent reaches a `CSSGroupingRule` and nothing else, and a `@keyframes` rule is not one. The
+* `@keyframes` rule itself is collected wherever it sits, and the keyframe rules inside it are not;
+* {@link findKeyframes} is the door to those.
+*
+* A stylesheet the document cannot read — a cross-origin sheet with no CORS grant — throws from its
+* own `cssRules` getter, and that sheet is skipped rather than ending the walk. What a page loaded
+* from another origin declares is unreadable to every caller here, so the alternative is a helper
+* that works until a test page adds a font or an analytics stylesheet.
+*
+* @example
+* ```ts
+* readRules().filter((rule) => rule instanceof CSSKeyframesRule)
+* ```
+*/
+function readRules() {
+	const rules = [];
+	for (const sheet of document.styleSheets) try {
+		rules.push(...sheet.cssRules);
+	} catch {
+		continue;
+	}
+	for (let index = 0; index < rules.length; index += 1) {
+		const rule = rules[index];
+		if (rule instanceof CSSGroupingRule) rules.push(...rule.cssRules);
+	}
+	return rules;
+}
+/**
+* Finds the first style rule in the cascade whose selector carries a fragment.
+*
+* @param selector - The selector fragment to look for, matched as a substring of the whole selector
+* text.
+* @returns The first matching rule in {@link readRules} order, or `undefined` when no rule carries
+* the fragment.
+*
+* @remarks
+* This proves a declaration exists in the cascade at all, which is a different question from what an
+* element resolves to: {@link style} reads the winner, and a rule this finds may be overridden by
+* another. Assert on this where the subject is the stylesheet, and on `style` where the subject is
+* the rendered result.
+*
+* The match is a substring, so `findRule('.card')` finds `.card`, `.card:hover`, and
+* `.panel > .card` alike. Pass more of the selector to narrow it.
+*
+* @example
+* ```ts
+* findRule('.card')?.style.getPropertyValue('padding')
+* ```
+*/
+function findRule(selector) {
+	for (const rule of readRules()) if (rule instanceof CSSStyleRule && rule.selectorText.includes(selector)) return rule;
+}
+/**
+* Finds the animation the cascade declares under one name.
+*
+* @param name - The exact `@keyframes` name.
+* @returns The first matching rule in {@link readRules} order, or `undefined` when the cascade
+* declares no animation under that name.
+*
+* @remarks
+* The name is matched exactly, which is where this parts from {@link findRule}: a selector is
+* compound and a fragment of one is a useful question, and an animation name is one atom that either
+* is or is not the one an `animation` declaration references.
+*
+* @example
+* ```ts
+* findKeyframes('fade')?.cssRules.length
+* ```
+*/
+function findKeyframes(name) {
+	for (const rule of readRules()) if (rule instanceof CSSKeyframesRule && rule.name === name) return rule;
+}
+/**
 * Reads the normalized visible text of every element a selector matches, in document order.
 *
 * @param root - The subtree to search.
@@ -1185,8 +1478,13 @@ function extractOrphans(root, child, parent) {
 * Reads one resolved CSS property from a real browser element.
 *
 * @param element - The element whose resolved style to inspect.
-* @param property - The CSS property name.
-* @returns The browser's resolved property value.
+* @param property - The CSS property name, registered or custom.
+* @returns The browser's resolved property value, trimmed; an empty string when the element resolves
+* none.
+*
+* @remarks
+* The value is trimmed, so what comes back is the value and never the whitespace around it. Internal
+* whitespace is kept: `--shadow: 0 0 2px` reads back with its spaces.
 *
 * @example
 * ```ts
@@ -1194,7 +1492,81 @@ function extractOrphans(root, child, parent) {
 * ```
 */
 function style(element, property) {
-	return getComputedStyle(element).getPropertyValue(property);
+	return getComputedStyle(element).getPropertyValue(property).trim();
+}
+/**
+* Reads one custom property from an element's resolved style.
+*
+* @param element - The element whose resolved style to inspect.
+* @param name - The custom property name, with or without its leading dashes.
+* @returns The resolved value, trimmed; an empty string when the element inherits no such property.
+*
+* @remarks
+* The dashes are optional because a token is spoken about both ways — `--surface` in a stylesheet
+* and `surface` in prose — and a reader that accepted only one spelling would turn that into a silent
+* empty string. An absent token reads as `''`, which is what the CSSOM returns and is
+* indistinguishable from a token declared empty; assert on the value you expect rather than on
+* presence.
+*
+* Resolution is inheritance, so a token declared on `:root` reads from any mounted descendant and
+* from an unmounted element reads as `''`. Use {@link rootToken} where the declaration is the
+* document's.
+*
+* @example
+* ```ts
+* token(panel, 'surface') // '#ffffff'
+* token(panel, '--surface') // '#ffffff'
+* ```
+*/
+function token(element, name) {
+	return style(element, name.startsWith("--") ? name : `--${name}`);
+}
+/**
+* Reads one custom property from the document element.
+*
+* @param name - The custom property name, with or without its leading dashes.
+* @returns The resolved value, trimmed; an empty string when the document declares no such property.
+*
+* @remarks
+* This is {@link token} against `document.documentElement`, which is where a theme declares its
+* tokens and where a `[data-theme]` switch retunes them. It exists as its own name because that
+* element is the one a token question is nearly always about, and naming it at every call site
+* buries the question.
+*
+* @example
+* ```ts
+* rootToken('surface')
+* ```
+*/
+function rootToken(name) {
+	return token(document.documentElement, name);
+}
+/**
+* Reads one resolved CSS length as a number of pixels.
+*
+* @param element - The element whose resolved style to inspect.
+* @param property - The CSS property name, registered or custom.
+* @returns The leading numeric part of the resolved value, and `0` when it carries none.
+*
+* @remarks
+* A resolved length is text with a unit — `'12px'` — so this reads the number in front of the unit
+* and discards the rest. The unit is not checked: the resolved value of a length is in pixels in
+* every case a browser hands back, and a property that resolves to something else is the caller's
+* mistake rather than this reader's.
+*
+* An unparsable value reads as `0` rather than as absence, because every caller of this is measuring
+* and `'auto'`, `'none'`, and `''` each contribute no pixels to what a reader sees. Where the
+* distinction matters, read the text with {@link style} instead.
+*
+* @example
+* ```ts
+* pixels(button, 'padding-left') // 12
+* pixels(button, 'width') // 0 when the width resolves to `auto`
+* ```
+*/
+function pixels(element, property) {
+	const measured = Number.parseFloat(style(element, property));
+	return Number.isFinite(measured) ? measured : 0;
 }
 /**
 * Sets the tester's viewport and renders the runner's pane at the size that viewport claims.
@@ -1355,6 +1727,72 @@ function expandCaptures(states, variants) {
 //#endregion
 //#region src/browser/factories.ts
 /**
+* Creates one real pointer event, ready to dispatch.
+*
+* @param name - The event type, such as `pointerdown`.
+* @param options - Any `PointerEventInit` member, each one overriding the default beneath it.
+* @returns A real `PointerEvent` of that type.
+*
+* @remarks
+* The defaults are what a browser's own pointer event carries and a hand-built one does not:
+* `bubbles` and `cancelable` are set, so a delegated listener hears it and a handler can prevent it,
+* and `pointerId`, `pointerType`, and `isPrimary` describe a single primary mouse, so a component
+* that branches on the pointer kind takes the branch a mouse takes. Override any of them by naming
+* it; a touch is `{ pointerType: 'touch' }` and nothing else has to be restated.
+*
+* The event is real rather than a shaped object, so `instanceof PointerEvent` holds and the
+* coordinate and modifier members a handler reads are the ones the platform defines.
+*
+* @example
+* ```ts
+* element.dispatchEvent(createPointerEvent('pointerdown', { clientX: 10, clientY: 20 }))
+* ```
+*/
+function createPointerEvent(name, options) {
+	return new PointerEvent(name, {
+		bubbles: true,
+		cancelable: true,
+		pointerId: 1,
+		pointerType: "mouse",
+		isPrimary: true,
+		...options
+	});
+}
+/**
+* Creates one real drag event carrying a live data transfer, ready to dispatch.
+*
+* @param name - The event type, such as `dragstart`.
+* @param options - Any `DragEventInit` member, each one overriding the default beneath it.
+* @returns A real `DragEvent` of that type.
+*
+* @remarks
+* A drag event with no `dataTransfer` is the shape that makes a drop handler fail in a test and work
+* in a browser, so one is allocated. Pass your own to seed it: a `dataTransfer` given in `options`
+* replaces the allocated one, which is how a drop is driven with the payload the drag was supposed
+* to carry.
+*
+* The platform declares the `dataTransfer` member on the constructed event as nullable, so calling
+* code still narrows it even though this always supplies one.
+*
+* `bubbles` and `cancelable` are set, because a drop handler that never prevents the default event
+* is a drop the browser handles itself.
+*
+* @example
+* ```ts
+* const started = createDragEvent('dragstart')
+* started.dataTransfer?.setData('text/plain', 'row-3')
+* element.dispatchEvent(started)
+* ```
+*/
+function createDragEvent(name, options) {
+	return new DragEvent(name, {
+		bubbles: true,
+		cancelable: true,
+		dataTransfer: new DataTransfer(),
+		...options
+	});
+}
+/**
 * Creates the capture portfolio one run places its screenshots through.
 *
 * @param options - The state registry, the variant matrix, the variant this run renders, the
@@ -1419,6 +1857,36 @@ function createPortfolio(options) {
 	};
 }
 /**
+* Creates one console channel that records every call it receives and hands that call on unchanged.
+*
+* @param name - The channel's name, which prefixes each line it records.
+* @param output - The list each call is recorded into, appended to in place.
+* @param forward - The channel every call is passed on to after it is recorded.
+* @returns A channel carrying the console's own call signature.
+*
+* @remarks
+* One call becomes one line. Every argument of that call is put through `String` and joined with a
+* space, so a call carrying several values reads as the one line the page printed rather than as
+* several entries.
+*
+* Nothing is swallowed. The record happens first and `forward` receives the arguments it would have
+* received, so a page recorded through this prints exactly what it printed without it. The list
+* belongs to the caller, so a channel writes into whatever it was handed and holds no state of its
+* own. {@link createJournal} builds one channel per console method over one list.
+*
+* @example
+* ```ts
+* const output: string[] = []
+* console.log = createChannel('log', output, console.log)
+* ```
+*/
+function createChannel(name, output, forward) {
+	return (...data) => {
+		output.push(`${name}: ${data.map((value) => String(value)).join(" ")}`);
+		forward(...data);
+	};
+}
+/**
 * Creates the journal one scenario records its steps and the page's own output into.
 *
 * @returns A journal that records nothing until it is started.
@@ -1472,10 +1940,7 @@ function createJournal() {
 				"info",
 				"log",
 				"warn"
-			]) console[channel] = (...data) => {
-				output.push(`${channel}: ${data.map((value) => String(value)).join(" ")}`);
-				forwarded[channel](...data);
-			};
+			]) console[channel] = createChannel(channel, output, forwarded[channel]);
 			const dropped = new AbortController();
 			listeners = dropped;
 			window.addEventListener("error", (event) => {
@@ -1503,6 +1968,6 @@ function createJournal() {
 	};
 }
 //#endregion
-export { ACCESSIBLE_ROLES, CANVAS_COLOR, CAPTURE_PANE, CONTENT_ROLES, FIELD_ROLES, FOCUSABLE_SELECTOR, HEADER_ROLES, IMPLICIT_ROLES, blendColor, captureFrame, clearStorage, clickAccessible, clickAccessibleWithin, clickDisclosure, contrast, createJournal, createPortfolio, describeFocus, describeTree, expandCaptures, extractOrphans, fillAccessible, isOutsideViewport, isReachable, isRendered, measureContrast, measureLuminance, parseColor, pressKeys, readBackdrop, readCascade, readFocus, readLayers, readName, readPage, readPerception, readRing, readRole, readRows, readStates, readText, readValue, releasePane, render, resolveAccessible, resolveRendered, stagePane, style, traverseAccessible, typeAccessible, waitForFrame };
+export { ACCESSIBLE_ROLES, CANVAS_COLOR, CAPTURE_PANE, CONTENT_ROLES, FIELD_ROLES, FOCUSABLE_SELECTOR, HEADER_ROLES, IMPLICIT_ROLES, blendColor, build, captureFrame, clearStorage, clickAccessible, clickAccessibleWithin, clickDisclosure, colorEqual, commitInput, contrast, createChannel, createDragEvent, createJournal, createPointerEvent, createPortfolio, describeFocus, describeTree, expandCaptures, extractOrphans, fillAccessible, findKeyframes, findRule, isOutsideViewport, isReachable, isRendered, measureContrast, measureLuminance, mount, parseColor, pixels, pressKeys, readBackdrop, readCascade, readFocus, readLayers, readName, readPage, readPerception, readRing, readRole, readRows, readRules, readStates, readText, readValue, releasePane, removeDatabase, render, resolveAccessible, resolveRendered, rgba, rootToken, stagePane, style, token, traverseAccessible, typeAccessible, typeInput, waitForFrame };
 
 //# sourceMappingURL=index.js.map