gesso-core 0.6.19 → 0.6.21

package/dist/{CanvasSurface-tAao5BLh.js → CanvasSurface-BAhcLj2K.js}

@@ -804,6 +804,10 @@ var DirtyNodeSet = class {
 	isEmpty() {
 		return this.nodes.size === 0;
 	}
+	/** The nodes in the set, without draining it. Not to be changed while walked. */
+	values() {
+		return this.nodes.values();
+	}
 	/**
 	* Whether any node in the set carries one of `flags`, without
 	* draining it.
@@ -877,9 +881,24 @@ var UiNode = class {
 	*   opacity  → 0.5
 	*   visible  → true
 	*   width    → 200
+	*
+	* Read it directly; write it through `setProperty` and
+	* `removeProperty`, which count the change in `propertyVersion`.
 	*/
 	properties = /* @__PURE__ */ new Map();
 	/**
+	* Counts writes to `properties`.
+	*
+	* Lets something derived from a node's own properties tell that it
+	* is still right without reading them again. The layout engine
+	* resolves forty of them into each record, and on a full pass over a
+	* tree where nothing changed that reading was most of a sixth of the
+	* pass. A counter is exact where a dirty flag is not: flags are
+	* cleared by whichever pass runs next, and a record is resolved by
+	* whichever pass reaches it.
+	*/
+	propertyVersion = 0;
+	/**
 	* Values a modifier has written over the element's own.
 	*
 	* Null until the first modifier writes, so a tree without modifiers
@@ -925,6 +944,13 @@ var UiNode = class {
 	}
 	setProperty(property, value) {
 		this.properties.set(property, value);
+		this.propertyVersion++;
+	}
+	/** Removes a property; whether it was there. */
+	removeProperty(property) {
+		if (!this.properties.delete(property)) return false;
+		this.propertyVersion++;
+		return true;
 	}
 };
 //#endregion
