gesso-core 0.6.20 → 0.6.22

package/dist/{CanvasSurface-VUJRrcXl.js → CanvasSurface-BxHC-NQ8.js}

@@ -881,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
@@ -929,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
@@ -1613,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;
@@ -4219,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",
@@ -4966,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;
@@ -5473,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;
 		}
@@ -6848,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
@@ -6914,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) {
@@ -6923,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);
 			}
@@ -6997,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()
 	};
@@ -7013,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 = [];
@@ -7313,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.
@@ -7336,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) {
@@ -7364,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
@@ -7371,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
@@ -7629,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);
@@ -7659,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
@@ -7702,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. */
@@ -7904,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
 	});
@@ -7912,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.
@@ -7982,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;
@@ -8092,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);
@@ -8554,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,
@@ -8881,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
@@ -8908,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
@@ -8924,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
@@ -10157,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;
@@ -12099,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) {
@@ -12272,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, "");
@@ -12477,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);
@@ -12542,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,
@@ -12812,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
@@ -12972,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) {
@@ -14142,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.
 	*
@@ -14257,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.
 	*
@@ -14270,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
@@ -14285,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;
@@ -14319,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;
@@ -14337,12 +14526,6 @@ var LayoutRecord = class {
 		this.paintReachTop = 0;
 		this.paintReachRight = 0;
 		this.paintReachBottom = 0;
-		this.scrollable = false;
-		this.scrollsText = false;
-		this.hidesScrollbars = false;
-		this.textScrollbars = false;
-		this.mirrored = false;
-		this.sticky = false;
 		this.stickyOffsetX = 0;
 		this.stickyOffsetY = 0;
 		this.scrollbarVisibleUntil = 0;
@@ -14361,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;
@@ -14371,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. */
@@ -15267,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
@@ -15308,6 +15499,14 @@ var LayoutEngine = class {
 		return this.records.get(node);
 	}
 	/**
+	* Every `position: 'sticky'` node in the tree. A sticky node moves
+	* with a scroll without its box moving, so a renderer keeping a
+	* scroll container's pixels has to be told where they are.
+	*/
+	allStickyNodes() {
+		return this.stickyNodes;
+	}
+	/**
 	* A box around everything in a node's subtree that could take a
 	* point, so a hit test can pass the subtree over instead of
 	* descending into it. Undefined for a node with no record, and
@@ -17105,37 +17304,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);
@@ -18318,7 +18559,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);
@@ -18371,9 +18633,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
@@ -20645,7 +20909,8 @@ var ScrollLayerCache = class {
 			scrollX: snapScroll(rec.scrollX, this.dpr),
 			scrollY: snapScroll(rec.scrollY, this.dpr),
 			used: true,
-			items: /* @__PURE__ */ new Map()
+			items: /* @__PURE__ */ new Map(),
+			stuck: /* @__PURE__ */ new Map()
 		};
 		this.layers.set(node, layer);
 		this.stats.built++;
@@ -20745,6 +21010,14 @@ var ScrollLayerCache = class {
 			else if (!sameBox(was, now)) boxes.push(was, now);
 		}
 		for (const [item, was] of layer.items) if (!seen.has(item)) boxes.push(was);
+		const stuck = stuckIn(container, layout);
+		if (stuck === null) return "all";
+		for (const [node, now] of stuck) {
+			const was = layer.stuck.get(node);
+			if (was === void 0) boxes.push(now);
+			else if (!sameBox(was, now)) boxes.push(was, now);
+		}
+		for (const [node, was] of layer.stuck) if (!stuck.has(node)) boxes.push(was);
 		const rects = [];
 		let area = 0;
 		for (const box of boxes) {
@@ -20763,6 +21036,7 @@ var ScrollLayerCache = class {
 			const box = boxOf(layout, item);
 			if (box !== void 0) layer.items.set(item, box);
 		}
+		layer.stuck = stuckIn(container, layout) ?? /* @__PURE__ */ new Map();
 	}
 	/** An item's box in the layer's pixels, widened for what paints past it, or null off the layer. */
 	toLayer(layer, box) {
@@ -20843,6 +21117,42 @@ function itemHolding(container, node) {
 	}
 	return null;
 }
+/**
+* Where each sticky node inside a container is drawn, in the
+* container's children's coordinates: its box moved by its own shift
+* and by every sticky ancestor's up to the container. Null when the
+* reader cannot say which nodes are sticky, which no layer can survive.
+*/
+function stuckIn(container, layout) {
+	const sticky = layout.allStickyNodes?.();
+	if (sticky === void 0) return null;
+	const drawn = /* @__PURE__ */ new Map();
+	for (const node of sticky) {
+		const rec = layout.recordFor(node);
+		if (rec === void 0) continue;
+		let x = rec.x + rec.stickyOffsetX;
+		let y = rec.y + rec.stickyOffsetY;
+		let inside = false;
+		for (let current = node.parent; current !== null; current = current.parent) {
+			if (current === container) {
+				inside = true;
+				break;
+			}
+			const above = layout.recordFor(current);
+			if (above !== void 0) {
+				x += above.stickyOffsetX;
+				y += above.stickyOffsetY;
+			}
+		}
+		if (inside) drawn.set(node, {
+			x,
+			y,
+			width: rec.width,
+			height: rec.height
+		});
+	}
+	return drawn;
+}
 function sameBox(a, b) {
 	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
 }
@@ -22077,6 +22387,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-VUJRrcXl.js.map
+//# sourceMappingURL=CanvasSurface-BxHC-NQ8.js.map