gesso-core 0.6.21 → 0.6.23

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # gesso-core
 
+## 0.6.23
+
+### Patch Changes
+
+- ae5a84e: A flex or grid container placed in the box its measurement already used no longer lays its children out a second time: placement takes the lines (or the tracks and placements) that measurement worked out. A full layout pass of five thousand nodes is about 7% faster.
+- 62e3bd4: A lazy list's scroll no longer slows down as more rows are measured. Row offsets are kept in a Fenwick tree, so finding a row and recording a row's height cost the logarithm of the list's length rather than the number of rows measured so far: 2,000 scroll frames over 100,000 measured rows went from 7 seconds to 38 ms.
+- 2aecc54: A modifier writing a property it already holds no longer sorts the property's overrides or allocates, which an animated modifier did on every frame.
+- 72f7b90, 4b92a02: Typing into a long text field no longer pushes every label's laid-out paragraph out of the cache: paragraphs of 16K characters or more are remembered apart, in a small budget of their own (eight paragraphs, half a million characters). The memo of a paragraph's hard lines is bounded by the length of the text it holds (a million characters) as well as by count, so a long line edited many times keeps about ten versions rather than twenty thousand: 300 edits of a 100 KB field keep 15 MB.
+
+## 0.6.22
+
+### Patch Changes
+
+- 02f186e: A scroll layer repaints a sticky node where a scroll carried it and where it sticks, so a spreadsheet's sticky header row and gutter no longer leave copies of themselves over the rows after scrolling down and back up. `LayoutEngine` gains `allStickyNodes()`, which `LayoutReader` may offer as well; a reader without it repaints a scroll layer whole every frame.
+
 ## 0.6.21
 
 ### Patch Changes

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

