gesso-core 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { $ as prepareInputSurface, $i as textContentOf, $n as nextWordEnd, $r as borderRadius, $t as createPaintState, A as accumulatedOffsetTo, Aa as UiBeforeInputEvent, Ai as raiseContrast, An as editorFor, Ar as pathValuesEqual, At as EditableLayout, B as parseFlexDirection, Ba as UiWheelEvent, Bi as boxShadowArraysEqual, Bn as caretRectFor, Br as radialGradient, Bt as textMeasureRequest, C as describeLength, Ca as writeOverrideProperty, Ci as hasThemeExtension, Cn as linkOf, Cr as statesEqual, Ct as wordRangeIn, D as formatNumber, Da as visualState, Di as withThemeExtension, Dn as CARET_WIDTH, Dr as validateSubgrid, Dt as ELLIPSIS, E as formatExplanation, Ea as hasVisualState, Ei as themeExtensionsEqual, En as CARET_BLINK_MS, Er as UI_SUBGRID_AXES, Et as spannedRunsFor, F as constraintsEqual, Fa as UiKeyboardEvent, Fi as spacingEqual, Fn as nextCaretToggle, Fr as transformsEqual, Ft as fillTextRects, G as MainAxisAlignment, Ga as UiBinding, Gi as defaultTypography, Gn as offsetAtX, Gr as isFrLength, Gt as fontStackFor, H as sizeGridTracks, Ha as wheelDeltaYOf, Hi as defaultShapes, Hn as lineIndexForOffset, Hr as auto, Ht as textRunDecorations, I as tightenConstraints, Ia as UiPinchEvent, Ii as spacingSteps, In as syncEditorValue, Ir as MAX_GRADIENT_STOPS, It as layoutTextLines, J as parseMainAxisAlignment, Ji as defaultTextStyle, Jn as EditableTextModel, Jr as minmax, Jt as DEFAULT_FONT_SIZE, K as parseAlignContent, Ki as isTypographyRole, Kn as offsetForVerticalMove, Kr as isMinMaxTrack, Kt as registerFontStack, L as MAX_MEASURES_PER_CHILD, La as UiPointerEvent, Li as defaultShadows, Ln as resolveColorValue, Lr as gradientPaint, Lt as runCanvasStyleInto, M as LayoutRecord, Ma as UiFocusEvent, Mi as densityFactors, Mn as isEditableNode, Mr as parseTransform, Mt as buildFontString, N as Constraints, Na as UiGestureEvent, Ni as defaultSpacing, Nn as isMultiline, Nr as transform, Nt as createCanvasTextStyle, O as labelNode, Oa as visualStatesEqual, Oi as contrastRatio, On as EDITOR_PROP, Or as inputsEqual, Ot as layoutParagraph, P as clampSize, Pa as UiInputEvent, Pi as scaleSpacing, Pn as isReadOnly, Pr as transformIsIdentity, Pt as drawText, Q as pointerDeviceOf, Qi as spannedTextOf, Qn as nextGraphemeEnd, Qr as UiBorderRadiuses, Qt as computeObjectFitRect, R as isLayoutProtocol, Ra as UiTextChangeEvent, Ri as shadowsEqual, Rn as isVideoSurface, Rr as gradientsEqual, Rt as runFontString, S as SCROLLBAR_LINGER_MS, Sa as writeDeclaredProperty, Si as defineThemeExtension, Sn as linkHoverOf, Sr as normalizeStates, St as selectionRectsIn, T as formatConstraints, Ta as defaultVisualState, Ti as themeExtension, Tn as setLinkHover, Tr as validateStates, Tt as ParagraphTextMeasurer, U as AlignContent, Ua as UiNodeType, Ui as isShapeName, Un as lineLimit, Ur as fr, Ut as bumpFontStack, V as placeGridItems, Va as noKeyModifiers, Vi as boxShadowsEqual, Vn as lineIndexAtY, Vr as validateGradient, Vt as textRunBackgrounds, W as CrossAxisAlignment, Wa as DirtyFlags, Wi as shapesEqual, Wn as offsetAtPoint, Wr as isAutoLength, Wt as clearFontStacks, X as UiPlatformAdapter, Xi as resolvedSpansOf, Xn as lineEndAt, Xr as repeat, Xt as DEFAULT_TEXT_COLOR, Y as CanvasPlatformSurface, Yi as flattenTextSpans, Yn as graphemeBoundaries, Yr as percent, Yt as DEFAULT_FONT_WEIGHT, Z as capturePointer, Zi as spanAtOffset, Zn as lineStartAt, Zr as resolveLength, Zt as colorToCss, _ as LABEL_PADDING_X, _a as UiNode, _i as darkTheme, _n as isNodeInert, _r as UiProperties, _t as UiInputDispatcher, a as PaintPictureCache, aa as UiBasicColors, ai as uniformBorderRadius, an as TEXT_MATCHES_PROP, ar as resolveProperty, at as isScrollContainer, b as LayoutEngine, ba as overrideSources, bi as withContrast, bn as clearLinkHover, br as isUiRole, bt as paragraphGeometry, c as EMPTY_RECORDING, ca as colorValuesEqual, ci as UiEnvironmentKeys, cn as setMatchRanges, cr as UiGraph, ct as UiFocusManager, d as tracePathData, da as parseColor, di as noInsets, dn as selectableTextNodes, dr as getPropertyNames, dt as SCROLLBAR_INSET, ea as textSpansEqual, ei as borderRadiusCorners, en as isPaintVisible, er as previousGraphemeStart, et as touchActionFor, f as ScaledImageCache, fa as rgb8, fi as observeViewportInsets, fn as selectableTextOf, fr as inheritedPropertyFlags, ft as SCROLLBAR_MIN_THUMB, g as paintsAfterChildren, ga as UiEnvironment, gi as unknownContainerSize, gn as isNodeHitTestable, gr as propertyValuesEqualByName, gt as scrollbarZoneAt, h as hasDecorationPhase, ha as findEnvironmentKey, hi as containerBands, hn as isNodeFocusable, hr as propertyIsInherited, ht as scrollbarThumbs, i as traceRoundedRect, ia as lightColors, ii as normalizeBorderRadius, in as DEFAULT_LINE_HEIGHT_FACTOR, ir as resolveNumber, it as UiWheelController, j as contentOffset, ja as UiEventType, ji as relativeLuminance, jn as editorOf, jr as UiTransforms, jt as applyCanvasTextStyle, k as withOverrideSource, ka as MOUSE_POINTER, ki as highContrastColors, kn as caretVisibleAt, kr as paintValuesEqual, kt as proportionalFontMetrics, l as PaintRecorder, la as colorsEqual, li as UiInsetRegistry, ln as TEXT_SELECTION_PROP, lr as closestPropertyName, lt as UiHitTester, m as decorationRect, ma as createEnvironmentKey, mi as bandOf, mn as setSelectionRange, mr as propertyEffects, mt as scrollbarThumb, n as createCanvasSurface, na as colorsEqualPalette, ni as borderRadiusIsZero, nn as normalizeVerticalAlign, nr as wordRangeAt, nt as UiGestureRecognizer, o as paintPictures, oa as colorToHex, oi as defineProperty, on as clearMatchRanges, or as resolvePropertyByName, ot as UiKeyboardController, p as decorationColor, pa as rgba, pi as UiContainerSizeSource, pn as selectionRangeOf, pr as inheritedPropertyNames, pt as SCROLLBAR_THICKNESS, q as parseCrossAxisAlignment, qi as typographyEqual, qn as selectionRects, qr as isPercentLength, qt as DEFAULT_FONT_FAMILY, r as Canvas2DRenderer, ra as darkColors, ri as borderRadiusValuesEqual, rn as resolvePaintState, rr as resolveBoolean, rt as UiPinchRecognizer, s as PaintTarget, sa as colorToRgba, si as propertyValuesEqual, sn as matchRangesOf, sr as resolveString, st as UiPointerController, t as CanvasSurface, ta as textStylesEqual, ti as borderRadiusEqual, tn as normalizeTextAlign, tr as previousWordStart, tt as UiTouchScroller, u as replayPaint, ua as normalizeColor, ui as insetsEqual, un as clearSelectionRange, ur as findPropertyDefinition, ut as SCROLLBAR_HOVER_ZONE, v as drawOverlayShapes, va as DirtyNodeSet, vi as lightTheme, vn as isNodeSelectable, vr as UI_ROLES, vt as hasDrawnText, w as describeOverrides, wa as UiVisualState, wi as noThemeExtensions, wn as linkRunAtPointIn, wr as validateRole, wt as CharacterCountTextMeasurer, x as SCROLLBAR_FADE_MS, xa as resetOverrideWarnings, xi as withDensity, xn as hasTextLinks, xr as isUiSemanticState, xt as paragraphGeometryFrom, y as labelOrigin, ya as clearOverrideProperty, yi as themesEqual, yn as resolveCursor, yr as UI_SEMANTIC_STATES, yt as offsetAtPointIn, z as FlexDirection, za as UiWheelDeltaMode, zi as boxShadow, zn as videoFrameSize, zr as linearGradient, zt as spanOf } from "./CanvasSurface-5dU-U3qQ.js";
+import { $ as prepareInputSurface, $a as UiBinding, $i as defaultTextStyle, $n as EditableTextModel, $r as minmax, $t as DEFAULT_FONT_WEIGHT, A as accumulatedOffsetTo, Aa as UiVisualState, Ai as themeExtension, An as setLinkHover, Ar as validateStates, At as proportionalFontMetrics, B as parseFlexDirection, Ba as UiInputEvent, Bi as spacingEqual, Bn as nextCaretToggle, Br as transformsEqual, Bt as layoutTextLines, C as describeLength, Ca as UiNode, Ci as lightTheme, Cn as isNodeTabStop, Cr as UI_ROLES, Ct as selectionRectsIn, D as formatNumber, Da as resetOverrideWarnings, Di as defineThemeExtension, Dn as linkHoverOf, Dr as normalizeStates, Dt as spannedRunsFor, E as formatExplanation, Ea as overrideSources, Ei as withDensity, En as hasTextLinks, Er as isUiSemanticState, Et as ParagraphTextMeasurer, F as constraintsEqual, Fa as MOUSE_POINTER, Fi as raiseContrast, Fn as editorFor, Fr as pathValuesEqual, Ft as applyCanvasTextStyle, G as MainAxisAlignment, Ga as UiSelectionChangeEvent, Gi as boxShadowArraysEqual, Gn as caretRectFor, Gr as radialGradient, Gt as textRunBackgrounds, H as sizeGridTracks, Ha as UiPasteEvent, Hi as defaultShadows, Hn as resolveColorValue, Hr as gradientPaint, Ht as runFontString, I as tightenConstraints, Ia as UiBeforeInputEvent, Ii as relativeLuminance, In as editorOf, Ir as UiTransforms, It as buildFontString, J as parseMainAxisAlignment, Ja as UiWheelEvent, Ji as isShapeName, Jn as lineLimit, Jr as fr, Jt as clearFontStacks, K as parseAlignContent, Ka as UiTextChangeEvent, Ki as boxShadowsEqual, Kn as lineIndexAtY, Kr as validateGradient, Kt as textRunDecorations, L as MAX_MEASURES_PER_CHILD, La as UiEventType, Li as densityFactors, Ln as isEditableNode, Lr as parseTransform, Lt as createCanvasTextStyle, M as LayoutRecord, Ma as hasVisualState, Mi as withThemeExtension, Mn as CARET_WIDTH, Mr as validateSubgrid, Mt as detectEditingPlatform, N as Constraints, Na as visualState, Ni as contrastRatio, Nn as EDITOR_PROP, Nr as inputsEqual, Nt as isPrintable, O as labelNode, Oa as writeDeclaredProperty, Oi as hasThemeExtension, On as linkOf, Or as statesEqual, Ot as ELLIPSIS, P as clampSize, Pa as visualStatesEqual, Pi as highContrastColors, Pn as caretVisibleAt, Pr as paintValuesEqual, Pt as EditableLayout, Q as pointerDeviceOf, Qa as DirtyFlags, Qi as typographyEqual, Qn as selectionRects, Qr as isPercentLength, Qt as DEFAULT_FONT_SIZE, R as isLayoutProtocol, Ra as UiFocusEvent, Ri as defaultSpacing, Rn as isMultiline, Rr as transform, Rt as drawText, S as SCROLLBAR_LINGER_MS, Sa as UiEnvironment, Si as darkTheme, Sn as isNodeSelectable, Sr as UiProperties, St as paragraphGeometryFrom, T as formatConstraints, Ta as clearOverrideProperty, Ti as withContrast, Tn as clearLinkHover, Tr as isUiRole, Tt as CharacterCountTextMeasurer, U as AlignContent, Ua as UiPinchEvent, Ui as shadowsEqual, Un as isVideoSurface, Ur as gradientsEqual, Ut as spanOf, V as placeGridItems, Va as UiKeyboardEvent, Vi as spacingSteps, Vn as syncEditorValue, Vr as MAX_GRADIENT_STOPS, Vt as runCanvasStyleInto, W as CrossAxisAlignment, Wa as UiPointerEvent, Wi as boxShadow, Wn as videoFrameSize, Wr as linearGradient, Wt as textMeasureRequest, X as UiPlatformAdapter, Xa as wheelDeltaYOf, Xi as defaultTypography, Xn as offsetAtX, Xr as isFrLength, Xt as registerFontStack, Y as CanvasPlatformSurface, Ya as noKeyModifiers, Yi as shapesEqual, Yn as offsetAtPoint, Yr as isAutoLength, Yt as fontStackFor, Z as capturePointer, Za as UiNodeType, Zi as isTypographyRole, Zn as offsetForVerticalMove, Zr as isMinMaxTrack, Zt as DEFAULT_FONT_FAMILY, _ as LABEL_PADDING_X, _a as parseColor, _i as observeViewportInsets, _n as selectionRangeOf, _r as inheritedPropertyFlags, _t as scrollbarZoneAt, a as PaintPictureCache, aa as textContentOf, ai as borderRadiusCorners, an as normalizeTextAlign, ar as previousGraphemeStart, at as UiWheelController, b as LayoutEngine, ba as createEnvironmentKey, bi as containerBands, bn as isNodeHitTestable, br as propertyIsInherited, bt as offsetAtPointIn, c as EMPTY_RECORDING, ca as colorsEqualPalette, ci as borderRadiusValuesEqual, cn as DEFAULT_LINE_HEIGHT_FACTOR, cr as resolveBoolean, ct as UiPointerController, d as tracePathData, da as UiBasicColors, di as defineProperty, dn as matchRangesOf, dr as resolvePropertyByName, dt as SCROLLBAR_HOVER_ZONE, ea as editableSpansOf, ei as percent, en as DEFAULT_TEXT_COLOR, er as graphemeBoundaries, et as touchActionFor, f as ScaledImageCache, fa as colorToHex, fi as propertyValuesEqual, fn as setMatchRanges, fr as resolveString, ft as SCROLLBAR_INSET, g as paintsAfterChildren, ga as normalizeColor, gi as noInsets, gn as selectableTextOf, gr as getPropertyNames, gt as scrollbarThumbs, h as hasDecorationPhase, ha as colorsEqual, hi as insetsEqual, hn as selectableTextNodes, hr as findPropertyDefinition, ht as scrollbarThumb, i as traceRoundedRect, ia as spannedTextOf, ii as borderRadius, in as isPaintVisible, ir as nextWordEnd, it as UiPinchRecognizer, j as contentOffset, ja as defaultVisualState, ji as themeExtensionsEqual, jn as CARET_BLINK_MS, jr as UI_SUBGRID_AXES, jt as commandForKey, k as withOverrideSource, ka as writeOverrideProperty, ki as noThemeExtensions, kn as linkRunAtPointIn, kr as validateRole, kt as layoutParagraph, l as PaintRecorder, la as darkColors, li as normalizeBorderRadius, ln as TEXT_MATCHES_PROP, lr as resolveNumber, lt as UiFocusManager, m as decorationRect, ma as colorValuesEqual, mi as UiInsetRegistry, mn as clearSelectionRange, mr as closestPropertyName, mt as SCROLLBAR_THICKNESS, n as createCanvasSurface, na as resolvedSpansOf, ni as resolveLength, nn as computeObjectFitRect, nr as lineStartAt, nt as UiTouchScroller, o as paintPictures, oa as textSpansEqual, oi as borderRadiusEqual, on as normalizeVerticalAlign, or as previousWordStart, ot as isScrollContainer, p as decorationColor, pa as colorToRgba, pi as UiEnvironmentKeys, pn as TEXT_SELECTION_PROP, pr as UiGraph, pt as SCROLLBAR_MIN_THUMB, q as parseCrossAxisAlignment, qa as UiWheelDeltaMode, qi as defaultShapes, qn as lineIndexForOffset, qr as auto, qt as bumpFontStack, r as Canvas2DRenderer, ra as spanAtOffset, ri as UiBorderRadiuses, rn as createPaintState, rr as nextGraphemeEnd, rt as UiGestureRecognizer, s as PaintTarget, sa as textStylesEqual, si as borderRadiusIsZero, sn as resolvePaintState, sr as wordRangeAt, st as UiKeyboardController, t as CanvasSurface, ta as flattenTextSpans, ti as repeat, tn as colorToCss, tr as lineEndAt, tt as UiEditingController, u as replayPaint, ua as lightColors, ui as uniformBorderRadius, un as clearMatchRanges, ur as resolveProperty, ut as UiHitTester, v as drawOverlayShapes, va as rgb8, vi as UiContainerSizeSource, vn as setSelectionRange, vr as inheritedPropertyNames, vt as UiInputDispatcher, w as describeOverrides, wa as DirtyNodeSet, wi as themesEqual, wn as resolveCursor, wr as UI_SEMANTIC_STATES, wt as wordRangeIn, x as SCROLLBAR_FADE_MS, xa as findEnvironmentKey, xi as unknownContainerSize, xn as isNodeInert, xr as propertyValuesEqualByName, xt as paragraphGeometry, y as labelOrigin, ya as rgba, yi as bandOf, yn as isNodeFocusable, yr as propertyEffects, yt as hasDrawnText, z as FlexDirection, za as UiGestureEvent, zi as scaleSpacing, zn as isReadOnly, zr as transformIsIdentity, zt as fillTextRects } from "./CanvasSurface-ifHkg0-g.js";
 import { BehaviorSubject, EMPTY, Subject, combineLatest, distinctUntilChanged, isObservable as isObservable$1, map, of } from "rxjs";
 //#region src/animation/UiEasing.ts
 /** Progress equals time. What a spinner and a sweep want. */
