gesso-core 0.2.1 → 0.4.0

package/dist/{index-DAdauEn9.d.ts → index-BzXn0Bci.d.ts}

@@ -1480,6 +1480,29 @@ interface DecorationBox {
   readonly y?: number;
   readonly width?: number;
   readonly height?: number;
+  /**
+   * The far edges, as distances inward from the node's right and
+   * bottom. Any two of `x`, `width`, `right` fix the horizontal axis,
+   * exactly as CSS's `left`, `width` and `right` do, and likewise
+   * `y`, `height`, `bottom`.
+   *
+   *   { y: 0, height: 2 }                 the top edge, two pixels
+   *   { bottom: 0, height: 2 }            the bottom edge
+   *   { x: 0, width: 2, y: 2, bottom: 2 } the left edge, between them
+   *
+   * Without them a shape could only be placed from the top left, and
+   * `width` and `height` only defaulted to the node's own — so
+   * anything pinned to a far edge, or spanning between two, had to be
+   * built by a caller that had already measured the node. An
+   * application that declares its own geometry, as a spreadsheet
+   * declares its row height, does not need this; a general modifier
+   * such as `borders()` cannot exist without it.
+   *
+   * Given all three on one axis, the size wins and the far inset is
+   * ignored, which is the rule CSS settles the same conflict with.
+   */
+  readonly right?: number;
+  readonly bottom?: number;
   /**
    * Grows the rectangle on all four sides. This is what puts a focus
    * ring outside the control instead of on top of it.
@@ -1993,7 +2016,43 @@ declare enum UiEventType {
   BeforeInput = "beforeinput",
   /** An editable's text changed. */
   Input = "input",
+  /**
+   * An editable's selection moved, whether or not its text changed.
+   *
+   * Separate from `Input` because the caret moves without the text on
+   * every arrow key, every click into the text and every
+   * select-all — and something has to be able to follow it. A formula
+   * editor that colours the bracket beside the caret has no other way
+   * to know it moved.
+   *
+   * Fires *after* `Input` when a change did both, so a listener that
+   * reads the text sees the new one. It is skipped entirely when the
+   * selection did not actually move, so holding a key that is already
+   * at the end of the text is silent.
+   */
+  SelectionChange = "selectionchange",
+  /**
+   * Text arrived from the system clipboard with nothing editable
+   * focused.
+   *
+   * A paste with a caret in it belongs to the text and never reaches
+   * here. This is the other case: a surface that owns a selection of
+   * its own — a grid with a rectangle of cells picked out — and is the
+   * only thing that knows what a block of text means to it.
+   * `preventDefault()` says it was taken.
+   */
+  Paste = "paste",
   Click = "click",
+  /**
+   * A second Click on the same node, soon enough after the first and
+   * close enough to it.
+   *
+   * Dispatched after that second Click rather than instead of it, as
+   * the DOM's `dblclick` is: a listener that answers a click has
+   * already answered both by the time this arrives, which is what lets
+   * a double click on a cell select it and then do more.
+   */
+  DoubleClick = "doubleclick",
   LongPress = "longpress",
   DragStart = "dragstart",
   DragMove = "dragmove",
@@ -2220,12 +2279,45 @@ declare class UiBeforeInputEvent extends UiInputEvent {
  * An editable node's text changed: the new value and the selection
  * after the change. Bubbles, so a form can watch all its fields.
  */
+/**
+ * Text from the system clipboard, offered to whatever holds focus.
+ *
+ * Carries the text rather than a clipboard handle, because a render
+ * worker has neither a clipboard nor a window: the shell reads it and
+ * sends it across, which is the same path `ShellService.copyText`
+ * takes in the other direction.
+ */
+declare class UiPasteEvent extends UiInputEvent {
+  readonly text: string;
+  constructor(text: string);
+}
 declare class UiTextChangeEvent extends UiInputEvent {
   readonly value: string;
   readonly selectionStart: number;
   readonly selectionEnd: number;
   constructor(value: string, selectionStart: number, selectionEnd: number);
 }
+/**
+ * An editable's selection moved.
+ *
+ * Carries the text as well as the offsets, because every use of this
+ * is "what is under the caret" and the answer needs both — and
+ * reading the text back off the model afterwards is a second source
+ * of truth that can disagree by a frame.
+ *
+ * `start` and `end` are ordered; `anchor` and `focus` are where the
+ * selection was begun and where the caret now is, which is the pair
+ * that says which way it was dragged.
+ */
+declare class UiSelectionChangeEvent extends UiInputEvent {
+  readonly value: string;
+  readonly start: number;
+  readonly end: number;
+  readonly anchor: number;
+  readonly focus: number;
+  constructor(value: string, start: number, end: number, anchor: number, focus: number);
+  get collapsed(): boolean;
+}
 /**
  * Wheel scroll input event.
  *
@@ -3760,6 +3852,24 @@ declare function spannedTextOf(node: UiNode): UiSpannedText | undefined;
 declare function textContentOf(node: UiNode): string;
 /** The runs of a node's paragraph; empty when it has none. */
 declare function resolvedSpansOf(node: UiNode): readonly UiResolvedTextSpan[];
+/**
+ * The runs an *editable* node styles its own text with.
+ *
+ * An editable's paragraph is the user's, held by its model rather
+ * than by a property — so unlike a `Text`, its runs do not supply the
+ * text, they only describe it. `spans` on an editable is presentation
+ * over a string somebody is typing.
+ *
+ * Which is why this checks. Every offset the editor works in — the
+ * caret, the selection, the hit test that turns a click into a text
+ * position — is an offset into the model's string. Runs describing a
+ * *different* string would put the glyphs somewhere the caret does
+ * not agree with, and the field would look subtly, unfixably wrong.
+ * When they disagree the text is drawn unstyled, which is a frame of
+ * plain colour rather than a frame of nonsense, and corrects itself
+ * as soon as the application catches up.
+ */
+declare function editableSpansOf(node: UiNode, text: string): readonly UiResolvedTextSpan[];
 /** The span covering an offset, or undefined where no run does. */
 declare function spanAtOffset(spans: readonly UiResolvedTextSpan[], offset: number): UiResolvedTextSpan | undefined;
 /**
@@ -4640,6 +4750,430 @@ declare const lazySource: ((args: LazySourceArgs, key?: string | number) => UiMo
   readonly kind: UiModifierKind<LazySourceArgs>;
 };
 //#endregion
+//#region src/composition/UiVirtualSheet.d.ts
+/**
+ * Two-axis windowing, for a surface whose geometry is known rather
+ * than measured.
+ *
+ * `LazyColumn` and `LazyGrid` window one axis and learn the extent of
+ * an item by mounting and measuring it, correcting an estimate as the
+ * user scrolls. A spreadsheet is the other case: every row is the same
+ * height and every column the same width because the sheet says so, so
+ * there is nothing to measure and nothing to correct, and the window
+ * on each axis is arithmetic on the scroll offset.
+ *
+ * That difference is why this is its own class rather than a second
+ * axis bolted onto `UiVirtualWindow`. Dropping measurement drops the
+ * correction table, the scroll anchoring and the per-frame walk that
+ * collects extents — none of which a sheet can use — and what is left
+ * is small enough to read in one sitting.
+ *
+ * It also deliberately does **not** use `subgrid: 'columns'`. A lazy
+ * grid's rows share tracks with a header because their widths come
+ * from their content, and `LayoutEngine.collectSubgridColumns` pays
+ * for that by measuring every cell of every mounted row, at unbounded
+ * constraints, on every layout. A sheet is told its column widths, so
+ * a row is an ordinary `Row` of fixed-width cells and the tracks never
+ * have to be sized at all.
+ */
+interface SheetViewport {
+  /** Horizontal scroll offset of the container. */
+  scrollX: number;
+  /** Vertical scroll offset of the container. */
+  scrollY: number;
+  /** Visible width. */
+  width: number;
+  /** Visible height. */
+  height: number;
+}
+/** The cells the window has mounted, inclusive on both ends. */
+interface SheetRange {
+  readonly firstRow: number;
+  readonly lastRow: number;
+  readonly firstColumn: number;
+  readonly lastColumn: number;
+}
+/**
+ * Builds one row, given the columns the window wants in it.
+ *
+ * It must return a `Row` (or anything that lays its children out
+ * horizontally), and exactly one child per column in `[firstColumn,
+ * lastColumn]`, each keyed by its **absolute** column index. The
+ * window adds the leading spacer and sets the row's own geometry, so
+ * the renderer is only ever asked for cells.
+ *
+ * Keys are absolute rather than positional on purpose: a scroll of one
+ * row then reconciles to one row built and one dropped, instead of
+ * every mounted cell being rewritten to hold its neighbour's value.
+ */
+type SheetRowRenderer = (row: number, firstColumn: number, lastColumn: number) => UiChild;
+interface UiVirtualSheetOptions {
+  readonly rowCount: Reactive<number>;
+  readonly columnCount: Reactive<number>;
+  /** The height every row has unless `rowHeights` says otherwise. */
+  readonly rowHeight: number;
+  /**
+   * The rows that are not the default height, by row index.
+   *
+   * **Sparse, where `columnWidth` is an array, and the asymmetry is
+   * deliberate.** A sheet has a few hundred columns and a width for
+   * each of them is a reasonable thing to hand over; it has up to a
+   * million rows, and an array that long — rebuilt whenever one row
+   * changed — would be the largest allocation in the application, to
+   * describe a sheet where every row but two is the same.
+   *
+   * What actually produces a non-default height is hiding a row
+   * (zero), autofitting one, or wrapping text in it. All three are
+   * exceptions by nature, and there are tens of them rather than
+   * thousands, so the offsets are a multiplication plus a binary
+   * search over the exceptions rather than a prefix sum over
+   * everything.
+   */
+  readonly rowHeights?: ReadonlyMap<number, number>;
+  /**
+   * One width for every column, or a width per column.
+   *
+   * An array is what makes a column resizable, and it is the reason
+   * the offsets below are a prefix sum rather than a multiplication.
+   * A sheet of a few hundred columns keeps the sum and searches it;
+   * that is two orders of magnitude cheaper than measuring, which is
+   * the thing this class exists not to do.
+   */
+  readonly columnWidth: number | readonly number[];
+  /** Rows mounted beyond each edge of the viewport. Default 3. */
+  readonly rowOverscan?: Reactive<number>;
+  /** Columns mounted beyond each edge of the viewport. Default 2. */
+  readonly columnOverscan?: Reactive<number>;
+  /**
+   * A frozen strip at the start of every row — a sheet's row numbers.
+   *
+   * The window needs its width because it is content: it shifts every
+   * column along by that much and it is part of the scrollable extent.
+   * Keeping it *visible* while the sheet scrolls sideways is the
+   * renderer's business, with `position: 'sticky'` on whatever the row
+   * renderer puts there.
+   */
+  readonly gutterWidth?: number;
+  /** Height of the header row above the rows, when there is one. */
+  readonly headerHeight?: number;
+  /**
+   * Rows and columns kept mounted however far the sheet is scrolled.
+   *
+   * A frozen pane, and the second thing that cannot be windowed by
+   * position alone — `extendRange` is no use here, because widening
+   * the window back to row 0 from row 5,000 would mount five thousand
+   * rows to show one.
+   *
+   * What this does is *mount* them and take them out of the scrolled
+   * window, so they appear once rather than twice and the spacers
+   * account for them. Keeping them **visible** is the renderer's
+   * business, with `position: 'sticky'` — exactly as it already is
+   * for the header row and the gutter, which are this idea with the
+   * count fixed at one.
+   *
+   * With `frozenColumns` set, a row renderer is asked for the columns
+   * in `[0, frozenColumns)` first and then for `[firstColumn,
+   * lastColumn]`, and the window puts the leading spacer between the
+   * two groups.
+   */
+  readonly frozenRows?: number;
+  readonly frozenColumns?: number;
+  /**
+   * Widens the window the viewport implies, for things the document
+   * says reach outside it.
+   *
+   * **The one place a sheet's geometry is allowed to depend on its
+   * contents.** Everything else here is arithmetic on the scroll
+   * offset, which is what makes it cheap; this is the exception, and
+   * it exists because two things genuinely cannot be windowed by
+   * position alone.
+   *
+   * A **merged cell** is the case that forced it. A merge spanning
+   * C3:E3 is drawn by its anchor, C3, and when the sheet is scrolled
+   * so the window begins at column D there is no anchor to draw —
+   * the merge silently disappears at the left edge of the screen.
+   * Widening the window to include the anchor is the only fix that
+   * does not put the document inside this class: the caller knows
+   * where its merges are, and returns a range that covers them.
+   *
+   * Called on every recompute, so it must be cheap — a lookup, not a
+   * scan. Returning the range unchanged costs nothing at all. If what
+   * it would answer changes without the viewport moving, the caller
+   * says so with `invalidate`.
+   */
+  readonly extendRange?: (range: SheetRange) => SheetRange;
+  /** Viewport assumed before the first layout. */
+  readonly initialViewport?: {
+    readonly width: number;
+    readonly height: number;
+  };
+}
+/**
+ * Builds the row above the rows, for the columns now in the window.
+ *
+ * Rendered once per column window rather than once per frame, and
+ * placed before the leading spacer, so a header that is
+ * `position: 'sticky'` with `top: 0` stays put while the rows scroll
+ * under it and moves with them when they scroll sideways.
+ */
+type SheetHeaderRenderer = (firstColumn: number, lastColumn: number) => UiChild;
+/** The sheet sits on its scroll container under this property. */
+declare const VIRTUAL_SHEET_PROP = "virtualSheet";
+declare class UiVirtualSheet {
+  readonly children$: BehaviorSubject<UiElement[]>;
+  /**
+   * 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.
+   */
+  readonly range$: BehaviorSubject<SheetRange>;
+  private rowCount;
+  private columnCount;
+  private rowOverscan;
+  private columnOverscan;
+  private rowHeight;
+  private readonly gutterWidth;
+  private readonly headerHeight;
+  private frozenRows;
+  private frozenColumns;
+  private readonly renderRow;
+  private renderHeader;
+  private readonly extendRange;
+  /** One width per column, or undefined when every column is the same. */
+  private widths;
+  /** `offsets[c]` is where column `c` starts, measured past the gutter. */
+  private offsets;
+  private uniformWidth;
+  /**
+   * 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.
+   */
+  private exceptionRows;
+  private exceptionHeights;
+  /** `exceptionStarts[i]` is where `exceptionRows[i]` starts, past the header. */
+  private exceptionStarts;
+  private range;
+  private viewport;
+  /** Rows built for the current column range, so a vertical scroll rebuilds one row. */
+  private readonly mountedRows;
+  /** The frozen rows, kept separately because they never leave. */
+  private readonly frozenMounted;
+  private mountedHeader;
+  constructor(options: UiVirtualSheetOptions, renderRow: SheetRowRenderer, renderHeader?: SheetHeaderRenderer);
+  /**
+   * 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: number | readonly number[]): void;
+  private adoptWidths;
+  /**
+   * 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: ReadonlyMap<number, number> | undefined): void;
+  /** The height every row has unless it is an exception. */
+  setRowHeight(height: number): void;
+  private adoptHeights;
+  /**
+   * 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.
+   */
+  private rebuildExceptionStarts;
+  /** The index of the last exception starting at or before an offset, or -1. */
+  private exceptionAt;
+  /** How many exceptions come before a row, as an index into them. */
+  private exceptionsBefore;
+  /** The height of one row. Zero when it is hidden. */
+  rowHeightOf(row: number): number;
+  /** Where a row starts, measured past the header. */
+  rowOffsetOf(row: number): number;
+  /** Total height of the rows, not counting the header. */
+  private get rowsHeight();
+  /**
+   * 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.
+   */
+  private extraWithin;
+  /** The width of one column. */
+  widthOf(column: number): number;
+  /** Where a column starts, measured past the gutter. */
+  offsetOf(column: number): number;
+  /** Total width of the columns, not counting the gutter. */
+  private get columnsWidth();
+  get contentWidth(): number;
+  /** Where the scrolled columns begin, past the gutter and the frozen ones. */
+  private get frozenWidth();
+  get contentHeight(): number;
+  /**
+   * 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: number, y: number): {
+    row: number;
+    column: number;
+  };
+  /**
+   * 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: number): number;
+  /**
+   * 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: number): number;
+  setRowCount(count: number): void;
+  setColumnCount(count: number): void;
+  /**
+   * 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: number, columns: number): void;
+  /**
+   * 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: number, columns: number): void;
+  /** Drops every mounted row and rebuilds against the last viewport. */
+  invalidate(): void;
+  /**
+   * 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: SheetViewport): void;
+  private recompute;
+  /**
+   * 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.
+   */
+  private windowFor;
+  private buildChildren;
+  /**
+   * 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.
+   */
+  private wrapHeader;
+  /**
+   * 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.
+   */
+  private withLead;
+  /**
+   * 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.
+   */
+  private wrap;
+}
+/** What `sheetSource` carries from a LazySheet's props to its window. */
+interface SheetSourceArgs {
+  readonly sheet: UiVirtualSheet;
+  readonly rowCount: Reactive<number>;
+  readonly columnCount: Reactive<number>;
+  readonly rowOverscan?: Reactive<number>;
+  readonly columnOverscan?: Reactive<number>;
+}
+/**
+ * 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.
+ */
+declare const sheetSource: ((args: SheetSourceArgs, key?: string | number) => UiModifier<SheetSourceArgs>) & {
+  readonly kind: UiModifierKind<SheetSourceArgs>;
+};
+type LazySheetProps = ScrollViewProps & Omit<UiVirtualSheetOptions, 'initialViewport'> & {
+  /** Hands the window to the caller, once, as the element is built. */
+  sheetRef?: (sheet: UiVirtualSheet) => void;
+  /** The row above the rows, sized by `headerHeight`. */
+  header?: SheetHeaderRenderer;
+};
+/**
+ * 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.
+ */
+declare function LazySheet(props: LazySheetProps, renderRow: SheetRowRenderer): UiElement;
+//#endregion
 //#region src/editing/EditableTextModel.d.ts
 /** How far a caret move or a delete reaches. */
 type EditUnit = 'grapheme' | 'word' | 'line' | 'document';
@@ -4693,6 +5227,21 @@ declare class EditableTextModel {
   blinkOrigin: number;
   /** The last `value` the host synchronised in; see `UiEditable`. */
   syncedValue: string | undefined;
+  /**
+   * The selection the last `selectionchange` reported.
+   *
+   * Kept on the model rather than worked out at each call site,
+   * because the caret is moved from a dozen places — arrows, clicks,
+   * select-all, an edit that replaces a range — and every one of them
+   * would otherwise have to remember to compare. Storing what was
+   * last said makes the comparison the notifier's job and the answer
+   * the same wherever the move came from.
+   *
+   * `NaN` to begin with, so the first report always fires: a fresh
+   * model at offset zero has genuinely not told anyone yet.
+   */
+  notifiedAnchor: number;
+  notifiedFocus: number;
   constructor(text?: string);
   get text(): string;
   get anchor(): number;
@@ -5079,6 +5628,18 @@ declare const UiProperties: {
    * 'right-end'.
    */
   readonly placement: UiPropertyDefinition<UiPlacement | undefined>;
+  /**
+   * A point to be placed beside, as though it were an anchor of no
+   * size: where a context menu was asked for. Relative to the
+   * containing block, like `top` and `left`, and with `placement` the
+   * same flip and clamp an anchored node gets — so a menu opened near
+   * the bottom edge opens upward instead of off the screen. Ignored
+   * when `anchor` is set.
+   */
+  readonly anchorPoint: UiPropertyDefinition<{
+    readonly x: number;
+    readonly y: number;
+  } | undefined>;
   /** Gap between an anchored node and its anchor. */
   readonly anchorOffset: UiPropertyDefinition<number | undefined>;
   /**
@@ -5202,6 +5763,7 @@ declare const UiProperties: {
   readonly selectable: UiPropertyDefinition<boolean | undefined>;
   readonly pointerEvents: UiPropertyDefinition<UiPointerEvents | undefined>;
   readonly focusable: UiPropertyDefinition<boolean | undefined>;
+  readonly tabStop: UiPropertyDefinition<boolean | undefined>;
   readonly disabled: UiPropertyDefinition<boolean | undefined>;
   /** What this node is, in ARIA's vocabulary. Closed: a typo throws. */
   readonly role: UiPropertyDefinition<UiRole | undefined>;
@@ -5292,6 +5854,8 @@ declare const UiProperties: {
   readonly virtualLead: UiPropertyDefinition<boolean | undefined>;
   /** Set by LazyColumn/LazyRow on the scroll container: its UiVirtualWindow. */
   readonly virtualWindow: UiPropertyDefinition<UiVirtualWindow | undefined>;
+  /** Set by LazySheet on the scroll container: its UiVirtualSheet. */
+  readonly virtualSheet: UiPropertyDefinition<UiVirtualSheet | undefined>;
   readonly theme: UiPropertyDefinition<UiTheme | undefined>;
   /**
    * The type this element and its subtree are written in: a role in
@@ -5400,6 +5964,8 @@ type UiEventProps = {
   onPointerEnter?: (event: UiPointerEvent) => void;
   onPointerLeave?: (event: UiPointerEvent) => void;
   onClick?: (event: UiPointerEvent) => void;
+  /** A second Click on the same node, within the double-click window. */
+  onDoubleClick?: (event: UiPointerEvent) => void;
   onLongPress?: (event: UiPointerEvent) => void;
   onDragStart?: (event: UiPointerEvent) => void;
   onDragMove?: (event: UiPointerEvent) => void;
@@ -5421,6 +5987,23 @@ type UiEventProps = {
   onBeforeInput?: (event: UiBeforeInputEvent) => void;
   /** An editable's text changed. */
   onInput?: (event: UiTextChangeEvent) => void;
+  /**
+   * An editable's selection moved, with or without a text change.
+   *
+   * The caret moves without the text on every arrow key, every click
+   * into the text and every select-all, and `onInput` says nothing
+   * about any of them. Anything that decorates by caret position — a
+   * bracket matched against the one beside it, a hint about the
+   * argument being typed — needs this one.
+   */
+  onSelectionChange?: (event: UiSelectionChangeEvent) => void;
+  /**
+   * Text from the clipboard, when nothing editable has the caret.
+   *
+   * `preventDefault()` says it was taken. A paste with a caret in it
+   * belongs to the text and never reaches here.
+   */
+  onPaste?: (event: UiPasteEvent) => void;
 };
 /** Reconciliation identity and node access; never stored on the node. */
 type IdentityProps = {
@@ -5432,14 +6015,14 @@ type BoxModelProps = PropsOf<'width' | 'height' | 'minWidth' | 'maxWidth' | 'min
 type FlexItemProps = PropsOf<'flex' | 'flexGrow' | 'flexShrink' | 'flexBasis' | 'selfX' | 'selfY' | 'layoutData'>;
 /** Where an element sits in a Grid. */
 type GridItemProps = PropsOf<'column' | 'columnSpan' | 'row' | 'rowSpan'>;
-type PositionProps = PropsOf<'position' | 'top' | 'right' | 'bottom' | 'left' | 'inset' | 'zIndex' | 'lift' | 'liftBoundary' | 'anchor' | 'placement' | 'anchorOffset'>;
+type PositionProps = PropsOf<'position' | 'top' | 'right' | 'bottom' | 'left' | 'inset' | 'zIndex' | 'lift' | 'liftBoundary' | 'anchor' | 'anchorPoint' | 'placement' | 'anchorOffset'>;
 type PaintProps = PropsOf<'backgroundColor' | 'backgroundGradient' | 'borderColor' | 'borderWidth' | 'borderRadius' | 'opacity' | 'boxShadows' | 'visible' | 'transform'>;
 /**
  * Inherited text properties. Legal on any element: set on a container,
  * they cascade to the text below it.
  */
 type TypographyProps = PropsOf<'color' | 'fontFamily' | 'fontSize' | 'fontWeight' | 'lineHeight' | 'letterSpacing' | 'textAlign' | 'textDirection' | 'fontStyle' | 'fontStretch' | 'fontVariant' | 'fontKerning' | 'textDecoration'>;
-type InteractionProps = PropsOf<'cursor' | 'pointerEvents' | 'focusable' | 'disabled' | 'hitTestable' | 'visualState' | 'selectable'>;
+type InteractionProps = PropsOf<'cursor' | 'pointerEvents' | 'focusable' | 'tabStop' | 'disabled' | 'hitTestable' | 'visualState' | 'selectable'>;
 /**
  * What the element means, for assistive technology. Legal on any
  * element; a component sets them on the node that *is* the control,
@@ -5496,8 +6079,16 @@ type TextProps = CommonProps & TextContentProps;
  * every change; `multiline` lets Enter insert a newline. Wrapping
  * follows `textWrap` (use `'none'` for a single-line field that scrolls
  * rather than wraps).
+ *
+ * `spans` styles that text in runs, and here it means something
+ * narrower than it does on a `Text`: an editable's paragraph is the
+ * model's, so the runs describe the text rather than supplying it.
+ * Their concatenation has to equal `value`, and when it does not the
+ * text is drawn unstyled — every offset the editor works in is an
+ * offset into the model's string, and runs describing a different one
+ * would put the glyphs where the caret does not agree with them.
  */
-type EditableTextProps = CommonProps & PropsOf<'value' | 'placeholder' | 'multiline' | 'readOnly' | 'textWrap' | 'verticalAlign' | 'caretColor' | 'selectionColor' | 'placeholderColor'>;
+type EditableTextProps = CommonProps & PropsOf<'value' | 'spans' | 'placeholder' | 'multiline' | 'readOnly' | 'textWrap' | 'verticalAlign' | 'caretColor' | 'selectionColor' | 'placeholderColor'>;
 /**
  * A Box stacks its children in one content box, aligned by `x` / `y`,
  * and may draw an image behind them.
@@ -8417,6 +9008,20 @@ declare class UiFocusManager {
    * this again once the frame's tree is built, which is when a dialog
    * gets its caret. Idempotent: with focus already inside the scope,
    * or no scope at all, it does nothing.
+   *
+   * **The scope root is the fallback, and it is the whole reason
+   * `tabStop` exists.** A scope with no tab stop inside it used to
+   * blur, which hands the keyboard to nothing: a `Dialog` whose body
+   * is a sentence and a button could not be dismissed with Escape,
+   * because Escape had nowhere to be delivered. Falling back to the
+   * root fixes that only if the root can hold focus without becoming a
+   * stop of its own, or every dialog grows a tab stop that announces
+   * nothing. `focusable: true, tabStop: false` on the body is exactly
+   * that pair, and the fallback is what makes it worth setting.
+   *
+   * Blurring is still what happens when the root cannot hold focus
+   * either, because a scope that has genuinely nothing to focus is
+   * better admitted than faked.
    */
   settleScope(): void;
   /**
@@ -8443,7 +9048,14 @@ declare class UiFocusManager {
    */
   handleNodeRemoved(_node: UiNode): void;
   private moveFocus;
-  /** Focusable nodes in document order (parent before children). */
+  /**
+   * The tab stops in document order (parent before children).
+   *
+   * Tab stops and not every focusable node: a container with
+   * `tabStop: false` can hold focus and is not a place the cycle
+   * stops, which is what lets a dialog body be the keyboard's home of
+   * last resort without becoming a stop of its own.
+   */
   private collectFocusable;
   /** Whether the node may hold focus given the active scope, if any. */
   private withinScope;
@@ -8787,7 +9399,15 @@ interface ScrollContainerState {
   scrollY: number;
   maxScrollX: number;
   maxScrollY: number;
-  /** True when the container scrolls horizontally (row layout). */
+  /**
+   * True when the container lays its children out in a row.
+   *
+   * The wheel no longer reads this: it asks each axis whether it has
+   * room, so a container that overflows both ways takes both deltas.
+   * `UiTouchScroller` still reads it to pick the axis a drag and its
+   * inertia run along, which is a single-axis model — a two-axis
+   * container is panned on whichever axis this names.
+   */
   horizontal: boolean;
   /**
    * The visible extent, which is what a page-mode wheel delta means.
@@ -9007,6 +9627,11 @@ interface PointerControllerOptions {
    * follows the pointer through this.
    */
   onHoverChange?: (node: UiNode | null) => void;
+  /**
+   * The clock a double click is timed against, in milliseconds.
+   * `performance.now` by default; a spec hands in its own.
+   */
+  now?: () => number;
   /**
    * Default pointer behaviour for editable text: a press places the
    * caret (or selects a word, a line), a drag extends the selection.
@@ -9100,6 +9725,15 @@ declare class UiPointerController {
   private readonly onHoverChange;
   private readonly editing;
   private readonly selection;
+  private readonly now;
+  /**
+   * The last Click, for telling whether the next one makes a pair.
+   *
+   * Only a Click counts, not a press: a press that became a drag, or
+   * was cancelled, is not half of a double click, and a release that
+   * followed one would otherwise be read as the second half of it.
+   */
+  private lastClick;
   private hoverNode;
   private downTarget;
   private downX;
@@ -9148,6 +9782,18 @@ declare class UiPointerController {
    * the same node. Returns null when nothing was pressed.
    */
   pointerUp(x: number, y: number, buttons?: number, modifiers?: UiKeyModifiers, pointer?: UiPointerDevice): UiPointerEvent | null;
+  /**
+   * Pairs this Click with the one before it, and dispatches a
+   * DoubleClick when they make a pair.
+   *
+   * A pair is two Clicks on the same node within `MULTI_CLICK_MS` and
+   * `MULTI_CLICK_SLOP` of each other — the window the editing and
+   * selection controllers already use for a word, so a double click
+   * means the same thing on a label as it does in a field. The pair is
+   * spent once it has fired: a third Click starts the next pair rather
+   * than making a second DoubleClick out of the second and third.
+   */
+  private countClick;
   /**
    * Aborts the active press: dispatches PointerCancel to the pressed
    * node and clears press state so no Click is synthesized.
@@ -9219,7 +9865,7 @@ interface KeyboardControllerOptions {
    * preventDefault(); a key it handles is marked default-prevented.
    */
   editing?: {
-    handleKey(node: UiNode, key: string, modifiers: UiKeyModifiers): boolean;
+    handleKey(node: UiNode, key: string, modifiers: UiKeyModifiers, textFromKeys?: boolean): boolean;
   };
   /**
    * Default keyboard behaviour for a canvas text selection: copy it,
@@ -9261,7 +9907,13 @@ declare class UiKeyboardController {
   private readonly activation;
   private readonly root;
   constructor(dispatcher: UiInputDispatcher, focusManager: UiFocusManager, root: UiNode | (() => UiNode), options?: KeyboardControllerOptions);
-  keyDown(key: string, modifiers?: UiKeyModifiers): UiKeyboardEvent;
+  /**
+   * `textFollows` says whether the shell will send the key's text on its
+   * own, as a `beforeinput`. False — a key that reached the canvas while
+   * an editable held the focus — has the key inserted here, whatever the
+   * text source; absent leaves it to the editing controller's setting.
+   */
+  keyDown(key: string, modifiers?: UiKeyModifiers, textFollows?: boolean): UiKeyboardEvent;
   keyUp(key: string, modifiers?: UiKeyModifiers): UiKeyboardEvent;
 }
 //#endregion
@@ -9732,7 +10384,7 @@ declare class UiTouchScroller {
    */
   private releaseVelocity;
   /**
-   * The container that should take this movement.
+   * The container that should take this movement, and which of its axes.
    *
    * The nearest scroll container that can still move in the direction
    * asked for, walking outward. A container already at its end is
@@ -9740,6 +10392,18 @@ declare class UiTouchScroller {
    * that has hit its bottom keep scrolling the page it sits in. When
    * nothing can move, the innermost container is returned so the
    * gesture still belongs somewhere.
+   *
+   * **Each axis is asked for separately**, because a container may
+   * scroll on both, and this used to pick one from the container's
+   * flex direction and drop the other on the floor. A spreadsheet is
+   * the case that found it on the wheel in 38e70a3: one `ScrollView`
+   * whose content overflows in both directions, classified as vertical,
+   * so a sideways drag moved nothing at all. This is the same fix on
+   * the same shared state, so the two input paths cannot disagree about
+   * which container takes a gesture.
+   *
+   * A container that overflows on one axis only is unaffected: the axis
+   * it does not scroll has no room, so it is not taken.
    */
   private resolve;
 }
@@ -9826,7 +10490,8 @@ declare class UiEditingController {
    * when the key was an editing command, so the caller can mark the
    * event handled.
    */
-  handleKey(node: UiNode, key: string, modifiers: UiKeyModifiers): boolean;
+  /** `textFromKeys` overrides the controller's own setting for this one key; see `UiKeyboardController.keyDown`. */
+  handleKey(node: UiNode, key: string, modifiers: UiKeyModifiers, textFromKeys?: boolean): boolean;
   private execute;
   private move;
   /**
@@ -9850,8 +10515,18 @@ declare class UiEditingController {
    * `onInput` rather than a delete and an insert.
    */
   replaceText(text: string): boolean;
-  /** Pastes text: newlines are kept in a multiline field and become spaces in a single-line one. */
+  /**
+   * Pastes text: newlines are kept in a multiline field and become
+   * spaces in a single-line one.
+   *
+   * With nothing editable focused the text is offered to whatever is,
+   * as a `Paste` event, instead of being dropped. That is the case a
+   * grid needs: it owns a rectangle of cells, a block of tab-separated
+   * text means something to it that it means to nothing else, and
+   * before this there was no way for it to hear about one at all.
+   */
   paste(text: string): boolean;
+  private offerPaste;
   private insert;
   compositionStart(): void;
   /** The composition text so far and the caret within it. */
@@ -9890,6 +10565,18 @@ declare class UiEditingController {
   private applyEdit;
   private history;
   private afterTextChange;
+  /**
+   * Reports the selection, if it has actually moved since last time.
+   *
+   * The guard is what keeps this quiet: holding a right arrow against
+   * the end of the text moves nothing and must say nothing, and a
+   * listener that recomputed decoration on every key would otherwise
+   * do it forever for no reason.
+   *
+   * `hasListeners` already makes an unheard dispatch free, so the
+   * cost when nobody is listening is the two comparisons here.
+   */
+  private notifySelection;
   private afterSelectionChange;
   /**
    * Asks the host to scroll the caret into view, when the node has been
@@ -9911,6 +10598,23 @@ declare class UiEditingController {
    * layout the record is empty and the lines fall at the origin, which
    * is still a valid place for a caret.
    */
+  /**
+   * Where the caret is inside a field, in the field's own coordinates.
+   *
+   * Relative to the node's border-box origin, with the field's own
+   * scroll already applied — so a popup placed under the caret adds
+   * the node's position on screen and nothing else.
+   *
+   * Public because an application cannot work this out. The geometry
+   * needs the paragraph as it was *laid out*, which means the
+   * measurer, the resolved paint and the layout record, and an
+   * application that re-measured the text to find the caret would be
+   * a second measurer that must never disagree with this one. Asking
+   * is the only version that stays right.
+   *
+   * Null when the node is not an editable, or has not been laid out.
+   */
+  caretRectOf(node: UiNode): CaretRect | null;
   private layoutOf;
 }
 //#endregion
@@ -10204,6 +10908,24 @@ declare function isNodeHitTestable(node: UiNode): boolean;
  * not. The graph Root never participates in tab order.
  */
 declare function isNodeFocusable(node: UiNode): boolean;
+/**
+ * Whether Tab should stop here.
+ *
+ * Every tab stop is focusable and not every focusable node is a tab
+ * stop, which is the distinction `tabindex="-1"` draws in the DOM and
+ * the one this engine was missing. `focusable` answers "may this node
+ * hold focus at all", and that is the wrong question for a container:
+ * a dialog's body must be able to *take* the keyboard, so that opening
+ * a dialog whose content is a sentence does not hand it to nothing, and
+ * must not be a place Tab *lands*, or every dialog gains a stop that
+ * announces nothing and does nothing.
+ *
+ * So `tabStop: false` means focusable, reachable by a press and by
+ * `focus()`, and skipped by the cycle. It says nothing on a node that
+ * is not focusable in the first place, because there is no order to be
+ * out of.
+ */
+declare function isNodeTabStop(node: UiNode): boolean;
 /**
  * Whether the user may select this node's text with the pointer.
  *
@@ -10694,6 +11416,7 @@ declare function formatExplanation(explanation: LayoutExplanation): string;
 declare const SCROLLBAR_LINGER_MS = 1200;
 /** Portion of the linger during which the scrollbar fades out. */
 declare const SCROLLBAR_FADE_MS = 350;
+/** An editable's text is the user's; runs are a property of a `Text` node. */
 interface ScrollAdjustment {
   container: UiNode;
   scrollX: number;
@@ -11097,6 +11820,26 @@ declare class LayoutEngine {
    * an item that fits nowhere starts a line of its own.
    */
   private breakLines;
+  /**
+   * A line's main size when the container shrink-wraps it.
+   *
+   * The sum of the hypothetical sizes would be the answer if an item
+   * never grew — but `flex: 1` is `flex-basis: 0`, and an item that
+   * starts flexing from zero asks for nothing while its content still
+   * wants the width of its text. A container wrapped around that sum
+   * comes out too narrow; the item's text then wraps inside a box that
+   * was measured as though it had not, and the container is left
+   * shorter than the children it draws — a menu whose last rows fall
+   * out of its own panel.
+   *
+   * So an item that can grow contributes whichever is larger, the size
+   * its basis gives it or the size its content asks for. Chrome ignores
+   * the basis entirely here and browsers disagree with each other about
+   * it; the larger of the two is the reading that keeps `flex-basis`
+   * counting for something, which is what `basis/sizes-container`
+   * already records this engine as doing.
+   */
+  private lineMaxContentMain;
   private lineOuterMain;
   /**
    * Resolves the flexible lengths of one line (CSS Flexbox §9.7).
@@ -11252,6 +11995,13 @@ declare class LayoutEngine {
    * into the same visible space before comparing them.
    */
   private placeAnchored;
+  /**
+   * Places a measured node beside a box — an anchor's, or a point's of
+   * no size — flipping to the opposite side when the named one would
+   * overflow the block and the other has more room, and clamping along
+   * the side to stay inside it.
+   */
+  private placeBeside;
   /**
    * Records which anchor an anchored node is placed against, in both
    * directions, so a moved anchor can name its dependents. Passing
@@ -12083,6 +12833,75 @@ interface FocusRingOptions {
  * attachment.
  */
 declare function focusRing(options?: FocusRingOptions): UiModifier<FocusRingOptions>;
+/** One edge's border: a thickness, and a colour if it is not the shared one. */
+interface BorderEdge {
+  readonly width: number;
+  readonly color?: UiColorValue;
+}
+/** What `borders()` takes. An omitted edge is not drawn. */
+interface BordersOptions {
+  readonly top?: number | BorderEdge;
+  readonly right?: number | BorderEdge;
+  readonly bottom?: number | BorderEdge;
+  readonly left?: number | BorderEdge;
+  /** The colour for any edge that does not name its own. Defaults to `border`. */
+  readonly color?: UiColorValue;
+}
+/**
+ * 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.
+ */
+declare function borders(options: BordersOptions): UiModifier<Decorations>;
+/**
+ * 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.
+ */
+declare function borderShapes(options: BordersOptions): readonly DecorationShape[];
 //#endregion
 //#region src/modifiers/focus.d.ts
 /** Takes focus the first time the node is laid out. */
@@ -16025,6 +16844,28 @@ interface UiSchedulerOptions {
    * animation reading it would not be reproducible.
    */
   beforeCollect?: (time: UiFrameTime) => void;
+  /**
+   * Told when a frame throws, instead of the clock simply stopping.
+   *
+   * A frame is the only thing that drives a Gesso application, so an
+   * exception escaping one used to end it: the throw unwound past the
+   * re-arm at the bottom of `handleFrame`, `pending` was already
+   * false, and nothing ever asked for another frame. The application
+   * did not crash — it *stopped*, with its last frame still on screen
+   * and every click landing in a surface nobody was listening to. The
+   * worker sat idle, so a debugger attached to it reported nothing
+   * running and nothing to pause.
+   *
+   * That failure is silent, indistinguishable from a hang, and was
+   * found by typing quickly into a spreadsheet. The scheduler now
+   * survives it: the frame is abandoned, this is called, and the
+   * clock keeps running so the next frame can try again.
+   *
+   * Defaults to reporting on `console.error`, because a frame that
+   * threw is a bug somewhere and the one thing that must not happen
+   * is for nobody to hear about it.
+   */
+  onFrameError?: (error: unknown, time: UiFrameTime) => void;
 }
 /**
  * Decides when a dirty graph gets processed.
@@ -16042,6 +16883,7 @@ declare class UiScheduler {
   private readonly dirty;
   private readonly onFrame;
   private readonly beforeCollect;
+  private readonly onFrameError;
   private disposed;
   private active;
   private pending;
@@ -16392,5 +17234,5 @@ interface UiSemanticsAction {
   readonly value?: string;
 }
 //#endregion
-export { Mp3Header as $, GestureRecognizerOptions as $a, UiChildrenBinding as $c, UiTrackSize as $d, UiInputDispatcher as $f, UiFrameClockFactory as $i, VIRTUAL_INDEX_PROP as $l, findEnvironmentKey as $m, VideoPlayback as $n, nextCaretToggle as $o, DecorationRect as $p, pressable as $r, SpannedRuns as $s, PaintResolver as $t, hasVisualState as $u, MARK_PREFIX as A, UiDropEffect as Aa, ResponsiveProps as Ac, inputsEqual as Ad, UiModifierFocus as Af, UiTransforms as Ah, proportionalFontMetrics as Ai, UiPropertyValueOf as Al, UiBorderRadius as Am, resolveString as An, scrollbarThumbs as Ao, rotateFrom as Ap, pinchable as Ar, PaintTextSpan as As, WebGPUTextureCache as At, densityFactors as Au, ByteSource as B, formatShortcut as Ba, Grid as Bc, UiGradientStop as Bd, UiModifierTeardown as Bf, colorsEqual as Bh, LayoutStateExplanation as Bi, normalizeStates as Bl, UiShapeName as Bm, breakpoint as Bn, UiEnvironmentProvider as Bo, LayoutStats as Bp, draggable as Br, DEFAULT_LINE_HEIGHT_FACTOR as Bs, WebGPUSurface as Bt, UiTypographyExtensions as Bu, paragraphGeometry as C, UiEditingController as Ca, lineStartAt as Cc, PaintLineCap as Cd, observeViewportInsets as Cf, defaultMotion as Ch, parseAlignContent as Ci, TextContentProps as Cl, UiTextAlign as Cm, CanvasHost as Cn, SCROLLBAR_HOVER_ZONE as Co, MotionStateInput as Cp, ShortcutOptions as Cr, Canvas2DGradient as Cs, glyphCount as Ct, withThemeExtension as Cu, UiFrameCallback as D, UiDragPayload as Da, previousWordStart as Dc, PaintTextStyle as Dd, containerBands as Df, interpolateTransform as Dh, parseFlexDirection as Di, UiNodeRef as Dl, UiThemeColorName as Dm, resolveNumber as Dn, ScrollbarAxis as Do, isMotionRest as Dp, shortcuts as Dr, DEFAULT_TEXT_COLOR as Ds, GlyphSlot as Dt, raiseContrast as Du, wordRangeIn as E, EXTERNAL_FILES as Ea, previousGraphemeStart as Ec, PaintTextAlign as Ed, bandOf as Ef, interpolateNumber as Eh, FlexDirection as Ei, UiEventProps as El, UiTextWrapValue as Em, resolveBoolean as En, SCROLLBAR_THICKNESS as Eo, fade as Ep, shortcut as Er, DEFAULT_FONT_WEIGHT as Es, GLYPH_SUBPIXEL_PHASES as Et, highContrastColors as Eu, setPerformanceMarks as F, ShortcutRegistryOptions as Fa, LazyRow as Fc, MAX_GRADIENT_STOPS as Fd, UiModifier as Ff, UiBasicColors as Fh, ScrollAdjustment as Fi, UiRole as Fl, borderRadiusIsZero as Fm, PublishInsetArgs as Fn, matchRangesOf as Fo, SharedClaim as Fp, dragSource as Fr, createPaintState as Fs, DrawStats as Ft, spacingSteps as Fu, Mp4AudioTrack as G, UiPointerController as Ga, Text as Gc, linearGradient as Gd, isComponentLikeElement as Gf, UiEasing as Gh, describeOverrides as Gi, EditUnit as Gl, UiColors as Gm, VideoClock as Gn, CARET_WIDTH as Go, tightenConstraints as Gp, FocusRingOptions as Gr, selectableTextOf as Gs, registerFontStack as Gt, MAX_MEASURES_PER_CHILD as Gu, RangeSourceOptions as H, KeyboardControllerOptions as Ha, Row as Hc, UiRadialGradient as Hd, ComponentLikeElement as Hf, parseColor as Hh, RelayoutExplanation as Hi, validateRole as Hl, defaultShapes as Hm, ScrollOffset as Hn, UiEnvironmentKeys as Ho, TightenOptions as Hp, clickOutside as Hr, TextRange as Hs, bumpFontStack as Ht, defaultTypography as Hu, VttCue as I, UiShortcut as Ia, Box as Ic, ResolvedGradient as Id, UiModifierKind as If, UiColor as Ih, AxisExplanation as Ii, UiSemanticState as Il, borderRadiusValuesEqual as Im, insetPadding as In, setMatchRanges as Io, UiSharedElements as Ip, dropTarget as Ir, isPaintVisible as Is, RenderHooks as It, UiShadows as Iu, demuxMp4Audio as J, UiScrollBehavior as Ja, BindingId as Jc, AutoLength as Jd, isUiElement as Jf, linear as Jh, labelNode as Ji, LazyGridOptions as Jl, lightColors as Jm, VideoTransport as Jn, editorFor as Jo, UiNode as Jp, BUTTON_INTERACTION as Jr, CharacterCountTextMeasurer as Js, PaintPictureCache as Jt, UiLayoutProtocol as Ju, Mp4Sample as K, ScrollContainerState as Ka, createElement as Kc, radialGradient as Kd, isObservable$1 as Kf, cubicBezier as Kh, formatConstraints as Ki, EditableTextModel as Kl, colorsEqualPalette as Km, VideoSourceArgs as Kn, EDITOR_PROP as Ko, NodeId as Kp, decorated as Kr, selectionRangeOf as Ks, PaintCanvas as Kt, UiLayoutChild as Ku, VttTrack as L, UiShortcutBinding as La, Button as Lc, ResolvedGradientStop as Ld, defineModifier as Lf, colorToHex as Lh, CustomLayoutExplanation as Li, UiSemanticStates as Ll, normalizeBorderRadius as Lm, publishInset as Ln, FindMatch as Lo, Constraints as Lp, reorderable as Lr, normalizeTextAlign as Ls, WebGPURenderer as Lt, defaultShadows as Lu, markNow as M, UiDroppedFile as Ma, LazyGrid as Mc, pathValuesEqual as Md, UiModifierSet as Mf, transform as Mh, LayoutEngine as Mi, UI_ROLES as Ml, borderRadius as Mm, themeTokens as Mn, SubtreeBounds as Mo, slideDown as Mp, DragSourceOptions as Mr, VerticalAlign as Ms, isWebGPUAvailable as Mt, defaultSpacing as Mu, measureSpan as N, UiFileDropMessage as Na, LazyGridProps as Nc, UiImage as Nd, UiUnknownModifierPropertyError as Nf, transformIsIdentity as Nh, SCROLLBAR_FADE_MS as Ni, UI_SEMANTIC_STATES as Nl, borderRadiusCorners as Nm, sameArgs as Nn, TEXT_MATCHES_PROP as No, slideFrom as Np, DropTargetOptions as Nr, colorToCss as Ns, WebGPUError as Nt, scaleSpacing as Nu, UiScheduler as O, UiDragSession as Oa, wordRangeAt as Oc, UiPaint as Od, unknownContainerSize as Of, interpolatorFor as Oh, ELLIPSIS as Oi, UiProperties as Ol, UiVerticalAlign as Om, resolveProperty as On, ScrollbarThumb as Oo, pop as Op, PinchableOptions as Or, ObjectFit as Os, GlyphUpload as Ot, relativeLuminance as Ou, performanceMarksEnabled as P, dragSessionFor as Pa, LazyListProps as Pc, GradientPaint as Pd, assertModifierList as Pf, transformsEqual as Ph, SCROLLBAR_LINGER_MS as Pi, UiLiveRegion as Pl, borderRadiusEqual as Pm, InsetPaddingArgs as Pn, clearMatchRanges as Po, slideUp as Pp, ReorderableOptions as Pr, computeObjectFitRect as Ps, CapturedFrame as Pt, spacingEqual as Pu, Mp3Frames as Q, GestureInput as Qa, ChildrenBindingId as Qc, UiLength as Qd, UiEventListenerOptions as Qf, UiFrameClock as Qi, UiVirtualWindow as Ql, createEnvironmentKey as Qm, RangeResponse as Qn, isReadOnly as Qo, DecorationFill as Qp, measure as Qr, ParagraphTextMeasurer as Qs, PaintGradient as Qt, defaultVisualState as Qu, cueAt as R, UiShortcutRegistry as Ra, Column as Rc, UiGradient as Rd, isUiModifier as Rf, colorToRgba as Rh, Edges as Ri, isUiRole as Rl, uniformBorderRadius as Rm, BreakpointArgs as Rn, FindOptions as Ro, LayoutBox as Rp, DragOffset as Rr, normalizeVerticalAlign as Rs, WebGPURendererOptions as Rt, shadowsEqual as Ru, offsetAtPointIn as S, EditingState as Sa, lineEndAt as Sc, PaintFillRule as Sd, noInsets as Sf, UiSpringToken as Sh, MainAxisAlignment as Si, StackProps as Sl, UiSubgridAxis as Sm, labelOrigin as Sn, UiPoint as So, MotionState as Sp, ContextMenuOptions as Sr, Canvas2DContext as Ss, createTextCache as St, themeExtensionsEqual as Su, selectionRectsIn as T, UiTouchScroller as Ta, nextWordEnd as Tc, PaintSurface as Td, UiContainerSizeSource as Tf, interpolateColor as Th, parseMainAxisAlignment as Ti, TypographyProps as Tl, UiTextOverflowValue as Tm, createCanvasSurface as Tn, SCROLLBAR_MIN_THUMB as To, ResolvedMotionState as Tp, contextMenu as Tr, DEFAULT_FONT_SIZE as Ts, GlyphShaper as Tt, contrastRatio as Tu, bufferSource as U, UiKeyboardController as Ua, ScrollView as Uc, gradientPaint as Ud, UiChild as Uf, rgb8 as Uh, SizeDecision as Ui, validateStates as Ul, isShapeName as Um, ScrollPositionArgs as Un, EnvironmentNotifier as Uo, clampSize as Up, autoFocus as Ur, clearSelectionRange as Us, clearFontStacks as Ut, isTypographyRole as Uu, DEFAULT_BLOCK_SIZE as V, parseShortcut as Va, Paint as Vc, UiLinearGradient as Vd, ComponentResolver as Vf, normalizeColor as Vh, OverrideSources as Vi, statesEqual as Vl, UiShapes as Vm, sizeContainer as Vn, provideEnvironment as Vo, Size as Vp, ClickOutsideOptions as Vr, TEXT_SELECTION_PROP as Vs, createWebGPUSurface as Vt, UiTypographyRole as Vu, rangeSource as W, PointerControllerOptions as Wa, Stack as Wc, gradientsEqual as Wd, UiElement as Wf, rgba as Wh, describeLength as Wi, CompositionRange as Wl, shapesEqual as Wm, scrollPosition as Wn, CARET_BLINK_MS as Wo, constraintsEqual as Wp, Decorations as Wr, selectableTextNodes as Ws, fontStackFor as Wt, typographyEqual as Wu, Mp3Format as X, UiWheelController as Xa, UiGraph as Xc, MinMaxTrack as Xd, UiProps as Xf, UiFrame as Xi, LazyListOptions as Xl, UiEnvironment as Xm, DefaultVideoResolver as Xn, isEditableNode as Xo, UiPropertyOverride as Xp, hoverable as Xr, FontMetrics as Xs, paintPictures as Xt, UiVisualState as Xu, demuxMp4Video as Y, UiScrollability as Ya, UiBinding as Yc, FrLength as Yd, UiPropValue as Yf, steps as Yh, withOverrideSource as Yi, LazyItemRenderer as Yl, LayoutRecord as Ym, videoSource as Yn, editorOf as Yo, UiNodeTransitions as Yp, InteractiveOptions as Yr, FixedMetricsOptions as Ys, PaintStats as Yt, isLayoutProtocol as Yu, Mp3Frame as Z, isScrollContainer as Za, UiEventBinding as Zc, PercentLength as Zd, UiEventListener as Zf, UiAnimationFrameClock as Zi, LazySourceArgs as Zl, UiEnvironmentKey as Zm, DefaultVideoResolverOptions as Zn, isMultiline as Zo, UiPropertyOverrides as Zp, interactive as Zr, ParagraphLayout as Zs, PaintContext2D as Zt, UiVisualStateSet as Zu, linkOf as _, pointerDeviceOf as _a, offsetAtPoint as _c, spannedTextOf as _d, UiInsetEdge as _f, createTween as _h, GridTrack as _i, PositionProps as _l, UiOverflow as _m, LayoutReader as _n, UiSelectionController as _o, wheelDeltaYOf as _p, DefaultImageResolver as _r, layoutTextLines as _s, ScissorRect as _t, UiThemeExtensions as _u, diffSemantics as a, UiTimerFrameClockOptions as aa, TextRunMeasurer as ac, UiFontVariant as ad, isPercentLength as af, assertTransitionMap as ah, contentOffset as ai, CommonProps as al, paintsAfterChildren as am, PaintRecording as an, UiFocusManager as ao, UiGestureEvent as ap, sharedElement as ar, isPrintable as as, CLIP_STRIDE_FLOATS as at, lazySource as au, ParagraphGeometry as b, EditingControllerOptions as ba, selectionRects as bc, textStylesEqual as bd, UiInsets as bf, UiMotion as bh, AlignContent as bi, RowProps as bl, UiPosition as bm, OverlayShape as bn, HitTester as bo, MOTION_REST as bp, AnimateLayoutOptions as br, textRunBackgrounds as bs, TextRunDraw as bt, noThemeExtensions as bu, UiSemanticsMap as c, isNodeInert as ca, TextWrap as cc, UiTextDecoration as cd, repeat as cf, tween as ch, getPropertyNames as ci, EnvironmentProps as cl, UiBorderRadiusValue as cm, InspectorOverlay as cn, clearOverrideProperty as co, UiKeyboardEvent as cp, ImageSources as cr, PlacedTextRun as cs, INSTANCE_STRIDE_BYTES as ct, videoFrameSize as cu, buildSemanticsTree as d, CanvasPlatformSurface as da, PlacedLine as dc, UiTextSpan as dd, boxShadow as df, UiAnimationOptions as dh, propertyEffects as di, GridItemProps as dl, UiCursor as dm, CanvasTextMeasurer as dn, writeDeclaredProperty as do, UiPointerEvent as dp, IconCanvas as dr, TextRunRect as ds, NO_CLIP_INDEX as dt, lightTheme as du, UiFrameTime as ea, TextLine as ec, visualState as ed, auto as ef, UiNodeType as eh, UiModifierBundle as ei, UiGraphBuilder as el, DecorationShape as em, PaintTarget as en, UiGestureRecognizer as eo, UiListenerErrorReporter as ep, VideoResolver as er, syncEditorValue as es, readMp3Header as et, VIRTUAL_LEAD_PROP as eu, semanticsInertAbove as f, PlatformAdapterOptions as fa, RunMeasure as fc, UiTextStyle as fd, boxShadowArraysEqual as ff, UiReducedMotionPolicy as fh, propertyIsInherited as fi, GridProps as fl, UiDirection as fm, Canvas2DRenderer as fn, writeOverrideProperty as fo, UiPointerKind as fp, IconContext as fr, applyCanvasTextStyle as fs, PrimitiveCommand as ft, themesEqual as fu, linkHoverOf as g, capturePointer as ga, lineLimit as gc, spanAtOffset as gd, propertyValuesEqual as gf, UiTweenOptions as gh, GridPlacement as gi, PaintProps as gl, UiObjectFit as gm, UiRenderer as gn, SelectionHost as go, noKeyModifiers as gp, iconKey as gr, fillTextRects as gs, RenderTextCache as gt, UiThemeExtensionOptions as gu, hasTextLinks as h, UiPlatformAdapter as ha, lineIndexForOffset as hc, resolvedSpansOf as hd, defineProperty as hf, UiTween as hh, GridItemRequest as hi, PaintElementProps as hl, UiGridAutoFlow as hm, RendererBackend as hn, SelectionControllerOptions as ho, UiWheelEvent as hp, IconSpec as hr, drawText as hs, RenderList as ht, UiThemeExtension as hu, UiSemanticsPatch as i, UiTimerFrameClock as ia, TextOverflow as ic, UiFontStyle as id, isMinMaxTrack as if, UiTransitionValue as ih, accumulatedOffsetTo as ii, ColumnProps as il, hasDecorationPhase as im, PaintRecorder as in, FocusSource as io, UiFocusEvent as ip, motion as ir, detectEditingPlatform as is, CLIP_STRIDE_BYTES as it, VirtualViewport as iu, markInstant as j, UiDropZone as ja, LazyColumn as jc, paintValuesEqual as jd, UiModifierLayout as jf, parseTransform as jh, LayoutNotifier as ji, UiPropertyValues as jl, UiBorderRadiuses as jm, ThemeTokenTarget as jn, scrollbarZoneAt as jo, scaleFrom as jp, AutoScrollOptions as jr, TextAlign as js, initializeWebGPU as jt, UiSpacing as ju, UiSchedulerOptions as k, UiDragState as ka, Responsive as kc, UiPath as kd, UiModifierEnvironment as kf, UiTransform as kh, layoutParagraph as ki, UiPropertyName as kl, validateSubgrid as km, resolvePropertyByName as kn, scrollbarThumb as ko, resolveMotionState as kp, ZoomState as kr, PaintState as ks, WebGPUGlyphAtlas as kt, UiDensity as ku, UiSemanticsRecord as l, isNodeSelectable as la, spannedRunsFor as lc, UiTextLink as ld, resolveLength as lf, AnimatedCell as lh, inheritedPropertyFlags as li, FlexContainerProps as ll, UiColorValue as lm, LayoutInspector as ln, overrideSources as lo, UiPinchEvent as lp, iconSource as lr, SpanPaint as ls, INSTANCE_STRIDE_FLOATS as lt, UiTheme as lu, clearLinkHover as m, PlatformSurface as ma, lineIndexAtY as mc, flattenTextSpans as md, UiPropertyDefinition as mf, UiSpringOptions as mh, GridContribution as mi, InteractionProps as ml, UiFontWeight as mm, traceRoundedRect as mn, UiFindController as mo, UiWheelDeltaMode as mp, IconRasterizerOptions as mr, createCanvasTextStyle as ms, RenderCommand as mt, withDensity as mu, UiSemanticsBox as n, UiHostFrameClockOptions as na, TextMeasureRequest as nc, UiFontKerning as nd, isAutoLength as nf, AnimationDriver as nh, noModifiers as ni, BoxProps as nl, decorationColor as nm, EMPTY_RECORDING as nn, UiPinchRecognizer as no, UiBeforeInputEvent as np, MotionArgs as nr, EditingPlatform as ns, WebGPUGlyphPages as nt, VirtualItemMeasure as nu, recordsEqual as o, isNodeFocusable as oa, TextRunSpan as oc, UiResolvedTextSpan as od, minmax as of, normalizeTransition as oh, closestPropertyName as oi, ContainerProps as ol, UI_SUBGRID_AXES as om, replayPaint as on, NodeTransitions as oo, UiInputEvent as op, IconSourceArgs as or, EditableLayout as os, CommandKind as ot, UiVideoSurface as ou, textRunOfRecordId as p, PlatformEventTarget as pa, caretRectFor as pc, defaultTextStyle as pd, boxShadowsEqual as pf, UiSpring as ph, propertyValuesEqualByName as pi, IdentityProps as pl, UiFlexWrap as pm, Canvas2DRendererOptions as pn, FindHost as po, UiTextChangeEvent as pp, IconRasterizer as pr, buildFontString as ps, PrimitiveKind as pt, withContrast as pu, Mp4VideoTrack as q, ScrollSink as qa, UiDefinition as qc, validateGradient as qd, isUiChild as qf, easings as qh, formatExplanation as qi, LazyAxis as ql, darkColors as qm, VideoState as qn, caretVisibleAt as qo, NodeProperty as qp, focusRing as qr, setSelectionRange as qs, PaintCanvasFactory as qt, UiLayoutContext as qu, UiSemanticsUpdate as r, UiManualFrameClock as ra, TextMeasurer as rc, UiFontStretch as rd, isFrLength as rf, UiTransitionSpec as rh, Transform as ri, ButtonProps as rl, decorationRect as rm, PaintOp as rn, FocusNotifier as ro, UiEventType as rp, SharedElementArgs as rr, commandForKey as rs, Affine as rt, VirtualUpdate as ru, TEXT_RUN_ID_SEPARATOR as s, isNodeHitTestable as sa, TextRunStyle as sc, UiSpannedText as sd, percent as sf, spring as sh, findPropertyDefinition as si, EditableTextProps as sl, UiAlignment as sm, INSPECTOR_HEAT_MS as sn, resetTransitionWarnings as so, UiKeyModifiers as sp, ImageSourceArgs as sr, CanvasTextStyle as ss, GlyphCommand as st, isVideoSurface as su, UiSemanticsAction as t, UiHostFrameClock as ta, TextLineRun as tc, visualStatesEqual as td, fr as tf, DirtyFlags as th, bundle as ti, BoxModelProps as tl, DecorationStroke as tm, tracePathData as tn, PinchRecognizerOptions as to, MOUSE_POINTER as tp, canDecodeVideo as tr, EditCommand as ts, splitMp3Frames as tt, VIRTUAL_WINDOW_PROP as tu, buildSemanticsSubtree as u, resolveCursor as ua, CaretRect as uc, UiTextMetrics as ud, UiBoxShadow as uf, UiAnimation as uh, inheritedPropertyNames as ui, FlexItemProps as ul, UiContentDistribution as um, LayoutInspectorOptions as un, resetOverrideWarnings as uo, UiPointerDevice as up, imageSource as ur, TextLinePlacement as us, ImageCommand as ut, darkTheme as uu, linkRunAtPointIn as v, prepareInputSurface as va, offsetAtX as vc, textContentOf as vd, UiInsetRegistry as vf, UiDurationToken as vh, placeGridItems as vi, PropsOf as vl, UiPlacement as vm, RenderContext as vn, HitTestLayoutReader as vo, DirtyNodeSet as vp, DefaultImageResolverOptions as vr, runCanvasStyleInto as vs, TEXTURED_STRIDE_BYTES as vt, defineThemeExtension as vu, paragraphGeometryFrom as w, TouchScrollerOptions as wa, nextGraphemeEnd as wc, PaintLineJoin as wd, UiContainerSize as wf, UiInterpolator as wh, parseCrossAxisAlignment as wi, TextProps as wl, UiTextDirection as wm, CanvasSurface as wn, SCROLLBAR_INSET as wo, MotionTiming as wp, ShortcutsOptions as wr, DEFAULT_FONT_FAMILY as ws, textRuns as wt, UiContrast as wu, hasDrawnText as x, EditingHost as xa, graphemeBoundaries as xc, PaintBox as xd, insetsEqual as xf, UiSpringSpec as xh, CrossAxisAlignment as xi, ScrollViewProps as xl, UiSelfAlignment as xm, drawOverlayShapes as xn, UiHitTester as xo, MotionChannel as xp, animateLayout as xr, textRunDecorations as xs, buildRenderList as xt, themeExtension as xu, setLinkHover as y, touchActionFor as ya, offsetForVerticalMove as yc, textSpansEqual as yd, UiInsetSource as yf, UiEasingToken as yh, sizeGridTracks as yi, Reactive as yl, UiPointerEvents as ym, LABEL_PADDING_X as yn, HitTestResult as yo, MOTION_CHANNELS as yp, ImageResolver as yr, runFontString as ys, TEXTURED_STRIDE_FLOATS as yt, hasThemeExtension as yu, parseWebVtt as z, UiShortcutStep as za, EditableText as zc, UiGradientOffset as zd, UiModifierHost as zf, colorValuesEqual as zh, LayoutExplanation as zi, isUiSemanticState as zl, UiShapeExtensions as zm, SizeContainerArgs as zn, findMatchesIn as zo, LayoutResult as zp, DraggableOptions as zr, resolvePaintState as zs, WebGPUCanvasHost as zt, UiTypography as zu };
-//# sourceMappingURL=index-DAdauEn9.d.ts.map
+export { Mp3Header as $, UiScrollBehavior as $a, BindingId as $c, ResolvedGradient as $d, UiModifierKind as $f, transformsEqual as $h, withOverrideSource as $i, LazySheetProps as $l, borderRadiusEqual as $m, VideoPlayback as $n, editorFor as $o, slideUp as $p, InteractiveOptions as $r, CharacterCountTextMeasurer as $s, PaintResolver as $t, defaultShadows as $u, MARK_PREFIX as A, UiTouchScroller as Aa, nextWordEnd as Ac, editableSpansOf as Ad, boxShadowsEqual as Af, UiAnimationOptions as Ah, FlexDirection as Ai, TypographyProps as Al, UiCursor as Am, resolveString as An, SCROLLBAR_MIN_THUMB as Ao, UiPointerKind as Ap, pinchable as Ar, DEFAULT_FONT_SIZE as As, WebGPUTextureCache as At, withDensity as Au, ByteSource as B, ShortcutRegistryOptions as Ba, LazyRow as Bc, PaintLineCap as Bd, observeViewportInsets as Bf, UiSpringSpec as Bh, AxisExplanation as Bi, UiRole as Bl, UiSelfAlignment as Bm, breakpoint as Bn, matchRangesOf as Bo, MotionChannel as Bp, draggable as Br, createPaintState as Bs, WebGPUSurface as Bt, UiContrast as Bu, paragraphGeometry as C, prepareInputSurface as Ca, offsetAtX as Cc, UiSpannedText as Cd, minmax as Cf, UiTransitionValue as Ch, sizeGridTracks as Ci, PropsOf as Cl, hasDecorationPhase as Cm, CanvasHost as Cn, HitTestLayoutReader as Co, UiInputEvent as Cp, ShortcutOptions as Cr, runCanvasStyleInto as Cs, glyphCount as Ct, isVideoSurface as Cu, UiFrameCallback as D, EditingState as Da, lineEndAt as Dc, UiTextSpan as Dd, UiBoxShadow as Df, tween as Dh, parseAlignContent as Di, StackProps as Dl, UiBorderRadiusValue as Dm, resolveNumber as Dn, UiPoint as Do, UiPinchEvent as Dp, shortcuts as Dr, Canvas2DContext as Ds, GlyphSlot as Dt, lightTheme as Du, wordRangeIn as E, EditingHost as Ea, graphemeBoundaries as Ec, UiTextMetrics as Ed, resolveLength as Ef, spring as Eh, MainAxisAlignment as Ei, ScrollViewProps as El, UiAlignment as Em, resolveBoolean as En, UiHitTester as Eo, UiPasteEvent as Ep, shortcut as Er, textRunDecorations as Es, GLYPH_SUBPIXEL_PHASES as Et, darkTheme as Eu, setPerformanceMarks as F, UiDropEffect as Fa, ResponsiveProps as Fc, textContentOf as Fd, UiInsetRegistry as Ff, UiTweenOptions as Fh, LayoutNotifier as Fi, UiPropertyValueOf as Fl, UiObjectFit as Fm, PublishInsetArgs as Fn, scrollbarThumbs as Fo, noKeyModifiers as Fp, dragSource as Fr, PaintTextSpan as Fs, DrawStats as Ft, hasThemeExtension as Fu, Mp4AudioTrack as G, formatShortcut as Ga, Grid as Gc, UiPaint as Gd, unknownContainerSize as Gf, interpolateNumber as Gh, OverrideSources as Gi, normalizeStates as Gl, UiTextWrapValue as Gm, VideoClock as Gn, UiEnvironmentProvider as Go, fade as Gp, BordersOptions as Gr, DEFAULT_LINE_HEIGHT_FACTOR as Gs, registerFontStack as Gt, UiDensity as Gu, RangeSourceOptions as H, UiShortcutBinding as Ha, Button as Hc, PaintSurface as Hd, UiContainerSizeSource as Hf, defaultMotion as Hh, Edges as Hi, UiSemanticStates as Hl, UiTextAlign as Hm, ScrollOffset as Hn, FindMatch as Ho, MotionStateInput as Hp, clickOutside as Hr, normalizeTextAlign as Hs, bumpFontStack as Ht, highContrastColors as Hu, VttCue as I, UiDropZone as Ia, LazyColumn as Ic, textSpansEqual as Id, UiInsetSource as If, createTween as Ih, LayoutEngine as Ii, UiPropertyValues as Il, UiOverflow as Im, insetPadding as In, scrollbarZoneAt as Io, wheelDeltaYOf as Ip, dropTarget as Ir, TextAlign as Is, RenderHooks as It, noThemeExtensions as Iu, demuxMp4Audio as J, UiKeyboardController as Ja, ScrollView as Jc, paintValuesEqual as Jd, UiModifierLayout as Jf, UiTransform as Jh, describeLength as Ji, validateStates as Jl, validateSubgrid as Jm, VideoTransport as Jn, EnvironmentNotifier as Jo, resolveMotionState as Jp, borderShapes as Jr, clearSelectionRange as Js, PaintPictureCache as Jt, defaultSpacing as Ju, Mp4Sample as K, parseShortcut as Ka, Paint as Kc, UiPath as Kd, UiModifierEnvironment as Kf, interpolateTransform as Kh, RelayoutExplanation as Ki, statesEqual as Kl, UiThemeColorName as Km, VideoSourceArgs as Kn, provideEnvironment as Ko, isMotionRest as Kp, Decorations as Kr, TEXT_SELECTION_PROP as Ks, PaintCanvas as Kt, densityFactors as Ku, VttTrack as L, UiDroppedFile as La, LazyGrid as Lc, textStylesEqual as Ld, UiInsets as Lf, UiDurationToken as Lh, SCROLLBAR_FADE_MS as Li, UI_ROLES as Ll, UiPlacement as Lm, publishInset as Ln, SubtreeBounds as Lo, DirtyNodeSet as Lp, reorderable as Lr, VerticalAlign as Ls, WebGPURenderer as Lt, themeExtension as Lu, markNow as M, UiDragPayload as Ma, previousWordStart as Mc, resolvedSpansOf as Md, defineProperty as Mf, UiSpring as Mh, ELLIPSIS as Mi, UiNodeRef as Ml, UiFlexWrap as Mm, themeTokens as Mn, ScrollbarAxis as Mo, UiTextChangeEvent as Mp, DragSourceOptions as Mr, DEFAULT_TEXT_COLOR as Ms, isWebGPUAvailable as Mt, UiThemeExtensionOptions as Mu, measureSpan as N, UiDragSession as Na, wordRangeAt as Nc, spanAtOffset as Nd, propertyValuesEqual as Nf, UiSpringOptions as Nh, layoutParagraph as Ni, UiProperties as Nl, UiFontWeight as Nm, sameArgs as Nn, ScrollbarThumb as No, UiWheelDeltaMode as Np, DropTargetOptions as Nr, ObjectFit as Ns, WebGPUError as Nt, UiThemeExtensions as Nu, UiScheduler as O, UiEditingController as Oa, lineStartAt as Oc, UiTextStyle as Od, boxShadow as Of, AnimatedCell as Oh, parseCrossAxisAlignment as Oi, TextContentProps as Ol, UiColorValue as Om, resolveProperty as On, SCROLLBAR_HOVER_ZONE as Oo, UiPointerDevice as Op, PinchableOptions as Or, Canvas2DGradient as Os, GlyphUpload as Ot, themesEqual as Ou, performanceMarksEnabled as P, UiDragState as Pa, Responsive as Pc, spannedTextOf as Pd, UiInsetEdge as Pf, UiTween as Ph, proportionalFontMetrics as Pi, UiPropertyName as Pl, UiGridAutoFlow as Pm, InsetPaddingArgs as Pn, scrollbarThumb as Po, UiWheelEvent as Pp, ReorderableOptions as Pr, PaintState as Ps, CapturedFrame as Pt, defineThemeExtension as Pu, Mp3Frames as Q, ScrollSink as Qa, UiDefinition as Qc, MAX_GRADIENT_STOPS as Qd, UiModifier as Qf, transformIsIdentity as Qh, labelNode as Qi, LazySheet as Ql, borderRadiusCorners as Qm, RangeResponse as Qn, caretVisibleAt as Qo, slideFrom as Qp, BUTTON_INTERACTION as Qr, setSelectionRange as Qs, PaintGradient as Qt, UiShadows as Qu, cueAt as R, UiFileDropMessage as Ra, LazyGridProps as Rc, PaintBox as Rd, insetsEqual as Rf, UiEasingToken as Rh, SCROLLBAR_LINGER_MS as Ri, UI_SEMANTIC_STATES as Rl, UiPointerEvents as Rm, BreakpointArgs as Rn, TEXT_MATCHES_PROP as Ro, MOTION_CHANNELS as Rp, DragOffset as Rr, colorToCss as Rs, WebGPURendererOptions as Rt, themeExtensionsEqual as Ru, offsetAtPointIn as S, pointerDeviceOf as Sa, offsetAtPoint as Sc, UiResolvedTextSpan as Sd, isPercentLength as Sf, UiTransitionSpec as Sh, placeGridItems as Si, PositionProps as Sl, decorationRect as Sm, labelOrigin as Sn, UiSelectionController as So, UiGestureEvent as Sp, ContextMenuOptions as Sr, layoutTextLines as Ss, createTextCache as St, UiVideoSurface as Su, selectionRectsIn as T, EditingControllerOptions as Ta, selectionRects as Tc, UiTextLink as Td, repeat as Tf, normalizeTransition as Th, CrossAxisAlignment as Ti, RowProps as Tl, UI_SUBGRID_AXES as Tm, createCanvasSurface as Tn, HitTester as To, UiKeyboardEvent as Tp, contextMenu as Tr, textRunBackgrounds as Ts, GlyphShaper as Tt, UiTheme as Tu, bufferSource as U, UiShortcutRegistry as Ua, Column as Uc, PaintTextAlign as Ud, bandOf as Uf, UiInterpolator as Uh, LayoutExplanation as Ui, isUiRole as Ul, UiTextDirection as Um, ScrollPositionArgs as Un, FindOptions as Uo, MotionTiming as Up, autoFocus as Ur, normalizeVerticalAlign as Us, clearFontStacks as Ut, raiseContrast as Uu, DEFAULT_BLOCK_SIZE as V, UiShortcut as Va, Box as Vc, PaintLineJoin as Vd, UiContainerSize as Vf, UiSpringToken as Vh, CustomLayoutExplanation as Vi, UiSemanticState as Vl, UiSubgridAxis as Vm, sizeContainer as Vn, setMatchRanges as Vo, MotionState as Vp, ClickOutsideOptions as Vr, isPaintVisible as Vs, createWebGPUSurface as Vt, contrastRatio as Vu, rangeSource as W, UiShortcutStep as Wa, EditableText as Wc, PaintTextStyle as Wd, containerBands as Wf, interpolateColor as Wh, LayoutStateExplanation as Wi, isUiSemanticState as Wl, UiTextOverflowValue as Wm, scrollPosition as Wn, findMatchesIn as Wo, ResolvedMotionState as Wp, BorderEdge as Wr, resolvePaintState as Ws, fontStackFor as Wt, relativeLuminance as Wu, Mp3Format as X, UiPointerController as Xa, Text as Xc, UiImage as Xd, UiUnknownModifierPropertyError as Xf, parseTransform as Xh, formatConstraints as Xi, EditUnit as Xl, UiBorderRadiuses as Xm, DefaultVideoResolver as Xn, CARET_WIDTH as Xo, scaleFrom as Xp, decorated as Xr, selectableTextOf as Xs, paintPictures as Xt, spacingEqual as Xu, demuxMp4Video as Y, PointerControllerOptions as Ya, Stack as Yc, pathValuesEqual as Yd, UiModifierSet as Yf, UiTransforms as Yh, describeOverrides as Yi, CompositionRange as Yl, UiBorderRadius as Ym, videoSource as Yn, CARET_BLINK_MS as Yo, rotateFrom as Yp, borders as Yr, selectableTextNodes as Ys, PaintStats as Yt, scaleSpacing as Yu, Mp3Frame as Z, ScrollContainerState as Za, createElement as Zc, GradientPaint as Zd, assertModifierList as Zf, transform as Zh, formatExplanation as Zi, EditableTextModel as Zl, borderRadius as Zm, DefaultVideoResolverOptions as Zn, EDITOR_PROP as Zo, slideDown as Zp, focusRing as Zr, selectionRangeOf as Zs, PaintContext2D as Zt, spacingSteps as Zu, linkOf as _, PlatformAdapterOptions as _a, RunMeasure as _c, visualStatesEqual as _d, auto as _f, createEnvironmentKey as _h, propertyValuesEqualByName as _i, GridProps as _l, DecorationFill as _m, LayoutReader as _n, writeOverrideProperty as _o, UiListenerErrorReporter as _p, DefaultImageResolver as _r, applyCanvasTextStyle as _s, ScissorRect as _t, VIRTUAL_WINDOW_PROP as _u, diffSemantics as a, UiHostFrameClock as aa, TextLine as ac, isTypographyRole as ad, UiRadialGradient as af, colorsEqual as ag, UiShapeName as ah, bundle as ai, UiGraphBuilder as al, LayoutStats as am, PaintRecording as an, UiGestureRecognizer as ao, ComponentLikeElement as ap, sharedElement as ar, syncEditorValue as as, CLIP_STRIDE_FLOATS as at, UiVirtualSheet as au, ParagraphGeometry as b, UiPlatformAdapter as ba, lineIndexForOffset as bc, UiFontStyle as bd, isFrLength as bf, DirtyFlags as bh, GridPlacement as bi, PaintElementProps as bl, DecorationStroke as bm, OverlayShape as bn, SelectionControllerOptions as bo, UiEventType as bp, AnimateLayoutOptions as br, drawText as bs, TextRunDraw as bt, VirtualViewport as bu, UiSemanticsMap as c, UiTimerFrameClock as ca, TextMeasurer as cc, UiLayoutChild as cd, linearGradient as cf, rgb8 as cg, isShapeName as ch, accumulatedOffsetTo as ci, ButtonProps as cl, clampSize as cm, InspectorOverlay as cn, FocusNotifier as co, isComponentLikeElement as cp, ImageSources as cr, commandForKey as cs, INSTANCE_STRIDE_BYTES as ct, sheetSource as cu, buildSemanticsTree as d, isNodeHitTestable as da, TextRunSpan as dc, isLayoutProtocol as dd, AutoLength as df, cubicBezier as dg, colorsEqualPalette as dh, findPropertyDefinition as di, ContainerProps as dl, NodeId as dm, CanvasTextMeasurer as dn, NodeTransitions as do, isUiElement as dp, IconCanvas as dr, EditableLayout as ds, NO_CLIP_INDEX as dt, LazyItemRenderer as du, UiFrame as ea, FixedMetricsOptions as ec, shadowsEqual as ed, ResolvedGradientStop as ef, UiBasicColors as eg, borderRadiusIsZero as eh, hoverable as ei, UiBinding as el, SharedClaim as em, PaintTarget as en, UiScrollability as eo, defineModifier as ep, VideoResolver as er, editorOf as es, readMp3Header as et, SheetHeaderRenderer as eu, semanticsInertAbove as f, isNodeInert as fa, TextRunStyle as fc, UiVisualState as fd, FrLength as ff, easings as fg, darkColors as fh, getPropertyNames as fi, EditableTextProps as fl, NodeProperty as fm, Canvas2DRenderer as fn, resetTransitionWarnings as fo, UiPropValue as fp, IconContext as fr, CanvasTextStyle as fs, PrimitiveCommand as ft, LazyListOptions as fu, linkHoverOf as g, CanvasPlatformSurface as ga, PlacedLine as gc, visualState as gd, UiTrackSize as gf, UiEnvironmentKey as gh, propertyIsInherited as gi, GridItemProps as gl, UiPropertyOverrides as gm, UiRenderer as gn, writeDeclaredProperty as go, UiInputDispatcher as gp, iconKey as gr, TextRunRect as gs, RenderTextCache as gt, VIRTUAL_LEAD_PROP as gu, hasTextLinks as h, resolveCursor as ha, CaretRect as hc, hasVisualState as hd, UiLength as hf, UiEnvironment as hh, propertyEffects as hi, FlexItemProps as hl, UiPropertyOverride as hm, RendererBackend as hn, resetOverrideWarnings as ho, UiEventListenerOptions as hp, IconSpec as hr, TextLinePlacement as hs, RenderList as ht, VIRTUAL_INDEX_PROP as hu, UiSemanticsPatch as i, UiFrameTime as ia, SpannedRuns as ic, defaultTypography as id, UiLinearGradient as if, colorValuesEqual as ig, UiShapeExtensions as ih, UiModifierBundle as ii, UiChildrenBinding as il, LayoutResult as im, PaintRecorder as in, GestureRecognizerOptions as io, ComponentResolver as ip, motion as ir, nextCaretToggle as is, CLIP_STRIDE_BYTES as it, SheetViewport as iu, markInstant as j, EXTERNAL_FILES as ja, previousGraphemeStart as jc, flattenTextSpans as jd, UiPropertyDefinition as jf, UiReducedMotionPolicy as jh, parseFlexDirection as ji, UiEventProps as jl, UiDirection as jm, ThemeTokenTarget as jn, SCROLLBAR_THICKNESS as jo, UiSelectionChangeEvent as jp, AutoScrollOptions as jr, DEFAULT_FONT_WEIGHT as js, initializeWebGPU as jt, UiThemeExtension as ju, UiSchedulerOptions as k, TouchScrollerOptions as ka, nextGraphemeEnd as kc, defaultTextStyle as kd, boxShadowArraysEqual as kf, UiAnimation as kh, parseMainAxisAlignment as ki, TextProps as kl, UiContentDistribution as km, resolvePropertyByName as kn, SCROLLBAR_INSET as ko, UiPointerEvent as kp, ZoomState as kr, DEFAULT_FONT_FAMILY as ks, WebGPUGlyphAtlas as kt, withContrast as ku, UiSemanticsRecord as l, UiTimerFrameClockOptions as la, TextOverflow as lc, UiLayoutContext as ld, radialGradient as lf, rgba as lg, shapesEqual as lh, contentOffset as li, ColumnProps as ll, constraintsEqual as lm, LayoutInspector as ln, FocusSource as lo, isObservable$1 as lp, iconSource as lr, detectEditingPlatform as ls, INSTANCE_STRIDE_FLOATS as lt, LazyAxis as lu, clearLinkHover as m, isNodeTabStop as ma, spannedRunsFor as mc, defaultVisualState as md, PercentLength as mf, steps as mg, LayoutRecord as mh, inheritedPropertyNames as mi, FlexContainerProps as ml, UiNodeTransitions as mm, traceRoundedRect as mn, overrideSources as mo, UiEventListener as mp, IconRasterizerOptions as mr, SpanPaint as ms, RenderCommand as mt, UiVirtualWindow as mu, UiSemanticsBox as n, UiFrameClock as na, ParagraphLayout as nc, UiTypographyExtensions as nd, UiGradientOffset as nf, colorToHex as ng, normalizeBorderRadius as nh, measure as ni, UiEventBinding as nl, Constraints as nm, EMPTY_RECORDING as nn, isScrollContainer as no, UiModifierHost as np, MotionArgs as nr, isMultiline as ns, WebGPUGlyphPages as nt, SheetRowRenderer as nu, recordsEqual as o, UiHostFrameClockOptions as oa, TextLineRun as oc, typographyEqual as od, gradientPaint as of, normalizeColor as og, UiShapes as oh, noModifiers as oi, BoxModelProps as ol, Size as om, replayPaint as on, PinchRecognizerOptions as oo, UiChild as op, IconSourceArgs as or, EditCommand as os, CommandKind as ot, UiVirtualSheetOptions as ou, textRunOfRecordId as p, isNodeSelectable as pa, TextWrap as pc, UiVisualStateSet as pd, MinMaxTrack as pf, linear as pg, lightColors as ph, inheritedPropertyFlags as pi, EnvironmentProps as pl, UiNode as pm, Canvas2DRendererOptions as pn, clearOverrideProperty as po, UiProps as pp, IconRasterizer as pr, PlacedTextRun as ps, PrimitiveKind as pt, LazySourceArgs as pu, Mp4VideoTrack as q, KeyboardControllerOptions as qa, Row as qc, inputsEqual as qd, UiModifierFocus as qf, interpolatorFor as qh, SizeDecision as qi, validateRole as ql, UiVerticalAlign as qm, VideoState as qn, UiEnvironmentKeys as qo, pop as qp, FocusRingOptions as qr, TextRange as qs, PaintCanvasFactory as qt, UiSpacing as qu, UiSemanticsUpdate as r, UiFrameClockFactory as ra, ParagraphTextMeasurer as rc, UiTypographyRole as rd, UiGradientStop as rf, colorToRgba as rg, uniformBorderRadius as rh, pressable as ri, ChildrenBindingId as rl, LayoutBox as rm, PaintOp as rn, GestureInput as ro, UiModifierTeardown as rp, SharedElementArgs as rr, isReadOnly as rs, Affine as rt, SheetSourceArgs as ru, TEXT_RUN_ID_SEPARATOR as s, UiManualFrameClock as sa, TextMeasureRequest as sc, MAX_MEASURES_PER_CHILD as sd, gradientsEqual as sf, parseColor as sg, defaultShapes as sh, Transform as si, BoxProps as sl, TightenOptions as sm, INSPECTOR_HEAT_MS as sn, UiPinchRecognizer as so, UiElement as sp, ImageSourceArgs as sr, EditingPlatform as ss, GlyphCommand as st, VIRTUAL_SHEET_PROP as su, UiSemanticsAction as t, UiAnimationFrameClock as ta, FontMetrics as tc, UiTypography as td, UiGradient as tf, UiColor as tg, borderRadiusValuesEqual as th, interactive as ti, UiGraph as tl, UiSharedElements as tm, tracePathData as tn, UiWheelController as to, isUiModifier as tp, canDecodeVideo as tr, isEditableNode as ts, splitMp3Frames as tt, SheetRange as tu, buildSemanticsSubtree as u, isNodeFocusable as ua, TextRunMeasurer as uc, UiLayoutProtocol as ud, validateGradient as uf, UiEasing as ug, UiColors as uh, closestPropertyName as ui, CommonProps as ul, tightenConstraints as um, LayoutInspectorOptions as un, UiFocusManager as uo, isUiChild as up, imageSource as ur, isPrintable as us, ImageCommand as ut, LazyGridOptions as uu, linkRunAtPointIn as v, PlatformEventTarget as va, caretRectFor as vc, UiFontKerning as vd, fr as vf, findEnvironmentKey as vh, GridContribution as vi, IdentityProps as vl, DecorationRect as vm, RenderContext as vn, FindHost as vo, MOUSE_POINTER as vp, DefaultImageResolverOptions as vr, buildFontString as vs, TEXTURED_STRIDE_BYTES as vt, VirtualItemMeasure as vu, paragraphGeometryFrom as w, touchActionFor as wa, offsetForVerticalMove as wc, UiTextDecoration as wd, percent as wf, assertTransitionMap as wh, AlignContent as wi, Reactive as wl, paintsAfterChildren as wm, CanvasSurface as wn, HitTestResult as wo, UiKeyModifiers as wp, ShortcutsOptions as wr, runFontString as ws, textRuns as wt, videoFrameSize as wu, hasDrawnText as x, capturePointer as xa, lineLimit as xc, UiFontVariant as xd, isMinMaxTrack as xf, AnimationDriver as xh, GridTrack as xi, PaintProps as xl, decorationColor as xm, drawOverlayShapes as xn, SelectionHost as xo, UiFocusEvent as xp, animateLayout as xr, fillTextRects as xs, buildRenderList as xt, lazySource as xu, setLinkHover as y, PlatformSurface as ya, lineIndexAtY as yc, UiFontStretch as yd, isAutoLength as yf, UiNodeType as yh, GridItemRequest as yi, InteractionProps as yl, DecorationShape as ym, LABEL_PADDING_X as yn, UiFindController as yo, UiBeforeInputEvent as yp, ImageResolver as yr, createCanvasTextStyle as ys, TEXTURED_STRIDE_FLOATS as yt, VirtualUpdate as yu, parseWebVtt as z, dragSessionFor as za, LazyListProps as zc, PaintFillRule as zd, noInsets as zf, UiMotion as zh, ScrollAdjustment as zi, UiLiveRegion as zl, UiPosition as zm, SizeContainerArgs as zn, clearMatchRanges as zo, MOTION_REST as zp, DraggableOptions as zr, computeObjectFitRect as zs, WebGPUCanvasHost as zt, withThemeExtension as zu };
+//# sourceMappingURL=index-BzXn0Bci.d.ts.map