@@ -710,17 +710,30 @@ function removeDeclaredProperty(graph, node, property, flags) {
 */
 function writeOverrideProperty(graph, node, property, override, flags) {
 	const overrides = overridesFor(node, property);
-	const existing = overrides.entries.find((entry) => entry.source === override.source);
+	const entries = overrides.entries;
+	const existing = entries.find((entry) => entry.source === override.source);
 	if (existing !== void 0) {
 		existing.value = override.value;
-		existing.order = override.order;
+		if (existing.order !== override.order) {
+			existing.order = override.order;
+			entries.sort((a, b) => a.order - b.order);
+		}
 	} else {
-		warnOnConflict(node, property, overrides.entries, override);
-		overrides.entries.push({ ...override });
+		warnOnConflict(node, property, entries, override);
+		entries.splice(insertionIndex(entries, override.order), 0, { ...override });
 	}
-	overrides.entries.sort((a, b) => a.order - b.order);
 	return applyEffective(graph, node, property, overrides, flags);
 }
+/**
+* Where a new entry goes in the sorted list: after every entry whose
+* order is at most its own, which is where a push followed by a stable
+* sort would have put it.
+*/
+function insertionIndex(entries, order) {
+	let index = entries.length;
+	while (index > 0 && entries[index - 1].order > order) index--;
+	return index;
+}
 /** Removes one modifier's write, restoring whatever was under it. */
 function clearOverrideProperty(graph, node, property, source, flags) {
 	const overrides = node.overrides?.get(property);
@@ -6967,8 +6980,23 @@ function layoutParagraph(request, runs) {
 		maxContentWidth
 	};
 }
-/** Hard lines remembered per measurer before the least recently used is forgotten. */
+/**
+* How much a measurer's hard-line memo holds before the least recently
+* used line is forgotten: a number of lines, and their text counted in
+* UTF-16 code units, whichever runs out first; the same two bounds as
+* the paragraph cache (`PARAGRAPH_CACHE_ENTRIES`), for the same reason.
+*
+* A count alone let one long hard line, edited over and over, keep a
+* copy of every version of itself (twice: in its key and in `ownCopy`)
+* up to the count, 20,000 copies of a line however long. The text
+* budget is a million code units, so every line of a document that
+* long is still here for the next edit to find; a longer one is broken
+* again whole. A line held costs far more than its text, since its
+* breaking at each width is kept with it: 300 edits of one 100 KB line
+* held 32 MB at twice this budget and hold 15 MB at it.
+*/
 const HARD_LINE_ENTRIES = 2e4;
+const HARD_LINE_TEXT = 1 << 20;
 /** Widths a hard line keeps its breaking for: a resize sweeps through many, an edit asks for one. */
 const WIDTHS_PER_LINE = 4;
 /**
@@ -6977,6 +7005,39 @@ const WIDTHS_PER_LINE = 4;
 * so a measurer that is dropped takes its lines with it.
 */
 const hardLineMemos = /* @__PURE__ */ new WeakMap();
+/** A least-recently-used map of hard lines, bounded by count and by text; see `HARD_LINE_ENTRIES`. */
+var HardLineMemo = class {
+	entries = /* @__PURE__ */ new Map();
+	text = 0;
+	get size() {
+		return this.entries.size;
+	}
+	/** The code units of text remembered, for specs. */
+	get textLength() {
+		return this.text;
+	}
+	get(key) {
+		const entry = this.entries.get(key);
+		if (entry === void 0) return;
+		this.entries.delete(key);
+		this.entries.set(key, entry);
+		return entry;
+	}
+	set(key, line) {
+		const previous = this.entries.get(key);
+		if (previous !== void 0) {
+			this.entries.delete(key);
+			this.text -= previous.text.length;
+		}
+		while (this.entries.size > 0 && (this.entries.size >= HARD_LINE_ENTRIES || this.text + line.text.length > HARD_LINE_TEXT)) {
+			const [oldest, entry] = this.entries.entries().next().value;
+			this.entries.delete(oldest);
+			this.text -= entry.text.length;
+		}
+		this.entries.set(key, line);
+		this.text += line.text.length;
+	}
+};
 /** Forgets a measurer's hard lines: what its widths mean has changed, as when a font face arrives. */
 function forgetHardLines(runs) {
 	hardLineMemos.delete(runs);
@@ -6984,7 +7045,7 @@ function forgetHardLines(runs) {
 function hardLinesFor(runs) {
 	let memo = hardLineMemos.get(runs);
 	if (memo === void 0) {
-		memo = /* @__PURE__ */ new Map();
+		memo = new HardLineMemo();
 		hardLineMemos.set(runs, memo);
 	}
 	return memo;
@@ -6996,11 +7057,7 @@ function styleKey(request) {
 function hardLine(memo, style, text, wrap, measure) {
 	const key = `${style}\0${wrap}\0${text}`;
 	const cached = memo.get(key);
-	if (cached !== void 0) {
-		memo.delete(key);
-		memo.set(key, cached);
-		return cached;
-	}
+	if (cached !== void 0) return cached;
 	const own = ownCopy(text);
 	const segments = segmentParagraph(own, wrap);
 	let minContentWidth = 0;
@@ -7012,10 +7069,6 @@ function hardLine(memo, style, text, wrap, measure) {
 		minContentWidth,
 		lines: /* @__PURE__ */ new Map()
 	};
-	if (memo.size >= HARD_LINE_ENTRIES) {
-		const oldest = memo.keys().next().value;
-		if (oldest !== void 0) memo.delete(oldest);
-	}
 	memo.set(key, entry);
 	return entry;
 }
@@ -7352,10 +7405,74 @@ function spannedRunsFor(request, runs) {
 */
 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`. */
+/**
+* The key length, in UTF-16 code units, from which a paragraph is
+* remembered apart from the rest; see `ParagraphCache`.
+*/
+const LARGE_PARAGRAPH = 16384;
+/**
+* The large map's budget, far below the labels': what it mostly holds
+* is the versions of a field being edited, and only the newest is asked
+* for again. A version costs much more than its text, since its lines
+* are kept with it: 300 edits of a 100 KB field held 33 MB in a map
+* with the labels' budget. Half a million code units still holds every
+* request for two documents of 250K drawn side by side, so neither
+* pushes the other out on each frame.
+*/
+const LARGE_PARAGRAPH_ENTRIES = 8;
+const LARGE_PARAGRAPH_TEXT = 1 << 19;
+/**
+* The paragraph cache: two least-recently-used maps, one for large
+* paragraphs (a key of `LARGE_PARAGRAPH` code units or more), with a
+* budget of its own (`LARGE_PARAGRAPH_ENTRIES`), and one for the rest,
+* with the whole budget of `PARAGRAPH_CACHE_ENTRIES`.
+*
+* A keystroke in a long field is a new request keyed by its whole
+* text, and both the layout engine and paint ask for it. In one map a
+* 100 KB field spent the text budget in about ten keystrokes, and
+* every label on screen was laid out again on the next frame. Apart,
+* the field's versions only push out each other's and those of other
+* long texts, which is what they did among themselves before, and the
+* labels are not touched. A paragraph's map is chosen by its key, so a
+* request finds it again without being told which it is.
+*
+* Editable text is not singled out instead: the layout engine's
+* request does not say whether it is for an editable, and paint (the
+* caret, the selection) asks for the field's paragraph again on every
+* frame it is drawn, so it does need remembering somewhere. A short
+* field still shares the map with labels, but one keystroke there
+* costs at most `LARGE_PARAGRAPH` of a million code units.
+*/
 var ParagraphCache = class {
+	small = new ParagraphLru(PARAGRAPH_CACHE_ENTRIES, PARAGRAPH_CACHE_TEXT);
+	large = new ParagraphLru(LARGE_PARAGRAPH_ENTRIES, LARGE_PARAGRAPH_TEXT);
+	get size() {
+		return this.small.size + this.large.size;
+	}
+	get(key) {
+		return this.mapFor(key).get(key);
+	}
+	set(key, paragraph, text) {
+		this.mapFor(key).set(key, paragraph, text);
+	}
+	clear() {
+		this.small.clear();
+		this.large.clear();
+	}
+	mapFor(key) {
+		return key.length >= LARGE_PARAGRAPH ? this.large : this.small;
+	}
+};
+/** A least-recently-used map of paragraphs, bounded by count and by text; see `PARAGRAPH_CACHE_ENTRIES`. */
+var ParagraphLru = class {
+	maxEntries;
+	maxText;
 	entries = /* @__PURE__ */ new Map();
 	text = 0;
+	constructor(maxEntries, maxText) {
+		this.maxEntries = maxEntries;
+		this.maxText = maxText;
+	}
 	get size() {
 		return this.entries.size;
 	}
@@ -7372,7 +7489,7 @@ var ParagraphCache = class {
 			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)) {
+		while (this.entries.size > 0 && (this.entries.size >= this.maxEntries || this.text + text > this.maxText)) {
 			const [oldest, entry] = this.entries.entries().next().value;
 			this.entries.delete(oldest);
 			this.text -= entry.text;
@@ -14330,6 +14447,24 @@ var LayoutRecord = class {
 	/** Constraints this record was last measured under. */
 	lastConstraints = NEVER_MEASURED;
 	/**
+	* What a flex or grid container's last measurement worked out about
+	* its children — the flexed items and their lines, or the sized
+	* tracks — kept for its placement to take over. Placement used to
+	* work it all out again, a FlexItem and a set of constraints per
+	* child, even when the box it was placing in was the very one the
+	* measurement had been given; a container's last measurement is
+	* usually its final one, so that was most of them.
+	*
+	* Only the last measurement that actually ran is kept, because it is
+	* the one its children's records still describe: a measurement
+	* recalled from an alternate leaves the children as the last run
+	* left them. Null when that run's content box was not definite on
+	* both axes, since placement's always is. Placement takes it and
+	* clears it whatever it decides, so nothing uses one twice; see
+	* `LayoutEngine.takeArrangement`.
+	*/
+	arrangement = null;
+	/**
 	* 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
@@ -14542,6 +14677,7 @@ var LayoutRecord = class {
 		this.contentWidth = 0;
 		this.contentHeight = 0;
 		this.lastConstraints = NEVER_MEASURED;
+		this.arrangement = null;
 		this.lastBaseWidth = void 0;
 		this.lastBaseHeight = void 0;
 		this.alternates = null;
@@ -15499,6 +15635,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
@@ -16392,7 +16536,19 @@ var LayoutEngine = class {
 	measureGrid(node, rec, content) {
 		const paddingH = rec.paddingLeft + rec.paddingRight;
 		const paddingV = rec.paddingTop + rec.paddingBottom;
-		const grid = this.layoutGrid(node, content, this.definiteAxis(content, "width"), this.definiteAxis(content, "height"));
+		const availableWidth = this.definiteAxis(content, "width");
+		const availableHeight = this.definiteAxis(content, "height");
+		const grid = this.layoutGrid(node, content, availableWidth, availableHeight);
+		let arrangement = null;
+		if (availableWidth !== void 0 && availableHeight !== void 0) arrangement = {
+			kind: "grid",
+			pass: this.layoutPass,
+			content,
+			contentMatters: rec.contentMatters,
+			subgridColumns: rec.subgridColumns,
+			grid
+		};
+		rec.arrangement = arrangement;
 		rec.minContentWidth = paddingH + grid.columns.minTotal;
 		const first = grid.placements[0];
 		if (first !== void 0) {
@@ -16411,7 +16567,8 @@ var LayoutEngine = class {
 		const contentWidth = Math.max(0, rec.width - rec.paddingLeft - rec.paddingRight);
 		const contentHeight = Math.max(0, rec.height - rec.paddingTop - rec.paddingBottom);
 		const content = new Constraints(contentWidth, contentWidth, contentHeight, contentHeight);
-		const grid = this.layoutGrid(node, content, contentWidth, contentHeight);
+		const kept = this.takeArrangement(rec, "grid", content);
+		const grid = kept !== null && kept.subgridColumns === rec.subgridColumns ? kept.grid : this.layoutGrid(node, content, contentWidth, contentHeight);
 		const gridX = parseCrossAxisAlignment(node.properties.get("x")) ?? 3;
 		const gridY = parseCrossAxisAlignment(node.properties.get("y")) ?? 3;
 		const mirrored = this.startEdge(node) === "right";
@@ -16673,6 +16830,34 @@ var LayoutEngine = class {
 		const paddingV = rec.paddingTop + rec.paddingBottom;
 		return new Constraints(Math.max(0, effective.minWidth - paddingH), Math.max(0, effective.maxWidth - paddingH), Math.max(0, effective.minHeight - paddingV), Math.max(0, effective.maxHeight - paddingV));
 	}
+	/**
+	* The arrangement a container's measurement kept, when placing it in
+	* `content` would work out the same one again; null otherwise.
+	* Cleared from the record either way, so it is used at most once:
+	* placement shares auto margins out and stretches items in the lines
+	* it is handed, and a second placement in the same pass (a relayout
+	* root inside one already laid out) must start from fresh ones.
+	*
+	* What it is checked against is everything the work reads that is
+	* not fixed for the length of a pass. The pass number stands for the
+	* tree and every property in it, which a pass never changes, and so
+	* for the children, their order and the container's own settings.
+	* The content box is the constraints the children were measured
+	* under and the base their percentages resolved against. The
+	* container's `contentMatters` decided its items' flags, and a parent
+	* can change it between the two (`clearBoundaries`). The children's
+	* records need no check: only this container measures them, so they
+	* are still as its last run left them, which is the run kept. (A
+	* subgrid's cells are the exception, measured unbounded by the grid
+	* around it as well, but `placeGrid` measures each item again before
+	* it reads anything off its record.)
+	*/
+	takeArrangement(rec, kind, content) {
+		const kept = rec.arrangement;
+		if (kept === null) return null;
+		rec.arrangement = null;
+		return kept.kind === kind && kept.pass === this.layoutPass && kept.contentMatters === rec.contentMatters && constraintsEqual(kept.content, content) ? kept : null;
+	}
 	measureFlex(node, rec, content, direction) {
 		const row = direction === 0;
 		const paddingMain = row ? rec.paddingLeft + rec.paddingRight : rec.paddingTop + rec.paddingBottom;
@@ -16683,6 +16868,7 @@ var LayoutEngine = class {
 		const mainBounded = isFinite(mainMax);
 		const mainDefinite = mainBounded && mainMin === mainMax;
 		const crossDefinite = row ? isFinite(content.maxHeight) && content.minHeight === content.maxHeight : isFinite(content.maxWidth) && content.minWidth === content.maxWidth;
+		rec.arrangement = null;
 		const items = this.collectFlexItems(node, content, direction, config, crossDefinite && !config.wrap);
 		if (items.length === 0) {
 			rec.minContentWidth = rec.paddingLeft + rec.paddingRight;
@@ -16698,7 +16884,7 @@ var LayoutEngine = class {
 			const lineTotal = this.lineOuterMain(line, config.gapMain, "hypothetical");
 			const lineWanted = this.lineMaxContentMain(line, config.gapMain);
 			if (mainBounded && (mainDefinite || lineTotal > mainMax || lineWanted > mainMax)) {
-				this.resolveLine(line, mainMax - config.gapMain * (line.items.length - 1), config);
+				line.free = this.resolveLine(line, mainMax - config.gapMain * (line.items.length - 1), config);
 				this.measureFlexedItems(line.items, content, direction, crossDefinite && !config.wrap ? row ? content.maxHeight : content.maxWidth : void 0);
 				contentMain = Math.max(contentMain, this.lineOuterMain(line, config.gapMain, "final"));
 			} else {
@@ -16714,6 +16900,13 @@ var LayoutEngine = class {
 			contentCross += line.cross;
 		}
 		contentCross += config.gapLine * (lines.length - 1);
+		if (mainDefinite && crossDefinite) rec.arrangement = {
+			kind: "flex",
+			pass: this.layoutPass,
+			content,
+			contentMatters: rec.contentMatters,
+			lines
+		};
 		this.setFlexBaseline(rec, lines[0].items, row);
 		rec.minContentWidth = this.flexMinContentWidth(rec, items, row, config);
 		rec.minContentHeight = row && config.wrap ? paddingCross + contentCross : this.flexMinContentHeight(rec, items, row, config);
@@ -18021,14 +18214,21 @@ var LayoutEngine = class {
 		const contentMain = Math.max(0, (row ? rec.width : rec.height) - (row ? paddingH : paddingV));
 		const contentCross = Math.max(0, (row ? rec.height : rec.width) - (row ? paddingV : paddingH));
 		const content = row ? new Constraints(contentMain, contentMain, contentCross, contentCross) : new Constraints(contentCross, contentCross, contentMain, contentMain);
-		const items = this.collectFlexItems(node, content, direction, config, !config.wrap);
-		if (items.length === 0) return;
-		const lines = this.breakLines(items, config, contentMain);
-		for (const line of lines) {
-			line.free = this.resolveLine(line, contentMain - config.gapMain * (line.items.length - 1), config);
-			this.distributeAutoMargins(line);
-			this.measureFlexedItems(line.items, content, direction, config.wrap ? void 0 : contentCross);
-			line.cross = this.flexLineCross(line.items, row);
+		const kept = this.takeArrangement(rec, "flex", content);
+		let lines;
+		if (kept !== null) {
+			lines = kept.lines;
+			for (const line of lines) this.distributeAutoMargins(line);
+		} else {
+			const items = this.collectFlexItems(node, content, direction, config, !config.wrap);
+			if (items.length === 0) return;
+			lines = this.breakLines(items, config, contentMain);
+			for (const line of lines) {
+				line.free = this.resolveLine(line, contentMain - config.gapMain * (line.items.length - 1), config);
+				this.distributeAutoMargins(line);
+				this.measureFlexedItems(line.items, content, direction, config.wrap ? void 0 : contentCross);
+				line.cross = this.flexLineCross(line.items, row);
+			}
 		}
 		this.markFlexBoundaries(lines);
 		if (lines.length === 1 && !config.wrap) lines[0].cross = contentCross;
@@ -20901,7 +21101,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++;
@@ -21001,6 +21202,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) {
@@ -21019,6 +21228,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) {
@@ -21099,6 +21309,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;
 }
@@ -22335,4 +22581,4 @@ function createCanvasSurface(host) {
 //#endregion
 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-BAhcLj2K.js.map
+//# sourceMappingURL=CanvasSurface-D5QaKaWH.js.map