@@ -1609,6 +1635,7 @@ function resolvedSpansOf(node) {
 * as soon as the application catches up.
 */
 function editableSpansOf(node, text, composition) {
+	if (node.properties.get("secret") === true) return EMPTY_SPANS;
 	const spanned = spannedTextOf(node);
 	if (spanned === void 0) return EMPTY_SPANS;
 	if (spanned.text === text) return spanned.spans;
@@ -3919,6 +3946,19 @@ const UiProperties = {
 		inherited: false,
 		affects: 6
 	}),
+	/**
+	* Whether a scroll container shows its overlay scrollbars: \`'auto'\`
+	* (the default) while scrolling, \`'none'\` never, and then they cannot
+	* be grabbed either. For a container scrolled by something else, as a
+	* picture is moved inside a window onto it, where a bar would claim
+	* the person could scroll it.
+	*/
+	scrollbars: defineProperty({
+		name: "scrollbars",
+		defaultValue: void 0,
+		inherited: false,
+		affects: 6
+	}),
 	inset: defineProperty({
 		name: "inset",
 		defaultValue: void 0,
@@ -4202,6 +4242,17 @@ const UiProperties = {
 		inherited: false,
 		affects: 64
 	}),
+	/**
+	* A password field: every character is drawn as a bullet, copy and
+	* cut take nothing, and the shell edits it through a password input.
+	* The value itself is unchanged. Single-line only.
+	*/
+	secret: defineProperty({
+		name: "secret",
+		defaultValue: void 0,
+		inherited: false,
+		affects: 262
+	}),
 	/** Colour of the caret; defaults to the text colour. */
 	caretColor: defineProperty({
 		name: "caretColor",
@@ -4949,39 +5000,6 @@ function createFallbackKey(definition) {
 * no line height is set. Shared by ParagraphLayout and PaintState.
 */
 const DEFAULT_LINE_HEIGHT_FACTOR = 1.2;
-/**
-* Resolves a node's font the one way layout and paint both use.
-*
-* Font size, family, weight and letter spacing inherit through the
-* environment's text style. Line height is the subtle one: a text
-* style carries a line height that belongs with its font size, so a
-* node that inherits the style takes it whole. A node that sets its
-* own `fontSize` without a `lineHeight` gets a normal line height for
-* that size, `fontSize × 1.2`, rather than the inherited pixel value
-* sized for a different font — the inherited 16.8px of the default
-* style is right for 14px text and wrong for 22px. An explicit
-* `lineHeight` always wins.
-*
-* Before this, layout read the raw props (unset line height → ×1.2)
-* and paint read the inherited ones (→ 16.8px), so any text whose size
-* differed from the style's was measured in one line box and drawn in
-* another, and sat high or low inside it.
-*/
-function resolveFont(node) {
-	const out = {
-		fontSize: 0,
-		fontFamily: "",
-		fontWeight: "normal",
-		lineHeight: 0,
-		letterSpacing: 0,
-		fontStyle: "normal",
-		fontStretch: "normal",
-		fontVariant: "normal",
-		fontKerning: "auto"
-	};
-	resolveFontInto(node, out);
-	return out;
-}
 /** `resolveFont`, writing into a target the caller owns. */
 function resolveFontInto(node, out) {
 	const fontSize = positive$1(resolveProperty(node, UiProperties.fontSize)) ?? UiProperties.fontSize.defaultValue;
@@ -5161,6 +5179,36 @@ var UiGraph = class {
 		this.nodeRemovedListener?.(node);
 		for (let i = removed.length - 1; i > 0; i--) this.detachNode(removed[i]);
 	}
+	/**
+	* Moves a child before \`reference\` among its own siblings, or to the
+	* end when that is null. Its parent is unchanged, and so is everything
+	* it inherits, so its subtree is not visited: a lazy list recycling its
+	* rows moves one from end to end on every frame of a scroll, and
+	* re-inheriting walked the whole row each time.
+	*/
+	moveWithin(child, reference) {
+		const parent = child.parent;
+		if (parent === null) throw new Error(`Node '${child.id}' has no parent to move within.`);
+		if (reference !== null && reference.parent !== parent) throw new Error(`Reference node '${reference.id}' is not a sibling of '${child.id}'.`);
+		if (child === reference || child.nextSibling === reference) return;
+		this.detachNode(child);
+		parent.childOrderVersion++;
+		child.parent = parent;
+		if (reference === null) {
+			const last = parent.lastChild;
+			child.previousSibling = last;
+			if (last !== null) last.nextSibling = child;
+			else parent.firstChild = child;
+			parent.lastChild = child;
+			return;
+		}
+		const previous = reference.previousSibling;
+		if (previous !== null) previous.nextSibling = child;
+		else parent.firstChild = child;
+		child.previousSibling = previous;
+		child.nextSibling = reference;
+		reference.previousSibling = child;
+	}
 	detachNode(node) {
 		const parent = node.parent;
 		if (!parent) return;
@@ -5426,7 +5474,7 @@ var UiGraph = class {
 	applyResolvedProperty(node, property, present, value, dirtyFlags) {
 		if (!present) {
 			if (!node.properties.has(property)) return false;
-			node.properties.delete(property);
+			node.removeProperty(property);
 			this.markDirty(node, this.withProvidedFlags(property, dirtyFlags));
 			return true;
 		}
@@ -6801,7 +6849,10 @@ const FIT_EPSILON = 1 / 64;
 * narrower than the widest segment. When a segment is wider than the
 * available width the paragraph grows to it, and every line wraps
 * against that grown width rather than the one asked for, because that
-* is the box the lines will be painted in.
+* is the box the lines will be painted in. When the width is the box's
+* own (`exactWidth`: a width set from outside, or the box being
+* painted), it does not grow: the lines wrap against it and the wide
+* segment overflows alone, as CSS wraps text in a box of a fixed width.
 *
 * The first baseline sits half the leading below the line top, plus the
 * ascent, with the half-leading floored to a whole pixel. That floor is
@@ -6867,7 +6918,7 @@ function layoutParagraph(request, runs) {
 		if (paragraphEnd >= text.length) break;
 		paragraphStart = paragraphEnd + 1;
 	}
-	const available = Math.max(maxWidth, minContentWidth);
+	const available = request.exactWidth === true ? maxWidth : Math.max(maxWidth, minContentWidth);
 	const unwrapped = wrap === "none" || !isFinite(available);
 	const lines = [];
 	for (const paragraph of paragraphs) {
@@ -6876,7 +6927,7 @@ function layoutParagraph(request, runs) {
 			const key = unwrapped ? -1 : available;
 			let relative = paragraph.cached.lines.get(key);
 			if (relative === void 0) {
-				relative = breakHardLine(paragraph.text, paragraph.segments, width, unwrapped, measure);
+				relative = breakHardLine(paragraph.cached.text, paragraph.segments, width, unwrapped, measure);
 				if (paragraph.cached.lines.size >= WIDTHS_PER_LINE) paragraph.cached.lines.clear();
 				paragraph.cached.lines.set(key, relative);
 			}
@@ -6950,12 +7001,14 @@ function hardLine(memo, style, text, wrap, measure) {
 		memo.set(key, cached);
 		return cached;
 	}
-	const segments = segmentParagraph(text, wrap);
+	const own = ownCopy(text);
+	const segments = segmentParagraph(own, wrap);
 	let minContentWidth = 0;
-	for (const segment of segments) minContentWidth = Math.max(minContentWidth, measure(text.slice(segment.start, segment.end), segment.start, segment.end));
+	for (const segment of segments) minContentWidth = Math.max(minContentWidth, measure(own.slice(segment.start, segment.end), segment.start, segment.end));
 	const entry = {
+		text: own,
 		segments,
-		maxContentWidth: measure(text, 0, text.length),
+		maxContentWidth: measure(own, 0, own.length),
 		minContentWidth,
 		lines: /* @__PURE__ */ new Map()
 	};
@@ -6966,6 +7019,23 @@ function hardLine(memo, style, text, wrap, measure) {
 	memo.set(key, entry);
 	return entry;
 }
+/**
+* `text` in a string of its own.
+*
+* A hard line arrives as a slice of the whole paragraph, and a slice
+* in V8 is a view that keeps the string it was cut from alive. The
+* memo outlives the paragraph — it is what a later edit finds the
+* unchanged lines in — so each line it remembered, and every line
+* broken from it, held on to the whole text it came from. Typing into
+* a 115 KB field kept every version of it: 100 MB over 4,096 edits.
+* Prefixing a character makes a new string that has to be flattened
+* before it can be sliced, and the slice is then of that copy. A short
+* line is copied by `slice` anyway, and an engine that copies every
+* slice loses nothing.
+*/
+function ownCopy(text) {
+	return text.length < 16 ? text : (" " + text).slice(1);
+}
 /** Breaks one hard line on its own, as if it were the whole text. */
 function breakHardLine(text, segments, available, unwrapped, measure) {
 	const lines = [];
@@ -7266,8 +7336,58 @@ function spannedRunsFor(request, runs) {
 		}
 	};
 }
-/** Paragraphs remembered before the least recently asked for is forgotten. */
-const PARAGRAPH_CACHE_ENTRIES = 4096;
+/**
+* How much the paragraph cache holds before the least recently asked
+* for is forgotten: a number of paragraphs, and their text counted in
+* UTF-16 code units, whichever runs out first.
+*
+* A count alone treated a two-word label and a whole document as the
+* same size. Every keystroke in a long field is a new request, its key
+* the whole text, so 4,096 edits to a 115 KB field held 4,096 copies of
+* it, keys and lines: 1.1 GB of heap, for paragraphs nobody would ask
+* for again. The text budget keeps a handful of those; the count is
+* what bounds a screen of labels, and is larger than it was, since a
+* label costs a few hundred bytes and a list that remounts its rows
+* should find them still here.
+*/
+const PARAGRAPH_CACHE_ENTRIES = 16384;
+const PARAGRAPH_CACHE_TEXT = 1 << 20;
+/** A least-recently-used map of paragraphs, bounded by count and by text; see `PARAGRAPH_CACHE_ENTRIES`. */
+var ParagraphCache = class {
+	entries = /* @__PURE__ */ new Map();
+	text = 0;
+	get size() {
+		return this.entries.size;
+	}
+	get(key) {
+		const entry = this.entries.get(key);
+		if (entry === void 0) return;
+		this.entries.delete(key);
+		this.entries.set(key, entry);
+		return entry.paragraph;
+	}
+	set(key, paragraph, text) {
+		const previous = this.entries.get(key);
+		if (previous !== void 0) {
+			this.entries.delete(key);
+			this.text -= previous.text;
+		}
+		while (this.entries.size > 0 && (this.entries.size >= PARAGRAPH_CACHE_ENTRIES || this.text + text > PARAGRAPH_CACHE_TEXT)) {
+			const [oldest, entry] = this.entries.entries().next().value;
+			this.entries.delete(oldest);
+			this.text -= entry.text;
+		}
+		this.entries.set(key, {
+			paragraph,
+			text
+		});
+		this.text += text;
+	}
+	clear() {
+		this.entries.clear();
+		this.text = 0;
+	}
+};
 /**
 * Base class for measurers: implement the two primitives and the
 * paragraph algorithm does the rest.
@@ -7289,21 +7409,31 @@ const PARAGRAPH_CACHE_ENTRIES = 4096;
 * The result is shared between callers and must not be mutated.
 */
 var ParagraphTextMeasurer = class {
-	paragraphs = /* @__PURE__ */ new Map();
+	paragraphs = new ParagraphCache();
+	/**
+	* Paragraphs that came out the same at every width they fit in, by
+	* their key without the width; see `layoutFitsAnyWidth`.
+	*
+	* A resize asks every paragraph again at a width a few pixels from
+	* the last, and a title, a caption or a label that fitted before
+	* fits still: its lines, its box and everything else are what they
+	* were. Keyed by its width as well, each of those missed on every
+	* step of a dragged window edge and was laid out again, and the
+	* box it was then painted in (its own width, exact) missed once
+	* more.
+	*/
+	fitting = new ParagraphCache();
+	generations = 0;
 	layout(request) {
-		const key = paragraphKey(request);
+		const style = paragraphStyleKey(request);
+		const key = `${request.maxWidth ?? ""}\0${request.exactWidth === true ? 1 : ""}\0${style}`;
 		const cached = this.paragraphs.get(key);
-		if (cached !== void 0) {
-			this.paragraphs.delete(key);
-			this.paragraphs.set(key, cached);
-			return cached;
-		}
+		if (cached !== void 0) return cached;
+		const fitted = this.fitting.get(style);
+		if (fitted !== void 0 && fitsWidth(fitted, request.maxWidth)) return fitted;
 		const paragraph = layoutParagraph(request, this);
-		if (this.paragraphs.size >= PARAGRAPH_CACHE_ENTRIES) {
-			const oldest = this.paragraphs.keys().next().value;
-			if (oldest !== void 0) this.paragraphs.delete(oldest);
-		}
-		this.paragraphs.set(key, paragraph);
+		this.paragraphs.set(key, paragraph, request.text.length);
+		if (layoutFitsAnyWidth(request, paragraph)) this.fitting.set(style, paragraph, request.text.length);
 		return paragraph;
 	}
 	measure(request) {
@@ -7317,6 +7447,9 @@ var ParagraphTextMeasurer = class {
 	get cachedParagraphs() {
 		return this.paragraphs.size;
 	}
+	get generation() {
+		return this.generations;
+	}
 	/**
 	* Forgets every laid-out paragraph. A subclass that caches its own
 	* primitives overrides this and calls it, so a font that finished
@@ -7324,13 +7457,47 @@ var ParagraphTextMeasurer = class {
 	* built from.
 	*/
 	invalidate() {
+		this.generations++;
 		this.paragraphs.clear();
+		this.fitting.clear();
 		forgetHardLines(this);
 	}
 };
-/** Every field of a request, in a fixed order; two requests that lay out alike share a key. */
-function paragraphKey(request) {
-	return `${request.fontSize}\0${request.maxWidth ?? ""}\0${request.fontFamily ?? ""}\0${request.fontWeight ?? ""}\0${request.lineHeight ?? ""}\0${request.letterSpacing ?? ""}\0${request.wrap ?? ""}\0${request.maxLines ?? ""}\0${request.overflow ?? ""}\0${request.fontStyle ?? ""}\0${request.fontStretch ?? ""}\0${request.fontVariant ?? ""}\0${request.fontKerning ?? ""}\0${spansKey(request.spans)}\0${request.text}`;
+/**
+* Whether `paragraph`, laid out for `request`, is what a request
+* differing only in its width would get at any width it fits in.
+*
+* A paragraph's width enters its layout in four places, and none of
+* them can tell two widths apart once every hard line fits whole:
+* nothing breaks (a line that fits is not broken, `exactWidth` or
+* not); the box is fit-content, which is the natural width; no line is
+* wider than the box, so none is ellipsised in place; and the one
+* ellipsis that is fitted to the width — the last line kept by
+* `maxLines` — is excluded here, because it is only drawn when there
+* were more hard lines than that. An unbounded request is left out:
+* it is laid out unwrapped, which is a different path, and it has a
+* key of its own that never changes anyway.
+*/
+function layoutFitsAnyWidth(request, paragraph) {
+	if (!fitsWidth(paragraph, request.maxWidth)) return false;
+	const maxLines = request.maxLines;
+	return request.overflow !== "ellipsis" || maxLines === void 0 || maxLines < 1 || !hasMoreHardLines(request.text, maxLines);
+}
+/** Whether a paragraph with nothing in it that depends on the width fits at `maxWidth`. */
+function fitsWidth(paragraph, maxWidth) {
+	return maxWidth !== void 0 && maxWidth >= 0 && paragraph.maxContentWidth <= maxWidth;
+}
+function hasMoreHardLines(text, count) {
+	let at = -1;
+	for (let i = 0; i < count; i++) {
+		at = text.indexOf("\n", at + 1);
+		if (at < 0) return false;
+	}
+	return true;
+}
+/** Every field of a request but its width, in a fixed order; two requests that lay out alike at one width share a key. */
+function paragraphStyleKey(request) {
+	return `${request.fontSize}\0${request.fontFamily ?? ""}\0${request.fontWeight ?? ""}\0${request.lineHeight ?? ""}\0${request.letterSpacing ?? ""}\0${request.wrap ?? ""}\0${request.maxLines ?? ""}\0${request.overflow ?? ""}\0${request.fontStyle ?? ""}\0${request.fontStretch ?? ""}\0${request.fontVariant ?? ""}\0${request.fontKerning ?? ""}\0${spansKey(request.spans)}\0${request.text}`;
 }
 /**
 * The runs' part of a paragraph key, remembered by the identity of the
@@ -7582,7 +7749,7 @@ function editorFor(node) {
 	let model = node.properties.get(EDITOR_PROP);
 	if (!(model instanceof EditableTextModel)) {
 		model = new EditableTextModel();
-		node.properties.set(EDITOR_PROP, model);
+		node.setProperty(EDITOR_PROP, model);
 	}
 	syncEditorValue(node, model);
 	syncEditorHidden(node, model);
@@ -7612,12 +7779,33 @@ function syncEditorHidden(node, model) {
 function isEditableNode(node) {
 	return node.type === "editable-text";
 }
+/** Whether Enter inserts a newline. Never in a secret field, which is one line, as a password input is. */
 function isMultiline(node) {
-	return node.properties.get("multiline") === true;
+	return node.properties.get("multiline") === true && !isSecret(node);
 }
 function isReadOnly(node) {
 	return node.properties.get("readOnly") === true;
 }
+function isSecret(node) {
+	return node.properties.get("secret") === true;
+}
+/**
+* A secret field's text as it is drawn: one bullet per UTF-16 code
+* unit, not per character. Every offset the editor works in (caret,
+* selection, hit-testing, the shell's mirror) is a code unit offset
+* into the model's text, and a mask of the same length keeps each of
+* them meaning the same position in both strings. A character outside
+* the BMP draws as two bullets, which says a little about it; counting
+* graphemes instead would need a map between the two strings' offsets
+* in every one of those places.
+*/
+function maskText(text) {
+	return "•".repeat(text.length);
+}
+/** The text an editable draws and measures: its model's, masked when it is secret. */
+function shownTextOf(node, model) {
+	return isSecret(node) ? maskText(model.text) : model.text;
+}
 /**
 * Whether the caret is in the visible half of its blink at `now`. It
 * is always visible while a composition is open — the IME caret must
@@ -7655,8 +7843,8 @@ function linkHoverOf(node) {
 /** Records the hovered run. Returns whether it changed. */
 function setLinkHover(node, index) {
 	if (linkHoverOf(node) === index) return false;
-	if (index < 0) node.properties.delete(TEXT_LINK_HOVER_PROP);
-	else node.properties.set(TEXT_LINK_HOVER_PROP, index);
+	if (index < 0) node.removeProperty(TEXT_LINK_HOVER_PROP);
+	else node.setProperty(TEXT_LINK_HOVER_PROP, index);
 	return true;
 }
 /** Forgets the hovered run. Returns whether there was one. */
@@ -7857,7 +8045,7 @@ function selectionRangeOf(node) {
 function setSelectionRange(node, start, end) {
 	const current = selectionRangeOf(node);
 	if (current !== void 0 && current.start === start && current.end === end) return false;
-	node.properties.set(TEXT_SELECTION_PROP, {
+	node.setProperty(TEXT_SELECTION_PROP, {
 		start,
 		end
 	});
@@ -7865,7 +8053,7 @@ function setSelectionRange(node, start, end) {
 }
 /** Clears a node's selected range. Returns whether it had one. */
 function clearSelectionRange(node) {
-	return node.properties.delete(TEXT_SELECTION_PROP);
+	return node.removeProperty(TEXT_SELECTION_PROP);
 }
 /**
 * The text a `Text` node draws, when the user may select it.
@@ -7935,12 +8123,12 @@ function setMatchRanges(node, ranges) {
 	const current = matchRangesOf(node);
 	if (current !== void 0 && rangesEqual(current, ranges)) return false;
 	if (ranges.length === 0) return clearMatchRanges(node);
-	node.properties.set(TEXT_MATCHES_PROP, ranges);
+	node.setProperty(TEXT_MATCHES_PROP, ranges);
 	return true;
 }
 /** Clears a node's matched ranges. Returns whether it had any. */
 function clearMatchRanges(node) {
-	return node.properties.delete(TEXT_MATCHES_PROP);
+	return node.removeProperty(TEXT_MATCHES_PROP);
 }
 function rangesEqual(a, b) {
 	if (a.length !== b.length) return false;
@@ -8045,7 +8233,7 @@ function resolvePaintState(node, out) {
 	if (isEditableNode(node)) {
 		const model = editorFor(node);
 		out.editor = model;
-		out.text = model.text;
+		out.text = shownTextOf(node, model);
 		out.placeholder = resolveString(node, "placeholder");
 		out.placeholderColor = resolveColor(node, UiProperties.placeholderColor) ?? themeColor(node, "textMuted") ?? DEFAULT_PLACEHOLDER_COLOR;
 		out.selectionColor = resolveColor(node, UiProperties.selectionColor) ?? defaultSelectionColor(node);
@@ -8507,6 +8695,7 @@ function textMeasureRequest(text, state, box) {
 		fontVariant: state.fontVariant,
 		fontKerning: state.fontKerning,
 		maxWidth: box.width > 0 ? box.width : void 0,
+		exactWidth: box.width > 0,
 		wrap: state.textWrap,
 		maxLines: state.maxLines,
 		overflow: state.textOverflow,
@@ -8834,23 +9023,32 @@ var EditableLayout = class {
 	placeholderLines;
 	measure;
 	rtl;
+	/**
+	* The text as drawn: the model's, or a secret field's mask of it
+	* (see `maskText`). The geometry is the drawing's, so it is measured
+	* from this; the two are the same length, so its offsets are the
+	* model's.
+	*/
+	text;
 	constructor(model, box, state, measurer) {
 		this.model = model;
 		this.box = box;
-		const request = textMeasureRequest(model.text, state, box);
+		const text = state.text ?? model.text;
+		this.text = text;
+		const request = textMeasureRequest(text, state, box);
 		request.maxLines = void 0;
 		request.overflow = "clip";
 		this.lines = placeLines(box, state, measurer.layout(request));
 		const spanned = spannedRunsFor(request, measurer);
-		this.measure = (text, start) => text.length === 0 ? 0 : spanned === void 0 || start === void 0 ? measurer.measureRunWidth(text, request) : spanned.width(model.text, start, start + text.length);
+		this.measure = (text, start) => text.length === 0 ? 0 : spanned === void 0 || start === void 0 ? measurer.measureRunWidth(text, request) : spanned.width(this.text, start, start + text.length);
 		this.rtl = state.rtl;
-		this.placeholderLines = model.text.length === 0 && state.placeholder !== void 0 && state.placeholder.length > 0 ? placeLines(box, state, measurer.layout({
+		this.placeholderLines = text.length === 0 && state.placeholder !== void 0 && state.placeholder.length > 0 ? placeLines(box, state, measurer.layout({
 			...request,
 			text: state.placeholder
 		})) : [];
 	}
 	caretRect(offset = this.model.focus) {
-		return caretRectFor(this.lines, this.model.text, offset, this.measure, this.rtl);
+		return caretRectFor(this.lines, this.text, offset, this.measure, this.rtl);
 	}
 	/**
 	* The caret position nearest a point. Where hidden text sits at the
@@ -8861,10 +9059,10 @@ var EditableLayout = class {
 	* apart. Never inside hidden text.
 	*/
 	offsetAt(x, y) {
-		return this.model.caretOffsetNear(offsetAtPoint(this.lines, this.model.text, x, y, this.measure, this.rtl));
+		return this.model.caretOffsetNear(offsetAtPoint(this.lines, this.text, x, y, this.measure, this.rtl));
 	}
 	verticalMove(offset, direction, goalX) {
-		const move = offsetForVerticalMove(this.lines, this.model.text, offset, direction, this.measure, this.rtl, goalX);
+		const move = offsetForVerticalMove(this.lines, this.text, offset, direction, this.measure, this.rtl, goalX);
 		return move === null ? null : {
 			offset: this.model.caretOffsetNear(move.offset),
 			x: move.x
@@ -8877,13 +9075,13 @@ var EditableLayout = class {
 	selectionBoxes(range) {
 		const start = range?.start ?? this.model.start;
 		const end = range?.end ?? this.model.end;
-		return selectionRects(this.lines, this.model.text, start, end, this.measure, this.rtl);
+		return selectionRects(this.lines, this.text, start, end, this.measure, this.rtl);
 	}
 	/** Boxes under the text the IME is composing, for its underline. */
 	compositionBoxes() {
 		const range = this.model.composition;
 		if (range === null) return [];
-		return selectionRects(this.lines, this.model.text, range.start, range.end, this.measure, this.rtl);
+		return selectionRects(this.lines, this.text, range.start, range.end, this.measure, this.rtl);
 	}
 };
 //#endregion
@@ -9379,6 +9577,7 @@ function scrollbarThumb(rec, axis) {
 	return thumbFor(rec, axis);
 }
 function thumbFor(rec, axis) {
+	if (rec.hidesScrollbars) return null;
 	const viewport = axis === "y" ? rec.height : rec.width;
 	const content = axis === "y" ? rec.contentHeight : rec.contentWidth;
 	if (!(content > viewport) || viewport <= 0) return null;
@@ -10109,8 +10308,21 @@ var UiFocusManager = class {
 	* when that scope was pushed, when that node is still in the tree
 	* and still focusable. Otherwise focus is dropped rather than left
 	* on a node the scope was hiding.
-	*/
-	popScope() {
+	*
+	* Given its root, only that scope ends: none, when it has gone already
+	* (its subtree removed, which pops it), so a trap released after its
+	* content was taken away cannot end the one under it, a submenu's
+	* menu's; and one under another is taken out where it is.
+	*/
+	popScope(root) {
+		if (root !== void 0 && this.scopes.at(-1)?.root !== root) {
+			const at = this.scopes.findIndex((each) => each.root === root);
+			if (at >= 0) {
+				this.scopes.splice(at, 1);
+				this.notifyScope();
+			}
+			return;
+		}
 		const scope = this.scopes.pop();
 		if (scope === void 0) return;
 		const restore = scope.restore;
@@ -10930,6 +11142,11 @@ var UiWheelController = class {
 	* wheel of a burst land correctly even though the first could not.
 	*/
 	lastWheelTarget = null;
+	/**
+	* The container the wheel last scrolled, for a frame's report of where
+	* scrolling put it. Null until the wheel has scrolled something.
+	*/
+	lastScrolled = null;
 	wheel(x, y, deltaX, deltaY, modifiers = noKeyModifiers(), deltaMode = 0, wheelDeltaY, at) {
 		const target = this.hitTester.hitTest(x, y)?.node ?? null;
 		this.lastWheelTarget = target;
@@ -11082,7 +11299,8 @@ var UiWheelController = class {
 					dirX: 0,
 					dirY: 0,
 					quiet: 0,
-					fresh: false
+					fresh: false,
+					fitted: false
 				};
 				this.pacing.set(container, paced);
 			}
@@ -11098,9 +11316,11 @@ var UiWheelController = class {
 			});
 			while (paced.samples.length > 2 && paced.samples[0].t < this.eventTime - VELOCITY_WINDOW_MS) paced.samples.shift();
 			this.scrollSink.scrollBy(container, 0, 0, "instant");
+			this.lastScrolled = container;
 			return;
 		}
 		this.scrollSink.scrollBy(container, dx, dy, behavior);
+		this.lastScrolled = container;
 	}
 	/**
 	* A container's state as a step should judge it: during a paced gesture,
@@ -11128,16 +11348,15 @@ var UiWheelController = class {
 	* comes a varying time after the last step: applied as they arrive, a
 	* steady flick moves the page by uneven amounts, which reads as
 	* judder. Evening that out by waiting for steps puts the page behind
-	* the hand. So this does what a browser does for its own scrolling:
-	* it puts the page where the input will have reached when the frame is
-	* shown, the steps so far plus their velocity times the time since the
-	* last one, never more than a frame and a half ahead. Steps come out
-	* even, and nothing trails.
+	* the hand. So this does what a browser does for its own scrolling: it
+	* resamples the steps at the frame's time, reading a line fitted through
+	* the last `VELOCITY_WINDOW_MS` of them. Frames come out even, and
+	* nothing trails.
 	*
-	* A gesture's first step, with no velocity yet, goes as it is. Once the
-	* steps stop, the prediction is withdrawn and the page settles exactly
-	* where they add up to; a trackpad's momentum slows to nothing first,
-	* so there is next to nothing to withdraw.
+	* A gesture's first step, with no line yet, goes as it is. Once the
+	* steps stop, the page eases over a few frames to exactly where they add
+	* up to; a trackpad's momentum slows to nothing first, so there is next
+	* to nothing to take up.
 	*
 	* True while a gesture is still being paced, so the host keeps frames
 	* coming until it has settled.
@@ -11157,14 +11376,38 @@ var UiWheelController = class {
 			let y = paced.totalY;
 			const samples = paced.samples;
 			const last = samples[samples.length - 1];
-			let first = last;
-			for (let k = samples.length - 2; k >= 0 && last !== void 0 && samples[k].t >= last.t - RECENT_MS; k--) first = samples[k];
+			const first = samples[0];
 			const since = time === void 0 || last === void 0 ? -1 : time - last.t;
-			if (last !== void 0 && first !== void 0 && since >= -1 && since < STALE_MS && last.t - first.t >= 2) {
-				const span = last.t - first.t;
-				const ahead = Math.min(Math.max(since, 0) + this.frameInterval, this.frameInterval * MAX_AHEAD_FRAMES);
-				x += (last.x - first.x) / span * ahead;
-				y += (last.y - first.y) / span * ahead;
+			const at = time === void 0 ? void 0 : time - RESAMPLE_MS;
+			if (at !== void 0 && last !== void 0 && first !== void 0 && since >= -1 && at - last.t < STALE_MS && samples.length >= MIN_FIT_STEPS && last.t - first.t >= 2) {
+				let meanT = 0;
+				let meanX = 0;
+				let meanY = 0;
+				for (const sample of samples) {
+					meanT += sample.t;
+					meanX += sample.x;
+					meanY += sample.y;
+				}
+				meanT /= samples.length;
+				meanX /= samples.length;
+				meanY /= samples.length;
+				let varT = 0;
+				let covX = 0;
+				let covY = 0;
+				for (const sample of samples) {
+					const dt = sample.t - meanT;
+					varT += dt * dt;
+					covX += dt * (sample.x - meanX);
+					covY += dt * (sample.y - meanY);
+				}
+				x = meanX + covX / varT * (at - meanT);
+				y = meanY + covY / varT * (at - meanT);
+				paced.fitted = true;
+			} else if (paced.fitted) {
+				const drawnX = paced.lastX - paced.baseX;
+				const drawnY = paced.lastY - paced.baseY;
+				x = Math.abs(x - drawnX) < SETTLED_PX ? x : drawnX + (x - drawnX) * SETTLE_RATE;
+				y = Math.abs(y - drawnY) < SETTLED_PX ? y : drawnY + (y - drawnY) * SETTLE_RATE;
 			}
 			const state = this.scrollSink.containerState(container);
 			if (state === void 0) {
@@ -11190,7 +11433,7 @@ var UiWheelController = class {
 			if (dx !== 0 || dy !== 0) this.scrollSink.scrollBy(container, dx, dy, "instant");
 			paced.lastX = toX;
 			paced.lastY = toY;
-			if (toX === Math.min(Math.max(paced.baseX + paced.totalX, 0), state.maxScrollX) && toY === Math.min(Math.max(paced.baseY + paced.totalY, 0), state.maxScrollY) && paced.quiet >= QUIET_FRAMES) this.pacing.delete(container);
+			if (toX === Math.min(Math.max(paced.baseX + paced.totalX, 0), state.maxScrollX) && toY === Math.min(Math.max(paced.baseY + paced.totalY, 0), state.maxScrollY) && paced.quiet >= QUIET_FRAMES && (since < 0 || since >= STALE_MS)) this.pacing.delete(container);
 		}
 		return this.pacing.size > 0;
 	}
@@ -11244,18 +11487,29 @@ function isScrollContainer(node) {
 * hand from a trackpad to a mouse.
 */
 const PRECISE_MEMORY_MS = 400;
-/** How far back the velocity is read: a few of a trackpad's steps. */
-const VELOCITY_WINDOW_MS = 40;
-/** How long after the last step its velocity is still trusted. */
-const STALE_MS = 40;
 /**
-* The furthest ahead a frame predicts, in frames: a frame's lead, for the
-* frame it takes to be shown, plus the time since the last step, which is
-* what evens out where each frame falls between steps.
+* How far back the steps are fitted: five or six of a trackpad's. Less, and
+* the line follows each step's rounding; more, and it lags a flick that is
+* speeding up or slowing down. Measured on a real flick on a Mac, 48 ms left
+* a sixth of the frame-to-frame variation of the last-few-steps velocity,
+* with no frame standing still and the page no further behind the hand.
 */
-const MAX_AHEAD_FRAMES = 1.5;
-/** How far back the velocity is read for a prediction. */
-const RECENT_MS = 20;
+const VELOCITY_WINDOW_MS = 48;
+/** How long after the last step its line is still trusted. */
+const STALE_MS = 40;
+/**
+* How long before the frame the line is read. Each millisecond is one more
+* of lag and less of a guess: measured on recorded flicks, 12 left the
+* worst frames a third as uneven as reading at the frame, and the page
+* about 11 ms behind the hand, against 15 for steps applied as they come.
+*/
+const RESAMPLE_MS = 12;
+/** Steps a line is fitted through: two are a line through their rounding. */
+const MIN_FIT_STEPS = 3;
+/** How much of the way to where the steps add up to a frame goes once they stop. */
+const SETTLE_RATE = .35;
+/** Close enough to where the steps add up to, to go the rest at once. */
+const SETTLED_PX = .25;
 /** The display's interval before one has been measured. */
 const DEFAULT_FRAME_MS = 1e3 / 60;
 /** Quiet frames, once settled, after which a gesture is over. */
@@ -12009,9 +12263,13 @@ var UiEditingController = class {
 		if (command === null) return false;
 		return this.execute(node, command);
 	}
-	execute(node, command) {
+	execute(node, keyed) {
 		const model = editorFor(node);
 		const readOnly = isReadOnly(node);
+		const command = (keyed.kind === "move" || keyed.kind === "delete") && keyed.unit === "word" ? {
+			...keyed,
+			unit: secretWordUnit(node)
+		} : keyed;
 		switch (command.kind) {
 			case "move":
 				if (this.span !== null && !command.extend) {
@@ -12182,7 +12440,8 @@ var UiEditingController = class {
 			case "deleteByCut":
 			case "deleteByDrag": {
 				if (readOnly) return true;
-				const unit = /Word/.test(inputType) ? "word" : /Line/.test(inputType) ? "line" : "grapheme";
+				if (inputType === "deleteByCut" && isSecret(node)) return true;
+				const unit = /Word/.test(inputType) ? secretWordUnit(node) : /Line/.test(inputType) ? "line" : "grapheme";
 				const forward = /Forward/.test(inputType);
 				return this.applyEdit(node, model, inputType, null, () => {
 					if (inputType === "deleteContent" || inputType === "deleteByCut" || inputType === "deleteByDrag") model.replaceRange(model.start, model.end, "");
@@ -12387,6 +12646,7 @@ var UiEditingController = class {
 		};
 		this.dragging = node;
 		if (modifiers.shift) model.moveTo(offset, true);
+		else if (count === 2 && isSecret(node)) model.selectAll();
 		else if (count === 2) {
 			const word = visibleWordRange(model.text, model.hidden, offset);
 			model.select(word.start, word.end);
@@ -12452,6 +12712,16 @@ var UiEditingController = class {
 				...html === void 0 ? {} : { html }
 			};
 		}
+		if (isSecret(node)) return {
+			text: maskText(model.text),
+			selectionStart: model.start,
+			selectionEnd: model.end,
+			caret,
+			multiline: false,
+			composing: model.composing,
+			clipboard: "",
+			secret: true
+		};
 		const html = model.collapsed || model.composing ? void 0 : this.fieldHtml(node, model.start, model.end);
 		return {
 			text: model.text,
@@ -12722,10 +12992,11 @@ var UiEditingController = class {
 		const end = forward ? span.focus : span.anchor;
 		const key = [span];
 		for (const node of span.lit) key.push(editorFor(node).text);
+		const textOf = (node) => isSecret(node) ? maskText(editorFor(node).text) : editorFor(node).text;
 		return this.cachedCopy(key, () => {
 			return {
 				text: span.group.copyText !== void 0 ? span.group.copyText(start, end) : span.lit.map((node) => {
-					const text = editorFor(node).text;
+					const text = textOf(node);
 					return text.slice(node === start.node ? start.offset : 0, node === end.node ? end.offset : text.length);
 				}).join("\n"),
 				html: span.group.copyHtml?.(start, end) ?? void 0
@@ -12882,6 +13153,13 @@ var UiEditingController = class {
 		return new EditableLayout(state.editor, box, state, this.host.measurer);
 	}
 };
+/**
+* The unit a word move or delete takes in a field: the whole text in a
+* secret one, whose word boundaries the caret stopping at would show.
+*/
+function secretWordUnit(node) {
+	return isSecret(node) ? "document" : "word";
+}
 function deleteInputType(unit, direction) {
 	const side = direction < 0 ? "Backward" : "Forward";
 	switch (unit) {
@@ -13985,6 +14263,8 @@ var LayoutRecord = class {
 	* multiline, the overlay scrollbars.
 	*/
 	scrollsText = false;
+	/** A scroll container set to show no scrollbars (\`scrollbars: 'none'\`). */
+	hidesScrollbars = false;
 	/**
 	* A multiline editable, which shows the overlay scrollbars a scroll
 	* container does over its own text. A single-line field scrolls
@@ -14050,6 +14330,23 @@ var LayoutRecord = class {
 	/** Constraints this record was last measured under. */
 	lastConstraints = NEVER_MEASURED;
 	/**
+	* The paragraphs a text leaf was last measured as, one asked with a
+	* width and one without; see `LayoutEngine.measureLeaf`. Flex asks
+	* an item both questions every pass (its max-content basis, then its
+	* final width), so one slot would be overwritten by the other every
+	* time. Null until the node is measured as text that way.
+	*
+	* **Not reset.** These are the one thing a record carries from one
+	* full pass into the next, on purpose: a full pass re-asks every
+	* text leaf, and a memo that every pass cleared would answer
+	* nothing a resize asks. They are safe to keep because they check
+	* themselves — a memo is used only when every field of the request
+	* it was laid out for matches and the measurer has not been
+	* invalidated since — rather than trusting that nothing changed.
+	*/
+	textBounded = null;
+	textUnbounded = null;
+	/**
 	* The percentage base the current measurement resolved against, and
 	* whether the node has a length that resolves against one.
 	*
@@ -14165,6 +14462,20 @@ var LayoutRecord = class {
 	propsBaseWidth = void 0;
 	propsBaseHeight = void 0;
 	/**
+	* The node's `propertyVersion` when its layout properties were last
+	* resolved, and whether that resolution read the node and nothing
+	* else (no inherited direction, no scroll leader). Together with the
+	* percentage base they let a later pass, a full one included, keep
+	* what the last one resolved instead of reading forty properties
+	* again; see `LayoutEngine.resolveLayoutProps`.
+	*
+	* **Not reset,** with the fields they vouch for: `reset()` leaves
+	* every field `resolveLayoutProps` writes as it was, because these
+	* say whether it is still right.
+	*/
+	propsVersion = -1;
+	propsFromNodeAlone = false;
+	/**
 	* Returns the record to the state a freshly constructed one is in,
 	* so a full layout can reuse the object instead of replacing it.
 	*
@@ -14178,7 +14489,9 @@ var LayoutRecord = class {
 	* never reused across.
 	*
 	* **Every field above has to appear here, with the value it is
-	* declared with.** A field that is added and not reset would carry
+	* declared with,** but the two text memos and the resolved layout
+	* properties, which check themselves and are kept across passes on
+	* purpose. A field that is added and not reset would carry
 	* one pass's answer into the next, which is the kind of fault that
 	* shows as a stale box on a screen and as nothing at all in a test
 	* that lays out once. `LayoutRecord.spec.ts` compares a reset record
@@ -14193,28 +14506,6 @@ var LayoutRecord = class {
 		this.measuredHeight = 0;
 		this.outerWidth = 0;
 		this.outerHeight = 0;
-		this.paddingLeft = 0;
-		this.paddingRight = 0;
-		this.paddingTop = 0;
-		this.paddingBottom = 0;
-		this.marginLeft = 0;
-		this.marginRight = 0;
-		this.marginTop = 0;
-		this.marginBottom = 0;
-		this.minWidth = 0;
-		this.maxWidth = Infinity;
-		this.minHeight = 0;
-		this.maxHeight = Infinity;
-		this.flexGrow = 0;
-		this.flexShrink = 1;
-		this.flexBasisZero = false;
-		this.minWidthAuto = true;
-		this.minHeightAuto = true;
-		this.marginLeftAuto = false;
-		this.marginRightAuto = false;
-		this.marginTopAuto = false;
-		this.marginBottomAuto = false;
-		this.aspectRatio = void 0;
 		this.hasBaseline = false;
 		this.baseline = 0;
 		this.minContentWidth = 0;
@@ -14227,16 +14518,6 @@ var LayoutRecord = class {
 		this.flexMin = 0;
 		this.flexMax = Infinity;
 		this.flexMinAuto = false;
-		this.positioned = false;
-		this.absolute = false;
-		this.top = void 0;
-		this.right = void 0;
-		this.bottom = void 0;
-		this.left = void 0;
-		this.zIndex = 0;
-		this.lifted = false;
-		this.liftBoundary = false;
-		this.clips = false;
 		this.extentMinX = 0;
 		this.extentMinY = 0;
 		this.extentMaxX = 0;
@@ -14245,11 +14526,6 @@ var LayoutRecord = class {
 		this.paintReachTop = 0;
 		this.paintReachRight = 0;
 		this.paintReachBottom = 0;
-		this.scrollable = false;
-		this.scrollsText = false;
-		this.textScrollbars = false;
-		this.mirrored = false;
-		this.sticky = false;
 		this.stickyOffsetX = 0;
 		this.stickyOffsetY = 0;
 		this.scrollbarVisibleUntil = 0;
@@ -14268,8 +14544,6 @@ var LayoutRecord = class {
 		this.lastConstraints = NEVER_MEASURED;
 		this.lastBaseWidth = void 0;
 		this.lastBaseHeight = void 0;
-		this.percentWidth = false;
-		this.percentHeight = false;
 		this.alternates = null;
 		this.contentMatters = true;
 		this.relayoutBoundary = false;
@@ -14278,8 +14552,6 @@ var LayoutRecord = class {
 		this.placeDirty = true;
 		this.transformDirty = false;
 		this.propsPass = 0;
-		this.propsBaseWidth = void 0;
-		this.propsBaseHeight = void 0;
 	}
 };
 /** How many earlier measurements a record remembers besides the current one. */
@@ -15174,6 +15446,18 @@ var LayoutEngine = class {
 	*/
 	stickyShifted = /* @__PURE__ */ new Set();
 	textMeasurer;
+	/** Where `measureLeaf` resolves a text node's font; read before anything else can resolve one. */
+	fontScratch = {
+		fontSize: 0,
+		fontFamily: "",
+		fontWeight: "normal",
+		lineHeight: 0,
+		letterSpacing: 0,
+		fontStyle: "normal",
+		fontStretch: "normal",
+		fontVariant: "normal",
+		fontKerning: "auto"
+	};
 	/**
 	* The definite size percentages resolve against while a container's
 	* children are measured: its content box. Undefined on an axis whose
@@ -17012,37 +17296,79 @@ var LayoutEngine = class {
 		const paddingV = rec.paddingTop + rec.paddingBottom;
 		const editable = node.type === "editable-text";
 		if (node.type === "text" || node.type === "button" || editable) {
-			const typed = editable ? editorFor(node).text : "";
+			const typed = editable ? shownTextOf(node, editorFor(node)) : "";
 			const spans = editable ? editableSpansOf(node, typed, editorFor(node).composition) : resolvedSpansOf(node);
 			const text = editable ? typed : spans.length > 0 ? textContentOf(node) : String(node.properties.get("text") ?? "");
 			const placeholderProp = node.properties.get("placeholder");
 			const placeholder = editable && text.length === 0 && typeof placeholderProp === "string" ? placeholderProp : void 0;
-			const font = resolveFont(node);
+			const font = this.fontScratch;
+			resolveFontInto(node, font);
 			const maxLines = editable ? void 0 : this.numberProp(node, "maxLines");
-			const request = {
-				text,
-				fontSize: font.fontSize,
-				fontFamily: font.fontFamily,
-				fontWeight: font.fontWeight,
-				lineHeight: font.lineHeight,
-				letterSpacing: font.letterSpacing,
-				fontStyle: font.fontStyle,
-				fontStretch: font.fontStretch,
-				fontVariant: font.fontVariant,
-				fontKerning: font.fontKerning,
-				maxWidth: isFinite(effective.maxWidth) ? Math.max(0, effective.maxWidth - paddingH) : void 0,
-				wrap: this.textWrapProp(node),
-				maxLines: maxLines !== void 0 && maxLines >= 1 ? Math.floor(maxLines) : void 0,
-				overflow: editable ? "clip" : this.textOverflowProp(node),
-				spans: spans.length > 0 ? spans : void 0
-			};
-			const paragraph = this.textMeasurer.layout(request);
+			const maxWidth = isFinite(effective.maxWidth) ? Math.max(0, effective.maxWidth - paddingH) : void 0;
+			const exactWidth = isFinite(effective.maxWidth) && effective.minWidth === effective.maxWidth;
+			const wrap = this.textWrapProp(node);
+			const lines = maxLines !== void 0 && maxLines >= 1 ? Math.floor(maxLines) : void 0;
+			const overflow = editable ? "clip" : this.textOverflowProp(node);
+			const runs = spans.length > 0 ? spans : void 0;
+			/**
+			* The node's own last paragraph, when nothing it was laid out
+			* from has changed.
+			*
+			* Flex asks a text leaf three or four questions a pass (its
+			* basis, its min- and max-content sizes, its final size), and
+			* each one went to the measurer as a new request, whose cache
+			* key spells out every field and the whole text before it can
+			* look anything up. That was a fifth of a full layout pass over
+			* the benchmark list with every answer already cached. Compared
+			* field by field here it is a handful of identity checks, and a
+			* paragraph that fits at the width it was laid out at also
+			* answers any wider question, which is most of the questions a
+			* row of labels is asked.
+			*/
+			const generation = this.textMeasurer.generation;
+			const memo = maxWidth === void 0 ? rec.textUnbounded : rec.textBounded;
+			const last = memo?.request;
+			let paragraph;
+			let asked;
+			if (memo !== null && last !== void 0 && generation !== void 0 && memo.generation === generation && last.text === text && last.fontSize === font.fontSize && last.fontFamily === font.fontFamily && last.fontWeight === font.fontWeight && last.lineHeight === font.lineHeight && last.letterSpacing === font.letterSpacing && last.fontStyle === font.fontStyle && last.fontStretch === font.fontStretch && last.fontVariant === font.fontVariant && last.fontKerning === font.fontKerning && last.wrap === wrap && last.maxLines === lines && last.overflow === overflow && last.spans === runs && (last.maxWidth === maxWidth && last.exactWidth === exactWidth || memo.fitsAnyWidth && fitsWidth(memo.paragraph, maxWidth))) {
+				paragraph = memo.paragraph;
+				asked = last;
+			} else {
+				const request = {
+					text,
+					fontSize: font.fontSize,
+					fontFamily: font.fontFamily,
+					fontWeight: font.fontWeight,
+					lineHeight: font.lineHeight,
+					letterSpacing: font.letterSpacing,
+					fontStyle: font.fontStyle,
+					fontStretch: font.fontStretch,
+					fontVariant: font.fontVariant,
+					fontKerning: font.fontKerning,
+					maxWidth,
+					exactWidth,
+					wrap,
+					maxLines: lines,
+					overflow,
+					spans: runs
+				};
+				paragraph = this.textMeasurer.layout(request);
+				asked = request;
+				const fresh = {
+					request,
+					paragraph,
+					generation: generation ?? -1,
+					fitsAnyWidth: layoutFitsAnyWidth(request, paragraph)
+				};
+				if (maxWidth === void 0) rec.textUnbounded = fresh;
+				else rec.textBounded = fresh;
+			}
 			let width = paragraph.width;
 			let minContentWidth = paragraph.minContentWidth;
 			let maxContentWidth = paragraph.maxContentWidth;
 			if (placeholder !== void 0 && placeholder.length > 0) {
 				const hint = this.textMeasurer.layout({
-					...request,
+					...asked,
 					text: placeholder
 				});
 				width = Math.max(width, hint.width);
@@ -18225,7 +18551,28 @@ var LayoutEngine = class {
 		const props = node.properties;
 		const base = this.percentBase;
 		if (rec.propsPass === this.layoutPass && rec.propsBaseWidth === base.width && rec.propsBaseHeight === base.height) return;
+		/**
+		* What an earlier pass resolved, when none of what it read has
+		* changed: the node's own properties (`propertyVersion`), and the
+		* percentage base only on an axis that has a percentage.
+		*
+		* Each pass used to read every property below again for every node
+		* it reached, and a full pass reaches all of them: a sixth of a full
+		* pass over the benchmark list, where nothing had changed since the
+		* last. A node whose resolution read anything inherited (a logical
+		* edge or a scroll container's direction) or another node (a scroll
+		* leader) is resolved again every pass, as it always was; they are
+		* few. The record keeps these fields across `reset()` for this.
+		*/
+		if (rec.propsFromNodeAlone && rec.propsVersion === node.propertyVersion && (!rec.percentWidth || rec.propsBaseWidth === base.width) && (!rec.percentHeight || rec.propsBaseHeight === base.height)) {
+			rec.propsPass = this.layoutPass;
+			rec.propsBaseWidth = base.width;
+			rec.propsBaseHeight = base.height;
+			if (rec.lifted) this.liftedNodes.add(node);
+			return;
+		}
 		rec.propsPass = this.layoutPass;
+		rec.propsVersion = node.propertyVersion;
 		rec.propsBaseWidth = base.width;
 		rec.propsBaseHeight = base.height;
 		rec.percentWidth = hasPercentLength(props, WIDTH_RELATIVE);
@@ -18266,6 +18613,7 @@ var LayoutEngine = class {
 		const overflow = props.get("overflow");
 		rec.scrollable = node.type === "scroll-view" || overflow === "scroll" || overflow === "auto" || overflow === "hidden" && scrollLeaderOf(node) !== null;
 		rec.scrollsText = node.type === "editable-text";
+		rec.hidesScrollbars = props.get("scrollbars") === "none";
 		rec.textScrollbars = rec.scrollsText && props.get("multiline") === true;
 		rec.mirrored = (rec.scrollable || rec.textScrollbars) && this.startEdge(node) === "right";
 		rec.clips = rec.scrollable || overflow === "hidden" || node.type === "editable-text";
@@ -18277,9 +18625,11 @@ var LayoutEngine = class {
 		rec.left = this.lengthProp(node, "left", base.width) ?? insetH;
 		rec.zIndex = this.numberProp(node, "zIndex") ?? 0;
 		this.setLifted(node, rec, node.properties.get("lift") === true);
+		if (rec.lifted) this.liftedNodes.add(node);
 		rec.liftBoundary = node.properties.get("liftBoundary") === true;
 		const ratio = this.numberProp(node, "aspectRatio");
 		rec.aspectRatio = ratio !== void 0 && ratio > 0 ? ratio : void 0;
+		rec.propsFromNodeAlone = !hasLogicalSpacing(props) && !rec.scrollable && !rec.textScrollbars && overflow !== "hidden";
 	}
 	/**
 	* Sizes with a fixed width:height ratio (CSS `aspect-ratio`). The
@@ -20441,15 +20791,10 @@ var ScrollLayerCache = class {
 	* is how every one of those ends.
 	*/
 	refused = /* @__PURE__ */ new Set();
-	geometryVersion = NaN;
 	dpr = 0;
 	surfaceWidth = 0;
 	surfaceHeight = 0;
 	frame = null;
-	/** Whether this frame changed nothing a layer could not absorb: no layout, children, content or environment. */
-	calm = false;
-	/** Nodes this frame dirtied, and every ancestor of each, less a container that only scrolled. */
-	disturbed = /* @__PURE__ */ new Set();
 	/** Consecutive frames each container without a layer has scrolled quietly. See `SCROLL_LAYER_SETTLE_FRAMES`. */
 	streaks = /* @__PURE__ */ new WeakMap();
 	/**
@@ -20481,46 +20826,26 @@ var ScrollLayerCache = class {
 	/**
 	* Settles which layers this frame's changes leave standing, before
 	* anything is drawn. Every rule here drops; none keeps. A frame the
-	* caller could not vouch for drops them all.
+	* caller could not vouch for drops them all. What changed inside a
+	* container is not settled here but drawn over: see \`damage\`.
 	*/
 	beginFrame(changes, dpr, surfaceWidth, surfaceHeight) {
 		const interrupted = this.open;
 		this.open = true;
-		this.disturbed.clear();
-		this.calm = changes !== void 0;
-		for (const [node, flags] of changes?.frame.entries() ?? []) {
-			if ((flags & -355) !== 0) {
-				this.calm = false;
-				break;
-			}
-			for (let current = (flags & 32) !== 0 ? node.parent : node; current !== null; current = current.parent) this.disturbed.add(current);
-		}
-		if (interrupted || changes === void 0 || dpr !== this.dpr || surfaceWidth !== this.surfaceWidth || surfaceHeight !== this.surfaceHeight || changes.geometryVersion !== this.geometryVersion) {
+		if (interrupted || changes === void 0 || dpr !== this.dpr || surfaceWidth !== this.surfaceWidth || surfaceHeight !== this.surfaceHeight) {
 			this.dropAll();
 			this.dpr = dpr;
 			this.surfaceWidth = surfaceWidth;
 			this.surfaceHeight = surfaceHeight;
-			this.geometryVersion = changes?.geometryVersion ?? NaN;
 			this.frame = changes?.frame ?? null;
 			return;
 		}
 		const frame = changes.frame;
 		this.frame = frame;
-		if (this.layers.size === 0 && this.refused.size === 0) return;
+		for (const node of this.layers.keys()) if (dirtyAbove(frame, node)) this.forget(node);
 		for (const [node, flags] of frame.entries()) {
-			if ((flags & -355) !== 0) {
-				this.dropAll();
-				return;
-			}
-			const scrolledOnly = flags === 32;
-			for (let current = scrolledOnly ? node.parent : node; current !== null; current = current.parent) this.forget(current);
-		}
-		for (const node of [...this.layers.keys(), ...this.refused]) for (let ancestor = node.parent; ancestor !== null; ancestor = ancestor.parent) {
-			const flags = frame.dirtyFlagsFor(ancestor);
-			if (flags !== 0 && flags !== 32) {
-				this.forget(node);
-				break;
-			}
+			if (flags === 32) continue;
+			for (const refused of this.refused) if (node === refused || contains(node, refused) || contains(refused, node)) this.refused.delete(refused);
 		}
 	}
 	/** Drops the layers the frame did not composite: their container was culled, removed, or drawn directly. */
@@ -20534,14 +20859,16 @@ var ScrollLayerCache = class {
 	}
 	/**
 	* Whether a container with no layer should get one now: it has
-	* scrolled on the last few frames running with nothing else in or
-	* above it changing, which is the evidence a layer would be kept, and
-	* it has not just shown it holds something a layer cannot.
+	* scrolled on the last few frames running with nothing above it
+	* changing, which is the evidence a layer would be kept, and it has
+	* not just shown it holds something a layer cannot. What changes
+	* inside it is absorbed item by item (see \`damage\`), so a lazy list
+	* mounting rows as it scrolls keeps its layer.
 	*/
 	wants(node) {
 		const frame = this.frame;
 		if (frame === null || this.layers.size >= MAX_LAYERS || this.refused.has(node)) return false;
-		if (!this.calm || this.disturbed.has(node) || dirtyAbove(frame, node)) {
+		if (dirtyAbove(frame, node)) {
 			this.streaks.delete(node);
 			return false;
 		}
@@ -20571,9 +20898,10 @@ var ScrollLayerCache = class {
 			offsetX: placement.offsetX,
 			offsetY: placement.offsetY,
 			dpr: this.dpr,
-			scrollX: rec.scrollX,
-			scrollY: rec.scrollY,
-			used: true
+			scrollX: snapScroll(rec.scrollX, this.dpr),
+			scrollY: snapScroll(rec.scrollY, this.dpr),
+			used: true,
+			items: /* @__PURE__ */ new Map()
 		};
 		this.layers.set(node, layer);
 		this.stats.built++;
@@ -20594,8 +20922,8 @@ var ScrollLayerCache = class {
 	* device pixels, which a copy cannot follow without resampling.
 	*/
 	shift(layer, rec) {
-		const exactX = (layer.scrollX - rec.scrollX) * layer.dpr;
-		const exactY = (layer.scrollY - rec.scrollY) * layer.dpr;
+		const exactX = (layer.scrollX - snapScroll(rec.scrollX, layer.dpr)) * layer.dpr;
+		const exactY = (layer.scrollY - snapScroll(rec.scrollY, layer.dpr)) * layer.dpr;
 		const dx = Math.round(exactX);
 		const dy = Math.round(exactY);
 		if (Math.abs(exactX - dx) > EPSILON || Math.abs(exactY - dy) > EPSILON) return null;
@@ -20633,6 +20961,79 @@ var ScrollLayerCache = class {
 		});
 		return strips;
 	}
+	/**
+	* The parts of a layer this frame's changes inside the container left
+	* wrong, in the layer's pixels, or \`'all'\` when that is most of it.
+	* Called after \`shift\`, so the layer's offset is the frame's.
+	*
+	* Judged item by item, an item being one of the container's children
+	* (through any fragments): a lazy list's row, say. An item added,
+	* removed or moved is wrong where it was and where it is; an item with
+	* anything changed inside it is wrong where it is. Whatever none of
+	* that touches is right already, which in a lazy list scrolling is
+	* everything on screen: the rows it mounts and unmounts are in its
+	* overscan, and the spacers that stand for the rest only grow and
+	* shrink off the top and bottom.
+	*/
+	damage(layer, container, layout) {
+		const frame = this.frame;
+		if (frame === null) return "all";
+		const boxes = [];
+		for (const [node, flags] of frame.entries()) {
+			if (node === container) {
+				if ((flags & 128) !== 0) return "all";
+				continue;
+			}
+			const item = itemHolding(container, node);
+			if (item === null) continue;
+			const was = layer.items.get(item);
+			const now = boxOf(layout, item);
+			if (was !== void 0) boxes.push(was);
+			if (now !== void 0 && (was === void 0 || !sameBox(was, now))) boxes.push(now);
+		}
+		const seen = /* @__PURE__ */ new Set();
+		for (const item of itemsOf(container)) {
+			seen.add(item);
+			const now = boxOf(layout, item);
+			const was = layer.items.get(item);
+			if (now === void 0) continue;
+			if (was === void 0) boxes.push(now);
+			else if (!sameBox(was, now)) boxes.push(was, now);
+		}
+		for (const [item, was] of layer.items) if (!seen.has(item)) boxes.push(was);
+		const rects = [];
+		let area = 0;
+		for (const box of boxes) {
+			const rect = this.toLayer(layer, box);
+			if (rect !== null && !rects.some((other) => sameBox(other, rect))) {
+				rects.push(rect);
+				area += rect.width * rect.height;
+			}
+		}
+		return area > layer.width * layer.height * MOSTLY ? "all" : rects;
+	}
+	/** Notes where the container's items are, for the next frame's \`damage\`. */
+	remember(layer, container, layout) {
+		layer.items.clear();
+		for (const item of itemsOf(container)) {
+			const box = boxOf(layout, item);
+			if (box !== void 0) layer.items.set(item, box);
+		}
+	}
+	/** An item's box in the layer's pixels, widened for what paints past it, or null off the layer. */
+	toLayer(layer, box) {
+		const dpr = layer.dpr;
+		const left = Math.max(0, Math.floor(layer.offsetX + dpr * (box.x - layer.scrollX - 8)));
+		const top = Math.max(0, Math.floor(layer.offsetY + dpr * (box.y - layer.scrollY - 8)));
+		const right = Math.min(layer.width, Math.ceil(layer.offsetX + dpr * (box.x + box.width - layer.scrollX + 8)));
+		const bottom = Math.min(layer.height, Math.ceil(layer.offsetY + dpr * (box.y + box.height - layer.scrollY + 8)));
+		return right > left && bottom > top ? {
+			x: left,
+			y: top,
+			width: right - left,
+			height: bottom - top
+		} : null;
+	}
 	/** Stops building layers for a container until its subtree is next dirtied. */
 	refuse(node) {
 		this.drop(node);
@@ -20655,14 +21056,63 @@ var ScrollLayerCache = class {
 		this.refused.delete(node);
 	}
 };
-/** Whether an ancestor was dirtied by more than its own scroll: inherited paint reaches the subtree without saying so. */
+/**
+* Whether an ancestor's properties or environment changed. An inherited
+* value set on an ancestor marks every descendant that reads it as well
+* (the graph re-provides it), so what it changes inside the container
+* is damage like any other; this keeps the old caution for the rest.
+* An ancestor marked for paint alone is the runtime asking for a frame
+* (a scrollbar fading, an inspector outline), which nothing inside the
+* container hears; one laid out again either leaves the container where
+* it was or moves it, which \`fits\` hears about; one whose children
+* changed has changed nothing inside this one. The last two happen on
+* every frame a lazy list mounts a row, since a layout need is marked
+* all the way up.
+*/
 function dirtyAbove(frame, node) {
-	for (let ancestor = node.parent; ancestor !== null; ancestor = ancestor.parent) {
-		const flags = frame.dirtyFlagsFor(ancestor);
-		if (flags !== 0 && flags !== 32) return true;
-	}
+	for (let ancestor = node.parent; ancestor !== null; ancestor = ancestor.parent) if ((frame.dirtyFlagsFor(ancestor) & INHERITED) !== 0) return true;
+	return false;
+}
+/** What an ancestor's dirt can say about how its descendants look. */
+const INHERITED = 192;
+/** Whether \`ancestor\` is above \`node\` in the tree. */
+function contains(ancestor, node) {
+	for (let current = node.parent; current !== null; current = current.parent) if (current === ancestor) return true;
 	return false;
 }
+/** A container's items: its children, and the children of any fragment among them, in order. */
+function itemsOf(container) {
+	const items = [];
+	const visit = (parent) => {
+		for (let child = parent.firstChild; child !== null; child = child.nextSibling) if (child.type === "fragment") visit(child);
+		else items.push(child);
+	};
+	visit(container);
+	return items;
+}
+/** The item of a container that holds a node, the node itself if it is one, or null outside the container or above its items. */
+function itemHolding(container, node) {
+	let item = null;
+	for (let current = node; current !== null; current = current.parent) {
+		if (current === container) return item;
+		if (current.type !== "fragment") item = current;
+	}
+	return null;
+}
+function sameBox(a, b) {
+	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function boxOf(layout, node) {
+	const rec = layout.recordFor(node);
+	return rec === void 0 ? void 0 : {
+		x: rec.x,
+		y: rec.y,
+		width: rec.width,
+		height: rec.height
+	};
+}
+/** Damage over this share of a layer repaints all of it in one walk. */
+const MOSTLY = .5;
 /**
 * Where a scroll container's viewport lands in device pixels, or null
 * when a layer could not reproduce the direct draw exactly: no
@@ -20708,6 +21158,273 @@ function clearLayer(ctx, width, height) {
 	ctx.clearRect(0, 0, width, height);
 }
 //#endregion
+//#region src/rendering/canvas2d/TextRasterCache.ts
+/**
+* Text kept as pixels, so a frame that only moved it copies it rather
+* than drawing its glyphs again.
+*
+* **Why.** Drawing glyphs is most of what a frame of text costs:
+* profiled while flicking through a file in Easel, `fillText` was 1,064
+* of the renderer's 1,985 ms. A scroll moves every line on screen and
+* changes none of them, so every one of those glyphs was drawn again
+* only to land a few pixels from where it was. In WKWebView a frame of
+* that cost 4 to 7 ms, which is more than a 165 Hz refresh holds.
+*
+* **What is kept.** What `drawText` draws for one node, drawn once into
+* a canvas of its own at the device scale and fraction of a pixel it
+* lands on, and copied onto the frame from then on. The copy lands on
+* whole device pixels, so the pixels are the ones a direct draw at that
+* fraction would have made, and a scroll, which moves by whole device
+* pixels, keeps the fraction.
+*
+* **When it is drawn again.** When anything `drawText` reads changes:
+* the text, its runs, its font, its colour, its box, the scale, or the
+* fraction of a pixel it sits at. Each is compared every frame, which is
+* a few comparisons; a run list or a colour that has not changed is the
+* same object it was.
+*
+* **What it is not for.** Text that changes on most frames (a clock, a
+* counter, an animated colour) would be drawn twice a frame, into the
+* cache and out of it. A node redrawn on most of its recent frames is
+* drawn directly instead, until it has been still for a while.
+*/
+var TextRasterCache = class {
+	createCanvas;
+	entries = /* @__PURE__ */ new Map();
+	frame = 0;
+	pixels = 0;
+	/** Draws served from the cache and drawn into it, since the last reset. For budget specs. */
+	stats = {
+		copied: 0,
+		drawn: 0,
+		direct: 0
+	};
+	constructor(createCanvas) {
+		this.createCanvas = createCanvas;
+	}
+	beginFrame() {
+		this.frame++;
+	}
+	/** Lets go of text not drawn lately: removed, scrolled far away, or hidden. */
+	endFrame() {
+		for (const [node, entry] of this.entries) if (this.frame - entry.used > IDLE_FRAMES) this.drop(node, entry);
+	}
+	dropAll() {
+		for (const [node, entry] of this.entries) this.drop(node, entry);
+	}
+	resetStats() {
+		this.stats.copied = 0;
+		this.stats.drawn = 0;
+		this.stats.direct = 0;
+	}
+	/**
+	* Draws a node's text from the cache, drawing it into the cache first
+	* when what it holds is out of date. False when the text should be
+	* drawn directly: a context that cannot say where it draws, one that
+	* rotates or skews, text too large to keep, or text that changes too
+	* often to be worth keeping.
+	*/
+	draw(ctx, node, box, paint, measurer) {
+		const m = ctx.getTransform?.();
+		if (m === void 0 || m.b !== 0 || m.c !== 0 || !(m.a > 0) || !(m.d > 0)) return false;
+		let entry = this.entries.get(node);
+		if (entry !== void 0 && entry.directUntil > this.frame) {
+			entry.used = this.frame;
+			this.stats.direct++;
+			return false;
+		}
+		let extent = entry !== void 0 && entry.drawnFrom(paint, box, m.a, m.d) ? entry.extent : null;
+		if (extent === null) {
+			extent = inkExtent(box, paint, measurer);
+			if (extent === null) return false;
+		}
+		const left = m.a * (box.x + extent.left) + m.e;
+		const top = m.d * (box.y + extent.top) + m.f;
+		const x = Math.floor(left);
+		const y = Math.floor(top);
+		const width = Math.ceil(m.a * (extent.right - extent.left) + (left - x)) + 1;
+		const height = Math.ceil(m.d * (extent.bottom - extent.top) + (top - y)) + 1;
+		if (width * height > MAX_ENTRY_PIXELS) return false;
+		const offsetX = m.e - x;
+		const offsetY = m.f - y;
+		let raster = entry ?? null;
+		if (raster === null || !raster.holds(paint, box, m.a, m.d, offsetX, offsetY, width, height)) {
+			raster = this.redraw(node, entry, paint, box, measurer, m.a, m.d, offsetX, offsetY, width, height, extent);
+			if (raster === null) return false;
+		}
+		raster.used = this.frame;
+		ctx.save();
+		ctx.setTransform(1, 0, 0, 1, 0, 0);
+		ctx.drawImage(raster.canvas, x, y, raster.canvasWidth, raster.canvasHeight);
+		ctx.restore();
+		this.stats.copied++;
+		return true;
+	}
+	redraw(node, previous, paint, box, measurer, scaleX, scaleY, offsetX, offsetY, width, height, extent) {
+		let entry = previous;
+		if (entry !== void 0) {
+			entry.churn = this.frame - entry.drawnAt <= CHURN_FRAMES ? entry.churn + 1 : 0;
+			if (entry.churn >= CHURN_LIMIT) {
+				entry.churn = 0;
+				entry.directUntil = this.frame + DIRECT_FRAMES;
+				entry.used = this.frame;
+				this.stats.direct++;
+				return null;
+			}
+		}
+		if (entry === void 0 || entry.canvasWidth < width || entry.canvasHeight < height) {
+			const canvasWidth = Math.max(width, entry?.canvasWidth ?? 0);
+			const canvasHeight = Math.max(height, entry?.canvasHeight ?? 0);
+			const canvas = this.createCanvas(canvasWidth, canvasHeight);
+			const context = canvas?.getContext("2d");
+			if (canvas === null || !context) return null;
+			this.make(canvasWidth * canvasHeight);
+			if (entry !== void 0) {
+				this.pixels -= entry.canvasWidth * entry.canvasHeight;
+				entry.canvas = canvas;
+				entry.context = context;
+				entry.canvasWidth = canvasWidth;
+				entry.canvasHeight = canvasHeight;
+			} else {
+				entry = new TextRaster(canvas, context, canvasWidth, canvasHeight);
+				this.entries.set(node, entry);
+			}
+			this.pixels += canvasWidth * canvasHeight;
+		}
+		const context = entry.context;
+		context.setTransform(1, 0, 0, 1, 0, 0);
+		context.clearRect(0, 0, entry.canvasWidth, entry.canvasHeight);
+		context.setTransform(scaleX, 0, 0, scaleY, offsetX, offsetY);
+		context.globalAlpha = 1;
+		drawText(context, box, paint, measurer);
+		entry.remember(paint, box, scaleX, scaleY, offsetX, offsetY, width, height);
+		entry.extent = extent;
+		entry.drawnAt = this.frame;
+		this.stats.drawn++;
+		return entry;
+	}
+	/** Makes room for `needed` more pixels, letting go of what was drawn least recently. */
+	make(needed) {
+		if (this.pixels + needed <= MAX_PIXELS) return;
+		const byAge = [...this.entries].sort((a, b) => a[1].used - b[1].used);
+		for (const [node, entry] of byAge) {
+			if (this.pixels + needed <= MAX_PIXELS || entry.used === this.frame) break;
+			this.drop(node, entry);
+		}
+	}
+	drop(node, entry) {
+		this.entries.delete(node);
+		this.pixels -= entry.canvasWidth * entry.canvasHeight;
+		entry.canvas.width = 0;
+		entry.canvas.height = 0;
+	}
+};
+/** One node's text as pixels, and what it was drawn from. */
+var TextRaster = class {
+	canvas;
+	context;
+	canvasWidth;
+	canvasHeight;
+	used = 0;
+	drawnAt = 0;
+	churn = 0;
+	directUntil = 0;
+	/** Where the ink reaches, from the box's corner, in layout pixels. */
+	extent = null;
+	text;
+	spans;
+	font = "";
+	color = "";
+	style = "";
+	linkHover = 0;
+	boxWidth = 0;
+	boxHeight = 0;
+	scaleX = 0;
+	scaleY = 0;
+	offsetX = 0;
+	offsetY = 0;
+	width = 0;
+	height = 0;
+	constructor(canvas, context, canvasWidth, canvasHeight) {
+		this.canvas = canvas;
+		this.context = context;
+		this.canvasWidth = canvasWidth;
+		this.canvasHeight = canvasHeight;
+	}
+	holds(paint, box, scaleX, scaleY, offsetX, offsetY, width, height) {
+		return this.drawnFrom(paint, box, scaleX, scaleY) && Math.abs(this.offsetX - offsetX) < SAME_PLACE && Math.abs(this.offsetY - offsetY) < SAME_PLACE && this.width === width && this.height === height;
+	}
+	/** Whether the pixels are of this text, in this style, at this size and scale, wherever they are. */
+	drawnFrom(paint, box, scaleX, scaleY) {
+		return this.text === paint.text && this.spans === paint.spans && this.linkHover === paint.linkHover && this.boxWidth === box.width && this.boxHeight === box.height && this.scaleX === scaleX && this.scaleY === scaleY && this.font === fontOf(paint) && this.color === colorToCss(paint.textColor) && this.style === styleOf(paint);
+	}
+	remember(paint, box, scaleX, scaleY, offsetX, offsetY, width, height) {
+		this.text = paint.text;
+		this.spans = paint.spans;
+		this.linkHover = paint.linkHover;
+		this.boxWidth = box.width;
+		this.boxHeight = box.height;
+		this.scaleX = scaleX;
+		this.scaleY = scaleY;
+		this.offsetX = offsetX;
+		this.offsetY = offsetY;
+		this.width = width;
+		this.height = height;
+		this.font = fontOf(paint);
+		this.color = colorToCss(paint.textColor);
+		this.style = styleOf(paint);
+	}
+};
+/**
+* The lines' extent, and a margin for what glyphs reach past their line
+* box (an italic's lean, a descender below a tight line height, an
+* underline). Null for text that draws nothing.
+*/
+function inkExtent(box, paint, measurer) {
+	const placements = layoutTextLines(box, paint, measurer);
+	if (placements.length === 0) return null;
+	let left = Infinity;
+	let top = Infinity;
+	let right = -Infinity;
+	let bottom = -Infinity;
+	for (const line of placements) {
+		left = Math.min(left, line.x);
+		top = Math.min(top, line.y);
+		right = Math.max(right, line.x + line.width);
+		bottom = Math.max(bottom, line.y + line.height);
+	}
+	const margin = Math.ceil(paint.fontSize * INK_MARGIN) + 2;
+	return {
+		left: left - box.x - margin,
+		top: top - box.y - margin,
+		right: right - box.x + margin,
+		bottom: bottom - box.y + margin
+	};
+}
+function fontOf(paint) {
+	return `${paint.fontStyle} ${paint.fontVariant} ${paint.fontWeight} ${paint.fontStretch} ${paint.fontSize}/${paint.lineHeight} ${paint.fontFamily}`;
+}
+/** Everything else `drawText` reads that places or decorates the glyphs. */
+function styleOf(paint) {
+	return `${paint.letterSpacing}|${paint.fontKerning}|${paint.textDecoration}|${paint.textAlign}|${paint.verticalAlign}|${paint.textWrap}|${paint.maxLines}|${paint.textOverflow}|${paint.rtl}`;
+}
+/** How far past its line box, as a share of the font size, a glyph's ink may reach. */
+const INK_MARGIN = .5;
+/** Within this much of a device pixel, text is at the same place. */
+const SAME_PLACE = 1 / 256;
+/** The largest single piece of text kept: a few screens of a long paragraph. */
+const MAX_ENTRY_PIXELS = 4e6;
+/** Everything kept, at most: about 128 MB. */
+const MAX_PIXELS = 32e6;
+/** Frames text is kept for without being drawn: about two seconds at 60 Hz. */
+const IDLE_FRAMES = 120;
+/** Drawn again within this many frames of the last time counts toward churn. */
+const CHURN_FRAMES = 2;
+/** Times in a row text may churn before it is drawn directly. */
+const CHURN_LIMIT = 3;
+/** Frames churning text is drawn directly for before the cache tries it again. */
+const DIRECT_FRAMES = 60;
+//#endregion
 //#region src/rendering/canvas2d/Canvas2DRenderer.ts
 /**
 * Canvas2D rendering backend.
@@ -20819,6 +21536,13 @@ var Canvas2DRenderer = class {
 	constructor(options) {
 		this.options = options;
 		this.layers = new ScrollLayerCache(options.createLayerCanvas ?? offscreenLayerCanvas, options.scrollLayerSettleFrames);
+		this.textCache = options.textCache === false ? null : new TextRasterCache(options.createLayerCanvas ?? offscreenLayerCanvas);
+	}
+	/** Text kept as pixels; see `TextRasterCache.ts`. */
+	textCache;
+	/** What the text cache did since the last reset, or null with it off. For budget specs. */
+	get textCacheStats() {
+		return this.textCache?.stats ?? null;
 	}
 	/** What the scroll layers did since the last reset. For budget specs. */
 	get scrollLayerStats() {
@@ -20844,11 +21568,13 @@ var Canvas2DRenderer = class {
 	/** A restored scroll layer reads as healthy and holds nothing. */
 	surfaceRestored() {
 		this.layers.dropAll();
+		this.textCache?.dropAll();
 	}
 	dispose() {
 		this.disposed = true;
 		this.scaledImages.dispose();
 		this.layers.dropAll();
+		this.textCache?.dropAll();
 	}
 	render(root, context) {
 		const raw = this.surface.getContext2D();
@@ -20862,11 +21588,13 @@ var Canvas2DRenderer = class {
 		this.liftedPass.length = 0;
 		this.paintOwner = null;
 		this.layerDepth = 0;
+		this.textCache?.beginFrame();
 		this.layers.beginFrame(this.options.scrollLayers === false ? void 0 : context.changes, this.surface.dpr, this.surface.physicalWidth, this.surface.physicalHeight);
 		this.renderNode(root, context, ctx, true, false);
 		this.renderLifted(context, ctx);
 		if (context.overlay !== void 0 && context.overlay.length > 0) drawOverlayShapes(ctx, context.overlay);
 		this.layers.endFrame();
+		this.textCache?.endFrame();
 	}
 	/**
 	* Folds a node's style into the shared scratch and records that it
@@ -20931,7 +21659,7 @@ var Canvas2DRenderer = class {
 		if (rec.clips) this.popCull();
 		if (hasText) {
 			if (this.paintOwner !== node) this.resolvePaint(node);
-			this.paintContent(ctx, rec, this.paint, context);
+			this.paintContent(ctx, node, rec, this.paint, context);
 		}
 		if (rec.liftBoundary && this.liftedPass.length > liftedBefore) this.renderLifted(context, ctx, liftedBefore, node);
 		if (rec.clips) ctx.restore();
@@ -21205,7 +21933,7 @@ var Canvas2DRenderer = class {
 			} else ctx.strokeRect(x, y, width, height);
 		}
 	}
-	paintContent(ctx, rec, paint, context) {
+	paintContent(ctx, node, rec, paint, context) {
 		if (paint.text !== void 0) {
 			this.contentBox.x = rec.x + rec.paddingLeft - rec.scrollX;
 			this.contentBox.y = rec.y + rec.paddingTop - rec.scrollY;
@@ -21219,6 +21947,7 @@ var Canvas2DRenderer = class {
 				this.paintHighlightedText(ctx, paint, context);
 				return;
 			}
+			if (this.textCache?.draw(ctx, node, this.contentBox, paint, context.text) === true) return;
 			drawText(ctx, this.contentBox, paint, context.text);
 		}
 	}
@@ -21320,8 +22049,21 @@ var Canvas2DRenderer = class {
 				layers.drop(node);
 				return false;
 			}
-			for (const strip of strips) this.paintLayer(layer, strip, node, rec, context);
+			const damage = layers.damage(layer, node, context.layout);
+			const wrong = damage === "all" ? [{
+				x: 0,
+				y: 0,
+				width: layer.width,
+				height: layer.height
+			}] : damage;
+			if (wrong.length > 0) {
+				const front = layer.frontContext;
+				front.setTransform(1, 0, 0, 1, 0, 0);
+				for (const rect of wrong) front.clearRect(rect.x, rect.y, rect.width, rect.height);
+			}
+			if (strips.length > 0 || wrong.length > 0) this.paintLayer(layer, [...strips, ...wrong], node, rec, context);
 		}
+		layers.remember(layer, node, context.layout);
 		layer.used = true;
 		layers.stats.composited++;
 		ctx.save();
@@ -21343,13 +22085,13 @@ var Canvas2DRenderer = class {
 	* strip saves is raster, which is the cost it exists for; the walk
 	* costs what a direct draw's walk would.
 	*/
-	paintLayer(layer, strip, node, rec, context) {
+	paintLayer(layer, strips, node, rec, context) {
 		const lctx = new PreciseContext(layer.frontContext);
 		lctx.save();
-		if (strip !== null) {
+		if (strips !== null) {
 			lctx.setTransform(1, 0, 0, 1, 0, 0);
 			lctx.beginPath();
-			lctx.rect(strip.x, strip.y, strip.width, strip.height);
+			for (const strip of strips) lctx.rect(strip.x, strip.y, strip.width, strip.height);
 			lctx.clip();
 		}
 		const dpr = layer.dpr;
@@ -21363,6 +22105,26 @@ var Canvas2DRenderer = class {
 		this.cullY = rec.y + layer.scrollY;
 		this.cullWidth = rec.width;
 		this.cullHeight = rec.height;
+		if (strips !== null && strips.length > 0) {
+			let left = Infinity;
+			let top = Infinity;
+			let right = -Infinity;
+			let bottom = -Infinity;
+			for (const strip of strips) {
+				left = Math.min(left, strip.x);
+				top = Math.min(top, strip.y);
+				right = Math.max(right, strip.x + strip.width);
+				bottom = Math.max(bottom, strip.y + strip.height);
+			}
+			const x0 = Math.max(this.cullX, (left - layer.offsetX) / dpr + layer.scrollX - 8);
+			const y0 = Math.max(this.cullY, (top - layer.offsetY) / dpr + layer.scrollY - 8);
+			const x1 = Math.min(this.cullX + this.cullWidth, (right - layer.offsetX) / dpr + layer.scrollX + 8);
+			const y1 = Math.min(this.cullY + this.cullHeight, (bottom - layer.offsetY) / dpr + layer.scrollY + 8);
+			this.cullX = x0;
+			this.cullY = y0;
+			this.cullWidth = Math.max(0, x1 - x0);
+			this.cullHeight = Math.max(0, y1 - y0);
+		}
 		this.layerDepth++;
 		try {
 			this.renderChildren(node, context, lctx, true);
@@ -21571,6 +22333,6 @@ function createCanvasSurface(host) {
 	return new CanvasSurface(host);
 }
 //#endregion
-export { isImeKey as $, MOUSE_POINTER as $a, spacingEqual as $i, ELLIPSIS as $n, transformsEqual as $r, registerFontStack as $t, withOverrideSource as A, colorToHex as Aa, observeViewportInsets as Ai, clearLinkHover as An, inheritedPropertyNames as Ar, adjacentField as At, FlexDirection as B, UiEnvironment as Ba, defineThemeExtension as Bi, editorFor as Bn, normalizeStates as Br, createCanvasTextStyle as Bt, SCROLLBAR_LINGER_MS as C, textContentOf as Ca, uniformBorderRadius as Ci, isNodeInert as Cn, resolveProperty as Cr, hasDrawnText as Ct, formatExplanation as D, darkColors as Da, UiInsetRegistry as Di, isSubtreeInert as Dn, findPropertyDefinition as Dr, selectionRectsIn as Dt, formatConstraints as E, colorsEqualPalette as Ea, UiEnvironmentKeys as Ei, isPressable as En, closestPropertyName as Er, paragraphGeometryFrom as Et, clampSize as F, parseColor as Fa, darkTheme as Fi, setLinkHover as Fn, UiProperties as Fr, detectEditingPlatform as Ft, CrossAxisAlignment as G, resetOverrideWarnings as Ga, withThemeExtension as Gi, nextCaretToggle as Gn, validateSubgrid as Gr, runFontString as Gt, placeGridItems as H, DirtyNodeSet as Ha, noThemeExtensions as Hi, isEditableNode as Hn, validateRole as Hr, fillTextRects as Ht, constraintsEqual as I, rgb8 as Ia, lightTheme as Ii, CARET_BLINK_MS as In, UI_ROLES as Ir, isPrintable as It, parseCrossAxisAlignment as J, UiVisualState as Ja, raiseContrast as Ji, isVideoSurface as Jn, pathValuesEqual as Jr, textRunBackgrounds as Jt, MainAxisAlignment as K, writeDeclaredProperty as Ka, contrastRatio as Ki, syncEditorValue as Kn, inputsEqual as Kr, spanOf as Kt, tightenConstraints as L, rgba as La, themesEqual as Li, CARET_WIDTH as Ln, UI_SEMANTIC_STATES as Lr, EditableLayout as Lt, contentOffset as M, colorValuesEqual as Ma, bandOf as Mi, linkHoverOf as Mn, propertyIsInherited as Mr, edgeField as Mt, LayoutRecord as N, colorsEqual as Na, containerBands as Ni, linkOf as Nn, propertyNarrowers as Nr, editingGroupOf as Nt, formatNumber as O, lightColors as Oa, insetsEqual as Oi, pointerEventsOf as On, getPropertyNames as Or, wordRangeIn as Ot, Constraints as P, normalizeColor as Pa, unknownContainerSize as Pi, linkRunAtPointIn as Pn, propertyValuesEqualByName as Pr, commandForKey as Pt, capturePointer as Q, visualStatesEqual as Qa, scaleSpacing as Qi, spannedRunsFor as Qn, transformIsIdentity as Qr, fontStackFor as Qt, MAX_MEASURES_PER_CHILD as R, createEnvironmentKey as Ra, withContrast as Ri, EDITOR_PROP as Rn, isUiRole as Rr, applyCanvasTextStyle as Rt, SCROLLBAR_FADE_MS as S, spansDifferOnlyInPaint as Sa, normalizeBorderRadius as Si, isNodeHitTestable as Sn, resolveNumber as Sr, UiInputDispatcher as St, describeOverrides as T, textStylesEqual as Ta, propertyValuesEqual as Ti, isNodeTabStop as Tn, resolveString as Tr, paragraphGeometry as Tt, sizeGridTracks as U, clearOverrideProperty as Ua, themeExtension as Ui, isMultiline as Un, validateStates as Ur, layoutTextLines as Ut, parseFlexDirection as V, UiNode as Va, hasThemeExtension as Vi, editorOf as Vn, statesEqual as Vr, drawText as Vt, AlignContent as W, overrideSources as Wa, themeExtensionsEqual as Wi, isReadOnly as Wn, UI_SUBGRID_AXES as Wr, runCanvasStyleInto as Wt, CanvasPlatformSurface as X, hasVisualState as Xa, densityFactors as Xi, CharacterCountTextMeasurer as Xn, parseTransform as Xr, bumpFontStack as Xt, parseMainAxisAlignment as Y, defaultVisualState as Ya, relativeLuminance as Yi, videoFrameSize as Yn, UiTransforms as Yr, textRunDecorations as Yt, UiPlatformAdapter as Z, visualState as Za, defaultSpacing as Zi, ParagraphTextMeasurer as Zn, transform as Zr, clearFontStacks as Zt, LABEL_PADDING_X as _, flattenTextSpans as _a, borderRadius as _i, selectableTextNodes as _n, DirtyFlags as _o, previousWordStart as _r, scrollLeaderOf as _t, PaintPictureCache as a, boxShadowArraysEqual as aa, validateGradient as ai, computeObjectFitRect as an, UiInputEvent as ao, lineLimit as ar, UiGestureRecognizer as at, snapScroll as b, spanAtOffset as ba, borderRadiusIsZero as bi, setSelectionRange as bn, DEFAULT_LINE_HEIGHT_FACTOR as br, scrollbarThumbs as bt, EMPTY_RECORDING as c, boxShadowsEqual as ca, isAutoLength as ci, normalizeTextAlign as cn, UiPinchEvent as co, offsetForVerticalMove as cr, isScrollContainer as ct, tracePathData as d, shapesEqual as da, isPercentLength as di, TEXT_MATCHES_PROP as dn, UiTextChangeEvent as do, graphemeBoundaries as dr, UiFocusManager as dt, spacingSteps as ea, MAX_GRADIENT_STOPS as ei, DEFAULT_FONT_FAMILY as en, UiBeforeInputEvent as eo, layoutParagraph as er, pointerDeviceOf as et, ScaledImageCache as f, defaultTypography as fa, minmax as fi, clearMatchRanges as fn, UiWheelDeltaMode as fo, lineEndAt as fr, UiHitTester as ft, paintsAfterChildren as g, editableSpansOf as ga, UiBorderRadiuses as gi, clearSelectionRange as gn, UiNodeType as go, previousGraphemeStart as gr, SCROLLBAR_THICKNESS as gt, hasDecorationPhase as h, defaultTextStyle as ha, resolveLength as hi, TEXT_SELECTION_PROP as hn, wheelDeltaYOf as ho, nextWordEnd as hr, SCROLLBAR_MIN_THUMB as ht, traceRoundedRect as i, boxShadow as ia, radialGradient as ii, colorToCss as in, UiGestureEvent as io, lineIndexForOffset as ir, UiTouchScroller as it, accumulatedOffsetTo as j, colorToRgba as ja, UiContainerSizeSource as ji, hasTextLinks as jn, propertyEffects as jr, comparePositions as jt, labelNode as k, UiBasicColors as ka, noInsets as ki, resolveCursor as kn, inheritedPropertyFlags as kr, textInputOf as kt, PaintRecorder as l, defaultShapes as la, isFrLength as li, normalizeVerticalAlign as ln, UiPointerEvent as lo, selectionRects as lr, UiKeyboardController as lt, decorationRect as m, typographyEqual as ma, repeat as mi, setMatchRanges as mn, noKeyModifiers as mo, nextGraphemeEnd as mr, SCROLLBAR_INSET as mt, createCanvasSurface as n, shadowsEqual as na, gradientsEqual as ni, DEFAULT_FONT_WEIGHT as nn, UiEventType as no, caretRectFor as nr, touchActionFor as nt, paintPictures as o, boxShadowRadius as oa, auto as oi, createPaintState as on, UiKeyboardEvent as oo, offsetAtPoint as or, UiPinchRecognizer as ot, decorationColor as p, isTypographyRole as pa, percent as pi, matchRangesOf as pn, UiWheelEvent as po, lineStartAt as pr, SCROLLBAR_HOVER_ZONE as pt, parseAlignContent as q, writeOverrideProperty as qa, highContrastColors as qi, resolveColorValue as qn, paintValuesEqual as qr, textMeasureRequest as qt, Canvas2DRenderer as r, BOX_SHADOW_BLUR_REACH as ra, linearGradient as ri, DEFAULT_TEXT_COLOR as rn, UiFocusEvent as ro, lineIndexAtY as rr, UiEditingController as rt, PaintTarget as s, boxShadowReach as sa, fr as si, isPaintVisible as sn, UiPasteEvent as so, offsetAtX as sr, UiWheelController as st, CanvasSurface as t, defaultShadows as ta, gradientPaint as ti, DEFAULT_FONT_SIZE as tn, UiCompositionEvent as to, proportionalFontMetrics as tr, prepareInputSurface as tt, replayPaint as u, isShapeName as ua, isMinMaxTrack as ui, resolvePaintState as un, UiSelectionChangeEvent as uo, EditableTextModel as ur, UiPointerController as ut, drawOverlayShapes as v, hiddenRangesOf as va, borderRadiusCorners as vi, selectableTextOf as vn, UiBinding as vo, wordRangeAt as vr, scrollRange as vt, describeLength as w, textSpansEqual as wa, defineProperty as wi, isNodeSelectable as wn, resolvePropertyByName as wr, offsetAtPointIn as wt, LayoutEngine as x, spannedTextOf as xa, borderRadiusValuesEqual as xi, isNodeFocusable as xn, resolveBoolean as xr, scrollbarZoneAt as xt, labelOrigin as y, resolvedSpansOf as ya, borderRadiusEqual as yi, selectionRangeOf as yn, UiGraph as yr, scrollbarThumb as yt, isLayoutProtocol as z, findEnvironmentKey as za, withDensity as zi, caretVisibleAt as zn, isUiSemanticState as zr, buildFontString as zt };
+export { isImeKey as $, visualStatesEqual as $a, scaleSpacing as $i, spannedRunsFor as $n, transformIsIdentity as $r, registerFontStack as $t, withOverrideSource as A, UiBasicColors as Aa, noInsets as Ai, clearLinkHover as An, inheritedPropertyFlags as Ar, adjacentField as At, FlexDirection as B, findEnvironmentKey as Ba, withDensity as Bi, editorFor as Bn, isUiSemanticState as Br, createCanvasTextStyle as Bt, SCROLLBAR_LINGER_MS as C, spansDifferOnlyInPaint as Ca, normalizeBorderRadius as Ci, isNodeInert as Cn, resolveNumber as Cr, hasDrawnText as Ct, formatExplanation as D, colorsEqualPalette as Da, UiEnvironmentKeys as Di, isSubtreeInert as Dn, closestPropertyName as Dr, selectionRectsIn as Dt, formatConstraints as E, textStylesEqual as Ea, propertyValuesEqual as Ei, isPressable as En, resolveString as Er, paragraphGeometryFrom as Et, clampSize as F, normalizeColor as Fa, unknownContainerSize as Fi, setLinkHover as Fn, propertyValuesEqualByName as Fr, detectEditingPlatform as Ft, CrossAxisAlignment as G, overrideSources as Ga, themeExtensionsEqual as Gi, maskText as Gn, UI_SUBGRID_AXES as Gr, runFontString as Gt, placeGridItems as H, UiNode as Ha, hasThemeExtension as Hi, isEditableNode as Hn, statesEqual as Hr, fillTextRects as Ht, constraintsEqual as I, parseColor as Ia, darkTheme as Ii, CARET_BLINK_MS as In, UiProperties as Ir, isPrintable as It, parseCrossAxisAlignment as J, writeOverrideProperty as Ja, highContrastColors as Ji, resolveColorValue as Jn, paintValuesEqual as Jr, textRunBackgrounds as Jt, MainAxisAlignment as K, resetOverrideWarnings as Ka, withThemeExtension as Ki, nextCaretToggle as Kn, validateSubgrid as Kr, spanOf as Kt, tightenConstraints as L, rgb8 as La, lightTheme as Li, CARET_WIDTH as Ln, UI_ROLES as Lr, EditableLayout as Lt, contentOffset as M, colorToRgba as Ma, UiContainerSizeSource as Mi, linkHoverOf as Mn, propertyEffects as Mr, edgeField as Mt, LayoutRecord as N, colorValuesEqual as Na, bandOf as Ni, linkOf as Nn, propertyIsInherited as Nr, editingGroupOf as Nt, formatNumber as O, darkColors as Oa, UiInsetRegistry as Oi, pointerEventsOf as On, findPropertyDefinition as Or, wordRangeIn as Ot, Constraints as P, colorsEqual as Pa, containerBands as Pi, linkRunAtPointIn as Pn, propertyNarrowers as Pr, commandForKey as Pt, capturePointer as Q, visualState as Qa, defaultSpacing as Qi, ParagraphTextMeasurer as Qn, transform as Qr, fontStackFor as Qt, MAX_MEASURES_PER_CHILD as R, rgba as Ra, themesEqual as Ri, EDITOR_PROP as Rn, UI_SEMANTIC_STATES as Rr, applyCanvasTextStyle as Rt, SCROLLBAR_FADE_MS as S, spannedTextOf as Sa, borderRadiusValuesEqual as Si, isNodeHitTestable as Sn, resolveBoolean as Sr, UiInputDispatcher as St, describeOverrides as T, textSpansEqual as Ta, defineProperty as Ti, isNodeTabStop as Tn, resolvePropertyByName as Tr, paragraphGeometry as Tt, sizeGridTracks as U, DirtyNodeSet as Ua, noThemeExtensions as Ui, isMultiline as Un, validateRole as Ur, layoutTextLines as Ut, parseFlexDirection as V, UiEnvironment as Va, defineThemeExtension as Vi, editorOf as Vn, normalizeStates as Vr, drawText as Vt, AlignContent as W, clearOverrideProperty as Wa, themeExtension as Wi, isReadOnly as Wn, validateStates as Wr, runCanvasStyleInto as Wt, CanvasPlatformSurface as X, defaultVisualState as Xa, relativeLuminance as Xi, videoFrameSize as Xn, UiTransforms as Xr, bumpFontStack as Xt, parseMainAxisAlignment as Y, UiVisualState as Ya, raiseContrast as Yi, isVideoSurface as Yn, pathValuesEqual as Yr, textRunDecorations as Yt, UiPlatformAdapter as Z, hasVisualState as Za, densityFactors as Zi, CharacterCountTextMeasurer as Zn, parseTransform as Zr, clearFontStacks as Zt, LABEL_PADDING_X as _, editableSpansOf as _a, UiBorderRadiuses as _i, selectableTextNodes as _n, UiNodeType as _o, previousGraphemeStart as _r, scrollLeaderOf as _t, PaintPictureCache as a, boxShadow as aa, radialGradient as ai, computeObjectFitRect as an, UiGestureEvent as ao, lineIndexForOffset as ar, UiGestureRecognizer as at, snapScroll as b, resolvedSpansOf as ba, borderRadiusEqual as bi, setSelectionRange as bn, UiGraph as br, scrollbarThumbs as bt, EMPTY_RECORDING as c, boxShadowReach as ca, fr as ci, normalizeTextAlign as cn, UiPasteEvent as co, offsetAtX as cr, isScrollContainer as ct, tracePathData as d, isShapeName as da, isMinMaxTrack as di, TEXT_MATCHES_PROP as dn, UiSelectionChangeEvent as do, EditableTextModel as dr, UiFocusManager as dt, spacingEqual as ea, transformsEqual as ei, DEFAULT_FONT_FAMILY as en, MOUSE_POINTER as eo, ELLIPSIS as er, pointerDeviceOf as et, ScaledImageCache as f, shapesEqual as fa, isPercentLength as fi, clearMatchRanges as fn, UiTextChangeEvent as fo, graphemeBoundaries as fr, UiHitTester as ft, paintsAfterChildren as g, defaultTextStyle as ga, resolveLength as gi, clearSelectionRange as gn, wheelDeltaYOf as go, nextWordEnd as gr, SCROLLBAR_THICKNESS as gt, hasDecorationPhase as h, typographyEqual as ha, repeat as hi, TEXT_SELECTION_PROP as hn, noKeyModifiers as ho, nextGraphemeEnd as hr, SCROLLBAR_MIN_THUMB as ht, traceRoundedRect as i, BOX_SHADOW_BLUR_REACH as ia, linearGradient as ii, colorToCss as in, UiFocusEvent as io, lineIndexAtY as ir, UiTouchScroller as it, accumulatedOffsetTo as j, colorToHex as ja, observeViewportInsets as ji, hasTextLinks as jn, inheritedPropertyNames as jr, comparePositions as jt, labelNode as k, lightColors as ka, insetsEqual as ki, resolveCursor as kn, getPropertyNames as kr, textInputOf as kt, PaintRecorder as l, boxShadowsEqual as la, isAutoLength as li, normalizeVerticalAlign as ln, UiPinchEvent as lo, offsetForVerticalMove as lr, UiKeyboardController as lt, decorationRect as m, isTypographyRole as ma, percent as mi, setMatchRanges as mn, UiWheelEvent as mo, lineStartAt as mr, SCROLLBAR_INSET as mt, createCanvasSurface as n, defaultShadows as na, gradientPaint as ni, DEFAULT_FONT_WEIGHT as nn, UiCompositionEvent as no, proportionalFontMetrics as nr, touchActionFor as nt, paintPictures as o, boxShadowArraysEqual as oa, validateGradient as oi, createPaintState as on, UiInputEvent as oo, lineLimit as or, UiPinchRecognizer as ot, decorationColor as p, defaultTypography as pa, minmax as pi, matchRangesOf as pn, UiWheelDeltaMode as po, lineEndAt as pr, SCROLLBAR_HOVER_ZONE as pt, parseAlignContent as q, writeDeclaredProperty as qa, contrastRatio as qi, syncEditorValue as qn, inputsEqual as qr, textMeasureRequest as qt, Canvas2DRenderer as r, shadowsEqual as ra, gradientsEqual as ri, DEFAULT_TEXT_COLOR as rn, UiEventType as ro, caretRectFor as rr, UiEditingController as rt, PaintTarget as s, boxShadowRadius as sa, auto as si, isPaintVisible as sn, UiKeyboardEvent as so, offsetAtPoint as sr, UiWheelController as st, CanvasSurface as t, spacingSteps as ta, MAX_GRADIENT_STOPS as ti, DEFAULT_FONT_SIZE as tn, UiBeforeInputEvent as to, layoutParagraph as tr, prepareInputSurface as tt, replayPaint as u, defaultShapes as ua, isFrLength as ui, resolvePaintState as un, UiPointerEvent as uo, selectionRects as ur, UiPointerController as ut, drawOverlayShapes as v, flattenTextSpans as va, borderRadius as vi, selectableTextOf as vn, DirtyFlags as vo, previousWordStart as vr, scrollRange as vt, describeLength as w, textContentOf as wa, uniformBorderRadius as wi, isNodeSelectable as wn, resolveProperty as wr, offsetAtPointIn as wt, LayoutEngine as x, spanAtOffset as xa, borderRadiusIsZero as xi, isNodeFocusable as xn, DEFAULT_LINE_HEIGHT_FACTOR as xr, scrollbarZoneAt as xt, labelOrigin as y, hiddenRangesOf as ya, borderRadiusCorners as yi, selectionRangeOf as yn, UiBinding as yo, wordRangeAt as yr, scrollbarThumb as yt, isLayoutProtocol as z, createEnvironmentKey as za, withContrast as zi, caretVisibleAt as zn, isUiRole as zr, buildFontString as zt };
 
-//# sourceMappingURL=CanvasSurface-tAao5BLh.js.map
+//# sourceMappingURL=CanvasSurface-BAhcLj2K.js.map