@@ -1425,9 +1425,11 @@ const EVENT_PROPS = {
 	onKeyDown: "keydown",
 	onKeyUp: "keyup",
 	onFocus: "focus",
+	onPaste: "paste",
 	onBlur: "blur",
 	onBeforeInput: "beforeinput",
 	onInput: "input",
+	onSelectionChange: "selectionchange",
 	onClick: "click",
 	onLongPress: "longpress",
 	onDragStart: "dragstart",
@@ -2883,7 +2885,7 @@ var UiVirtualWindow = class {
 		const total = this.totalExtent();
 		const header = viewport.lead ?? 0;
 		this.checkViewport(viewport.extent, total + header);
-		const scrolled = clamp$1(viewport.scroll + scrollAdjust, 0, Math.max(0, total + header - viewport.extent));
+		const scrolled = clamp$2(viewport.scroll + scrollAdjust, 0, Math.max(0, total + header - viewport.extent));
 		const scroll = Math.max(0, scrolled - header);
 		let first = 0;
 		let last = -1;
@@ -3054,7 +3056,7 @@ function markRow(row, props, subject) {
 		}
 	};
 }
-function clamp$1(value, min, max) {
+function clamp$2(value, min, max) {
 	return Math.min(Math.max(value, min), max);
 }
 function assertCount(count) {
@@ -3074,10 +3076,10 @@ function assertCount(count) {
 const lazySource = defineModifier({
 	name: "lazySource",
 	attach(host, args) {
-		follow$1(host, args.count, (value) => args.window.setCount(value));
+		follow$2(host, args.count, (value) => args.window.setCount(value));
 		if (args.revision !== void 0) {
 			let first = true;
-			follow$1(host, args.revision, () => {
+			follow$2(host, args.revision, () => {
 				if (first) {
 					first = false;
 					return;
@@ -3087,7 +3089,7 @@ const lazySource = defineModifier({
 		}
 	}
 });
-function follow$1(host, source, apply) {
+function follow$2(host, source, apply) {
 	if (!isObservable$1(source)) {
 		apply(source);
 		return;
@@ -3287,120 +3289,609 @@ function Responsive(props, build) {
 	}, [children]);
 }
 //#endregion
-//#region src/editing/EditingKeymap.ts
-/**
-* The platform the runtime is on, decided once. Available in a worker
-* too, since `navigator.userAgent` is; tests set it explicitly.
-*/
-function detectEditingPlatform() {
-	const agent = typeof navigator !== "undefined" ? navigator.userAgent : "";
-	return /Mac|iPhone|iPad|iPod/.test(agent) ? "mac" : "other";
-}
-/**
-* Maps a key press to an editing command, following the host's
-* conventions:
-*
-*   Mac    — Option steps by word, Command jumps to line and document
-*            ends, Command+Backspace deletes to the line start.
-*   Others — Control steps by word, Home/End and Control+Home/End are
-*            the line and document ends.
-*
-* Shift extends every move. Enter is a newline (the controller drops
-* it in a single-line field). A printable key becomes `insert` only
-* when `textFromKeys` is set: a host with an editing proxy delivers
-* text through `beforeinput` instead, where the IME and dead keys
-* have already been resolved.
-*/
-function commandForKey(key, modifiers, platform, textFromKeys) {
-	const mac = platform === "mac";
-	const primary = mac ? modifiers.meta : modifiers.ctrl;
-	const word = mac ? modifiers.alt : modifiers.ctrl;
-	const extend = modifiers.shift;
-	switch (key) {
-		case "ArrowLeft":
-		case "ArrowRight": {
-			const direction = key === "ArrowLeft" ? -1 : 1;
-			if (mac && modifiers.meta) return {
-				kind: "move",
-				unit: "line",
-				direction,
-				extend
-			};
-			return {
-				kind: "move",
-				unit: word ? "word" : "grapheme",
-				direction,
-				extend
-			};
+//#region src/composition/UiVirtualSheet.ts
+/** The sheet sits on its scroll container under this property. */
+const VIRTUAL_SHEET_PROP = "virtualSheet";
+const EMPTY_RANGE = {
+	firstRow: 0,
+	lastRow: -1,
+	firstColumn: 0,
+	lastColumn: -1
+};
+var UiVirtualSheet = class {
+	children$ = new BehaviorSubject([]);
+	/**
+	* The range now mounted, for whoever has to fetch the values in it.
+	*
+	* This is the whole reason the window is reachable from outside: the
+	* render thread does not hold the cells, so the range it settles on
+	* each frame is what it asks the application thread for. Emits only
+	* when the range changes, so binding a command to it does not send
+	* one per frame.
+	*/
+	range$ = new BehaviorSubject(EMPTY_RANGE);
+	rowCount;
+	columnCount;
+	rowOverscan;
+	columnOverscan;
+	rowHeight;
+	gutterWidth;
+	headerHeight;
+	frozenRows;
+	frozenColumns;
+	renderRow;
+	renderHeader;
+	extendRange;
+	/** One width per column, or undefined when every column is the same. */
+	widths;
+	/** `offsets[c]` is where column `c` starts, measured past the gutter. */
+	offsets = [];
+	uniformWidth = 0;
+	/**
+	* The rows that are not `rowHeight` tall, in row order.
+	*
+	* Three parallel arrays rather than a map of objects: this is
+	* searched on every hit test and on every frame that scrolls, and
+	* the arrays are read in step.
+	*/
+	exceptionRows = [];
+	exceptionHeights = [];
+	/** `exceptionStarts[i]` is where `exceptionRows[i]` starts, past the header. */
+	exceptionStarts = [];
+	range = EMPTY_RANGE;
+	viewport;
+	/** Rows built for the current column range, so a vertical scroll rebuilds one row. */
+	mountedRows = /* @__PURE__ */ new Map();
+	/** The frozen rows, kept separately because they never leave. */
+	frozenMounted = /* @__PURE__ */ new Map();
+	mountedHeader;
+	constructor(options, renderRow, renderHeader) {
+		this.rowCount = typeof options.rowCount === "number" ? options.rowCount : 0;
+		this.columnCount = typeof options.columnCount === "number" ? options.columnCount : 0;
+		this.rowHeight = positive("rowHeight", options.rowHeight);
+		this.adoptHeights(options.rowHeights);
+		this.gutterWidth = Math.max(0, options.gutterWidth ?? 0);
+		this.headerHeight = Math.max(0, options.headerHeight ?? 0);
+		this.frozenRows = Math.max(0, Math.floor(options.frozenRows ?? 0));
+		this.frozenColumns = Math.max(0, Math.floor(options.frozenColumns ?? 0));
+		this.rowOverscan = typeof options.rowOverscan === "number" ? options.rowOverscan : 3;
+		this.columnOverscan = typeof options.columnOverscan === "number" ? options.columnOverscan : 2;
+		this.renderRow = renderRow;
+		this.renderHeader = renderHeader;
+		this.extendRange = options.extendRange;
+		this.adoptWidths(options.columnWidth);
+		this.viewport = {
+			scrollX: 0,
+			scrollY: 0,
+			width: options.initialViewport?.width ?? 800,
+			height: options.initialViewport?.height ?? 600
+		};
+		this.recompute();
+	}
+	/**
+	* New column widths, as a drag on a header edge produces.
+	*
+	* The prefix sum is rebuilt whole. It is one pass over the columns
+	* and it happens once per frame of a drag at most, against a
+	* per-column offset that would otherwise have to be corrected
+	* everywhere downstream of the column that moved.
+	*/
+	setColumnWidths(widths) {
+		this.adoptWidths(widths);
+		this.invalidate();
+	}
+	adoptWidths(widths) {
+		if (typeof widths === "number") {
+			this.uniformWidth = positive("columnWidth", widths);
+			this.widths = void 0;
+			this.offsets = [];
+			return;
 		}
-		case "ArrowUp":
-		case "ArrowDown": {
-			const direction = key === "ArrowUp" ? -1 : 1;
-			if (mac && modifiers.meta) return {
-				kind: "move",
-				unit: "document",
-				direction,
-				extend
-			};
-			return {
-				kind: "move",
-				unit: "vertical",
-				direction,
-				extend
-			};
+		const owned = widths.slice();
+		for (const width of owned) if (!(width >= 0)) throw new Error(`LazySheet column widths must not be negative, got ${String(width)}.`);
+		this.widths = owned;
+		this.offsets = Array.from({ length: owned.length + 1 });
+		let running = 0;
+		for (let column = 0; column < owned.length; column++) {
+			this.offsets[column] = running;
+			running += owned[column];
+		}
+		this.offsets[owned.length] = running;
+	}
+	/**
+	* New row heights, as hiding a row or autofitting one produces.
+	*
+	* The exceptions are rebuilt whole, which is one pass over *them*
+	* and not over the rows — the whole reason they are sparse. A
+	* height of zero is a hidden row and is allowed; a negative one is
+	* not.
+	*/
+	setRowHeights(heights) {
+		this.adoptHeights(heights);
+		this.invalidate();
+	}
+	/** The height every row has unless it is an exception. */
+	setRowHeight(height) {
+		const next = positive("rowHeight", height);
+		if (next === this.rowHeight) return;
+		this.rowHeight = next;
+		this.rebuildExceptionStarts();
+		this.invalidate();
+	}
+	adoptHeights(heights) {
+		this.exceptionRows = [];
+		this.exceptionHeights = [];
+		if (heights !== void 0) {
+			const rows = [...heights.keys()].sort((a, b) => a - b);
+			for (const row of rows) {
+				const height = heights.get(row) ?? 0;
+				if (!(height >= 0)) throw new Error(`LazySheet row heights must not be negative, got ${String(height)}.`);
+				if (height !== this.rowHeight) {
+					this.exceptionRows.push(row);
+					this.exceptionHeights.push(height);
+				}
+			}
+		}
+		this.rebuildExceptionStarts();
+	}
+	/**
+	* Where each exception begins, and what they cost in total.
+	*
+	* `start` is the row's own offset past the header, so the inverse —
+	* `rowAt` — can binary search it directly rather than reconstructing
+	* it per probe.
+	*/
+	rebuildExceptionStarts() {
+		this.exceptionStarts = Array.from({ length: this.exceptionRows.length });
+		let extra = 0;
+		for (let index = 0; index < this.exceptionRows.length; index++) {
+			this.exceptionStarts[index] = this.exceptionRows[index] * this.rowHeight + extra;
+			extra += this.exceptionHeights[index] - this.rowHeight;
+		}
+	}
+	/** The index of the last exception starting at or before an offset, or -1. */
+	exceptionAt(offset) {
+		let low = 0;
+		let high = this.exceptionStarts.length - 1;
+		let found = -1;
+		while (low <= high) {
+			const mid = low + high >> 1;
+			if (this.exceptionStarts[mid] <= offset) {
+				found = mid;
+				low = mid + 1;
+			} else high = mid - 1;
+		}
+		return found;
+	}
+	/** How many exceptions come before a row, as an index into them. */
+	exceptionsBefore(row) {
+		let low = 0;
+		let high = this.exceptionRows.length;
+		while (low < high) {
+			const mid = low + high >> 1;
+			if (this.exceptionRows[mid] < row) low = mid + 1;
+			else high = mid;
 		}
-		case "Home": return {
-			kind: "move",
-			unit: modifiers.ctrl ? "document" : "line",
-			direction: -1,
-			extend
+		return low;
+	}
+	/** The height of one row. Zero when it is hidden. */
+	rowHeightOf(row) {
+		if (this.exceptionRows.length === 0) return this.rowHeight;
+		const index = this.exceptionsBefore(row);
+		return this.exceptionRows[index] === row ? this.exceptionHeights[index] : this.rowHeight;
+	}
+	/** Where a row starts, measured past the header. */
+	rowOffsetOf(row) {
+		const clamped = clamp$1(row, 0, this.rowCount);
+		return clamped * this.rowHeight + this.extraWithin(clamped);
+	}
+	/** Total height of the rows, not counting the header. */
+	get rowsHeight() {
+		return this.rowCount * this.rowHeight + this.extraWithin(this.rowCount);
+	}
+	/**
+	* What the exceptions before `row` add to or take off the offset.
+	*
+	* Read off the last exception before it rather than summed: the
+	* start of an exception already carries everything before it, so
+	* its end minus where it *would* have ended is the running total.
+	*/
+	extraWithin(row) {
+		const before = this.exceptionsBefore(row);
+		if (before === 0) return 0;
+		const index = before - 1;
+		return this.exceptionStarts[index] + this.exceptionHeights[index] - (this.exceptionRows[index] + 1) * this.rowHeight;
+	}
+	/** The width of one column. */
+	widthOf(column) {
+		if (this.widths === void 0) return this.uniformWidth;
+		return this.widths[column] ?? 0;
+	}
+	/** Where a column starts, measured past the gutter. */
+	offsetOf(column) {
+		if (this.widths === void 0) return column * this.uniformWidth;
+		const clamped = clamp$1(column, 0, this.offsets.length - 1);
+		return this.offsets[clamped] ?? 0;
+	}
+	/** Total width of the columns, not counting the gutter. */
+	get columnsWidth() {
+		return this.widths === void 0 ? this.columnCount * this.uniformWidth : this.offsets[this.widths.length] ?? 0;
+	}
+	get contentWidth() {
+		return this.gutterWidth + this.columnsWidth;
+	}
+	/** Where the scrolled columns begin, past the gutter and the frozen ones. */
+	get frozenWidth() {
+		return this.offsetOf(this.frozenColumns);
+	}
+	get contentHeight() {
+		return this.headerHeight + this.rowsHeight;
+	}
+	/**
+	* The cell under a point in the scroll container's own coordinates.
+	*
+	* The window already knows where everything is and how far it is
+	* scrolled, which is the whole of this: a drag towards a cell — a
+	* fill handle, a selection being stretched — is usually heading for
+	* one that has not been mounted, so there is no node to hit-test and
+	* arithmetic is the only answer available.
+	*/
+	cellAt(x, y) {
+		return {
+			row: this.rowAt(this.viewport.scrollY + y),
+			column: this.columnAt(this.viewport.scrollX + x)
 		};
-		case "End": return {
-			kind: "move",
-			unit: modifiers.ctrl ? "document" : "line",
-			direction: 1,
-			extend
+	}
+	/**
+	* The row at a content offset, clamped to the sheet.
+	*
+	* A division when every row is the default height — the common case
+	* by a very long way — and otherwise a binary search over the
+	* exceptions followed by a division inside the uniform run that
+	* follows the one it lands in.
+	*
+	* A hidden row occupies no offset at all, so the offset where it
+	* *would* be belongs to the row after it. That falls out of the
+	* arithmetic rather than being special-cased: a zero-height
+	* exception starts and ends at the same place, so the point is
+	* never inside it.
+	*/
+	rowAt(offset) {
+		const last = Math.max(0, this.rowCount - 1);
+		const past = offset - this.headerHeight;
+		if (this.exceptionRows.length === 0) return clamp$1(Math.floor(past / this.rowHeight), 0, last);
+		if (past <= 0) return 0;
+		const index = this.exceptionAt(past);
+		if (index === -1) return clamp$1(Math.floor(past / this.rowHeight), 0, last);
+		const start = this.exceptionStarts[index];
+		const height = this.exceptionHeights[index];
+		if (past < start + height) return clamp$1(this.exceptionRows[index], 0, last);
+		return clamp$1(this.exceptionRows[index] + 1 + Math.floor((past - start - height) / this.rowHeight), 0, last);
+	}
+	/**
+	* The column at a content offset, clamped to the sheet.
+	*
+	* A binary search over the prefix sum when the columns differ, and
+	* a division when they do not — the uniform case is the common one
+	* and should not pay for the general one.
+	*/
+	columnAt(offset) {
+		const last = Math.max(0, this.columnCount - 1);
+		const past = offset - this.gutterWidth;
+		if (this.widths === void 0) return clamp$1(Math.floor(past / this.uniformWidth), 0, last);
+		if (past <= 0) return 0;
+		if (past >= this.columnsWidth) return last;
+		let low = 0;
+		let high = last;
+		while (low < high) {
+			const mid = low + high + 1 >> 1;
+			if (this.offsets[mid] <= past) low = mid;
+			else high = mid - 1;
+		}
+		return low;
+	}
+	setRowCount(count) {
+		if (count === this.rowCount) return;
+		this.rowCount = Math.max(0, Math.floor(count));
+		this.invalidate();
+	}
+	setColumnCount(count) {
+		if (count === this.columnCount) return;
+		this.columnCount = Math.max(0, Math.floor(count));
+		this.invalidate();
+	}
+	/**
+	* The bands, which the spike tunes from the screen.
+	*
+	* A band is the only defence against the round trip to the
+	* application thread: rows inside it already hold their values when
+	* the scroll reaches them. Widening it costs nodes on every frame
+	* and cells on every publish, so what it should be is a measurement,
+	* not a default — hence setters rather than a constant.
+	*/
+	setOverscan(rows, columns) {
+		const nextRows = Math.max(0, Math.floor(rows));
+		const nextColumns = Math.max(0, Math.floor(columns));
+		if (nextRows === this.rowOverscan && nextColumns === this.columnOverscan) return;
+		this.rowOverscan = nextRows;
+		this.columnOverscan = nextColumns;
+		this.invalidate();
+	}
+	/**
+	* How many rows and columns stay put while the rest scrolls.
+	*
+	* Freezing changes which rows are in the scrolled window, so every
+	* mounted row is rebuilt — a row that was scrolling is now frozen
+	* or the other way about.
+	*/
+	setFrozen(rows, columns) {
+		const nextRows = Math.max(0, Math.floor(rows));
+		const nextColumns = Math.max(0, Math.floor(columns));
+		if (nextRows === this.frozenRows && nextColumns === this.frozenColumns) return;
+		this.frozenRows = nextRows;
+		this.frozenColumns = nextColumns;
+		this.invalidate();
+	}
+	/** Drops every mounted row and rebuilds against the last viewport. */
+	invalidate() {
+		this.mountedRows.clear();
+		this.frozenMounted.clear();
+		this.mountedHeader = void 0;
+		this.range = EMPTY_RANGE;
+		this.recompute();
+	}
+	/**
+	* One step, run by the host each frame before layout.
+	*
+	* Nothing is measured and nothing is anchored: the offsets are exact,
+	* so the rows a scroll reveals are placed correctly on the frame
+	* that reveals them rather than corrected on the one after.
+	*/
+	update(viewport) {
+		this.viewport = viewport;
+		this.recompute();
+	}
+	recompute() {
+		const next = this.windowFor(this.viewport);
+		if (sameRange(next, this.range)) return;
+		if (next.firstColumn !== this.range.firstColumn || next.lastColumn !== this.range.lastColumn) {
+			this.mountedRows.clear();
+			this.frozenMounted.clear();
+			this.mountedHeader = void 0;
+		}
+		this.range = next;
+		this.children$.next(this.buildChildren());
+		this.range$.next(next);
+	}
+	/**
+	* The window, in content coordinates.
+	*
+	* The header and the gutter are *content*: they occupy the first
+	* `headerHeight` pixels and the first `gutterWidth`, and `rowAt` and
+	* `columnAt` already subtract them. So the range comes out slightly
+	* generous at the near edges — the rows a header is covering are
+	* mounted, and the columns behind the gutter are too — which is
+	* correct rather than wasteful, since a sticky strip is drawn over
+	* cells that are really there.
+	*/
+	windowFor(viewport) {
+		if (this.rowCount === 0 || this.columnCount === 0) return EMPTY_RANGE;
+		const firstRow = Math.max(this.frozenRows, this.rowAt(viewport.scrollY) - this.rowOverscan);
+		const lastRow = Math.min(this.rowCount - 1, this.rowAt(viewport.scrollY + Math.max(0, viewport.height)) + this.rowOverscan);
+		const firstColumn = Math.max(this.frozenColumns, this.columnAt(viewport.scrollX) - this.columnOverscan);
+		const lastColumn = Math.min(this.columnCount - 1, this.columnAt(viewport.scrollX + Math.max(0, viewport.width)) + this.columnOverscan);
+		const range = {
+			firstRow,
+			lastRow,
+			firstColumn,
+			lastColumn
 		};
-		case "Backspace":
-			if (mac && modifiers.meta) return {
-				kind: "delete",
-				unit: "line",
-				direction: -1
-			};
-			return {
-				kind: "delete",
-				unit: word ? "word" : "grapheme",
-				direction: -1
-			};
-		case "Delete": return {
-			kind: "delete",
-			unit: word ? "word" : "grapheme",
-			direction: 1
+		if (this.extendRange === void 0) return range;
+		const wanted = this.extendRange(range);
+		return {
+			firstRow: clamp$1(Math.min(wanted.firstRow, firstRow), this.frozenRows, firstRow),
+			lastRow: clamp$1(Math.max(wanted.lastRow, lastRow), lastRow, this.rowCount - 1),
+			firstColumn: clamp$1(Math.min(wanted.firstColumn, firstColumn), this.frozenColumns, firstColumn),
+			lastColumn: clamp$1(Math.max(wanted.lastColumn, lastColumn), lastColumn, this.columnCount - 1)
 		};
-		case "Enter": return primary ? null : { kind: "newline" };
 	}
-	if (primary && !modifiers.alt) {
-		switch (key.toLowerCase()) {
-			case "a": return { kind: "selectAll" };
-			case "z": return modifiers.shift ? { kind: "redo" } : { kind: "undo" };
-			case "y": return mac ? null : { kind: "redo" };
+	buildChildren() {
+		const { firstRow, lastRow, firstColumn, lastColumn } = this.range;
+		if (lastRow < firstRow) return [];
+		const width = this.contentWidth;
+		const lead = this.offsetOf(firstColumn) - this.frozenWidth;
+		const children = [];
+		if (this.renderHeader !== void 0) {
+			this.mountedHeader ??= this.wrapHeader(this.renderHeader(firstColumn, lastColumn), width, lead);
+			children.push(this.mountedHeader);
+		}
+		for (let row = 0; row < this.frozenRows && row < this.rowCount; row++) {
+			let built = this.frozenMounted.get(row);
+			if (built === void 0) {
+				built = this.wrap(row, width, lead);
+				this.frozenMounted.set(row, built);
+			}
+			children.push(built);
+		}
+		children.push(spacer("sheet:top", this.rowOffsetOf(firstRow) - this.rowOffsetOf(this.frozenRows)));
+		for (const row of this.mountedRows.keys()) if (row < firstRow || row > lastRow) this.mountedRows.delete(row);
+		for (let row = firstRow; row <= lastRow; row++) {
+			let built = this.mountedRows.get(row);
+			if (built === void 0) {
+				built = this.wrap(row, width, lead);
+				this.mountedRows.set(row, built);
+			}
+			children.push(built);
 		}
-		return null;
+		children.push(spacer("sheet:bottom", this.rowsHeight - this.rowOffsetOf(lastRow + 1)));
+		return children;
 	}
-	if (textFromKeys && isPrintable(key) && !modifiers.ctrl && !modifiers.meta) return {
-		kind: "insert",
-		text: key
-	};
-	return null;
+	/**
+	* The header, given the same geometry a row gets.
+	*
+	* Its own children are laid out exactly like a row's, so that a
+	* column header lines up with the column under it without either
+	* being told where the other is: the same leading spacer, the same
+	* gutter-sized first cell, the same widths.
+	*/
+	wrapHeader(built, width, lead) {
+		if (!isRowElement(built)) throw new Error("A sheet's header must be a Row element, laid out like the rows it labels.");
+		return {
+			...built,
+			props: {
+				...built.props,
+				key: "sheet:header",
+				width,
+				height: this.headerHeight,
+				flexShrink: 0
+			},
+			children: this.withLead(built.children, lead)
+		};
+	}
+	/**
+	* A row's children with the leading spacer in the right place.
+	*
+	* With a gutter, the renderer's first child *is* the gutter: it sits
+	* at content x 0 and the columns begin past it, so the spacer for
+	* the columns scrolled out of view goes after it. Without one the
+	* spacer goes first. Either way the renderer is handed a range of
+	* columns and never has to know where the window is.
+	*/
+	withLead(children, lead) {
+		const pad = spacer("sheet:lead", void 0, lead);
+		const stays = (this.gutterWidth > 0 ? 1 : 0) + this.frozenColumns;
+		if (stays === 0) return [pad, ...children];
+		return [
+			...children.slice(0, stays),
+			pad,
+			...children.slice(stays)
+		];
+	}
+	/**
+	* The row the renderer returned, given its place in the sheet.
+	*
+	* The leading spacer is prepended here rather than asked of the
+	* renderer, because it is windowing bookkeeping and not a cell: it is
+	* what puts column `firstColumn` at its own offset without the row
+	* holding the columns to its left.
+	*/
+	wrap(row, width, lead) {
+		const built = this.renderRow(row, this.range.firstColumn, this.range.lastColumn);
+		if (!isRowElement(built)) throw new Error(`A sheet row must be a Row element; row ${row} rendered something else. Its cells are laid out along one axis at widths the window already knows.`);
+		return {
+			...built,
+			props: {
+				...built.props,
+				key: `sheet:row:${row}`,
+				width,
+				height: this.rowHeightOf(row),
+				flexShrink: 0
+			},
+			children: this.withLead(built.children, lead)
+		};
+	}
+};
+function spacer(key, height, width) {
+	return Box({
+		key,
+		height,
+		width,
+		flexShrink: 0
+	});
+}
+function isRowElement(child) {
+	return typeof child === "object" && child !== null && child.type === "row" && Array.isArray(child.children);
+}
+function sameRange(a, b) {
+	return a.firstRow === b.firstRow && a.lastRow === b.lastRow && a.firstColumn === b.firstColumn && a.lastColumn === b.lastColumn;
 }
-/** A key value that is the character it types: one grapheme, not a name like 'Shift'. */
-function isPrintable(key) {
-	if (key.length === 1) return true;
-	if (key.length === 2) {
-		const code = key.charCodeAt(0);
-		return code >= 55296 && code <= 56319;
+function clamp$1(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function positive(name, value) {
+	if (!(value > 0)) throw new Error(`LazySheet ${name} must be positive, got ${String(value)}.`);
+	return value;
+}
+/**
+* Feeds a sheet the inputs that may change, with the node's lifetime.
+*
+* The same reasoning as `lazySource`: a modifier is released inside
+* `removeSubtree`, and it attaches after the element's props and
+* before its children, so a count that arrives with the tree is in the
+* window before the first children are read from it.
+*/
+const sheetSource = defineModifier({
+	name: "sheetSource",
+	attach(host, args) {
+		follow$1(host, args.rowCount, (value) => args.sheet.setRowCount(value));
+		follow$1(host, args.columnCount, (value) => args.sheet.setColumnCount(value));
+		let rows;
+		let columns;
+		const apply = () => {
+			if (rows !== void 0 || columns !== void 0) args.sheet.setOverscan(rows ?? 3, columns ?? 2);
+		};
+		if (args.rowOverscan !== void 0) follow$1(host, args.rowOverscan, (value) => {
+			rows = value;
+			apply();
+		});
+		if (args.columnOverscan !== void 0) follow$1(host, args.columnOverscan, (value) => {
+			columns = value;
+			apply();
+		});
 	}
-	return false;
+});
+function follow$1(host, source, apply) {
+	if (!isObservable$1(source)) {
+		apply(source);
+		return;
+	}
+	host.own(source.subscribe((value) => {
+		apply(value);
+		host.requestFrame();
+	}));
+}
+/**
+* A scrolling surface that mounts only the cells in view, on both axes.
+*
+*   LazySheet({ rowCount: 10_000, columnCount: 100, rowHeight: 24, columnWidth: 96 },
+*     (row, first, last) => Row({}, ...cells(row, first, last)))
+*
+* It is a ScrollView whose children are a spacer for the rows above
+* the window, the mounted rows, and a spacer for the rows below; each
+* row carries a spacer for the columns to its left and is as wide as
+* the whole sheet, so the container's content extent — and both
+* scrollbars — are the sheet's real size on the first frame rather
+* than an estimate that settles.
+*/
+function LazySheet(props, renderRow) {
+	const { rowCount, columnCount, rowHeight, rowHeights, columnWidth, rowOverscan, columnOverscan, gutterWidth, headerHeight, frozenRows, frozenColumns, header, extendRange, modifiers, sheetRef, ...rest } = props;
+	const sheet = new UiVirtualSheet({
+		rowCount,
+		columnCount,
+		rowHeight,
+		rowHeights,
+		columnWidth,
+		rowOverscan,
+		columnOverscan,
+		gutterWidth,
+		headerHeight,
+		frozenRows,
+		frozenColumns,
+		extendRange
+	}, renderRow, header);
+	sheetRef?.(sheet);
+	return createElement("scroll-view", {
+		...rest,
+		modifiers: [...modifiers ?? [], sheetSource({
+			sheet,
+			rowCount,
+			columnCount,
+			rowOverscan,
+			columnOverscan
+		})],
+		direction: "column",
+		[VIRTUAL_SHEET_PROP]: sheet
+	}, [sheet.children$]);
 }
 //#endregion
 //#region src/environment/EnvironmentNotifier.ts
@@ -4328,449 +4819,6 @@ function dragSessionFor(node) {
 	return session;
 }
 //#endregion
-//#region src/input/UiEditingController.ts
-/** How long two presses may be apart and still count as a double click. */
-const MULTI_CLICK_MS$1 = 500;
-const MULTI_CLICK_SLOP$1 = 4;
-/** Room kept around the caret when scrolling it into view. */
-const CARET_REVEAL_PADDING = 4;
-/**
-* Editing behaviour for EditableText nodes.
-*
-* The keyboard and pointer controllers call in here as their default
-* behaviour for an editable target — after the app's listeners have
-* run and only when none of them called preventDefault() — and the
-* host feeds it the shell's text input: `beforeinput` edits,
-* composition, paste. The model on the node is the single source of
-* truth; this class turns intents into model changes, marks the node
-* dirty so layout and paint follow, reports the change through an
-* `input` event, and keeps the caret in view.
-*
-* Text arrives one of two ways. A shell with an editing proxy sends
-* `beforeinput`, where the browser has already resolved the IME, dead
-* keys and the keyboard layout; then printable key presses are not
-* text and `textFromKeys` is off. Without a proxy — tests, a bare
-* runtime — printable keys become insertions.
-*/
-var UiEditingController = class {
-	host;
-	dispatcher;
-	focus;
-	/** Insert printable key presses as text; off when a shell delivers text through beforeinput. */
-	textFromKeys = true;
-	platform;
-	paint = createPaintState();
-	focusedEditable = null;
-	visible = true;
-	/** x the current run of vertical moves keeps returning to. */
-	verticalGoalX = void 0;
-	dragging = null;
-	lastPress = null;
-	compositionOpen = false;
-	constructor(host, dispatcher, focus, options = {}) {
-		this.host = host;
-		this.dispatcher = dispatcher;
-		this.focus = focus;
-		this.platform = options.platform ?? detectEditingPlatform();
-		this.focus.onFocusChange((node) => this.handleFocusChange(node));
-	}
-	/** The editable that holds focus, or null. */
-	get focused() {
-		return this.focusedEditable;
-	}
-	/** Whether the pointer controller should hand presses on the node to this controller. */
-	isEditable(node) {
-		return isEditableNode(node);
-	}
-	/**
-	* Default keyboard behaviour for the focused editable. Returns true
-	* when the key was an editing command, so the caller can mark the
-	* event handled.
-	*/
-	handleKey(node, key, modifiers) {
-		if (!isEditableNode(node)) return false;
-		const command = commandForKey(key, modifiers, this.platform, this.textFromKeys);
-		if (command === null) return false;
-		return this.execute(node, command);
-	}
-	execute(node, command) {
-		const model = editorFor(node);
-		const readOnly = isReadOnly(node);
-		switch (command.kind) {
-			case "move":
-				this.move(node, model, command.unit, command.direction, command.extend);
-				return true;
-			case "delete":
-				if (readOnly) return true;
-				return this.applyEdit(node, model, deleteInputType(command.unit, command.direction), null, () => {
-					if (command.direction < 0) model.deleteBackward(command.unit);
-					else model.deleteForward(command.unit);
-				});
-			case "newline":
-				if (!isMultiline(node)) return false;
-				if (readOnly) return true;
-				return this.applyEdit(node, model, "insertLineBreak", "\n", () => model.insertText("\n"));
-			case "insert":
-				if (readOnly) return true;
-				return this.applyEdit(node, model, "insertText", command.text, () => model.insertText(command.text));
-			case "selectAll":
-				model.selectAll();
-				this.afterSelectionChange(node, model);
-				return true;
-			case "undo":
-				if (readOnly) return true;
-				this.history(node, model, "historyUndo", () => model.undo());
-				return true;
-			case "redo":
-				if (readOnly) return true;
-				this.history(node, model, "historyRedo", () => model.redo());
-				return true;
-		}
-	}
-	move(node, model, unit, direction, extend) {
-		if (unit === "vertical") {
-			const target = this.layoutOf(node).verticalMove(model.focus, direction, this.verticalGoalX);
-			if (target === null) {
-				model.moveTo(direction < 0 ? 0 : model.text.length, extend);
-				this.verticalGoalX = void 0;
-			} else {
-				model.moveTo(target.offset, extend);
-				this.verticalGoalX = target.x;
-			}
-			this.afterSelectionChange(node, model, true);
-			return;
-		}
-		if (unit === "line") {
-			const layout = this.layoutOf(node);
-			const caret = layout.caretRect(model.focus);
-			const line = layout.lines[caret.line];
-			const hard = direction < 0 ? lineStartAt(model.text, model.focus) : lineEndAt(model.text, model.focus);
-			const visual = direction < 0 ? line.start : line.end;
-			model.moveTo(direction < 0 ? Math.max(hard, visual) : Math.min(hard, visual), extend);
-			this.afterSelectionChange(node, model);
-			return;
-		}
-		model.move(unit, direction, extend);
-		this.afterSelectionChange(node, model);
-	}
-	/**
-	* A `beforeinput` from the shell's editing proxy, in the DOM's
-	* vocabulary. Returns true when it was applied to the focused
-	* editable. Composition types are not handled here: the composition
-	* methods carry them, and an engine that fires both must not insert
-	* twice.
-	*/
-	beforeInput(inputType, data) {
-		const node = this.focusedEditable;
-		if (node === null) return false;
-		const model = editorFor(node);
-		const readOnly = isReadOnly(node);
-		switch (inputType) {
-			case "insertText":
-			case "insertReplacementText":
-			case "insertFromDrop":
-			case "insertFromYank":
-				if (data === null || data.length === 0) return false;
-				return readOnly || this.insert(node, model, inputType, data);
-			case "insertFromPaste": return readOnly || data !== null && this.insert(node, model, inputType, data);
-			case "insertLineBreak":
-			case "insertParagraph":
-				if (!isMultiline(node)) return false;
-				return readOnly || this.applyEdit(node, model, inputType, "\n", () => model.insertText("\n"));
-			case "deleteContentBackward":
-			case "deleteWordBackward":
-			case "deleteSoftLineBackward":
-			case "deleteHardLineBackward":
-			case "deleteContentForward":
-			case "deleteWordForward":
-			case "deleteSoftLineForward":
-			case "deleteHardLineForward":
-			case "deleteContent":
-			case "deleteByCut":
-			case "deleteByDrag": {
-				if (readOnly) return true;
-				const unit = /Word/.test(inputType) ? "word" : /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, "");
-					else if (forward) model.deleteForward(unit);
-					else model.deleteBackward(unit);
-				});
-			}
-			case "historyUndo": return readOnly || this.history(node, model, inputType, () => model.undo());
-			case "historyRedo": return readOnly || this.history(node, model, inputType, () => model.redo());
-			default: return false;
-		}
-	}
-	/** Inserts text at the selection of the focused editable, as typing would. */
-	insertText(text) {
-		const node = this.focusedEditable;
-		if (node === null || isReadOnly(node)) return false;
-		return this.insert(node, editorFor(node), "insertText", text);
-	}
-	/**
-	* Replaces the focused editable's whole text, as an assistive
-	* technology's "set value" does.
-	*
-	* `insertReplacementText` is the DOM's own input type for this, so an
-	* `onBeforeInput` that vets edits sees the same vocabulary it sees
-	* for typing, and an app that rejects the edit rejects this one too.
-	* Selecting everything first is what makes it one undo step and one
-	* `onInput` rather than a delete and an insert.
-	*/
-	replaceText(text) {
-		const node = this.focusedEditable;
-		if (node === null || isReadOnly(node)) return false;
-		const model = editorFor(node);
-		model.selectAll();
-		return this.insert(node, model, "insertReplacementText", text);
-	}
-	/** Pastes text: newlines are kept in a multiline field and become spaces in a single-line one. */
-	paste(text) {
-		const node = this.focusedEditable;
-		if (node === null || isReadOnly(node)) return false;
-		return this.insert(node, editorFor(node), "insertFromPaste", text);
-	}
-	insert(node, model, inputType, text) {
-		const data = isMultiline(node) ? text : text.replace(/\r\n|\r|\n/g, " ");
-		return this.applyEdit(node, model, inputType, data, () => model.insertText(data));
-	}
-	compositionStart() {
-		const node = this.focusedEditable;
-		if (node === null || isReadOnly(node)) return;
-		const model = editorFor(node);
-		model.beginComposition();
-		this.compositionOpen = true;
-		this.afterTextChange(node, model, false);
-	}
-	/** The composition text so far and the caret within it. */
-	compositionUpdate(text, caret = text.length) {
-		const node = this.focusedEditable;
-		if (node === null || isReadOnly(node)) return;
-		const model = editorFor(node);
-		model.updateComposition(text, caret);
-		this.compositionOpen = true;
-		this.afterTextChange(node, model, false);
-	}
-	/** The IME committed `text` (possibly empty: the composition was cancelled). */
-	compositionEnd(text) {
-		const node = this.focusedEditable;
-		this.compositionOpen = false;
-		if (node === null || isReadOnly(node)) return;
-		const model = editorFor(node);
-		const data = isMultiline(node) ? text : text.replace(/\r\n|\r|\n/g, " ");
-		const before = model.text;
-		model.commitComposition(data);
-		this.afterTextChange(node, model, before !== model.text);
-	}
-	/**
-	* A press on an editable places the caret (Shift extends the
-	* selection to it); a second press within the double-click window
-	* selects the word, a third the line. Dragging afterwards extends the
-	* selection from the anchor.
-	*/
-	pointerDown(node, x, y, modifiers) {
-		if (!isEditableNode(node)) return;
-		const model = editorFor(node);
-		const layout = this.layoutOf(node);
-		const local = this.host.toLocal(node, x, y);
-		const offset = layout.offsetAt(local.x, local.y);
-		const now = this.host.now();
-		const last = this.lastPress;
-		const count = !modifiers.shift && last !== null && last.node === node && now - last.at <= MULTI_CLICK_MS$1 && Math.abs(last.x - x) <= MULTI_CLICK_SLOP$1 && Math.abs(last.y - y) <= MULTI_CLICK_SLOP$1 ? last.count + 1 : 1;
-		this.lastPress = {
-			node,
-			x,
-			y,
-			at: now,
-			count
-		};
-		this.dragging = node;
-		if (modifiers.shift) model.moveTo(offset, true);
-		else if (count === 2) {
-			const word = wordRangeAt(model.text, offset);
-			model.select(word.start, word.end);
-		} else if (count >= 3) model.select(lineStartAt(model.text, offset), lineEndAt(model.text, offset));
-		else model.select(offset);
-		model.breakUndoGroup();
-		this.afterSelectionChange(node, model);
-	}
-	pointerMove(node, x, y) {
-		if (this.dragging !== node) return;
-		const model = editorFor(node);
-		const layout = this.layoutOf(node);
-		const local = this.host.toLocal(node, x, y);
-		const offset = layout.offsetAt(local.x, local.y);
-		if (offset !== model.focus) {
-			model.moveTo(offset, true);
-			this.afterSelectionChange(node, model);
-		}
-	}
-	pointerUp() {
-		this.dragging = null;
-	}
-	/** The focused editable's state for the shell to mirror, or null. */
-	state() {
-		const node = this.focusedEditable;
-		if (node === null || this.host.recordFor(node) === void 0) return null;
-		const model = editorFor(node);
-		const caret = this.layoutOf(node).caretRect();
-		const visible = this.host.visibleBox(node);
-		return {
-			text: model.text,
-			selectionStart: model.start,
-			selectionEnd: model.end,
-			caret: {
-				x: visible.x + caret.x,
-				y: visible.y + caret.y,
-				width: 1,
-				height: caret.height
-			},
-			multiline: isMultiline(node),
-			composing: model.composing
-		};
-	}
-	/**
-	* When the focused caret next toggles, or undefined when nothing
-	* blinks: no focused editable, a composition in progress (the caret
-	* holds), or a hidden page.
-	*/
-	nextCaretChange(now) {
-		const node = this.focusedEditable;
-		if (node === null || !this.visible) return;
-		const model = editorFor(node);
-		if (model.composing || !model.collapsed) return;
-		return nextCaretToggle(model, now);
-	}
-	/**
-	* The page was hidden or shown. A hidden page stops the blink so a
-	* background tab schedules no frames; showing it restarts the caret.
-	*/
-	setVisible(visible) {
-		if (this.visible === visible) return;
-		this.visible = visible;
-		const node = this.focusedEditable;
-		if (node !== null) {
-			editorFor(node).blinkOrigin = this.host.now();
-			this.host.markDirty(node, 2);
-		}
-	}
-	/** Whether the caret may be drawn at all (the page is visible). */
-	get caretEnabled() {
-		return this.visible;
-	}
-	handleFocusChange(node) {
-		const previous = this.focusedEditable;
-		const next = node !== null && isEditableNode(node) ? node : null;
-		if (previous === next) return;
-		if (previous !== null) {
-			const model = editorFor(previous);
-			if (model.composing) model.commitComposition(model.text.slice(model.composition.start, model.composition.end));
-			model.focused = false;
-			this.host.markDirty(previous, 2);
-		}
-		this.focusedEditable = next;
-		this.compositionOpen = false;
-		this.verticalGoalX = void 0;
-		if (next !== null) {
-			const model = editorFor(next);
-			model.focused = true;
-			model.blinkOrigin = this.host.now();
-			this.host.markDirty(next, 2);
-		}
-	}
-	/**
-	* Runs an edit unless a `beforeinput` listener cancels it, then
-	* reports it. Returns true when the input was consumed either way.
-	*/
-	applyEdit(node, model, inputType, data, run) {
-		const before = new UiBeforeInputEvent(inputType, data);
-		this.dispatcher.dispatch(before, node);
-		if (before.defaultPrevented) return true;
-		const text = model.text;
-		run();
-		this.afterTextChange(node, model, text !== model.text);
-		return true;
-	}
-	history(node, model, inputType, run) {
-		const before = new UiBeforeInputEvent(inputType, null);
-		this.dispatcher.dispatch(before, node);
-		if (before.defaultPrevented) return true;
-		const text = model.text;
-		run();
-		this.afterTextChange(node, model, text !== model.text);
-		return true;
-	}
-	afterTextChange(node, model, changed) {
-		this.verticalGoalX = void 0;
-		model.blinkOrigin = this.host.now();
-		this.host.markDirty(node, changed || this.compositionOpen ? 5 : 2);
-		if (changed) this.dispatcher.dispatch(new UiTextChangeEvent(model.text, model.start, model.end), node);
-		this.revealCaret(node);
-	}
-	afterSelectionChange(node, model, keepGoal = false) {
-		if (!keepGoal) this.verticalGoalX = void 0;
-		model.blinkOrigin = this.host.now();
-		this.host.markDirty(node, 2);
-		this.revealCaret(node);
-	}
-	/**
-	* Asks the host to scroll the caret into view, when the node has been
-	* laid out: the field's own text first, then any scroll container
-	* around it.
-	*
-	* `layoutOf` places the text where it is seen, so the caret comes
-	* back with the field's own scroll already taken off; the reveal is
-	* asked for in the node's unscrolled coordinates, which is where the
-	* offset it wants is measured from.
-	*/
-	revealCaret(node) {
-		const rec = this.host.recordFor(node);
-		if (rec === void 0) return;
-		const caret = this.layoutOf(node).caretRect();
-		this.host.reveal(node, {
-			x: caret.x + rec.scrollX - CARET_REVEAL_PADDING,
-			y: caret.y + rec.scrollY - CARET_REVEAL_PADDING,
-			width: 9,
-			height: caret.height + 8
-		});
-	}
-	/**
-	* The node's text laid out in node-local coordinates: the content box
-	* starts at the padding and is shifted by the field's own scroll, as
-	* it is for the renderers in the parent's space. Points from the
-	* pointer and the caret box the shell is given are both in that same
-	* seen space, so neither has to know the offset. Before the first
-	* layout the record is empty and the lines fall at the origin, which
-	* is still a valid place for a caret.
-	*/
-	layoutOf(node) {
-		const rec = this.host.recordFor(node);
-		const state = resolvePaintState(node, this.paint);
-		const box = rec === void 0 ? {
-			x: 0,
-			y: 0,
-			width: 0,
-			height: 0
-		} : {
-			x: rec.paddingLeft - rec.scrollX,
-			y: rec.paddingTop - rec.scrollY,
-			width: Math.max(0, rec.width - rec.paddingLeft - rec.paddingRight),
-			height: Math.max(0, rec.height - rec.paddingTop - rec.paddingBottom)
-		};
-		return new EditableLayout(state.editor, box, state, this.host.measurer);
-	}
-};
-function deleteInputType(unit, direction) {
-	const side = direction < 0 ? "Backward" : "Forward";
-	switch (unit) {
-		case "word": return `deleteWord${side}`;
-		case "line":
-		case "document": return `deleteSoftLine${side}`;
-		default: return `deleteContent${side}`;
-	}
-}
-//#endregion
 //#region src/layout/LayoutNotifier.ts
 /**
 * Tells listeners when a node's layout changed.
@@ -4976,6 +5024,110 @@ const DEFAULT_RING = kind$3(Object.freeze({}));
 function focusRing(options) {
 	return options === void 0 ? DEFAULT_RING : kind$3(options);
 }
+/**
+* A border per edge, as paint rather than as layout.
+*
+* `borderWidth` is one number and `borderColor` one colour, so a node
+* cannot have a heavy bottom edge and a hairline top. This is the gap
+* closed from the cheap side. A border in Gesso is paint-only —
+* `paintBorder` strokes inside the box and touches no layout — so four
+* edges are four filled rectangles in the node's own paint pass, with
+* nothing to lay out and nothing to hit test. A bordered cell costs
+* four draw instances and no extra nodes.
+*
+*   Box({ modifiers: [borders({ bottom: 2, right: 1, color: 'border' })] })
+*
+* They lie *inside* the box, where `borderWidth` puts them, so a border
+* never changes where anything sits and never overlaps a neighbour.
+*
+* **Why this is a modifier and not four props, and why that is the
+* answer rather than a stopgap.** First-class `borderTopWidth` is a
+* much larger change, and the cost is not where it looks: the
+* property, the paint state and the Canvas2D stroke are easy, but the
+* WebGPU instance packs `radius, opacity, borderWidth` as one
+* `float32x3`, the fragment shader draws the border as an isotropic
+* SDF band, and one instance carries one colour — so four widths need
+* a wider vertex format, an anisotropic inner rect in the shader, and
+* up to four instances when the colours differ. This needs none of it,
+* because a decoration is already a rectangle with its own colour that
+* both backends draw.
+*
+* What the properties would buy over this, once written, is a rounded
+* per-edge border and one instance instead of four. The first is a
+* thing square-cornered borders are for — a grid, a table, a rule —
+* and the second is four draws on a node that already costs one. So
+* the properties are not planned. If something turns up that wants a
+* heavy bottom edge on a rounded card, that is the case to reopen it
+* with, and it will be a better case than "for completeness".
+*
+* What it does not do is round its corners. Four rectangles meeting at
+* a square corner is right for a grid, a table and a rule, which is
+* what per-edge borders are for; a rounded box wants the single
+* `borderWidth`, which the renderers draw as one band and get right.
+*/
+function borders(options) {
+	return decorated(borderShapes(options));
+}
+/**
+* The rectangles `borders()` draws, without the modifier around them.
+*
+* For a surface that cannot afford a modifier per node and pushes its
+* decorations in instead. A spreadsheet is the case: ten thousand
+* mounted cells, each with its own border, fed from one writer into a
+* subject per cell — a modifier per cell would be ten thousand
+* attachments to do what ten thousand array writes already do. The
+* arithmetic is the same either way, and sharing it is the point:
+* an application that rolled its own would be the second place a
+* corner could be painted twice.
+*/
+function borderShapes(options) {
+	const shared = options.color ?? "border";
+	const edge = (side) => {
+		if (side === void 0) return;
+		const resolved = typeof side === "number" ? { width: side } : side;
+		return resolved.width > 0 ? resolved : void 0;
+	};
+	const top = edge(options.top);
+	const bottom = edge(options.bottom);
+	const left = edge(options.left);
+	const right = edge(options.right);
+	const between = {
+		y: top?.width ?? 0,
+		bottom: bottom?.width ?? 0
+	};
+	const shapes = [];
+	if (top !== void 0) shapes.push({
+		kind: "fill",
+		color: top.color ?? shared,
+		y: 0,
+		height: top.width,
+		radius: 0
+	});
+	if (bottom !== void 0) shapes.push({
+		kind: "fill",
+		color: bottom.color ?? shared,
+		bottom: 0,
+		height: bottom.width,
+		radius: 0
+	});
+	if (left !== void 0) shapes.push({
+		kind: "fill",
+		color: left.color ?? shared,
+		x: 0,
+		width: left.width,
+		radius: 0,
+		...between
+	});
+	if (right !== void 0) shapes.push({
+		kind: "fill",
+		color: right.color ?? shared,
+		right: 0,
+		width: right.width,
+		radius: 0,
+		...between
+	});
+	return shapes;
+}
 //#endregion
 //#region src/modifiers/focus.ts
 /**
@@ -9660,12 +9812,16 @@ function buildRenderList(root, layout, measurer, logicalWidth, logicalHeight, dp
 			if (text.editor !== void 0) {
 				const model = text.editor;
 				const editable = new EditableLayout(model, contentBox, text, measurer);
+				pushTextRects(textRunBackgrounds(editable.lines, text));
 				if (model.focused && !model.collapsed) {
 					const selection = parseColor$1(text.selectionColor);
 					if (selection !== void 0) for (const box of editable.selectionBoxes()) pushContentRect(box, selection);
 				}
 				if (editable.placeholderLines.length > 0) pushTextRun(editable.placeholderLines, colorToCss(text.placeholderColor));
-				else pushTextRun(editable.lines, colorToCss(text.textColor));
+				else {
+					pushTextRun(editable.lines, colorToCss(text.textColor));
+					pushTextRects(textRunDecorations(editable.lines, text));
+				}
 				if (model.composing) {
 					const underline = parseColor$1(text.textColor);
 					if (underline !== void 0) {
@@ -13380,6 +13536,7 @@ var UiScheduler = class {
 	dirty;
 	onFrame;
 	beforeCollect;
+	onFrameError;
 	disposed = false;
 	active = true;
 	pending = false;
@@ -13398,6 +13555,9 @@ var UiScheduler = class {
 		this.dirty = options.dirty;
 		this.onFrame = options.onFrame;
 		this.beforeCollect = options.beforeCollect;
+		this.onFrameError = options.onFrameError ?? ((error) => {
+			console.error("A Gesso frame threw. The frame was abandoned and the clock kept running.", error);
+		});
 		this.clock = options.clock((time) => {
 			this.handleFrame(time);
 		});
@@ -13505,30 +13665,42 @@ var UiScheduler = class {
 		this.collecting = true;
 		let frame;
 		let collected = 0;
+		/**
+		* Everything a frame does, inside one guard.
+		*
+		* The guard is the whole point: an exception used to unwind past
+		* the re-arm at the bottom of this method, and since `pending` had
+		* already been cleared at the top, nothing asked for another
+		* frame. One throw stopped the application for good.
+		*/
 		try {
-			this.beforeCollect?.(time);
+			try {
+				this.beforeCollect?.(time);
+				if (measuring) {
+					collected = markNow();
+					measureSpan("before collect", started, collected);
+				}
+				frame = this.collectFrame(time);
+			} finally {
+				this.collecting = false;
+			}
+			let processed = 0;
 			if (measuring) {
-				collected = markNow();
-				measureSpan("before collect", started, collected);
+				processed = markNow();
+				measureSpan("collect", collected, processed);
 			}
-			frame = this.collectFrame(time);
-		} finally {
-			this.collecting = false;
-		}
-		let processed = 0;
-		if (measuring) {
-			processed = markNow();
-			measureSpan("collect", collected, processed);
-		}
-		if (frame.size > 0) this.onFrame(frame);
-		if (measuring) {
-			const finished = markNow();
-			const detail = {
-				frame: frame.id,
-				nodes: frame.size
-			};
-			measureSpan("process", processed, finished, detail);
-			measureSpan("frame", started, finished, detail);
+			if (frame.size > 0) this.onFrame(frame);
+			if (measuring) {
+				const finished = markNow();
+				const detail = {
+					frame: frame.id,
+					nodes: frame.size
+				};
+				measureSpan("process", processed, finished, detail);
+				measureSpan("frame", started, finished, detail);
+			}
+		} catch (error) {
+			this.onFrameError(error, time);
 		}
 		if (!this.dirty.isEmpty()) this.notifyDirty();
 	}
@@ -14667,6 +14839,6 @@ function recordsEqual(a, b) {
 	return true;
 }
 //#endregion
-export { AlignContent, AnimationDriver, BUTTON_INTERACTION, Box, Button, CARET_BLINK_MS, CARET_WIDTH, CLIP_STRIDE_BYTES, CLIP_STRIDE_FLOATS, Canvas2DRenderer, CanvasPlatformSurface, CanvasSurface, CanvasTextMeasurer, CharacterCountTextMeasurer, Column, CommandKind, Constraints, CrossAxisAlignment, DEFAULT_BLOCK_SIZE, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_FONT_WEIGHT, DEFAULT_LINE_HEIGHT_FACTOR, DEFAULT_TEXT_COLOR, DefaultImageResolver, DefaultVideoResolver, DirtyFlags, DirtyNodeSet, EDITOR_PROP, ELLIPSIS, EMPTY_RECORDING, EXTERNAL_FILES, EditableLayout, EditableText, EditableTextModel, EnvironmentNotifier, FlexDirection, FocusNotifier, GLYPH_SUBPIXEL_PHASES, GlyphShaper, Grid, INSPECTOR_HEAT_MS, INSTANCE_STRIDE_BYTES, INSTANCE_STRIDE_FLOATS, IconRasterizer, LABEL_PADDING_X, LayoutEngine, LayoutInspector, LayoutNotifier, LayoutRecord, LazyColumn, LazyGrid, LazyRow, MARK_PREFIX, MAX_GRADIENT_STOPS, MAX_MEASURES_PER_CHILD, MOTION_CHANNELS, MOTION_REST, MOUSE_POINTER, MainAxisAlignment, Mp3Frames, NO_CLIP_INDEX, NodeTransitions, Paint, PaintPictureCache, PaintRecorder, PaintTarget, ParagraphTextMeasurer, PrimitiveKind, Responsive, Row, SCROLLBAR_FADE_MS, SCROLLBAR_HOVER_ZONE, SCROLLBAR_INSET, SCROLLBAR_LINGER_MS, SCROLLBAR_MIN_THUMB, SCROLLBAR_THICKNESS, ScrollView, Stack, TEXTURED_STRIDE_BYTES, TEXTURED_STRIDE_FLOATS, TEXT_MATCHES_PROP, TEXT_RUN_ID_SEPARATOR, TEXT_SELECTION_PROP, Text, UI_ROLES, UI_SEMANTIC_STATES, UI_SUBGRID_AXES, UiAnimation, UiAnimationFrameClock, UiBasicColors, UiBeforeInputEvent, UiBinding, UiBorderRadiuses, UiChildrenBinding, UiContainerSizeSource, UiDragSession, UiEditingController, UiEnvironment, UiEnvironmentKeys, UiEventBinding, UiEventType, UiFindController, UiFocusEvent, UiFocusManager, UiFrame, UiGestureEvent, UiGestureRecognizer, UiGraph, UiGraphBuilder, UiHitTester, UiHostFrameClock, UiInputDispatcher, UiInputEvent, UiInsetRegistry, UiKeyboardController, UiKeyboardEvent, UiManualFrameClock, UiModifierSet, UiNode, UiNodeType, UiPinchEvent, UiPinchRecognizer, UiPlatformAdapter, UiPointerController, UiPointerEvent, UiProperties, UiScheduler, UiSelectionController, UiSharedElements, UiShortcutRegistry, UiSpring, UiTextChangeEvent, UiTimerFrameClock, UiTouchScroller, UiTransforms, UiTween, UiUnknownModifierPropertyError, UiVirtualWindow, UiVisualState, UiWheelController, UiWheelDeltaMode, UiWheelEvent, VIRTUAL_INDEX_PROP, VIRTUAL_LEAD_PROP, VIRTUAL_WINDOW_PROP, WebGPUError, WebGPUGlyphAtlas, WebGPUGlyphPages, WebGPURenderer, WebGPUSurface, WebGPUTextureCache, accumulatedOffsetTo, animateLayout, applyCanvasTextStyle, assertModifierList, assertTransitionMap, auto, autoFocus, bandOf, borderRadius, borderRadiusCorners, borderRadiusEqual, borderRadiusIsZero, borderRadiusValuesEqual, boxShadow, boxShadowArraysEqual, boxShadowsEqual, breakpoint, bufferSource, buildFontString, buildRenderList, buildSemanticsSubtree, buildSemanticsTree, bumpFontStack, bundle, canDecodeVideo, capturePointer, caretRectFor, caretVisibleAt, clampSize, clearFontStacks, clearLinkHover, clearMatchRanges, clearOverrideProperty, clearSelectionRange, clickOutside, closestPropertyName, colorToCss, colorToHex, colorToRgba, colorValuesEqual, colorsEqual, colorsEqualPalette, commandForKey, computeObjectFitRect, constraintsEqual, containerBands, contentOffset, contextMenu, contrastRatio, createCanvasSurface, createCanvasTextStyle, createElement, createEnvironmentKey, createPaintState, createTextCache, createTween, createWebGPUSurface, cubicBezier, cueAt, darkColors, darkTheme, decorated, decorationColor, decorationRect, defaultMotion, defaultShadows, defaultShapes, defaultSpacing, defaultTextStyle, defaultTypography, defaultVisualState, defineModifier, defineProperty, defineThemeExtension, demuxMp4Audio, demuxMp4Video, densityFactors, describeLength, describeOverrides, detectEditingPlatform, diffSemantics, dragSessionFor, dragSource, draggable, drawOverlayShapes, drawText, dropTarget, easings, editorFor, editorOf, fade, fillTextRects, findEnvironmentKey, findMatchesIn, findPropertyDefinition, flattenTextSpans, focusRing, fontStackFor, formatConstraints, formatExplanation, formatShortcut, fr, getPropertyNames, glyphCount, gradientPaint, gradientsEqual, graphemeBoundaries, hasDecorationPhase, hasDrawnText, hasTextLinks, hasThemeExtension, hasVisualState, highContrastColors, hoverable, iconKey, iconSource, imageSource, inheritedPropertyFlags, inheritedPropertyNames, initializeWebGPU, inputsEqual, insetPadding, insetsEqual, interactive, interpolateColor, interpolateNumber, interpolateTransform, interpolatorFor, isAutoLength, isComponentLikeElement, isEditableNode, isFrLength, isLayoutProtocol, isMinMaxTrack, isMotionRest, isMultiline, isNodeFocusable, isNodeHitTestable, isNodeInert, isNodeSelectable, isObservable, isPaintVisible, isPercentLength, isPrintable, isReadOnly, isScrollContainer, isShapeName, isTypographyRole, isUiChild, isUiElement, isUiModifier, isUiRole, isUiSemanticState, isVideoSurface, isWebGPUAvailable, labelNode, labelOrigin, layoutParagraph, layoutTextLines, lazySource, lightColors, lightTheme, lineEndAt, lineIndexAtY, lineIndexForOffset, lineLimit, lineStartAt, linear, linearGradient, linkHoverOf, linkOf, linkRunAtPointIn, markInstant, markNow, matchRangesOf, measure, measureSpan, minmax, motion, nextCaretToggle, nextGraphemeEnd, nextWordEnd, noInsets, noKeyModifiers, noModifiers, noThemeExtensions, normalizeBorderRadius, normalizeColor, normalizeStates, normalizeTextAlign, normalizeTransition, normalizeVerticalAlign, observeViewportInsets, offsetAtPoint, offsetAtPointIn, offsetAtX, offsetForVerticalMove, overrideSources, paintPictures, paintValuesEqual, paintsAfterChildren, paragraphGeometry, paragraphGeometryFrom, parseAlignContent, parseColor, parseCrossAxisAlignment, parseFlexDirection, parseMainAxisAlignment, parseShortcut, parseTransform, parseWebVtt, pathValuesEqual, percent, performanceMarksEnabled, pinchable, placeGridItems, pointerDeviceOf, pop, prepareInputSurface, pressable, previousGraphemeStart, previousWordStart, propertyEffects, propertyIsInherited, propertyValuesEqual, propertyValuesEqualByName, proportionalFontMetrics, provideEnvironment, publishInset, radialGradient, raiseContrast, rangeSource, readMp3Header, recordsEqual, registerFontStack, relativeLuminance, reorderable, repeat, replayPaint, resetOverrideWarnings, resetTransitionWarnings, resolveBoolean, resolveCursor, resolveLength, resolveMotionState, resolveNumber, resolvePaintState, resolveProperty, resolvePropertyByName, resolveString, resolvedSpansOf, rgb8, rgba, rotateFrom, runCanvasStyleInto, runFontString, sameArgs, scaleFrom, scaleSpacing, scrollPosition, scrollbarThumb, scrollbarThumbs, scrollbarZoneAt, selectableTextNodes, selectableTextOf, selectionRangeOf, selectionRects, selectionRectsIn, semanticsInertAbove, setLinkHover, setMatchRanges, setPerformanceMarks, setSelectionRange, shadowsEqual, shapesEqual, sharedElement, shortcut, shortcuts, sizeContainer, sizeGridTracks, slideDown, slideFrom, slideUp, spacingEqual, spacingSteps, spanAtOffset, spannedRunsFor, spannedTextOf, splitMp3Frames, spring, statesEqual, steps, syncEditorValue, textContentOf, textRunBackgrounds, textRunDecorations, textRunOfRecordId, textRuns, textSpansEqual, textStylesEqual, themeExtension, themeExtensionsEqual, themeTokens, themesEqual, tightenConstraints, touchActionFor, tracePathData, traceRoundedRect, transform, transformIsIdentity, transformsEqual, tween, typographyEqual, uniformBorderRadius, unknownContainerSize, validateGradient, validateRole, validateStates, validateSubgrid, videoFrameSize, videoSource, visualState, visualStatesEqual, wheelDeltaYOf, withContrast, withDensity, withOverrideSource, withThemeExtension, wordRangeAt, wordRangeIn, writeDeclaredProperty, writeOverrideProperty };
+export { AlignContent, AnimationDriver, BUTTON_INTERACTION, Box, Button, CARET_BLINK_MS, CARET_WIDTH, CLIP_STRIDE_BYTES, CLIP_STRIDE_FLOATS, Canvas2DRenderer, CanvasPlatformSurface, CanvasSurface, CanvasTextMeasurer, CharacterCountTextMeasurer, Column, CommandKind, Constraints, CrossAxisAlignment, DEFAULT_BLOCK_SIZE, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_FONT_WEIGHT, DEFAULT_LINE_HEIGHT_FACTOR, DEFAULT_TEXT_COLOR, DefaultImageResolver, DefaultVideoResolver, DirtyFlags, DirtyNodeSet, EDITOR_PROP, ELLIPSIS, EMPTY_RECORDING, EXTERNAL_FILES, EditableLayout, EditableText, EditableTextModel, EnvironmentNotifier, FlexDirection, FocusNotifier, GLYPH_SUBPIXEL_PHASES, GlyphShaper, Grid, INSPECTOR_HEAT_MS, INSTANCE_STRIDE_BYTES, INSTANCE_STRIDE_FLOATS, IconRasterizer, LABEL_PADDING_X, LayoutEngine, LayoutInspector, LayoutNotifier, LayoutRecord, LazyColumn, LazyGrid, LazyRow, LazySheet, MARK_PREFIX, MAX_GRADIENT_STOPS, MAX_MEASURES_PER_CHILD, MOTION_CHANNELS, MOTION_REST, MOUSE_POINTER, MainAxisAlignment, Mp3Frames, NO_CLIP_INDEX, NodeTransitions, Paint, PaintPictureCache, PaintRecorder, PaintTarget, ParagraphTextMeasurer, PrimitiveKind, Responsive, Row, SCROLLBAR_FADE_MS, SCROLLBAR_HOVER_ZONE, SCROLLBAR_INSET, SCROLLBAR_LINGER_MS, SCROLLBAR_MIN_THUMB, SCROLLBAR_THICKNESS, ScrollView, Stack, TEXTURED_STRIDE_BYTES, TEXTURED_STRIDE_FLOATS, TEXT_MATCHES_PROP, TEXT_RUN_ID_SEPARATOR, TEXT_SELECTION_PROP, Text, UI_ROLES, UI_SEMANTIC_STATES, UI_SUBGRID_AXES, UiAnimation, UiAnimationFrameClock, UiBasicColors, UiBeforeInputEvent, UiBinding, UiBorderRadiuses, UiChildrenBinding, UiContainerSizeSource, UiDragSession, UiEditingController, UiEnvironment, UiEnvironmentKeys, UiEventBinding, UiEventType, UiFindController, UiFocusEvent, UiFocusManager, UiFrame, UiGestureEvent, UiGestureRecognizer, UiGraph, UiGraphBuilder, UiHitTester, UiHostFrameClock, UiInputDispatcher, UiInputEvent, UiInsetRegistry, UiKeyboardController, UiKeyboardEvent, UiManualFrameClock, UiModifierSet, UiNode, UiNodeType, UiPasteEvent, UiPinchEvent, UiPinchRecognizer, UiPlatformAdapter, UiPointerController, UiPointerEvent, UiProperties, UiScheduler, UiSelectionChangeEvent, UiSelectionController, UiSharedElements, UiShortcutRegistry, UiSpring, UiTextChangeEvent, UiTimerFrameClock, UiTouchScroller, UiTransforms, UiTween, UiUnknownModifierPropertyError, UiVirtualSheet, UiVirtualWindow, UiVisualState, UiWheelController, UiWheelDeltaMode, UiWheelEvent, VIRTUAL_INDEX_PROP, VIRTUAL_LEAD_PROP, VIRTUAL_SHEET_PROP, VIRTUAL_WINDOW_PROP, WebGPUError, WebGPUGlyphAtlas, WebGPUGlyphPages, WebGPURenderer, WebGPUSurface, WebGPUTextureCache, accumulatedOffsetTo, animateLayout, applyCanvasTextStyle, assertModifierList, assertTransitionMap, auto, autoFocus, bandOf, borderRadius, borderRadiusCorners, borderRadiusEqual, borderRadiusIsZero, borderRadiusValuesEqual, borderShapes, borders, boxShadow, boxShadowArraysEqual, boxShadowsEqual, breakpoint, bufferSource, buildFontString, buildRenderList, buildSemanticsSubtree, buildSemanticsTree, bumpFontStack, bundle, canDecodeVideo, capturePointer, caretRectFor, caretVisibleAt, clampSize, clearFontStacks, clearLinkHover, clearMatchRanges, clearOverrideProperty, clearSelectionRange, clickOutside, closestPropertyName, colorToCss, colorToHex, colorToRgba, colorValuesEqual, colorsEqual, colorsEqualPalette, commandForKey, computeObjectFitRect, constraintsEqual, containerBands, contentOffset, contextMenu, contrastRatio, createCanvasSurface, createCanvasTextStyle, createElement, createEnvironmentKey, createPaintState, createTextCache, createTween, createWebGPUSurface, cubicBezier, cueAt, darkColors, darkTheme, decorated, decorationColor, decorationRect, defaultMotion, defaultShadows, defaultShapes, defaultSpacing, defaultTextStyle, defaultTypography, defaultVisualState, defineModifier, defineProperty, defineThemeExtension, demuxMp4Audio, demuxMp4Video, densityFactors, describeLength, describeOverrides, detectEditingPlatform, diffSemantics, dragSessionFor, dragSource, draggable, drawOverlayShapes, drawText, dropTarget, easings, editableSpansOf, editorFor, editorOf, fade, fillTextRects, findEnvironmentKey, findMatchesIn, findPropertyDefinition, flattenTextSpans, focusRing, fontStackFor, formatConstraints, formatExplanation, formatShortcut, fr, getPropertyNames, glyphCount, gradientPaint, gradientsEqual, graphemeBoundaries, hasDecorationPhase, hasDrawnText, hasTextLinks, hasThemeExtension, hasVisualState, highContrastColors, hoverable, iconKey, iconSource, imageSource, inheritedPropertyFlags, inheritedPropertyNames, initializeWebGPU, inputsEqual, insetPadding, insetsEqual, interactive, interpolateColor, interpolateNumber, interpolateTransform, interpolatorFor, isAutoLength, isComponentLikeElement, isEditableNode, isFrLength, isLayoutProtocol, isMinMaxTrack, isMotionRest, isMultiline, isNodeFocusable, isNodeHitTestable, isNodeInert, isNodeSelectable, isNodeTabStop, isObservable, isPaintVisible, isPercentLength, isPrintable, isReadOnly, isScrollContainer, isShapeName, isTypographyRole, isUiChild, isUiElement, isUiModifier, isUiRole, isUiSemanticState, isVideoSurface, isWebGPUAvailable, labelNode, labelOrigin, layoutParagraph, layoutTextLines, lazySource, lightColors, lightTheme, lineEndAt, lineIndexAtY, lineIndexForOffset, lineLimit, lineStartAt, linear, linearGradient, linkHoverOf, linkOf, linkRunAtPointIn, markInstant, markNow, matchRangesOf, measure, measureSpan, minmax, motion, nextCaretToggle, nextGraphemeEnd, nextWordEnd, noInsets, noKeyModifiers, noModifiers, noThemeExtensions, normalizeBorderRadius, normalizeColor, normalizeStates, normalizeTextAlign, normalizeTransition, normalizeVerticalAlign, observeViewportInsets, offsetAtPoint, offsetAtPointIn, offsetAtX, offsetForVerticalMove, overrideSources, paintPictures, paintValuesEqual, paintsAfterChildren, paragraphGeometry, paragraphGeometryFrom, parseAlignContent, parseColor, parseCrossAxisAlignment, parseFlexDirection, parseMainAxisAlignment, parseShortcut, parseTransform, parseWebVtt, pathValuesEqual, percent, performanceMarksEnabled, pinchable, placeGridItems, pointerDeviceOf, pop, prepareInputSurface, pressable, previousGraphemeStart, previousWordStart, propertyEffects, propertyIsInherited, propertyValuesEqual, propertyValuesEqualByName, proportionalFontMetrics, provideEnvironment, publishInset, radialGradient, raiseContrast, rangeSource, readMp3Header, recordsEqual, registerFontStack, relativeLuminance, reorderable, repeat, replayPaint, resetOverrideWarnings, resetTransitionWarnings, resolveBoolean, resolveCursor, resolveLength, resolveMotionState, resolveNumber, resolvePaintState, resolveProperty, resolvePropertyByName, resolveString, resolvedSpansOf, rgb8, rgba, rotateFrom, runCanvasStyleInto, runFontString, sameArgs, scaleFrom, scaleSpacing, scrollPosition, scrollbarThumb, scrollbarThumbs, scrollbarZoneAt, selectableTextNodes, selectableTextOf, selectionRangeOf, selectionRects, selectionRectsIn, semanticsInertAbove, setLinkHover, setMatchRanges, setPerformanceMarks, setSelectionRange, shadowsEqual, shapesEqual, sharedElement, sheetSource, shortcut, shortcuts, sizeContainer, sizeGridTracks, slideDown, slideFrom, slideUp, spacingEqual, spacingSteps, spanAtOffset, spannedRunsFor, spannedTextOf, splitMp3Frames, spring, statesEqual, steps, syncEditorValue, textContentOf, textRunBackgrounds, textRunDecorations, textRunOfRecordId, textRuns, textSpansEqual, textStylesEqual, themeExtension, themeExtensionsEqual, themeTokens, themesEqual, tightenConstraints, touchActionFor, tracePathData, traceRoundedRect, transform, transformIsIdentity, transformsEqual, tween, typographyEqual, uniformBorderRadius, unknownContainerSize, validateGradient, validateRole, validateStates, validateSubgrid, videoFrameSize, videoSource, visualState, visualStatesEqual, wheelDeltaYOf, withContrast, withDensity, withOverrideSource, withThemeExtension, wordRangeAt, wordRangeIn, writeDeclaredProperty, writeOverrideProperty };
 
 //# sourceMappingURL=index.js.map